Prevent AAC frame size overflows.
[ffmpeg.git] / libavcodec / alacenc.c
index f18ab26..f8a18b9 100644 (file)
  */
 
 #include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
+#include "put_bits.h"
 #include "dsputil.h"
 #include "lpc.h"
+#include "mathops.h"
 
 #define DEFAULT_FRAME_SIZE        4096
 #define DEFAULT_SAMPLE_SIZE       16
@@ -130,7 +132,7 @@ static void calc_predictor_params(AlacEncodeContext *s, int ch)
     int shift[MAX_LPC_ORDER];
     int opt_order;
 
-    opt_order = ff_lpc_calc_coefs(&s->dspctx, s->sample_buf[ch], s->avctx->frame_size, DEFAULT_MIN_PRED_ORDER, DEFAULT_MAX_PRED_ORDER,
+    opt_order = ff_lpc_calc_coefs(&s->dspctx, s->sample_buf[ch], s->avctx->frame_size, s->min_prediction_order, s->max_prediction_order,
                                    ALAC_MAX_LPC_PRECISION, coefs, shift, 1, ORDER_METHOD_EST, ALAC_MAX_LPC_SHIFT, 1);
 
     s->lpc[ch].lpc_order = opt_order;
@@ -217,12 +219,121 @@ static void alac_stereo_decorrelation(AlacEncodeContext *s)
     }
 }
 
