aacsbr: prevent multiple ff_aac_sbr_ctx_init()
[ffmpeg.git] / libavcodec / alac.c
index 6815fa1..06bf6f8 100644 (file)
  */
 
 /**
- * @file alac.c
+ * @file
  * ALAC (Apple Lossless Audio Codec) decoder
  * @author 2005 David Hammerton
- *
- * For more information on the ALAC format, visit:
- *  http://crazney.net/programs/itunes/alac.html
+ * @see http://crazney.net/programs/itunes/alac.html
  *
  * Note: This decoder expects a 36- (0x24-)byte QuickTime atom to be
  * passed through the extradata[_size] fields. This atom is tacked onto
 
 
 #include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
 #include "bytestream.h"
 #include "unary.h"
+#include "mathops.h"
 
 #define ALAC_EXTRADATA_SIZE 36
 #define MAX_CHANNELS 2
@@ -64,9 +63,6 @@ typedef struct {
 
     AVCodecContext *avctx;
     GetBitContext gb;
-    /* init to 0; first frame decode should initialize from extradata and
-     * set this to 1 */
-    int context_initialized;
 
     int numchannels;
     int bytespersample;
@@ -76,6 +72,8 @@ typedef struct {
 
     int32_t *outputsamples_buffer[MAX_CHANNELS];
 
+    int32_t *wasted_bits_buffer[MAX_CHANNELS];
+
     /* stuff from setinfo */
     uint32_t setinfo_max_samples_per_frame; /* 0x1000 = 4096 */    /* max samples per frame? */
     uint8_t setinfo_sample_size; /* 0x10 */
@@ -84,6 +82,7 @@ typedef struct {
     uint8_t setinfo_rice_kmodifier; /* 0x0e */
     /* end setinfo stuff */
 
+    int wasted_bits;
 } ALACContext;
 
 static void allocate_buffers(ALACContext *alac)
@@ -95,6 +94,8 @@ static void allocate_buffers(ALACContext *alac)
 
         alac->outputsamples_buffer[chan] =
             av_malloc(alac->setinfo_max_samples_per_frame * 4);
+
+        alac->wasted_bits_buffer[chan] = av_malloc(alac->setinfo_max_samples_per_frame * 4);
     }
 }
 
@@ -229,11 +230,6 @@ static void bastardized_rice_decompress(ALACContext *alac,
     }
 }
 
-static inline int32_t extend_sign32(int32_t val, int bits)
-{
-    return (val << (32 - bits)) >> (32 - bits);
-}
-
 static inline int sign_only(int v)
 {
     return v ? FFSIGN(v) : 0;
@@ -273,7 +269,7 @@ static void predictor_decompress_fir_adapt(int32_t *error_buffer,
             prev_value = buffer_out[i];
             error_value = error_buffer[i+1];
             buffer_out[i+1] =
-                extend_sign32((prev_value + error_value), readsamplesize);
+                sign_extend((prev_value + error_value), readsamplesize);
         }
         return;
     }
@@ -284,24 +280,13 @@ static void predictor_decompress_fir_adapt(int32_t *error_buffer,
             int32_t val;
 
             val = buffer_out[i] + error_buffer[i+1];
-            val = extend_sign32(val, readsamplesize);
+            val = sign_extend(val, readsamplesize);
             buffer_out[i+1] = val;
         }
 
-#if 0
     /* 4 and 8 are very common cases (the only ones i've seen). these
      * should be unrolled and optimized
      */
