diff options
Diffstat (limited to 'libavcodec/wmaprodec.c')
| -rw-r--r-- | libavcodec/wmaprodec.c | 785 |
1 files changed, 576 insertions, 209 deletions
diff --git a/libavcodec/wmaprodec.c b/libavcodec/wmaprodec.c index 4eaeed610e..d0fa974c80 100644 --- a/libavcodec/wmaprodec.c +++ b/libavcodec/wmaprodec.c @@ -3,20 +3,20 @@ * Copyright (c) 2007 Baptiste Coudurier, Benjamin Larsson, Ulion * Copyright (c) 2008 - 2011 Sascha Sommer, Benjamin Larsson * - * This file is part of Libav. + * This file is part of FFmpeg. * - * Libav is free software; you can redistribute it and/or + * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * Libav is distributed in the hope that it will be useful, + * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with Libav; if not, write to the Free Software + * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ @@ -88,13 +88,13 @@ #include <inttypes.h> +#include "libavutil/ffmath.h" #include "libavutil/float_dsp.h" #include "libavutil/intfloat.h" #include "libavutil/intreadwrite.h" - #include "avcodec.h" -#include "bitstream.h" #include "internal.h" +#include "get_bits.h" #include "put_bits.h" #include "wmaprodata.h" #include "sinewin.h" @@ -106,6 +106,9 @@ #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 XMA_MAX_STREAMS 8 +#define XMA_MAX_CHANNELS_STREAM 2 +#define XMA_MAX_CHANNELS (XMA_MAX_STREAMS * XMA_MAX_CHANNELS_STREAM) #define WMAPRO_BLOCK_MIN_BITS 6 ///< log2 of min block size #define WMAPRO_BLOCK_MAX_BITS 13 ///< log2 of max block size @@ -172,13 +175,13 @@ typedef struct WMAProChannelGrp { typedef struct WMAProDecodeCtx { /* generic decoder variables */ AVCodecContext* avctx; ///< codec context for av_log - AVFloatDSPContext fdsp; + AVFloatDSPContext *fdsp; uint8_t frame_data[MAX_FRAMESIZE + AV_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data PutBitContext pb; ///< context for filling the frame_data buffer FFTContext mdct_ctx[WMAPRO_BLOCK_SIZES]; ///< MDCT context per block size DECLARE_ALIGNED(32, float, tmp)[WMAPRO_BLOCK_MAX_SIZE]; ///< IMDCT output buffer - float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes + const float* windows[WMAPRO_BLOCK_SIZES]; ///< windows for the different block sizes /* frame size dependent frame information (set during initialization) */ uint32_t decode_flags; ///< used compression features @@ -198,7 +201,7 @@ typedef struct WMAProDecodeCtx { int16_t subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values /* packet decode state */ - BitstreamContext pbc; ///< bitstream reader context for the packet + GetBitContext pgb; ///< bitstream reader context for the packet int next_packet_start; ///< start offset of the next wma packet in the demuxer packet uint8_t packet_offset; ///< frame offset in the packet uint8_t packet_sequence_number; ///< current packet number @@ -207,17 +210,20 @@ typedef struct WMAProDecodeCtx { int subframe_offset; ///< subframe offset in the bit reservoir uint8_t packet_loss; ///< set in case of bitstream error uint8_t packet_done; ///< set when a packet is fully decoded + uint8_t eof_done; ///< set when EOF reached and extra subframe is written (XMA1/2) /* frame decode state */ uint32_t frame_num; ///< current frame number (not used for decoding) - BitstreamContext bc; ///< bitstream reader context + GetBitContext gb; ///< bitstream reader context int buf_bit_size; ///< buffer size in bits uint8_t drc_gain; ///< gain for the DRC tool int8_t skip_frame; ///< skip output step int8_t parsed_all_subframes; ///< all subframes decoded? + uint8_t skip_packets; ///< packets to skip to find next packet in a stream (XMA1/2) /* subframe/block decode state */ int16_t subframe_len; ///< current subframe length + int8_t nb_channels; ///< number of channels in stream (XMA1/2) int8_t channels_for_cur_subframe; ///< number of channels that contain the subframe int8_t channel_indexes_for_cur_subframe[WMAPRO_MAX_CHANNELS]; int8_t num_bands; ///< number of scale factor bands @@ -232,6 +238,15 @@ typedef struct WMAProDecodeCtx { WMAProChannelCtx channel[WMAPRO_MAX_CHANNELS]; ///< per channel data } WMAProDecodeCtx; +typedef struct XMADecodeCtx { + WMAProDecodeCtx xma[XMA_MAX_STREAMS]; + AVFrame *frames[XMA_MAX_STREAMS]; + int current_stream; + int num_streams; + float samples[XMA_MAX_CHANNELS][512 * 64]; + int offset[XMA_MAX_STREAMS]; + int start_channel[XMA_MAX_STREAMS]; +} XMADecodeCtx; /** *@brief helper function to print the most important members of the context @@ -248,7 +263,7 @@ static av_cold void dump_context(WMAProDecodeCtx *s) PRINT("log2 frame size", s->log2_frame_size); PRINT("max num subframes", s->max_num_subframes); PRINT("len prefix", s->len_prefix); - PRINT("num channels", s->avctx->channels); + PRINT("num channels", s->nb_channels); } /** @@ -256,52 +271,103 @@ static av_cold void dump_context(WMAProDecodeCtx *s) *@param avctx codec context *@return 0 on success, < 0 otherwise */ -static av_cold int decode_end(AVCodecContext *avctx) +static av_cold int decode_end(WMAProDecodeCtx *s) { - WMAProDecodeCtx *s = avctx->priv_data; int i; + av_freep(&s->fdsp); + for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) ff_mdct_end(&s->mdct_ctx[i]); return 0; } +static av_cold int wmapro_decode_end(AVCodecContext *avctx) +{ + WMAProDecodeCtx *s = avctx->priv_data; + + decode_end(s); + + return 0; +} + +static av_cold int get_rate(AVCodecContext *avctx) +{ + if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { // XXX: is this really only for XMA? + if (avctx->sample_rate > 44100) + return 48000; + else if (avctx->sample_rate > 32000) + return 44100; + else if (avctx->sample_rate > 24000) + return 32000; + return 24000; + } + + return avctx->sample_rate; +} + /** *@brief Initialize the decoder. *@param avctx codec context *@return 0 on success, -1 otherwise */ -static av_cold int decode_init(AVCodecContext *avctx) +static av_cold int decode_init(WMAProDecodeCtx *s, AVCodecContext *avctx, int num_stream) { - WMAProDecodeCtx *s = avctx->priv_data; uint8_t *edata_ptr = avctx->extradata; unsigned int channel_mask; int i, bits; int log2_max_num_subframes; int num_possible_block_sizes; + if (avctx->codec_id == AV_CODEC_ID_XMA1 || avctx->codec_id == AV_CODEC_ID_XMA2) + avctx->block_align = 2048; + if (!avctx->block_align) { av_log(avctx, AV_LOG_ERROR, "block_align is not set\n"); return AVERROR(EINVAL); } s->avctx = avctx; - avpriv_float_dsp_init(&s->fdsp, avctx->flags & AV_CODEC_FLAG_BITEXACT); init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); avctx->sample_fmt = AV_SAMPLE_FMT_FLTP; - if (avctx->extradata_size >= 18) { + /** dump the extradata */ + av_log(avctx, AV_LOG_DEBUG, "extradata:\n"); + for (i = 0; i < avctx->extradata_size; i++) + av_log(avctx, AV_LOG_DEBUG, "[%x] ", avctx->extradata[i]); + av_log(avctx, AV_LOG_DEBUG, "\n"); + + if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */ + s->decode_flags = 0x10d6; + s->bits_per_sample = 16; + channel_mask = 0; //AV_RL32(edata_ptr+2); /* not always in expected order */ + if ((num_stream+1) * XMA_MAX_CHANNELS_STREAM > avctx->channels) /* stream config is 2ch + 2ch + ... + 1/2ch */ + s->nb_channels = 1; + else + s->nb_channels = 2; + } else if (avctx->codec_id == AV_CODEC_ID_XMA2) { /* XMA2WAVEFORMAT */ + s->decode_flags = 0x10d6; + s->bits_per_sample = 16; + channel_mask = 0; /* would need to aggregate from all streams */ + s->nb_channels = edata_ptr[32 + ((edata_ptr[0]==3)?0:8) + 4*num_stream + 0]; /* nth stream config */ + } else if (avctx->codec_id == AV_CODEC_ID_XMA1) { /* XMAWAVEFORMAT */ + s->decode_flags = 0x10d6; + s->bits_per_sample = 16; + channel_mask = 0; /* would need to aggregate from all streams */ + s->nb_channels = edata_ptr[8 + 20*num_stream + 17]; /* nth stream config */ + } else if (avctx->codec_id == AV_CODEC_ID_WMAPRO && avctx->extradata_size >= 18) { s->decode_flags = AV_RL16(edata_ptr+14); channel_mask = AV_RL32(edata_ptr+2); s->bits_per_sample = AV_RL16(edata_ptr); - /** dump the extradata */ - for (i = 0; i < avctx->extradata_size; i++) - ff_dlog(avctx, "[%x] ", avctx->extradata[i]); - ff_dlog(avctx, "\n"); + s->nb_channels = avctx->channels; + if (s->bits_per_sample > 32 || s->bits_per_sample < 1) { + avpriv_request_sample(avctx, "bits per sample is %d", s->bits_per_sample); + return AVERROR_PATCHWELCOME; + } } else { avpriv_request_sample(avctx, "Unknown extradata size"); return AVERROR_PATCHWELCOME; @@ -309,19 +375,31 @@ static av_cold int decode_init(AVCodecContext *avctx) /** generic init */ s->log2_frame_size = av_log2(avctx->block_align) + 4; + if (s->log2_frame_size > 25) { + avpriv_request_sample(avctx, "Large block align"); + return AVERROR_PATCHWELCOME; + } /** frame info */ - s->skip_frame = 1; /* skip first frame */ + if (avctx->codec_id != AV_CODEC_ID_WMAPRO) + s->skip_frame = 0; + else + s->skip_frame = 1; /* skip first frame */ + s->packet_loss = 1; s->len_prefix = (s->decode_flags & 0x40); /** get frame len */ - bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags); - if (bits > WMAPRO_BLOCK_MAX_BITS) { - avpriv_request_sample(avctx, "14-bit block sizes"); - return AVERROR_PATCHWELCOME; + if (avctx->codec_id == AV_CODEC_ID_WMAPRO) { + bits = ff_wma_get_frame_len_bits(avctx->sample_rate, 3, s->decode_flags); + if (bits > WMAPRO_BLOCK_MAX_BITS) { + avpriv_request_sample(avctx, "14-bit block sizes"); + return AVERROR_PATCHWELCOME; + } + s->samples_per_frame = 1 << bits; + } else { + s->samples_per_frame = 512; } - s->samples_per_frame = 1 << bits; /** subframe info */ log2_max_num_subframes = ((s->decode_flags & 0x38) >> 3); @@ -341,8 +419,8 @@ static av_cold int decode_init(AVCodecContext *avctx) } if (s->min_samples_per_subframe < WMAPRO_BLOCK_MIN_SIZE) { - av_log(avctx, AV_LOG_ERROR, "Invalid minimum block size %"PRId8"\n", - s->max_num_subframes); + av_log(avctx, AV_LOG_ERROR, "min_samples_per_subframe of %d too small\n", + s->min_samples_per_subframe); return AVERROR_INVALIDDATA; } @@ -351,18 +429,22 @@ static av_cold int decode_init(AVCodecContext *avctx) return AVERROR_INVALIDDATA; } - if (avctx->channels < 0) { + if (s->nb_channels <= 0) { av_log(avctx, AV_LOG_ERROR, "invalid number of channels %d\n", - avctx->channels); + s->nb_channels); + return AVERROR_INVALIDDATA; + } else if (avctx->codec_id != AV_CODEC_ID_WMAPRO && s->nb_channels > XMA_MAX_CHANNELS_STREAM) { + av_log(avctx, AV_LOG_ERROR, "invalid number of channels per XMA stream %d\n", + s->nb_channels); return AVERROR_INVALIDDATA; - } else if (avctx->channels > WMAPRO_MAX_CHANNELS) { + } else if (s->nb_channels > WMAPRO_MAX_CHANNELS) { avpriv_request_sample(avctx, "More than %d channels", WMAPRO_MAX_CHANNELS); return AVERROR_PATCHWELCOME; } /** init previous block len */ - for (i = 0; i < avctx->channels; i++) + for (i = 0; i < s->nb_channels; i++) s->channel[i].prev_block_len = s->samples_per_frame; /** extract lfe channel position */ @@ -410,18 +492,25 @@ static av_cold int decode_init(AVCodecContext *avctx) int subframe_len = s->samples_per_frame >> i; int x; int band = 1; + int rate = get_rate(avctx); s->sfb_offsets[i][0] = 0; for (x = 0; x < MAX_BANDS-1 && s->sfb_offsets[i][band - 1] < subframe_len; x++) { - int offset = (subframe_len * 2 * critical_freq[x]) - / s->avctx->sample_rate + 2; + int offset = (subframe_len * 2 * critical_freq[x]) / rate + 2; offset &= ~3; if (offset > s->sfb_offsets[i][band - 1]) s->sfb_offsets[i][band++] = offset; + + if (offset >= subframe_len) + break; } s->sfb_offsets[i][band - 1] = subframe_len; s->num_sfb[i] = band - 1; + if (s->num_sfb[i] <= 0) { + av_log(avctx, AV_LOG_ERROR, "num_sfb invalid\n"); + return AVERROR_INVALIDDATA; + } } @@ -438,14 +527,19 @@ static av_cold int decode_init(AVCodecContext *avctx) + s->sfb_offsets[i][b + 1] - 1) << i) >> 1; for (x = 0; x < num_possible_block_sizes; x++) { int v = 0; - while (s->sfb_offsets[x][v + 1] << x < offset) - if (++v >= MAX_BANDS) - return AVERROR_INVALIDDATA; + while (s->sfb_offsets[x][v + 1] << x < offset) { + v++; + av_assert0(v < MAX_BANDS); + } s->sf_offsets[i][x][b] = v; } } } + s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT); + if (!s->fdsp) + return AVERROR(ENOMEM); + /** init MDCT, FIXME: only init needed sizes */ for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) ff_mdct_init(&s->mdct_ctx[i], WMAPRO_BLOCK_MIN_BITS+1+i, 1, @@ -462,7 +556,7 @@ static av_cold int decode_init(AVCodecContext *avctx) /** calculate subwoofer cutoff values */ for (i = 0; i < num_possible_block_sizes; i++) { int block_size = s->samples_per_frame >> i; - int cutoff = (440*block_size + 3 * (s->avctx->sample_rate >> 1) - 1) + int cutoff = (440*block_size + 3LL * (s->avctx->sample_rate >> 1) - 1) / s->avctx->sample_rate; s->subwoofer_cutoffs[i] = av_clip(cutoff, 4, block_size); } @@ -480,6 +574,18 @@ static av_cold int decode_init(AVCodecContext *avctx) } /** + *@brief Initialize the decoder. + *@param avctx codec context + *@return 0 on success, -1 otherwise + */ +static av_cold int wmapro_decode_init(AVCodecContext *avctx) +{ + WMAProDecodeCtx *s = avctx->priv_data; + + return decode_init(s, avctx, 0); +} + +/** *@brief Decode the subframe length. *@param s context *@param offset sample offset in the frame @@ -494,13 +600,15 @@ static int decode_subframe_length(WMAProDecodeCtx *s, int offset) if (offset == s->samples_per_frame - s->min_samples_per_subframe) return s->min_samples_per_subframe; + if (get_bits_left(&s->gb) < 1) + return AVERROR_INVALIDDATA; + /** 1 bit indicates if the subframe is of maximum length */ if (s->max_subframe_len_bit) { - if (bitstream_read_bit(&s->bc)) - frame_len_shift = 1 + bitstream_read(&s->bc, - s->subframe_len_bits - 1); + if (get_bits1(&s->gb)) + frame_len_shift = 1 + get_bits(&s->gb, s->subframe_len_bits-1); } else - frame_len_shift = bitstream_read(&s->bc, s->subframe_len_bits); + frame_len_shift = get_bits(&s->gb, s->subframe_len_bits); subframe_len = s->samples_per_frame >> frame_len_shift; @@ -538,7 +646,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s) { uint16_t num_samples[WMAPRO_MAX_CHANNELS] = { 0 };/**< sum of samples for all currently known subframes of a channel */ uint8_t contains_subframe[WMAPRO_MAX_CHANNELS]; /**< flag indicating if a channel contains the current subframe */ - int channels_for_cur_subframe = s->avctx->channels; /**< number of channels that contain the current subframe */ + int channels_for_cur_subframe = s->nb_channels; /**< number of channels that contain the current subframe */ int fixed_channel_layout = 0; /**< flag indicating that all channels use the same subframe offsets and sizes */ int min_channel_len = 0; /**< smallest sum of samples (channels with this length will be processed first) */ int c; @@ -550,10 +658,10 @@ static int decode_tilehdr(WMAProDecodeCtx *s) */ /** reset tiling information */ - for (c = 0; c < s->avctx->channels; c++) + for (c = 0; c < s->nb_channels; c++) s->channel[c].num_subframes = 0; - if (s->max_num_subframes == 1 || bitstream_read_bit(&s->bc)) + if (s->max_num_subframes == 1 || get_bits1(&s->gb)) fixed_channel_layout = 1; /** loop until the frame data is split between the subframes */ @@ -561,13 +669,13 @@ static int decode_tilehdr(WMAProDecodeCtx *s) int subframe_len; /** check which channels contain the subframe */ - for (c = 0; c < s->avctx->channels; c++) { + for (c = 0; c < s->nb_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; else - contains_subframe[c] = bitstream_read_bit(&s->bc); + contains_subframe[c] = get_bits1(&s->gb); } else contains_subframe[c] = 0; } @@ -578,7 +686,7 @@ static int decode_tilehdr(WMAProDecodeCtx *s) /** add subframes to the individual channels and find new min_channel_len */ min_channel_len += subframe_len; - for (c = 0; c < s->avctx->channels; c++) { + for (c = 0; c < s->nb_channels; c++) { WMAProChannelCtx* chan = &s->channel[c]; if (contains_subframe[c]) { @@ -605,12 +713,12 @@ static int decode_tilehdr(WMAProDecodeCtx *s) } } while (min_channel_len < s->samples_per_frame); - for (c = 0; c < s->avctx->channels; c++) { + for (c = 0; c < s->nb_channels; c++) { int i; int offset = 0; for (i = 0; i < s->channel[c].num_subframes; i++) { - ff_dlog(s->avctx, "frame[%"PRIi32"] channel[%i] subframe[%i]" - " len %"PRIu16"\n", s->frame_num, c, i, + ff_dlog(s->avctx, "frame[%"PRIu32"] channel[%i] subframe[%i]" + " len %i\n", s->frame_num, c, i, s->channel[c].subframe_len[i]); s->channel[c].subframe_offset[i] = offset; offset += s->channel[c].subframe_len[i]; @@ -631,15 +739,15 @@ static void decode_decorrelation_matrix(WMAProDecodeCtx *s, int i; int offset = 0; int8_t rotation_offset[WMAPRO_MAX_CHANNELS * WMAPRO_MAX_CHANNELS]; - memset(chgroup->decorrelation_matrix, 0, s->avctx->channels * - s->avctx->channels * sizeof(*chgroup->decorrelation_matrix)); + memset(chgroup->decorrelation_matrix, 0, s->nb_channels * + s->nb_channels * sizeof(*chgroup->decorrelation_matrix)); for (i = 0; i < chgroup->num_channels * (chgroup->num_channels - 1) >> 1; i++) - rotation_offset[i] = bitstream_read(&s->bc, 6); + rotation_offset[i] = get_bits(&s->gb, 6); for (i = 0; i < chgroup->num_channels; i++) chgroup->decorrelation_matrix[chgroup->num_channels * i + i] = - bitstream_read_bit(&s->bc) ? 1.0 : -1.0; + get_bits1(&s->gb) ? 1.0 : -1.0; for (i = 1; i < chgroup->num_channels; i++) { int x; @@ -673,7 +781,7 @@ static void decode_decorrelation_matrix(WMAProDecodeCtx *s, /** *@brief Decode channel transformation parameters *@param s codec context - *@return 0 in case of success, < 0 in case of bitstream errors + *@return >= 0 in case of success, < 0 in case of bitstream errors */ static int decode_channel_transform(WMAProDecodeCtx* s) { @@ -685,10 +793,10 @@ static int decode_channel_transform(WMAProDecodeCtx* s) /** in the one channel case channel transforms are pointless */ s->num_chgroups = 0; - if (s->avctx->channels > 1) { + if (s->nb_channels > 1) { int remaining_channels = s->channels_for_cur_subframe; - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { avpriv_request_sample(s->avctx, "Channel transform bit"); return AVERROR_PATCHWELCOME; @@ -706,7 +814,7 @@ static int decode_channel_transform(WMAProDecodeCtx* s) for (i = 0; i < s->channels_for_cur_subframe; i++) { int channel_idx = s->channel_indexes_for_cur_subframe[i]; if (!s->channel[channel_idx].grouped - && bitstream_read_bit(&s->bc)) { + && get_bits1(&s->gb)) { ++chgroup->num_channels; s->channel[channel_idx].grouped = 1; *channel_data++ = s->channel[channel_idx].coeffs; @@ -724,15 +832,15 @@ static int decode_channel_transform(WMAProDecodeCtx* s) /** decode transform type */ if (chgroup->num_channels == 2) { - if (bitstream_read_bit(&s->bc)) { - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { + if (get_bits1(&s->gb)) { avpriv_request_sample(s->avctx, "Unknown channel transform type"); return AVERROR_PATCHWELCOME; } } else { chgroup->transform = 1; - if (s->avctx->channels == 2) { + if (s->nb_channels == 2) { chgroup->decorrelation_matrix[0] = 1.0; chgroup->decorrelation_matrix[1] = -1.0; chgroup->decorrelation_matrix[2] = 1.0; @@ -746,9 +854,9 @@ static int decode_channel_transform(WMAProDecodeCtx* s) } } } else if (chgroup->num_channels > 2) { - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { chgroup->transform = 1; - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { decode_decorrelation_matrix(s, chgroup); } else { /** FIXME: more than 6 coupled channels not supported */ @@ -767,11 +875,11 @@ static int decode_channel_transform(WMAProDecodeCtx* s) /** decode transform on / off */ if (chgroup->transform) { - if (!bitstream_read_bit(&s->bc)) { + if (!get_bits1(&s->gb)) { int i; /** transform can be enabled for individual bands */ for (i = 0; i < s->num_bands; i++) { - chgroup->transform_band[i] = bitstream_read_bit(&s->bc); + chgroup->transform_band[i] = get_bits1(&s->gb); } } else { memset(chgroup->transform_band, 1, s->num_bands); @@ -811,7 +919,7 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c) ff_dlog(s->avctx, "decode coefficients for channel %i\n", c); - vlctable = bitstream_read_bit(&s->bc); + vlctable = get_bits1(&s->gb); vlc = &coef_vlc[vlctable]; if (vlctable) { @@ -830,19 +938,19 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c) int i; unsigned int idx; - idx = bitstream_read_vlc(&s->bc, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); + idx = get_vlc2(&s->gb, vec4_vlc.table, VLCBITS, VEC4MAXDEPTH); if (idx == HUFF_VEC4_SIZE - 1) { for (i = 0; i < 4; i += 2) { - idx = bitstream_read_vlc(&s->bc, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); + idx = get_vlc2(&s->gb, vec2_vlc.table, VLCBITS, VEC2MAXDEPTH); if (idx == HUFF_VEC2_SIZE - 1) { uint32_t v0, v1; - v0 = bitstream_read_vlc(&s->bc, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); + v0 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); if (v0 == HUFF_VEC1_SIZE - 1) - v0 += ff_wma_get_large_val(&s->bc); - v1 = bitstream_read_vlc(&s->bc, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); + v0 += ff_wma_get_large_val(&s->gb); + v1 = get_vlc2(&s->gb, vec1_vlc.table, VLCBITS, VEC1MAXDEPTH); if (v1 == HUFF_VEC1_SIZE - 1) - v1 += ff_wma_get_large_val(&s->bc); + v1 += ff_wma_get_large_val(&s->gb); vals[i ] = av_float2int(v0); vals[i+1] = av_float2int(v1); } else { @@ -860,7 +968,7 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c) /** decode sign */ for (i = 0; i < 4; i++) { if (vals[i]) { - uint32_t sign = bitstream_read_bit(&s->bc) - 1; + uint32_t sign = get_bits1(&s->gb) - 1; AV_WN32A(&ci->coeffs[cur_coeff], vals[i] ^ sign << 31); num_zeros = 0; } else { @@ -877,7 +985,7 @@ static int decode_coeffs(WMAProDecodeCtx *s, int c) if (cur_coeff < s->subframe_len) { memset(&ci->coeffs[cur_coeff], 0, sizeof(*ci->coeffs) * (s->subframe_len - cur_coeff)); - if (ff_wma_run_level_decode(s->avctx, &s->bc, vlc, + if (ff_wma_run_level_decode(s->avctx, &s->gb, vlc, level, run, 1, ci->coeffs, cur_coeff, s->subframe_len, s->subframe_len, s->esc_len, 0)) @@ -920,14 +1028,15 @@ static int decode_scale_factors(WMAProDecodeCtx* s) s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++]; } - if (!s->channel[c].cur_subframe || bitstream_read_bit(&s->bc)) { + if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) { + if (!s->channel[c].reuse_sf) { int val; /** decode DPCM coded scale factors */ - s->channel[c].scale_factor_step = bitstream_read(&s->bc, 2) + 1; + s->channel[c].scale_factor_step = get_bits(&s->gb, 2) + 1; val = 45 / s->channel[c].scale_factor_step; for (sf = s->channel[c].scale_factors; sf < sf_end; sf++) { - val += bitstream_read_vlc(&s->bc, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60; + val += get_vlc2(&s->gb, sf_vlc.table, SCALEVLCBITS, SCALEMAXDEPTH) - 60; *sf = val; } } else { @@ -939,10 +1048,10 @@ static int decode_scale_factors(WMAProDecodeCtx* s) int val; int sign; - idx = bitstream_read_vlc(&s->bc, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); + idx = get_vlc2(&s->gb, sf_rl_vlc.table, VLCBITS, SCALERLMAXDEPTH); if (!idx) { - uint32_t code = bitstream_read(&s->bc, 14); + uint32_t code = get_bits(&s->gb, 14); val = code >> 6; sign = (code & 1) - 1; skip = (code & 0x3f) >> 1; @@ -951,7 +1060,7 @@ static int decode_scale_factors(WMAProDecodeCtx* s) } else { skip = scale_rl_run[idx]; val = scale_rl_level[idx]; - sign = bitstream_read_bit(&s->bc)-1; + sign = get_bits1(&s->gb)-1; } i += skip; @@ -1021,12 +1130,12 @@ static void inverse_channel_transform(WMAProDecodeCtx *s) (*ch)[y] = sum; } } - } else if (s->avctx->channels == 2) { + } else if (s->nb_channels == 2) { int len = FFMIN(sfb[1], s->subframe_len) - sfb[0]; - s->fdsp.vector_fmul_scalar(ch_data[0] + sfb[0], + s->fdsp->vector_fmul_scalar(ch_data[0] + sfb[0], ch_data[0] + sfb[0], 181.0 / 128, len); - s->fdsp.vector_fmul_scalar(ch_data[1] + sfb[0], + s->fdsp->vector_fmul_scalar(ch_data[1] + sfb[0], ch_data[1] + sfb[0], 181.0 / 128, len); } @@ -1044,7 +1153,7 @@ static void wmapro_window(WMAProDecodeCtx *s) int i; for (i = 0; i < s->channels_for_cur_subframe; i++) { int c = s->channel_indexes_for_cur_subframe[i]; - float* window; + const float* window; int winlen = s->channel[c].prev_block_len; float* start = s->channel[c].coeffs - (winlen >> 1); @@ -1057,7 +1166,7 @@ static void wmapro_window(WMAProDecodeCtx *s) winlen >>= 1; - s->fdsp.vector_fmul_window(start, start, start + winlen, + s->fdsp->vector_fmul_window(start, start, start + winlen, window, winlen); s->channel[c].prev_block_len = s->subframe_len; @@ -1074,17 +1183,17 @@ static int decode_subframe(WMAProDecodeCtx *s) int offset = s->samples_per_frame; int subframe_len = s->samples_per_frame; int i; - int total_samples = s->samples_per_frame * s->avctx->channels; + int total_samples = s->samples_per_frame * s->nb_channels; int transmit_coeffs = 0; int cur_subwoofer_cutoff; - s->subframe_offset = bitstream_tell(&s->bc); + s->subframe_offset = get_bits_count(&s->gb); /** reset channel context and find the next block offset and size == the next block of the channel with the smallest number of decoded samples */ - for (i = 0; i < s->avctx->channels; i++) { + for (i = 0; i < s->nb_channels; i++) { s->channel[i].grouped = 0; if (offset > s->channel[i].decoded_samples) { offset = s->channel[i].decoded_samples; @@ -1098,7 +1207,7 @@ static int decode_subframe(WMAProDecodeCtx *s) /** get a list of all channels that contain the estimated block */ s->channels_for_cur_subframe = 0; - for (i = 0; i < s->avctx->channels; i++) { + for (i = 0; i < s->nb_channels; i++) { const int cur_subframe = s->channel[i].cur_subframe; /** subtract already processed samples */ total_samples -= s->channel[i].decoded_samples; @@ -1142,25 +1251,25 @@ static int decode_subframe(WMAProDecodeCtx *s) s->esc_len = av_log2(s->subframe_len - 1) + 1; /** skip extended header if any */ - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { int num_fill_bits; - if (!(num_fill_bits = bitstream_read(&s->bc, 2))) { - int len = bitstream_read(&s->bc, 4); - num_fill_bits = bitstream_read(&s->bc, len) + 1; + if (!(num_fill_bits = get_bits(&s->gb, 2))) { + int len = get_bits(&s->gb, 4); + num_fill_bits = get_bitsz(&s->gb, len) + 1; } if (num_fill_bits >= 0) { - if (bitstream_tell(&s->bc) + num_fill_bits > s->num_saved_bits) { + if (get_bits_count(&s->gb) + num_fill_bits > s->num_saved_bits) { av_log(s->avctx, AV_LOG_ERROR, "invalid number of fill bits\n"); return AVERROR_INVALIDDATA; } - bitstream_skip(&s->bc, num_fill_bits); + skip_bits_long(&s->gb, num_fill_bits); } } /** no idea for what the following bit is used */ - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { avpriv_request_sample(s->avctx, "Reserved bit"); return AVERROR_PATCHWELCOME; } @@ -1172,24 +1281,26 @@ static int decode_subframe(WMAProDecodeCtx *s) for (i = 0; i < s->channels_for_cur_subframe; i++) { int c = s->channel_indexes_for_cur_subframe[i]; - if ((s->channel[c].transmit_coefs = bitstream_read_bit(&s->bc))) + if ((s->channel[c].transmit_coefs = get_bits1(&s->gb))) transmit_coeffs = 1; } + av_assert0(s->subframe_len <= WMAPRO_BLOCK_MAX_SIZE); if (transmit_coeffs) { int step; int quant_step = 90 * s->bits_per_sample >> 4; /** decode number of vector coded coefficients */ - if ((s->transmit_num_vec_coeffs = bitstream_read_bit(&s->bc))) { + if ((s->transmit_num_vec_coeffs = get_bits1(&s->gb))) { int num_bits = av_log2((s->subframe_len + 3)/4) + 1; for (i = 0; i < s->channels_for_cur_subframe; i++) { int c = s->channel_indexes_for_cur_subframe[i]; - int num_vec_coeffs = bitstream_read(&s->bc, num_bits) << 2; - if (num_vec_coeffs + offset > FF_ARRAY_ELEMS(s->channel[c].out)) { + int num_vec_coeffs = get_bits(&s->gb, num_bits) << 2; + if (num_vec_coeffs > s->subframe_len) { av_log(s->avctx, AV_LOG_ERROR, "num_vec_coeffs %d is too large\n", num_vec_coeffs); return AVERROR_INVALIDDATA; } + av_assert0(num_vec_coeffs + offset <= FF_ARRAY_ELEMS(s->channel[c].out)); s->channel[c].num_vec_coeffs = num_vec_coeffs; } } else { @@ -1199,13 +1310,13 @@ static int decode_subframe(WMAProDecodeCtx *s) } } /** decode quantization step */ - step = bitstream_read_signed(&s->bc, 6); + step = get_sbits(&s->gb, 6); quant_step += step; if (step == -32 || step == 31) { const int sign = (step == 31) - 1; int quant = 0; - while (bitstream_tell(&s->bc) + 5 < s->num_saved_bits && - (step = bitstream_read(&s->bc, 5)) == 31) { + while (get_bits_count(&s->gb) + 5 < s->num_saved_bits && + (step = get_bits(&s->gb, 5)) == 31) { quant += 31; } quant_step += ((quant + step) ^ sign) - sign; @@ -1219,13 +1330,13 @@ static int decode_subframe(WMAProDecodeCtx *s) if (s->channels_for_cur_subframe == 1) { s->channel[s->channel_indexes_for_cur_subframe[0]].quant_step = quant_step; } else { - int modifier_len = bitstream_read(&s->bc, 3); + int modifier_len = get_bits(&s->gb, 3); for (i = 0; i < s->channels_for_cur_subframe; i++) { int c = s->channel_indexes_for_cur_subframe[i]; s->channel[c].quant_step = quant_step; - if (bitstream_read_bit(&s->bc)) { + if (get_bits1(&s->gb)) { if (modifier_len) { - s->channel[c].quant_step += bitstream_read(&s->bc, modifier_len) + 1; + s->channel[c].quant_step += get_bits(&s->gb, modifier_len) + 1; } else ++s->channel[c].quant_step; } @@ -1238,13 +1349,13 @@ static int decode_subframe(WMAProDecodeCtx *s) } ff_dlog(s->avctx, "BITSTREAM: subframe header length was %i\n", - bitstream_tell(&s->bc) - s->subframe_offset); + get_bits_count(&s->gb) - s->subframe_offset); /** parse coefficients */ for (i = 0; i < s->channels_for_cur_subframe; i++) { int c = s->channel_indexes_for_cur_subframe[i]; if (s->channel[c].transmit_coefs && - bitstream_tell(&s->bc) < s->num_saved_bits) { + get_bits_count(&s->gb) < s->num_saved_bits) { decode_coeffs(s, c); } else memset(s->channel[c].coeffs, 0, @@ -1252,7 +1363,7 @@ static int decode_subframe(WMAProDecodeCtx *s) } ff_dlog(s->avctx, "BITSTREAM: subframe length was %i\n", - bitstream_tell(&s->bc) - s->subframe_offset); + get_bits_count(&s->gb) - s->subframe_offset); if (transmit_coeffs) { FFTContext *mdct = &s->mdct_ctx[av_log2(subframe_len) - WMAPRO_BLOCK_MIN_BITS]; @@ -1273,9 +1384,9 @@ static int decode_subframe(WMAProDecodeCtx *s) const int exp = s->channel[c].quant_step - (s->channel[c].max_scale_factor - *sf++) * s->channel[c].scale_factor_step; - const float quant = pow(10.0, exp / 20.0); + const float quant = ff_exp10(exp / 20.0); int start = s->cur_sfb_offsets[b]; - s->fdsp.vector_fmul_scalar(s->tmp + start, + s->fdsp->vector_fmul_scalar(s->tmp + start, s->channel[c].coeffs + start, quant, end - start); } @@ -1309,15 +1420,14 @@ static int decode_subframe(WMAProDecodeCtx *s) */ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr) { - AVCodecContext *avctx = s->avctx; - BitstreamContext *bc = &s->bc; + GetBitContext* gb = &s->gb; int more_frames = 0; int len = 0; - int i, ret; + int i; /** get frame length */ if (s->len_prefix) - len = bitstream_read(bc, s->log2_frame_size); + len = get_bits(gb, s->log2_frame_size); ff_dlog(s->avctx, "decoding frame with length %x\n", len); @@ -1328,44 +1438,44 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr) } /** read postproc transform */ - if (s->avctx->channels > 1 && bitstream_read_bit(bc)) { - if (bitstream_read_bit(bc)) { - for (i = 0; i < avctx->channels * avctx->channels; i++) - bitstream_skip(bc, 4); + if (s->nb_channels > 1 && get_bits1(gb)) { + if (get_bits1(gb)) { + for (i = 0; i < s->nb_channels * s->nb_channels; i++) + skip_bits(gb, 4); } } /** read drc info */ if (s->dynamic_range_compression) { - s->drc_gain = bitstream_read(bc, 8); + s->drc_gain = get_bits(gb, 8); ff_dlog(s->avctx, "drc_gain %i\n", s->drc_gain); } /** 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 (bitstream_read_bit(bc)) { + if (get_bits1(gb)) { int av_unused skip; /** usually true for the first frame */ - if (bitstream_read_bit(bc)) { - skip = bitstream_read(bc, av_log2(s->samples_per_frame * 2)); + if (get_bits1(gb)) { + skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); ff_dlog(s->avctx, "start skip: %i\n", skip); } /** sometimes true for the last frame */ - if (bitstream_read_bit(bc)) { - skip = bitstream_read(bc, av_log2(s->samples_per_frame * 2)); + if (get_bits1(gb)) { + skip = get_bits(gb, av_log2(s->samples_per_frame * 2)); ff_dlog(s->avctx, "end skip: %i\n", skip); } } ff_dlog(s->avctx, "BITSTREAM: frame header length was %i\n", - bitstream_tell(bc) - s->frame_offset); + get_bits_count(gb) - s->frame_offset); /** reset subframe states */ s->parsed_all_subframes = 0; - for (i = 0; i < avctx->channels; i++) { + for (i = 0; i < s->nb_channels; i++) { s->channel[i].decoded_samples = 0; s->channel[i].cur_subframe = 0; s->channel[i].reuse_sf = 0; @@ -1379,20 +1489,12 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr) } } - /* get output buffer */ - frame->nb_samples = s->samples_per_frame; - if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) { - av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); - s->packet_loss = 1; - return 0; - } - /** copy samples to the output buffer */ - for (i = 0; i < avctx->channels; i++) + for (i = 0; i < s->nb_channels; i++) memcpy(frame->extended_data[i], s->channel[i].out, s->samples_per_frame * sizeof(*s->channel[i].out)); - for (i = 0; i < avctx->channels; i++) { + for (i = 0; i < s->nb_channels; i++) { /** reuse second half of the IMDCT output for the next frame */ memcpy(&s->channel[i].out[0], &s->channel[i].out[s->samples_per_frame], @@ -1408,25 +1510,25 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr) } if (s->len_prefix) { - if (len != (bitstream_tell(bc) - s->frame_offset) + 2) { + if (len != (get_bits_count(gb) - s->frame_offset) + 2) { /** FIXME: not sure if this is always an error */ av_log(s->avctx, AV_LOG_ERROR, "frame[%"PRIu32"] would have to skip %i bits\n", s->frame_num, - len - (bitstream_tell(bc) - s->frame_offset) - 1); + len - (get_bits_count(gb) - s->frame_offset) - 1); s->packet_loss = 1; return 0; } /** skip the rest of the frame data */ - bitstream_skip(bc, len - (bitstream_tell(bc) - s->frame_offset) - 1); + skip_bits_long(gb, len - (get_bits_count(gb) - s->frame_offset) - 1); } else { - while (bitstream_tell(bc) < s->num_saved_bits && bitstream_read_bit(bc) == 0) { + while (get_bits_count(gb) < s->num_saved_bits && get_bits1(gb) == 0) { } } /** decode trailer bit */ - more_frames = bitstream_read_bit(bc); + more_frames = get_bits1(gb); ++s->frame_num; return more_frames; @@ -1435,22 +1537,22 @@ static int decode_frame(WMAProDecodeCtx *s, AVFrame *frame, int *got_frame_ptr) /** *@brief Calculate remaining input buffer length. *@param s codec context - *@param bc bitstream reader context + *@param gb bitstream reader context *@return remaining size in bits */ -static int remaining_bits(WMAProDecodeCtx *s, BitstreamContext *bc) +static int remaining_bits(WMAProDecodeCtx *s, GetBitContext *gb) { - return s->buf_bit_size - bitstream_tell(bc); + return s->buf_bit_size - get_bits_count(gb); } /** *@brief Fill the bit reservoir with a (partial) frame. *@param s codec context - *@param bc bitstream reader context + *@param gb bitstream reader context *@param len length of the partial frame *@param append decides whether to reset the buffer or not */ -static void save_bits(WMAProDecodeCtx *s, BitstreamContext *bc, int len, +static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len, int append) { int buflen; @@ -1460,12 +1562,12 @@ static void save_bits(WMAProDecodeCtx *s, BitstreamContext *bc, int len, and skipped later so that a fast byte copy is possible */ if (!append) { - s->frame_offset = bitstream_tell(bc) & 7; + s->frame_offset = get_bits_count(gb) & 7; s->num_saved_bits = s->frame_offset; init_put_bits(&s->pb, s->frame_data, MAX_FRAMESIZE); } - buflen = (s->num_saved_bits + len + 8) >> 3; + buflen = (put_bits_count(&s->pb) + len + 8) >> 3; if (len <= 0 || buflen > MAX_FRAMESIZE) { avpriv_request_sample(s->avctx, "Too small input buffer"); @@ -1473,48 +1575,34 @@ static void save_bits(WMAProDecodeCtx *s, BitstreamContext *bc, int len, return; } - if (len > put_bits_left(&s->pb)) { - av_log(s->avctx, AV_LOG_ERROR, - "Cannot append %d bits, only %d bits available.\n", - len, put_bits_left(&s->pb)); - s->packet_loss = 1; - return; - } + av_assert0(len <= put_bits_left(&s->pb)); s->num_saved_bits += len; if (!append) { - avpriv_copy_bits(&s->pb, bc->buffer + (bitstream_tell(bc) >> 3), - s->num_saved_bits); + avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), + s->num_saved_bits); } else { - int align = 8 - (bitstream_tell(bc) & 7); + int align = 8 - (get_bits_count(gb) & 7); align = FFMIN(align, len); - put_bits(&s->pb, align, bitstream_read(bc, align)); + put_bits(&s->pb, align, get_bits(gb, align)); len -= align; - avpriv_copy_bits(&s->pb, bc->buffer + (bitstream_tell(bc) >> 3), len); + avpriv_copy_bits(&s->pb, gb->buffer + (get_bits_count(gb) >> 3), len); } - bitstream_skip(bc, len); + skip_bits_long(gb, len); { PutBitContext tmp = s->pb; flush_put_bits(&tmp); } - bitstream_init(&s->bc, s->frame_data, s->num_saved_bits); - bitstream_skip(&s->bc, s->frame_offset); + init_get_bits(&s->gb, s->frame_data, s->num_saved_bits); + skip_bits(&s->gb, s->frame_offset); } -/** - *@brief Decode a single WMA packet. - *@param avctx codec context - *@param data 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) +static int decode_packet(AVCodecContext *avctx, WMAProDecodeCtx *s, + void *data, int *got_frame_ptr, AVPacket *avpkt) { - WMAProDecodeCtx *s = avctx->priv_data; - BitstreamContext *bc = &s->pbc; + GetBitContext* gb = &s->pgb; const uint8_t* buf = avpkt->data; int buf_size = avpkt->size; int num_bits_prev_frame; @@ -1522,32 +1610,76 @@ static int decode_packet(AVCodecContext *avctx, void *data, *got_frame_ptr = 0; - if (s->packet_done || s->packet_loss) { + if (!buf_size) { + AVFrame *frame = data; + int i; + + /** Must output remaining samples after stream end. WMAPRO 5.1 created + * by XWMA encoder don't though (maybe only 1/2ch streams need it). */ + s->packet_done = 0; + if (s->eof_done) + return 0; + + /** clean output buffer and copy last IMDCT samples */ + for (i = 0; i < s->nb_channels; i++) { + memset(frame->extended_data[i], 0, + s->samples_per_frame * sizeof(*s->channel[i].out)); + + memcpy(frame->extended_data[i], s->channel[i].out, + s->samples_per_frame * sizeof(*s->channel[i].out) >> 1); + } + + /* TODO: XMA should output 128 samples only (instead of 512) and WMAPRO + * maybe 768 (with 2048), XMA needs changes in multi-stream handling though. */ + + s->eof_done = 1; + s->packet_done = 1; + *got_frame_ptr = 1; + return 0; + } + else if (s->packet_done || s->packet_loss) { s->packet_done = 0; /** sanity check for the buffer length */ - if (buf_size < avctx->block_align) { + if (avctx->codec_id == AV_CODEC_ID_WMAPRO && buf_size < avctx->block_align) { av_log(avctx, AV_LOG_ERROR, "Input packet too small (%d < %d)\n", buf_size, avctx->block_align); return AVERROR_INVALIDDATA; } - s->next_packet_start = buf_size - avctx->block_align; - buf_size = avctx->block_align; + if (avctx->codec_id == AV_CODEC_ID_WMAPRO) { + s->next_packet_start = buf_size - avctx->block_align; + buf_size = avctx->block_align; + } else { + s->next_packet_start = buf_size - FFMIN(buf_size, avctx->block_align); + buf_size = FFMIN(buf_size, avctx->block_align); + } s->buf_bit_size = buf_size << 3; /** parse packet header */ - bitstream_init(bc, buf, s->buf_bit_size); - packet_sequence_number = bitstream_read(bc, 4); - bitstream_skip(bc, 2); + init_get_bits(gb, buf, s->buf_bit_size); + if (avctx->codec_id != AV_CODEC_ID_XMA2) { + packet_sequence_number = get_bits(gb, 4); + skip_bits(gb, 2); + } else { + int num_frames = get_bits(gb, 6); + ff_dlog(avctx, "packet[%d]: number of frames %d\n", avctx->frame_number, num_frames); + packet_sequence_number = 0; + } /** get number of bits that need to be added to the previous frame */ - num_bits_prev_frame = bitstream_read(bc, s->log2_frame_size); + num_bits_prev_frame = get_bits(gb, s->log2_frame_size); + if (avctx->codec_id != AV_CODEC_ID_WMAPRO) { + skip_bits(gb, 3); + s->skip_packets = get_bits(gb, 8); + ff_dlog(avctx, "packet[%d]: skip packets %d\n", avctx->frame_number, s->skip_packets); + } + ff_dlog(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number, num_bits_prev_frame); /** check for packet loss */ - if (!s->packet_loss && + if (avctx->codec_id == AV_CODEC_ID_WMAPRO && !s->packet_loss && ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) { s->packet_loss = 1; av_log(avctx, AV_LOG_ERROR, @@ -1557,7 +1689,7 @@ static int decode_packet(AVCodecContext *avctx, void *data, s->packet_sequence_number = packet_sequence_number; if (num_bits_prev_frame > 0) { - int remaining_packet_bits = s->buf_bit_size - bitstream_tell(bc); + int remaining_packet_bits = s->buf_bit_size - get_bits_count(gb); if (num_bits_prev_frame >= remaining_packet_bits) { num_bits_prev_frame = remaining_packet_bits; s->packet_done = 1; @@ -1565,7 +1697,7 @@ static int decode_packet(AVCodecContext *avctx, void *data, /** append the previous frame data to the remaining data from the previous packet to create a full frame */ - save_bits(s, bc, num_bits_prev_frame, 1); + save_bits(s, gb, num_bits_prev_frame, 1); ff_dlog(avctx, "accumulated %x bits of frame data\n", s->num_saved_bits - s->frame_offset); @@ -1584,19 +1716,19 @@ static int decode_packet(AVCodecContext *avctx, void *data, s->num_saved_bits = 0; s->packet_loss = 0; } - } else { int frame_size; s->buf_bit_size = (avpkt->size - s->next_packet_start) << 3; - bitstream_init(bc, avpkt->data, s->buf_bit_size); - bitstream_skip(bc, s->packet_offset); - if (s->len_prefix && remaining_bits(s, bc) > s->log2_frame_size && - (frame_size = bitstream_peek(bc, s->log2_frame_size)) && - frame_size <= remaining_bits(s, bc)) { - save_bits(s, bc, frame_size, 0); - s->packet_done = !decode_frame(s, data, got_frame_ptr); + init_get_bits(gb, avpkt->data, s->buf_bit_size); + skip_bits(gb, s->packet_offset); + if (s->len_prefix && remaining_bits(s, gb) > s->log2_frame_size && + (frame_size = show_bits(gb, s->log2_frame_size)) && + frame_size <= remaining_bits(s, gb)) { + save_bits(s, gb, frame_size, 0); + if (!s->packet_loss) + s->packet_done = !decode_frame(s, data, got_frame_ptr); } else if (!s->len_prefix - && s->num_saved_bits > bitstream_tell(&s->bc)) { + && s->num_saved_bits > get_bits_count(&s->gb)) { /** when the frames do not have a length prefix, we don't know the compressed length of the individual frames however, we know what part of a new packet belongs to the @@ -1605,38 +1737,244 @@ static int decode_packet(AVCodecContext *avctx, void *data, the "previous frame" data from the next packet so that we get a buffer that only contains full frames */ s->packet_done = !decode_frame(s, data, got_frame_ptr); - } else + } else { s->packet_done = 1; + } + } + + if (remaining_bits(s, gb) < 0) { + av_log(avctx, AV_LOG_ERROR, "Overread %d\n", -remaining_bits(s, gb)); + s->packet_loss = 1; } if (s->packet_done && !s->packet_loss && - remaining_bits(s, bc) > 0) { + remaining_bits(s, gb) > 0) { /** save the rest of the data so that it can be decoded with the next packet */ - save_bits(s, bc, remaining_bits(s, bc), 0); + save_bits(s, gb, remaining_bits(s, gb), 0); } - s->packet_offset = bitstream_tell(bc) & 7; + s->packet_offset = get_bits_count(gb) & 7; if (s->packet_loss) return AVERROR_INVALIDDATA; - return bitstream_tell(bc) >> 3; + return get_bits_count(gb) >> 3; } /** - *@brief Clear decoder buffers (for seeking). + *@brief Decode a single WMA packet. *@param avctx codec context + *@param data the output buffer + *@param avpkt input packet + *@return number of bytes that were read from the input buffer */ -static void flush(AVCodecContext *avctx) +static int wmapro_decode_packet(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) { WMAProDecodeCtx *s = avctx->priv_data; + AVFrame *frame = data; + int ret; + + /* get output buffer */ + frame->nb_samples = s->samples_per_frame; + if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) { + s->packet_loss = 1; + return 0; + } + + return decode_packet(avctx, s, data, got_frame_ptr, avpkt); +} + +static int xma_decode_packet(AVCodecContext *avctx, void *data, + int *got_frame_ptr, AVPacket *avpkt) +{ + XMADecodeCtx *s = avctx->priv_data; + int got_stream_frame_ptr = 0; + AVFrame *frame = data; + int i, ret, offset = INT_MAX; + + /* decode current stream packet */ + ret = decode_packet(avctx, &s->xma[s->current_stream], s->frames[s->current_stream], + &got_stream_frame_ptr, avpkt); + + /* copy stream samples (1/2ch) to sample buffer (Nch) */ + if (got_stream_frame_ptr) { + int start_ch = s->start_channel[s->current_stream]; + memcpy(&s->samples[start_ch + 0][s->offset[s->current_stream] * 512], + s->frames[s->current_stream]->extended_data[0], 512 * 4); + if (s->xma[s->current_stream].nb_channels > 1) + memcpy(&s->samples[start_ch + 1][s->offset[s->current_stream] * 512], + s->frames[s->current_stream]->extended_data[1], 512 * 4); + s->offset[s->current_stream]++; + } else if (ret < 0) { + memset(s->offset, 0, sizeof(s->offset)); + s->current_stream = 0; + return ret; + } + + /* find next XMA packet's owner stream, and update. + * XMA streams find their packets following packet_skips + * (at start there is one packet per stream, then interleave non-linearly). */ + if (s->xma[s->current_stream].packet_done || + s->xma[s->current_stream].packet_loss) { + + /* select stream with 0 skip_packets (= uses next packet) */ + if (s->xma[s->current_stream].skip_packets != 0) { + int min[2]; + + min[0] = s->xma[0].skip_packets; + min[1] = i = 0; + + for (i = 1; i < s->num_streams; i++) { + if (s->xma[i].skip_packets < min[0]) { + min[0] = s->xma[i].skip_packets; + min[1] = i; + } + } + + s->current_stream = min[1]; + } + + /* all other streams skip next packet */ + for (i = 0; i < s->num_streams; i++) { + s->xma[i].skip_packets = FFMAX(0, s->xma[i].skip_packets - 1); + } + + /* copy samples from buffer to output if possible */ + for (i = 0; i < s->num_streams; i++) { + offset = FFMIN(offset, s->offset[i]); + } + if (offset > 0) { + int bret; + + frame->nb_samples = 512 * offset; + if ((bret = ff_get_buffer(avctx, frame, 0)) < 0) + return bret; + + /* copy samples buffer (Nch) to frame samples (Nch), move unconsumed samples */ + for (i = 0; i < s->num_streams; i++) { + int start_ch = s->start_channel[i]; + memcpy(frame->extended_data[start_ch + 0], s->samples[start_ch + 0], frame->nb_samples * 4); + if (s->xma[i].nb_channels > 1) + memcpy(frame->extended_data[start_ch + 1], s->samples[start_ch + 1], frame->nb_samples * 4); + + s->offset[i] -= offset; + if (s->offset[i]) { + memmove(s->samples[start_ch + 0], s->samples[start_ch + 0] + frame->nb_samples, s->offset[i] * 4 * 512); + if (s->xma[i].nb_channels > 1) + memmove(s->samples[start_ch + 1], s->samples[start_ch + 1] + frame->nb_samples, s->offset[i] * 4 * 512); + } + } + + *got_frame_ptr = 1; + } + } + + return ret; +} + +static av_cold int xma_decode_init(AVCodecContext *avctx) +{ + XMADecodeCtx *s = avctx->priv_data; + int i, ret, start_channels = 0; + + if (avctx->channels <= 0 || avctx->extradata_size == 0) + return AVERROR_INVALIDDATA; + + /* get stream config */ + if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size == 34) { /* XMA2WAVEFORMATEX */ + s->num_streams = (avctx->channels + 1) / 2; + } else if (avctx->codec_id == AV_CODEC_ID_XMA2 && avctx->extradata_size >= 2) { /* XMA2WAVEFORMAT */ + s->num_streams = avctx->extradata[1]; + if (avctx->extradata_size != (32 + ((avctx->extradata[0]==3)?0:8) + 4*s->num_streams)) { + av_log(avctx, AV_LOG_ERROR, "Incorrect XMA2 extradata size\n"); + return AVERROR(EINVAL); + } + } else if (avctx->codec_id == AV_CODEC_ID_XMA1 && avctx->extradata_size >= 4) { /* XMAWAVEFORMAT */ + s->num_streams = avctx->extradata[4]; + if (avctx->extradata_size != (8 + 20*s->num_streams)) { + av_log(avctx, AV_LOG_ERROR, "Incorrect XMA1 extradata size\n"); + return AVERROR(EINVAL); + } + } else { + av_log(avctx, AV_LOG_ERROR, "Incorrect XMA config\n"); + return AVERROR(EINVAL); + } + + /* encoder supports up to 64 streams / 64*2 channels (would have to alloc arrays) */ + if (avctx->channels > XMA_MAX_CHANNELS || s->num_streams > XMA_MAX_STREAMS) { + avpriv_request_sample(avctx, "More than %d channels in %d streams", XMA_MAX_CHANNELS, s->num_streams); + return AVERROR_PATCHWELCOME; + } + + /* init all streams (several streams of 1/2ch make Nch files) */ + for (i = 0; i < s->num_streams; i++) { + ret = decode_init(&s->xma[i], avctx, i); + if (ret < 0) + return ret; + s->frames[i] = av_frame_alloc(); + if (!s->frames[i]) + return AVERROR(ENOMEM); + s->frames[i]->nb_samples = 512; + if ((ret = ff_get_buffer(avctx, s->frames[i], 0)) < 0) { + return AVERROR(ENOMEM); + } + + s->start_channel[i] = start_channels; + start_channels += s->xma[i].nb_channels; + } + + return ret; +} + +static av_cold int xma_decode_end(AVCodecContext *avctx) +{ + XMADecodeCtx *s = avctx->priv_data; + int i; + + for (i = 0; i < s->num_streams; i++) { + decode_end(&s->xma[i]); + av_frame_free(&s->frames[i]); + } + + return 0; +} + +static void flush(WMAProDecodeCtx *s) +{ int i; /** reset output buffer as a part of it is used during the windowing of a new frame */ - for (i = 0; i < avctx->channels; i++) + for (i = 0; i < s->nb_channels; i++) memset(s->channel[i].out, 0, s->samples_per_frame * sizeof(*s->channel[i].out)); s->packet_loss = 1; + s->skip_packets = 0; + s->eof_done = 0; +} + + +/** + *@brief Clear decoder buffers (for seeking). + *@param avctx codec context + */ +static void wmapro_flush(AVCodecContext *avctx) +{ + WMAProDecodeCtx *s = avctx->priv_data; + + flush(s); +} + +static void xma_flush(AVCodecContext *avctx) +{ + XMADecodeCtx *s = avctx->priv_data; + int i; + + for (i = 0; i < s->num_streams; i++) + flush(&s->xma[i]); + + memset(s->offset, 0, sizeof(s->offset)); + s->current_stream = 0; } @@ -1649,11 +1987,40 @@ AVCodec ff_wmapro_decoder = { .type = AVMEDIA_TYPE_AUDIO, .id = AV_CODEC_ID_WMAPRO, .priv_data_size = sizeof(WMAProDecodeCtx), - .init = decode_init, - .close = decode_end, - .decode = decode_packet, + .init = wmapro_decode_init, + .close = wmapro_decode_end, + .decode = wmapro_decode_packet, .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1, - .flush = flush, + .flush = wmapro_flush, + .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, + AV_SAMPLE_FMT_NONE }, +}; + +AVCodec ff_xma1_decoder = { + .name = "xma1", + .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 1"), + .type = AVMEDIA_TYPE_AUDIO, + .id = AV_CODEC_ID_XMA1, + .priv_data_size = sizeof(XMADecodeCtx), + .init = xma_decode_init, + .close = xma_decode_end, + .decode = xma_decode_packet, + .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, + .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, + AV_SAMPLE_FMT_NONE }, +}; + +AVCodec ff_xma2_decoder = { + .name = "xma2", + .long_name = NULL_IF_CONFIG_SMALL("Xbox Media Audio 2"), + .type = AVMEDIA_TYPE_AUDIO, + .id = AV_CODEC_ID_XMA2, + .priv_data_size = sizeof(XMADecodeCtx), + .init = xma_decode_init, + .close = xma_decode_end, + .decode = xma_decode_packet, + .flush = xma_flush, + .capabilities = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY, .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE }, }; |