* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#include "libavutil/attributes.h"
#include "avcodec.h"
#include "internal.h"
#include "get_bits.h"
#include "put_bits.h"
#include "wma.h"
+#include "wma_common.h"
/** current decoder limitations */
#define WMALL_MAX_CHANNELS 8 ///< max number of handled channels
#define MAX_SUBFRAMES 32 ///< max number of subframes per channel
#define MAX_BANDS 29 ///< max number of scale factor bands
#define MAX_FRAMESIZE 32768 ///< maximum compressed frame size
+#define MAX_ORDER 256
#define WMALL_BLOCK_MIN_BITS 6 ///< log2 of min block size
#define WMALL_BLOCK_MAX_BITS 12 ///< log2 of max block size
uint32_t frame_num; ///< current frame number (not used for decoding)
GetBitContext gb; ///< bitstream reader context
int buf_bit_size; ///< buffer size in bits
- int16_t *samples_16; ///< current samplebuffer pointer (16-bit)
- int16_t *samples_16_end; ///< maximum samplebuffer pointer
- int *samples_32; ///< current samplebuffer pointer (24-bit)
- int *samples_32_end; ///< maximum samplebuffer pointer
+ int16_t *samples_16[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (16-bit)
+ int32_t *samples_32[WMALL_MAX_CHANNELS]; ///< current samplebuffer pointer (24-bit)
uint8_t drc_gain; ///< gain for the DRC tool
int8_t skip_frame; ///< skip output step
int8_t parsed_all_subframes; ///< all subframes decoded?
int scaling;
int coefsend;
int bitsend;
- int16_t coefs[256];
- int16_t lms_prevvalues[512];
- int16_t lms_updates[512];
+ int16_t coefs[MAX_ORDER];
+ int16_t lms_prevvalues[MAX_ORDER * 2];
+ int16_t lms_updates[MAX_ORDER * 2];
int recent;
} cdlms[2][9];
WmallDecodeCtx *s = avctx->priv_data;
uint8_t *edata_ptr = avctx->extradata;
unsigned int channel_mask;
- int i, log2_max_num_subframes, num_possible_block_sizes;
+ int i, log2_max_num_subframes;
s->avctx = avctx;
init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE);
}
/* dump the extradata */
for (i = 0; i < avctx->extradata_size; i++)
- av_dlog(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]);
- av_dlog(avctx, AV_LOG_DEBUG, "\n");
+ av_dlog(avctx, "[%x] ", avctx->extradata[i]);
+ av_dlog(avctx, "\n");
} else {
av_log_ask_for_sample(avctx, "Unsupported extradata size\n");
s->max_subframe_len_bit = 0;
s->subframe_len_bits = av_log2(log2_max_num_subframes) + 1;
- num_possible_block_sizes = log2_max_num_subframes + 1;
s->min_samples_per_subframe = s->samples_per_frame / s->max_num_subframes;
s->dynamic_range_compression = s->decode_flags & 0x80;
s->bV3RTM = s->decode_flags & 0x100;
/* loop until the frame data is split between the subframes */
do {
- int subframe_len;
+ int subframe_len, in_use = 0;
/* check which channels contain the subframe */
for (c = 0; c < s->num_channels; c++) {
if (num_samples[c] == min_channel_len) {
if (fixed_channel_layout || channels_for_cur_subframe == 1 ||
(min_channel_len == s->samples_per_frame - s->min_samples_per_subframe)) {
- contains_subframe[c] = 1;
+ contains_subframe[c] = in_use = 1;
} else {
- contains_subframe[c] = get_bits1(&s->gb);
+ if (get_bits1(&s->gb))
+ contains_subframe[c] = in_use = 1;
}
} else
contains_subframe[c] = 0;
}
+ if (!in_use) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Found empty subframe\n");
+ return AVERROR_INVALIDDATA;
+ }
+
/* get subframe length, subframe_len == 0 is not allowed */
if ((subframe_len = decode_subframe_length(s, min_channel_len)) <= 0)
return AVERROR_INVALIDDATA;
if (get_bits1(&s->gb)) {
int i, send_coef_bits;
int cbits = av_log2(s->mclms_scaling + 1);
- assert(cbits == my_log2(s->mclms_scaling + 1));
if (1 << cbits < s->mclms_scaling + 1)
cbits++;
}
}
-static void decode_cdlms(WmallDecodeCtx *s)
+static int decode_cdlms(WmallDecodeCtx *s)
{
int c, i;
int cdlms_send_coef = get_bits1(&s->gb);
for (c = 0; c < s->num_channels; c++) {
s->cdlms_ttl[c] = get_bits(&s->gb, 3) + 1;
- for (i = 0; i < s->cdlms_ttl[c]; i++)
+ for (i = 0; i < s->cdlms_ttl[c]; i++) {
s->cdlms[c][i].order = (get_bits(&s->gb, 7) + 1) * 8;
+ if (s->cdlms[c][i].order > MAX_ORDER) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Order[%d][%d] %d > max (%d), not supported\n",
+ c, i, s->cdlms[c][i].order, MAX_ORDER);
+ s->cdlms[0][0].order = 0;
+ return AVERROR_INVALIDDATA;
+ }
+ }
for (i = 0; i < s->cdlms_ttl[c]; i++)
s->cdlms[c][i].scaling = get_bits(&s->gb, 4);
}
}
}
+
+ return 0;
}
static int decode_channel_residues(WmallDecodeCtx *s, int ch, int tile_size)
int num_channels = s->num_channels;
for (ich = 0; ich < num_channels; ich++) {
+ pred[ich] = 0;
if (!s->is_channel_coded[ich])
continue;
- pred[ich] = 0;
for (i = 0; i < order * num_channels; i++)
pred[ich] += s->mclms_prevvalues[i + s->mclms_recent] *
s->mclms_coeffs[i + order * num_channels * ich];
{
if (s->num_channels != 2)
return;
- else if (s->is_channel_coded[0] && s->is_channel_coded[1]) {
+ else if (s->is_channel_coded[0] || s->is_channel_coded[1]) {
int icoef;
for (icoef = 0; icoef < tile_size; icoef++) {
s->channel_residues[0][icoef] -= s->channel_residues[1][icoef] >> 1;
int offset = s->samples_per_frame;
int subframe_len = s->samples_per_frame;
int total_samples = s->samples_per_frame * s->num_channels;
- int i, j, rawpcm_tile, padding_zeroes;
+ int i, j, rawpcm_tile, padding_zeroes, res;
s->subframe_offset = get_bits_count(&s->gb);
s->do_arith_coding = get_bits1(&s->gb);
if (s->do_arith_coding) {
- av_dlog(s->avctx, AV_LOG_DEBUG, "do_arith_coding == 1");
- abort();
+ av_log_missing_feature(s->avctx, "arithmetic coding", 1);
+ return AVERROR_PATCHWELCOME;
}
s->do_ac_filter = get_bits1(&s->gb);
s->do_inter_ch_decorr = get_bits1(&s->gb);
if (s->do_mclms)
decode_mclms(s);
- decode_cdlms(s);
+ if ((res = decode_cdlms(s)) < 0)
+ return res;
s->movave_scaling = get_bits(&s->gb, 3);
s->quant_stepsize = get_bits(&s->gb, 8) + 1;
reset_codec(s);
+ } else if (!s->cdlms[0][0].order) {
+ av_log(s->avctx, AV_LOG_DEBUG,
+ "Waiting for seekable tile\n");
+ s->frame.nb_samples = 0;
+ return -1;
}
rawpcm_tile = get_bits1(&s->gb);
if (rawpcm_tile) {
int bits = s->bits_per_sample - padding_zeroes;
- av_dlog(s->avctx, AV_LOG_DEBUG, "RAWPCM %d bits per sample. "
+ if (bits <= 0) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Invalid number of padding bits in raw PCM tile\n");
+ return AVERROR_INVALIDDATA;
+ }
+ av_dlog(s->avctx, "RAWPCM %d bits per sample. "
"total %d bits, remain=%d\n", bits,
bits * s->num_channels * subframe_len, get_bits_count(&s->gb));
for (i = 0; i < s->num_channels; i++)
else
use_normal_update_speed(s, i);
revert_cdlms(s, i, 0, subframe_len);
+ } else {
+ memset(s->channel_residues[i], 0, sizeof(**s->channel_residues) * subframe_len);
}
}
if (s->do_mclms)
s->channel_residues[i][j] *= s->quant_stepsize;
/* Write to proper output buffer depending on bit-depth */
- for (i = 0; i < subframe_len; i++)
- for (j = 0; j < s->num_channels; j++) {
- if (s->bits_per_sample == 16)
- *s->samples_16++ = (int16_t) s->channel_residues[j][i];
- else
- *s->samples_32++ = s->channel_residues[j][i];
+ for (i = 0; i < s->channels_for_cur_subframe; i++) {
+ int c = s->channel_indexes_for_cur_subframe[i];
+ int subframe_len = s->channel[c].subframe_len[s->channel[c].cur_subframe];
+
+ for (j = 0; j < subframe_len; j++) {
+ if (s->bits_per_sample == 16) {
+ *s->samples_16[c] = (int16_t) s->channel_residues[c][j] << padding_zeroes;
+ s->samples_16[c] += s->num_channels;
+ } else {
+ *s->samples_32[c] = s->channel_residues[c][j] << padding_zeroes;
+ s->samples_32[c] += s->num_channels;
+ }
}
+ }
/* handled one subframe */
for (i = 0; i < s->channels_for_cur_subframe; i++) {
s->packet_loss = 1;
return ret;
}
- s->samples_16 = (int16_t *)s->frame.data[0];
- s->samples_32 = (int32_t *)s->frame.data[0];
+ for (i = 0; i < s->num_channels; i++) {
+ s->samples_16[i] = (int16_t *)s->frame.data[0] + i;
+ s->samples_32[i] = (int32_t *)s->frame.data[0] + i;
+ }
/* get frame length */
if (s->len_prefix)
/* no idea what these are for, might be the number of samples
that need to be skipped at the beginning or end of a stream */
if (get_bits1(gb)) {
- int skip;
+ int av_unused skip;
/* usually true for the first frame */
if (get_bits1(gb)) {
skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
- av_dlog(s->avctx, AV_LOG_DEBUG, "start skip: %i\n", skip);
+ av_dlog(s->avctx, "start skip: %i\n", skip);
}
/* sometimes true for the last frame */
if (get_bits1(gb)) {
skip = get_bits(gb, av_log2(s->samples_per_frame * 2));
- av_dlog(s->avctx, AV_LOG_DEBUG, "end skip: %i\n", skip);
+ av_dlog(s->avctx, "end skip: %i\n", skip);
}
}
}
}
- av_dlog(s->avctx, AV_LOG_DEBUG, "Frame done\n");
+ av_dlog(s->avctx, "Frame done\n");
if (s->skip_frame)
s->skip_frame = 0;
skip_bits(&s->gb, s->frame_offset);
}
-/**
- * @brief Decode a single WMA packet.
- * @param avctx codec context
- * @param data the output buffer
- * @param data_size number of bytes that were written to the output buffer
- * @param avpkt input packet
- * @return number of bytes that were read from the input buffer
- */
static int decode_packet(AVCodecContext *avctx, void *data, int *got_frame_ptr,
AVPacket* avpkt)
{
GetBitContext* gb = &s->pgb;
const uint8_t* buf = avpkt->data;
int buf_size = avpkt->size;
- int num_bits_prev_frame, packet_sequence_number,
- seekable_frame_in_packet, spliced_packet;
+ int num_bits_prev_frame, packet_sequence_number, spliced_packet;
+
+ s->frame.nb_samples = 0;
if (s->packet_done || s->packet_loss) {
s->packet_done = 0;
/* parse packet header */
init_get_bits(gb, buf, s->buf_bit_size);
- packet_sequence_number = get_bits(gb, 4);
- seekable_frame_in_packet = get_bits1(gb);
- spliced_packet = get_bits1(gb);
+ packet_sequence_number = get_bits(gb, 4);
+ skip_bits(gb, 1); // Skip seekable_frame_in_packet, currently ununused
+ spliced_packet = get_bits1(gb);
+ if (spliced_packet)
+ av_log_missing_feature(avctx, "Bitstream splicing", 1);
/* get number of bits that need to be added to the previous frame */
num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
save_bits(s, gb, num_bits_prev_frame, 1);
/* decode the cross packet frame if it is valid */
- if (!s->packet_loss)
+ if (num_bits_prev_frame < remaining_packet_bits && !s->packet_loss)
decode_frame(s);
} else if (s->num_saved_bits - s->frame_offset) {
- av_dlog(avctx, AV_LOG_DEBUG, "ignoring %x previously saved bits\n",
+ av_dlog(avctx, "ignoring %x previously saved bits\n",
s->num_saved_bits - s->frame_offset);
}
}
*(AVFrame *)data = s->frame;
- *got_frame_ptr = 1;
+ *got_frame_ptr = s->frame.nb_samples > 0;
s->packet_offset = get_bits_count(gb) & 7;
return (s->packet_loss) ? AVERROR_INVALIDDATA : get_bits_count(gb) >> 3;
}
+static void flush(AVCodecContext *avctx)
+{
+ WmallDecodeCtx *s = avctx->priv_data;
+ s->packet_loss = 1;
+ s->packet_done = 0;
+ s->num_saved_bits = 0;
+ s->frame_offset = 0;
+ s->next_packet_start = 0;
+ s->cdlms[0][0].order = 0;
+ s->frame.nb_samples = 0;
+}
AVCodec ff_wmalossless_decoder = {
.name = "wmalossless",
.type = AVMEDIA_TYPE_AUDIO,
- .id = CODEC_ID_WMALOSSLESS,
+ .id = AV_CODEC_ID_WMALOSSLESS,
.priv_data_size = sizeof(WmallDecodeCtx),
.init = decode_init,
.decode = decode_packet,
- .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1,
+ .flush = flush,
+ .capabilities = CODEC_CAP_SUBFRAMES | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
.long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio Lossless"),
};
projects / ffmpeg / blobdiff