-    if (predictor_coef_num == 4) {
-        /* FIXME: optimized general case */
-        return;
-    }
-
-    if (predictor_coef_table == 8) {
-        /* FIXME: optimized general case */
-        return;
-    }
-#endif
 
     /* general case */
     if (predictor_coef_num > 0) {
@@ -319,7 +304,7 @@ static void predictor_decompress_fir_adapt(int32_t *error_buffer,
             outval = (1 << (predictor_quantitization-1)) + sum;
             outval = outval >> predictor_quantitization;
             outval = outval + buffer_out[0] + error_val;
-            outval = extend_sign32(outval, readsamplesize);
+            outval = sign_extend(outval, readsamplesize);
 
             buffer_out[predictor_coef_num+1] = outval;
 
@@ -402,38 +387,75 @@ static void reconstruct_stereo_16(int32_t *buffer[MAX_CHANNELS],
     }
 }
 
+static void decorrelate_stereo_24(int32_t *buffer[MAX_CHANNELS],
+                                  int32_t *buffer_out,
+                                  int32_t *wasted_bits_buffer[MAX_CHANNELS],
+                                  int wasted_bits,
+                                  int numchannels, int numsamples,
+                                  uint8_t interlacing_shift,
+                                  uint8_t interlacing_leftweight)
+{
+    int i;
+
+    if (numsamples <= 0)
+        return;
+
+    /* weighted interlacing */
+    if (interlacing_leftweight) {
+        for (i = 0; i < numsamples; i++) {
+            int32_t a, b;
+
+            a = buffer[0][i];
+            b = buffer[1][i];
+
+            a -= (b * interlacing_leftweight) >> interlacing_shift;
+            b += a;
+
+            if (wasted_bits) {
+                b  = (b  << wasted_bits) | wasted_bits_buffer[0][i];
+                a  = (a  << wasted_bits) | wasted_bits_buffer[1][i];
+            }
+
+            buffer_out[i * numchannels]     = b << 8;
+            buffer_out[i * numchannels + 1] = a << 8;
+        }
+    } else {
+        for (i = 0; i < numsamples; i++) {
+            int32_t left, right;
+
+            left  = buffer[0][i];
+            right = buffer[1][i];
+
+            if (wasted_bits) {
+                left   = (left   << wasted_bits) | wasted_bits_buffer[0][i];
+                right  = (right  << wasted_bits) | wasted_bits_buffer[1][i];
+            }
+
+            buffer_out[i * numchannels]     = left  << 8;
+            buffer_out[i * numchannels + 1] = right << 8;
+        }
+    }
+}
+
 static int alac_decode_frame(AVCodecContext *avctx,
                              void *outbuffer, int *outputsize,
-                             const uint8_t *inbuffer, int input_buffer_size)
+                             AVPacket *avpkt)
 {
+    const uint8_t *inbuffer = avpkt->data;
+    int input_buffer_size = avpkt->size;
     ALACContext *alac = avctx->priv_data;
 
     int channels;
     unsigned int outputsamples;
     int hassize;
-    int readsamplesize;
-    int wasted_bytes;
+    unsigned int readsamplesize;
     int isnotcompressed;
     uint8_t interlacing_shift;
     uint8_t interlacing_leftweight;
 
     /* short-circuit null buffers */
     if (!inbuffer || !input_buffer_size)
-        return input_buffer_size;
-
-    /* initialize from the extradata */
-    if (!alac->context_initialized) {
-        if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
-            av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
-                ALAC_EXTRADATA_SIZE);
-            return input_buffer_size;
-        }
-        if (alac_set_info(alac)) {
-            av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
-            return input_buffer_size;
-        }
-        alac->context_initialized = 1;
-    }
+        return -1;
 
     init_get_bits(&alac->gb, inbuffer, input_buffer_size * 8);
 
