Merge FFTContext and MDCTContext
[ffmpeg.git] / libavcodec / wmaprodec.c
index 495e27a..7f35edc 100644 (file)
@@ -137,8 +137,9 @@ typedef struct {
     int8_t   reuse_sf;                                ///< share scale factors between subframes
     int8_t   scale_factor_step;                       ///< scaling step for the current subframe
     int      max_scale_factor;                        ///< maximum scale factor for the current subframe
-    int      scale_factors[MAX_BANDS];                ///< scale factor values for the current subframe
-    int      saved_scale_factors[MAX_BANDS];          ///< scale factors from a previous subframe
+    int      saved_scale_factors[2][MAX_BANDS];       ///< resampled and (previously) transmitted scale factor values
+    int8_t   scale_factor_idx;                        ///< index for the transmitted scale factor values (used for resampling)
+    int*     scale_factors;                           ///< pointer to the scale factor values used for decoding
     uint8_t  table_idx;                               ///< index in sf_offsets for the scale factor reference block
     float*   coeffs;                                  ///< pointer to the subframe decode buffer
     DECLARE_ALIGNED_16(float, out[WMAPRO_BLOCK_MAX_SIZE + WMAPRO_BLOCK_MAX_SIZE / 2]); ///< output buffer
@@ -165,7 +166,7 @@ typedef struct WMAProDecodeCtx {
     uint8_t          frame_data[MAX_FRAMESIZE +
                       FF_INPUT_BUFFER_PADDING_SIZE];///< compressed frame data
     PutBitContext    pb;                            ///< context for filling the frame_data buffer
-    MDCTContext      mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
+    FFTContext       mdct_ctx[WMAPRO_BLOCK_SIZES];  ///< MDCT context per block size
     DECLARE_ALIGNED_16(float, tmp[WMAPRO_BLOCK_MAX_SIZE]); ///< IMDCT output buffer
     float*           windows[WMAPRO_BLOCK_SIZES];   ///< windows for the different block sizes
 
@@ -188,11 +189,14 @@ typedef struct WMAProDecodeCtx {
     int16_t          subwoofer_cutoffs[WMAPRO_BLOCK_SIZES]; ///< subwoofer cutoff values
 
     /* packet decode state */
+    GetBitContext    pgb;                           ///< bitstream reader context for the packet
+    uint8_t          packet_offset;                 ///< frame offset in the packet
     uint8_t          packet_sequence_number;        ///< current packet number
     int              num_saved_bits;                ///< saved number of bits
     int              frame_offset;                  ///< frame offset in the bit reservoir
     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
 
     /* frame decode state */
     uint32_t         frame_num;                     ///< current frame number (not used for decoding)
@@ -422,7 +426,7 @@ static av_cold int decode_init(AVCodecContext *avctx)
     /** init MDCT windows: simple sinus window */
     for (i = 0; i < WMAPRO_BLOCK_SIZES; i++) {
         const int n       = 1 << (WMAPRO_BLOCK_MAX_BITS - i);
-        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i - 7;
+        const int win_idx = WMAPRO_BLOCK_MAX_BITS - i;
         ff_sine_window_init(ff_sine_windows[win_idx], n);
         s->windows[WMAPRO_BLOCK_SIZES - i - 1] = ff_sine_windows[win_idx];
     }
@@ -857,7 +861,9 @@ static int decode_scale_factors(WMAProDecodeCtx* s)
     for (i = 0; i < s->channels_for_cur_subframe; i++) {
         int c = s->channel_indexes_for_cur_subframe[i];
         int* sf;
-        int* sf_end = s->channel[c].scale_factors + s->num_bands;
+        int* sf_end;
+        s->channel[c].scale_factors = s->channel[c].saved_scale_factors[!s->channel[c].scale_factor_idx];
+        sf_end = s->channel[c].scale_factors + s->num_bands;
 
         /** resample scale factors for the new block size
          *  as the scale factors might need to be resampled several times
@@ -869,7 +875,7 @@ static int decode_scale_factors(WMAProDecodeCtx* s)
             int b;
             for (b = 0; b < s->num_bands; b++)
                 s->channel[c].scale_factors[b] =
-                                   s->channel[c].saved_scale_factors[*sf_offsets++];
+                    s->channel[c].saved_scale_factors[s->channel[c].scale_factor_idx][*sf_offsets++];
         }
 
         if (!s->channel[c].cur_subframe || get_bits1(&s->gb)) {
@@ -916,12 +922,8 @@ static int decode_scale_factors(WMAProDecodeCtx* s)
                     s->channel[c].scale_factors[i] += (val ^ sign) - sign;
                 }
             }
-
-            /** save transmitted scale factors so that they can be reused for
-                the next subframe */
-            memcpy(s->channel[c].saved_scale_factors,
-                   s->channel[c].scale_factors, s->num_bands *
-                   sizeof(*s->channel[c].saved_scale_factors));
+            /** swap buffers */
+            s->channel[c].scale_factor_idx = !s->channel[c].scale_factor_idx;
             s->channel[c].table_idx = s->table_idx;
             s->channel[c].reuse_sf  = 1;
         }
@@ -1255,6 +1257,7 @@ static int decode_frame(WMAProDecodeCtx *s)
 
     /** check for potential output buffer overflow */
     if (s->num_channels * s->samples_per_frame > s->samples_end - s->samples) {
+        /** return an error if no frame could be decoded at all */
         av_log(s->avctx, AV_LOG_ERROR,
                "not enough space for the output samples\n");
         s->packet_loss = 1;
@@ -1441,90 +1444,88 @@ static void save_bits(WMAProDecodeCtx *s, GetBitContext* gb, int len,
 static int decode_packet(AVCodecContext *avctx,
                          void *data, int *data_size, AVPacket* avpkt)
 {
-    GetBitContext gb;
     WMAProDecodeCtx *s = avctx->priv_data;
-    const uint8_t* buf   = avpkt->data;
-    int buf_size         = avpkt->size;
-    int more_frames      = 1;
+    GetBitContext* gb  = &s->pgb;
+    const uint8_t* buf = avpkt->data;
+    int buf_size       = avpkt->size;
     int num_bits_prev_frame;
     int packet_sequence_number;
 
-    s->samples      = data;
-    s->samples_end  = (float*)((int8_t*)data + *data_size);
-    s->buf_bit_size = buf_size << 3;
-
-
+    s->samples       = data;
+    s->samples_end   = (float*)((int8_t*)data + *data_size);
     *data_size = 0;
 
-    /** sanity check for the buffer length */
-    if (buf_size < avctx->block_align)
-        return 0;
+    if (s->packet_done || s->packet_loss) {
+        s->packet_done = 0;
+        s->buf_bit_size = buf_size << 3;
 
-    buf_size = avctx->block_align;
-
-    /** parse packet header */
-    init_get_bits(&gb, buf, s->buf_bit_size);
-    packet_sequence_number = get_bits(&gb, 4);
-    skip_bits(&gb, 2);
+        /** sanity check for the buffer length */
+        if (buf_size < avctx->block_align)
+            return 0;
 
-    /** get number of bits that need to be added to the previous frame */
-    num_bits_prev_frame = get_bits(&gb, s->log2_frame_size);
-    dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
-            num_bits_prev_frame);
+        buf_size = avctx->block_align;
 
-    /** check for packet loss */
-    if (!s->packet_loss &&
-        ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
-        s->packet_loss = 1;
-        av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
-               s->packet_sequence_number, packet_sequence_number);
-    }
-    s->packet_sequence_number = packet_sequence_number;
-
-    if (num_bits_prev_frame > 0) {
-        /** append the previous frame data to the remaining data from the
-            previous packet to create a full frame */
-        save_bits(s, &gb, num_bits_prev_frame, 1);
-        dprintf(avctx, "accumulated %x bits of frame data\n",
-                s->num_saved_bits - s->frame_offset);
-
-        /** decode the cross packet frame if it is valid */
-        if (!s->packet_loss)
-            decode_frame(s);
-    } else if (s->num_saved_bits - s->frame_offset) {
-        dprintf(avctx, "ignoring %x previously saved bits\n",
-                s->num_saved_bits - s->frame_offset);
-    }
+        /** parse packet header */
+        init_get_bits(gb, buf, s->buf_bit_size);
+        packet_sequence_number = get_bits(gb, 4);
+        skip_bits(gb, 2);
 
-    s->packet_loss = 0;
-    /** decode the rest of the packet */
-    while (!s->packet_loss && more_frames &&
-           remaining_bits(s, &gb) > s->log2_frame_size) {
-        int frame_size = show_bits(&gb, s->log2_frame_size);
+        /** get number of bits that need to be added to the previous frame */
+        num_bits_prev_frame = get_bits(gb, s->log2_frame_size);
+        dprintf(avctx, "packet[%d]: nbpf %x\n", avctx->frame_number,
+                num_bits_prev_frame);
 
-        /** there is enough data for a full frame */
-        if (remaining_bits(s, &gb) >= frame_size && frame_size > 0) {
-            save_bits(s, &gb, frame_size, 0);
+        /** check for packet loss */
+        if (!s->packet_loss &&
+            ((s->packet_sequence_number + 1) & 0xF) != packet_sequence_number) {
+            s->packet_loss = 1;
+            av_log(avctx, AV_LOG_ERROR, "Packet loss detected! seq %x vs %x\n",
+                   s->packet_sequence_number, packet_sequence_number);
+        }
+        s->packet_sequence_number = packet_sequence_number;
+
+        if (num_bits_prev_frame > 0) {
+            /** append the previous frame data to the remaining data from the
+                previous packet to create a full frame */
+            save_bits(s, gb, num_bits_prev_frame, 1);
+            dprintf(avctx, "accumulated %x bits of frame data\n",
+                    s->num_saved_bits - s->frame_offset);
+
+            /** decode the cross packet frame if it is valid */
+            if (!s->packet_loss)
+                decode_frame(s);
+        } else if (s->num_saved_bits - s->frame_offset) {
+            dprintf(avctx, "ignoring %x previously saved bits\n",
+                    s->num_saved_bits - s->frame_offset);
+        }
 
-            /** decode the frame */
-            more_frames = decode_frame(s);
+        s->packet_loss = 0;
 
-            if (!more_frames) {
-                dprintf(avctx, "no more frames\n");
-            }
+    } else {
+        int frame_size;
+        s->buf_bit_size = avpkt->size << 3;
+        init_get_bits(gb, avpkt->data, s->buf_bit_size);
+        skip_bits(gb, s->packet_offset);
+        if (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);
+            s->packet_done = !decode_frame(s);
         } else
-            more_frames = 0;
+            s->packet_done = 1;
     }
 
-    if (!s->packet_loss && remaining_bits(s, &gb) > 0) {
+    if (s->packet_done && !s->packet_loss &&
+        remaining_bits(s, gb) > 0) {
         /** save the rest of the data so that it can be decoded
             with the next packet */
-        save_bits(s, &gb, remaining_bits(s, &gb), 0);
+        save_bits(s, gb, remaining_bits(s, gb), 0);
     }
 
     *data_size = (int8_t *)s->samples - (int8_t *)data;
+    s->packet_offset = get_bits_count(gb) & 7;
 
-    return avctx->block_align;
+    return get_bits_count(gb) >> 3;
 }
 
 /**
@@ -1556,6 +1557,7 @@ AVCodec wmapro_decoder = {
     NULL,
     decode_end,
     decode_packet,
+    .capabilities = CODEC_CAP_SUBFRAMES,
     .flush= flush,
     .long_name = NULL_IF_CONFIG_SMALL("Windows Media Audio 9 Professional"),
 };