ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavcodec/alac.c

 /*
  * ALAC (Apple Lossless Audio Codec) decoder
  * Copyright (c) 2005 David Hammerton
  *
  * This file is part of FFmpeg.
  *
  * 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.
@@ skipping 59 matching lines @@
     int context_initialized;
 
     int numchannels;
     int bytespersample;
 
     /* buffers */
     int32_t *predicterror_buffer[MAX_CHANNELS];
 
     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 */
     uint8_t setinfo_rice_historymult; /* 0x28 */
     uint8_t setinfo_rice_initialhistory; /* 0x0a */
     uint8_t setinfo_rice_kmodifier; /* 0x0e */
     /* end setinfo stuff */
 
+    int wasted_bits;
 } ALACContext;
 
 static void allocate_buffers(ALACContext *alac)
 {
     int chan;
     for (chan = 0; chan < MAX_CHANNELS; chan++) {
         alac->predicterror_buffer[chan] =
             av_malloc(alac->setinfo_max_samples_per_frame * 4);
 
         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);
     }
 }
 
 static int alac_set_info(ALACContext *alac)
 {
     const unsigned char *ptr = alac->avctx->extradata;
 
     ptr += 4; /* size */
     ptr += 4; /* alac */
     ptr += 4; /* 0 ? */
@@ skipping 282 matching lines @@
         int16_t left, right;
 
         left = buffer[0][i];
         right = buffer[1][i];
 
         buffer_out[i*numchannels] = left;
         buffer_out[i*numchannels + 1] = right;
     }
 }
 
+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,
                              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;
     unsigned int readsamplesize;
-    int wasted_bytes;
     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) {
@@ skipping 21 matching lines @@
     /* 2^result = something to do with output waiting.
      * perhaps matters if we read > 1 frame in a pass?
      */
     skip_bits(&alac->gb, 4);
 
     skip_bits(&alac->gb, 12); /* unknown, skip 12 bits */
 
     /* 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);
 
     if (hassize) {
         /* now read the number of samples as a 32bit integer */
         outputsamples = get_bits_long(&alac->gb, 32);
         if(outputsamples > alac->setinfo_max_samples_per_frame){
             av_log(avctx, AV_LOG_ERROR, "outputsamples %d > %d\n", outputsamples, alac->setinfo_max_samples_per_frame);
             return -1;
         }
     } else
         outputsamples = alac->setinfo_max_samples_per_frame;
 
+    switch (alac->setinfo_sample_size) {
+    case 16: avctx->sample_fmt    = SAMPLE_FMT_S16;
+             alac->bytespersample = channels << 1;
+             break;
+    case 24: avctx->sample_fmt    = 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];
         int i, chan;
 
         interlacing_shift = get_bits(&alac->gb, 8);
         interlacing_leftweight = get_bits(&alac->gb, 8);
 
         for (chan = 0; chan < channels; chan++) {
             prediction_type[chan] = get_bits(&alac->gb, 4);
             prediction_quantitization[chan] = get_bits(&alac->gb, 4);
 
             ricemodifier[chan] = get_bits(&alac->gb, 3);
             predictor_coef_num[chan] = get_bits(&alac->gb, 5);
 
             /* read the predictor table */
             for (i = 0; i < predictor_coef_num[chan]; i++)
                 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],
                                         outputsamples,
                                         readsamplesize,
                                         alac->setinfo_rice_initialhistory,
                                         alac->setinfo_rice_kmodifier,
                                         ricemodifier[chan] * alac->setinfo_rice_historymult / 4,
                                         (1 << alac->setinfo_rice_kmodifier) - 1);
 
@@ skipping 12 matching lines @@
                  * just a boolean?) runs adaptive fir twice.. like:
                  * predictor_decompress_fir_adapt(predictor_error, tempout, ...)
                  * predictor_decompress_fir_adapt(predictor_error, outputsamples ...)
                  * little strange..
                  */
             }
         }
     } 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_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;
     }
     if (get_bits(&alac->gb, 3) != 7)
         av_log(avctx, AV_LOG_ERROR, "Error : Wrong End Of Frame\n");
 
     switch(alac->setinfo_sample_size) {
     case 16:
         if (channels == 2) {
             reconstruct_stereo_16(alac->outputsamples_buffer,
                                   (int16_t*)outbuffer,
                                   alac->numchannels,
                                   outputsamples,
                                   interlacing_shift,
                                   interlacing_leftweight);
         } 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;
     }
 
     if (input_buffer_size * 8 - get_bits_count(&alac->gb) > 8)
         av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n", input_buffer_size * 8 - get_bits_count(&alac->gb));
 
     return input_buffer_size;
 }
 
 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 = 2 * alac->numchannels;
-    avctx->sample_fmt = SAMPLE_FMT_S16;
 
     return 0;
 }
 
 static av_cold int alac_decode_close(AVCodecContext *avctx)
 {
     ALACContext *alac = avctx->priv_data;
 
     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,
     .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
 };