@@ -441,7 +463,7 @@ static int alac_decode_frame(AVCodecContext *avctx,
     if (channels > MAX_CHANNELS) {
         av_log(avctx, AV_LOG_ERROR, "channels > %d not supported\n",
                MAX_CHANNELS);
-        return input_buffer_size;
+        return -1;
     }
 
     /* 2^result = something to do with output waiting.
@@ -454,7 +476,7 @@ static int alac_decode_frame(AVCodecContext *avctx,
     /* the output sample size is stored soon */
     hassize = get_bits1(&alac->gb);
 
-    wasted_bytes = get_bits(&alac->gb, 2); /* unknown ? */
+    alac->wasted_bits = get_bits(&alac->gb, 2) << 3;
 
     /* whether the frame is compressed */
     isnotcompressed = get_bits1(&alac->gb);
@@ -469,21 +491,37 @@ static int alac_decode_frame(AVCodecContext *avctx,
     } else
         outputsamples = alac->setinfo_max_samples_per_frame;
 
+    switch (alac->setinfo_sample_size) {
+    case 16: avctx->sample_fmt    = AV_SAMPLE_FMT_S16;
+             alac->bytespersample = channels << 1;
+             break;
+    case 24: avctx->sample_fmt    = AV_SAMPLE_FMT_S32;
+             alac->bytespersample = channels << 2;
+             break;
+    default: av_log(avctx, AV_LOG_ERROR, "Sample depth %d is not supported.\n",
+                    alac->setinfo_sample_size);
+             return -1;
+    }
+
     if(outputsamples > *outputsize / alac->bytespersample){
         av_log(avctx, AV_LOG_ERROR, "sample buffer too small\n");
         return -1;
     }
 
     *outputsize = outputsamples * alac->bytespersample;
-    readsamplesize = alac->setinfo_sample_size - (wasted_bytes * 8) + channels - 1;
+    readsamplesize = alac->setinfo_sample_size - (alac->wasted_bits) + channels - 1;
+    if (readsamplesize > MIN_CACHE_BITS) {
+        av_log(avctx, AV_LOG_ERROR, "readsamplesize too big (%d)\n", readsamplesize);
+        return -1;
+    }
 
     if (!isnotcompressed) {
         /* so it is compressed */
-        int16_t predictor_coef_table[channels][32];
-        int predictor_coef_num[channels];
-        int prediction_type[channels];
-        int prediction_quantitization[channels];
-        int ricemodifier[channels];
+        int16_t predictor_coef_table[MAX_CHANNELS][32];
+        int predictor_coef_num[MAX_CHANNELS];
+        int prediction_type[MAX_CHANNELS];
+        int prediction_quantitization[MAX_CHANNELS];
+        int ricemodifier[MAX_CHANNELS];
         int i, chan;
 
         interlacing_shift = get_bits(&alac->gb, 8);
@@ -501,9 +539,13 @@ static int alac_decode_frame(AVCodecContext *avctx,
                 predictor_coef_table[chan][i] = (int16_t)get_bits(&alac->gb, 16);
         }
 
-        if (wasted_bytes)
-            av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented, unhandling of wasted_bytes\n");
-
+        if (alac->wasted_bits) {
+            int i, ch;
+            for (i = 0; i < outputsamples; i++) {
+                for (ch = 0; ch < channels; ch++)
+                    alac->wasted_bits_buffer[ch][i] = get_bits(&alac->gb, alac->wasted_bits);
+            }
+        }
         for (chan = 0; chan < channels; chan++) {
             bastardized_rice_decompress(alac,
                                         alac->predicterror_buffer[chan],
@@ -536,16 +578,26 @@ static int alac_decode_frame(AVCodecContext *avctx,
     } else {
         /* not compressed, easy case */
         int i, chan;
+        if (alac->setinfo_sample_size <= 16) {
         for (i = 0; i < outputsamples; i++)
             for (chan = 0; chan < channels; chan++) {
                 int32_t audiobits;
 
-                audiobits = get_bits_long(&alac->gb, alac->setinfo_sample_size);
-                audiobits = extend_sign32(audiobits, alac->setinfo_sample_size);
+                audiobits = get_sbits_long(&alac->gb, alac->setinfo_sample_size);
 
                 alac->outputsamples_buffer[chan][i] = audiobits;
             }
-        /* wasted_bytes = 0; */
+        } else {
+            for (i = 0; i < outputsamples; i++) {
+                for (chan = 0; chan < channels; chan++) {
+                    alac->outputsamples_buffer[chan][i] = get_bits(&alac->gb,
+                                                          alac->setinfo_sample_size);
+                    alac->outputsamples_buffer[chan][i] = sign_extend(alac->outputsamples_buffer[chan][i],
+                                                                      alac->setinfo_sample_size);
+                }
+            }
+        }
+        alac->wasted_bits = 0;
         interlacing_shift = 0;
         interlacing_leftweight = 0;
     }
@@ -564,19 +616,25 @@ static int alac_decode_frame(AVCodecContext *avctx,
         } else {
             int i;
             for (i = 0; i < outputsamples; i++) {
-                int16_t sample = alac->outputsamples_buffer[0][i];
-                ((int16_t*)outbuffer)[i * alac->numchannels] = sample;
+                ((int16_t*)outbuffer)[i] = alac->outputsamples_buffer[0][i];
             }
         }
         break;
-    case 20:
     case 24:
-        // It is not clear if there exist any encoder that creates 24 bit ALAC
-        // files. iTunes convert 24 bit raw files to 16 bit before encoding.
-    case 32:
-        av_log(avctx, AV_LOG_ERROR, "FIXME: unimplemented sample size %i\n", alac->setinfo_sample_size);
-        break;
-    default:
+        if (channels == 2) {
+            decorrelate_stereo_24(alac->outputsamples_buffer,
+                                  outbuffer,
+                                  alac->wasted_bits_buffer,
+                                  alac->wasted_bits,
+                                  alac->numchannels,
+                                  outputsamples,
+                                  interlacing_shift,
+                                  interlacing_leftweight);
+        } else {
+            int i;
+            for (i = 0; i < outputsamples; i++)
+                ((int32_t *)outbuffer)[i] = alac->outputsamples_buffer[0][i] << 8;
+        }
         break;
     }
 
@@ -590,10 +648,18 @@ static av_cold int alac_decode_init(AVCodecContext * avctx)
 {
     ALACContext *alac = avctx->priv_data;
     alac->avctx = avctx;
-    alac->context_initialized = 0;
-
     alac->numchannels = alac->avctx->channels;
-    alac->bytespersample = (avctx->bits_per_sample / 8) * alac->numchannels;
+
+    /* initialize from the extradata */
+    if (alac->avctx->extradata_size != ALAC_EXTRADATA_SIZE) {
+        av_log(avctx, AV_LOG_ERROR, "alac: expected %d extradata bytes\n",
+            ALAC_EXTRADATA_SIZE);
+        return -1;
+    }
+    if (alac_set_info(alac)) {
+        av_log(avctx, AV_LOG_ERROR, "alac: set_info failed\n");
+        return -1;
+    }
 
     return 0;
 }
@@ -604,21 +670,21 @@ static av_cold int alac_decode_close(AVCodecContext *avctx)
 
     int chan;
     for (chan = 0; chan < MAX_CHANNELS; chan++) {
-        av_free(alac->predicterror_buffer[chan]);
-        av_free(alac->outputsamples_buffer[chan]);
+        av_freep(&alac->predicterror_buffer[chan]);
+        av_freep(&alac->outputsamples_buffer[chan]);
+        av_freep(&alac->wasted_bits_buffer[chan]);
     }
 
     return 0;
 }
 
-AVCodec alac_decoder = {
-    "alac",
-    CODEC_TYPE_AUDIO,
-    CODEC_ID_ALAC,
-    sizeof(ALACContext),
-    alac_decode_init,
-    NULL,
-    alac_decode_close,
-    alac_decode_frame,
+AVCodec ff_alac_decoder = {
+    .name           = "alac",
+    .type           = AVMEDIA_TYPE_AUDIO,
+    .id             = CODEC_ID_ALAC,
+    .priv_data_size = sizeof(ALACContext),
+    .init           = alac_decode_init,
+    .close          = alac_decode_close,
+    .decode         = alac_decode_frame,
     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
 };