+static void alac_linear_predictor(AlacEncodeContext *s, int ch)
+{
+    int i;
+    LPCContext lpc = s->lpc[ch];
+
+    if(lpc.lpc_order == 31) {
+        s->predictor_buf[0] = s->sample_buf[ch][0];
+
+        for(i=1; i<s->avctx->frame_size; i++)
+            s->predictor_buf[i] = s->sample_buf[ch][i] - s->sample_buf[ch][i-1];
+
+        return;
+    }
+
+    // generalised linear predictor
+
+    if(lpc.lpc_order > 0) {
+        int32_t *samples  = s->sample_buf[ch];
+        int32_t *residual = s->predictor_buf;
+
+        // generate warm-up samples
+        residual[0] = samples[0];
+        for(i=1;i<=lpc.lpc_order;i++)
+            residual[i] = samples[i] - samples[i-1];
+
+        // perform lpc on remaining samples
+        for(i = lpc.lpc_order + 1; i < s->avctx->frame_size; i++) {
+            int sum = 1 << (lpc.lpc_quant - 1), res_val, j;
+
+            for (j = 0; j < lpc.lpc_order; j++) {
+                sum += (samples[lpc.lpc_order-j] - samples[0]) *
+                        lpc.lpc_coeff[j];
+            }
+
+            sum >>= lpc.lpc_quant;
+            sum += samples[0];
+            residual[i] = sign_extend(samples[lpc.lpc_order+1] - sum,
+                                      s->write_sample_size);
+            res_val = residual[i];
+
+            if(res_val) {
+                int index = lpc.lpc_order - 1;
+                int neg = (res_val < 0);
+
+                while(index >= 0 && (neg ? (res_val < 0):(res_val > 0))) {
+                    int val = samples[0] - samples[lpc.lpc_order - index];
+                    int sign = (val ? FFSIGN(val) : 0);
+
+                    if(neg)
+                        sign*=-1;
+
+                    lpc.lpc_coeff[index] -= sign;
+                    val *= sign;
+                    res_val -= ((val >> lpc.lpc_quant) *
+                            (lpc.lpc_order - index));
+                    index--;
+                }
+            }
+            samples++;
+        }
+    }
+}
+
+static void alac_entropy_coder(AlacEncodeContext *s)
+{
+    unsigned int history = s->rc.initial_history;
+    int sign_modifier = 0, i, k;
+    int32_t *samples = s->predictor_buf;
+
+    for(i=0;i < s->avctx->frame_size;) {
+        int x;
+
+        k = av_log2((history >> 9) + 3);
+
+        x = -2*(*samples)-1;
+        x ^= (x>>31);
+
+        samples++;
+        i++;
+
+        encode_scalar(s, x - sign_modifier, k, s->write_sample_size);
+
+        history += x * s->rc.history_mult
+                   - ((history * s->rc.history_mult) >> 9);
+
+        sign_modifier = 0;
+        if(x > 0xFFFF)
+            history = 0xFFFF;
+
+        if((history < 128) && (i < s->avctx->frame_size)) {
+            unsigned int block_size = 0;
+
+            k = 7 - av_log2(history) + ((history + 16) >> 6);
+
+            while((*samples == 0) && (i < s->avctx->frame_size)) {
+                samples++;
+                i++;
+                block_size++;
+            }
+            encode_scalar(s, block_size, k, 16);
+
+            sign_modifier = (block_size <= 0xFFFF);
+
+            history = 0;
+        }
+
+    }
+}
+
 static void write_compressed_frame(AlacEncodeContext *s)
 {
     int i, j;
 
-    /* only simple mid/side decorrelation supported as of now */
-    alac_stereo_decorrelation(s);
+    if(s->avctx->channels == 2)
+        alac_stereo_decorrelation(s);
     put_bits(&s->pbctx, 8, s->interlacing_shift);
     put_bits(&s->pbctx, 8, s->interlacing_leftweight);
 
@@ -255,7 +366,7 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
     uint8_t *alac_extradata = av_mallocz(ALAC_EXTRADATA_SIZE+1);
 
     avctx->frame_size      = DEFAULT_FRAME_SIZE;
-    avctx->bits_per_sample = DEFAULT_SAMPLE_SIZE;
+    avctx->bits_per_coded_sample = DEFAULT_SAMPLE_SIZE;
 
     if(avctx->sample_fmt != SAMPLE_FMT_S16) {
         av_log(avctx, AV_LOG_ERROR, "only pcm_s16 input samples are supported\n");
@@ -275,17 +386,17 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
     s->rc.rice_modifier   = 4;
 
     s->max_coded_frame_size = (ALAC_FRAME_HEADER_SIZE + ALAC_FRAME_FOOTER_SIZE +
-                               avctx->frame_size*avctx->channels*avctx->bits_per_sample)>>3;
+                               avctx->frame_size*avctx->channels*avctx->bits_per_coded_sample)>>3;
 
-    s->write_sample_size  = avctx->bits_per_sample + avctx->channels - 1; // FIXME: consider wasted_bytes
+    s->write_sample_size  = avctx->bits_per_coded_sample + avctx->channels - 1; // FIXME: consider wasted_bytes
 
     AV_WB32(alac_extradata,    ALAC_EXTRADATA_SIZE);
     AV_WB32(alac_extradata+4,  MKBETAG('a','l','a','c'));
     AV_WB32(alac_extradata+12, avctx->frame_size);
-    AV_WB8 (alac_extradata+17, avctx->bits_per_sample);
+    AV_WB8 (alac_extradata+17, avctx->bits_per_coded_sample);
     AV_WB8 (alac_extradata+21, avctx->channels);
     AV_WB32(alac_extradata+24, s->max_coded_frame_size);
-    AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_sample); // average bitrate
+    AV_WB32(alac_extradata+28, avctx->sample_rate*avctx->channels*avctx->bits_per_coded_sample); // average bitrate
     AV_WB32(alac_extradata+32, avctx->sample_rate);
 
     // Set relevant extradata fields
@@ -295,9 +406,10 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
         AV_WB8(alac_extradata+20, s->rc.k_modifier);
     }
 
+    s->min_prediction_order = DEFAULT_MIN_PRED_ORDER;
     if(avctx->min_prediction_order >= 0) {
         if(avctx->min_prediction_order < MIN_LPC_ORDER ||
-            avctx->min_prediction_order > MAX_LPC_ORDER) {
+           avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) {
             av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", avctx->min_prediction_order);
                 return -1;
         }
@@ -305,9 +417,10 @@ static av_cold int alac_encode_init(AVCodecContext *avctx)
         s->min_prediction_order = avctx->min_prediction_order;
     }
 
+    s->max_prediction_order = DEFAULT_MAX_PRED_ORDER;
     if(avctx->max_prediction_order >= 0) {
         if(avctx->max_prediction_order < MIN_LPC_ORDER ||
-           avctx->max_prediction_order > MAX_LPC_ORDER) {
+           avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) {
             av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", avctx->max_prediction_order);
                 return -1;
         }