Add long names to many AVCodec declarations.
[ffmpeg.git] / libavcodec / flacenc.c
index aec63ef..9e5036b 100644 (file)
@@ -2,25 +2,29 @@
  * FLAC audio encoder
  * Copyright (c) 2006  Justin Ruggles <jruggle@earthlink.net>
  *
- * This library is free software; you can redistribute it and/or
+ * 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 of the License, or (at your option) any later version.
+ * version 2.1 of the License, or (at your option) any later version.
  *
- * This library 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 this library; 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
  */
 
 #include "avcodec.h"
 #include "bitstream.h"
 #include "crc.h"
+#include "dsputil.h"
 #include "golomb.h"
+#include "lls.h"
 
 #define FLAC_MAX_CH  8
 #define FLAC_MIN_BLOCKSIZE  16
@@ -42,6 +46,7 @@
 #define ORDER_METHOD_4LEVEL  2
 #define ORDER_METHOD_8LEVEL  3
 #define ORDER_METHOD_SEARCH  4
+#define ORDER_METHOD_LOG     5
 
 #define FLAC_STREAMINFO_SIZE  34
 
@@ -80,7 +85,7 @@ typedef struct FlacSubframe {
     int shift;
     RiceContext rc;
     int32_t samples[FLAC_MAX_BLOCKSIZE];
-    int32_t residual[FLAC_MAX_BLOCKSIZE];
+    int32_t residual[FLAC_MAX_BLOCKSIZE+1];
 } FlacSubframe;
 
 typedef struct FlacFrame {
@@ -97,12 +102,12 @@ typedef struct FlacEncodeContext {
     int ch_code;
     int samplerate;
     int sr_code[2];
-    int blocksize;
     int max_framesize;
     uint32_t frame_count;
     FlacFrame frame;
     CompressionOptions options;
     AVCodecContext *avctx;
+    DSPContext dsp;
 } FlacEncodeContext;
 
 static const int flac_samplerates[16] = {
@@ -130,8 +135,8 @@ static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
     init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
 
     /* streaminfo metadata block */
-    put_bits(&pb, 16, s->blocksize);
-    put_bits(&pb, 16, s->blocksize);
+    put_bits(&pb, 16, s->avctx->frame_size);
+    put_bits(&pb, 16, s->avctx->frame_size);
     put_bits(&pb, 24, 0);
     put_bits(&pb, 24, s->max_framesize);
     put_bits(&pb, 20, s->samplerate);
@@ -163,16 +168,18 @@ static int select_blocksize(int samplerate, int block_time_ms)
     return blocksize;
 }
 
-static int flac_encode_init(AVCodecContext *avctx)
+static av_cold int flac_encode_init(AVCodecContext *avctx)
 {
     int freq = avctx->sample_rate;
     int channels = avctx->channels;
     FlacEncodeContext *s = avctx->priv_data;
-    int i;
+    int i, level;
     uint8_t *streaminfo;
 
     s->avctx = avctx;
 
+    dsputil_init(&s->dsp, avctx);
+
     if(avctx->sample_fmt != SAMPLE_FMT_S16) {
         return -1;
     }
@@ -219,66 +226,33 @@ static int flac_encode_init(AVCodecContext *avctx)
     }
     av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
 
-    if(s->options.compression_level == 0) {
-        s->options.block_time_ms = 27;
-        s->options.use_lpc = 0;
-        s->options.min_prediction_order = 2;
-        s->options.max_prediction_order = 3;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 2;
-        s->options.max_partition_order = 2;
-    } else if(s->options.compression_level == 1) {
-        s->options.block_time_ms = 27;
-        s->options.use_lpc = 0;
-        s->options.min_prediction_order = 0;
-        s->options.max_prediction_order = 4;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 2;
-        s->options.max_partition_order = 2;
-    } else if(s->options.compression_level == 2) {
-        s->options.block_time_ms = 27;
-        s->options.use_lpc = 0;
-        s->options.min_prediction_order = 0;
-        s->options.max_prediction_order = 4;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 0;
-        s->options.max_partition_order = 3;
-    } else if(s->options.compression_level == 3) {
-        s->options.block_time_ms = 105;
-        s->options.use_lpc = 1;
-        s->options.min_prediction_order = 1;
-        s->options.max_prediction_order = 6;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 0;
-        s->options.max_partition_order = 3;
-    } else if(s->options.compression_level == 4) {
-        s->options.block_time_ms = 105;
-        s->options.use_lpc = 1;
-        s->options.min_prediction_order = 1;
-        s->options.max_prediction_order = 8;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 0;
-        s->options.max_partition_order = 3;
-    } else if(s->options.compression_level == 5) {
-        s->options.block_time_ms = 105;
-        s->options.use_lpc = 1;
-        s->options.min_prediction_order = 1;
-        s->options.max_prediction_order = 8;
-        s->options.prediction_order_method = ORDER_METHOD_EST;
-        s->options.min_partition_order = 0;
-        s->options.max_partition_order = 8;
-    } else {
+    level= s->options.compression_level;
+    if(level > 12) {
         av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
                s->options.compression_level);
         return -1;
     }
 
+    s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
+    s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
+    s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
+    s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
+    s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
+                                                   ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
+                                                   ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
+                                                   ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
+                                                   ORDER_METHOD_SEARCH})[level];
+    s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
+    s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
+
     /* set compression option overrides from AVCodecContext */
     if(avctx->use_lpc >= 0) {
-        s->options.use_lpc = !!avctx->use_lpc;
+        s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
     }
-    av_log(avctx, AV_LOG_DEBUG, " use lpc: %s\n",
-           s->options.use_lpc? "yes" : "no");
+    if(s->options.use_lpc == 1)
+        av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
+    else if(s->options.use_lpc > 1)
+        av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
 
     if(avctx->min_prediction_order >= 0) {
         if(s->options.use_lpc) {
@@ -323,14 +297,14 @@ static int flac_encode_init(AVCodecContext *avctx)
            s->options.min_prediction_order, s->options.max_prediction_order);
 
     if(avctx->prediction_order_method >= 0) {
-        if(avctx->prediction_order_method > ORDER_METHOD_SEARCH) {
+        if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
             av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
                    avctx->prediction_order_method);
             return -1;
         }
         s->options.prediction_order_method = avctx->prediction_order_method;
     }
-    switch(avctx->prediction_order_method) {
+    switch(s->options.prediction_order_method) {
         case ORDER_METHOD_EST:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
                                          "estimate"); break;
         case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
@@ -341,6 +315,8 @@ static int flac_encode_init(AVCodecContext *avctx)
                                          "8-level"); break;
         case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
                                          "full search"); break;
+        case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
+                                         "log search"); break;
     }
 
     if(avctx->min_partition_order >= 0) {
@@ -369,17 +345,15 @@ static int flac_encode_init(AVCodecContext *avctx)
 
     if(avctx->frame_size > 0) {
         if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
-                avctx->frame_size > FLAC_MIN_BLOCKSIZE) {
+                avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
             av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
                    avctx->frame_size);
             return -1;
         }
-        s->blocksize = avctx->frame_size;
     } else {
-        s->blocksize = select_blocksize(s->samplerate, s->options.block_time_ms);
-        avctx->frame_size = s->blocksize;
+        s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
     }
-    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->blocksize);
+    av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
 
     /* set LPC precision */
     if(avctx->lpc_coeff_precision > 0) {
@@ -390,25 +364,17 @@ static int flac_encode_init(AVCodecContext *avctx)
         }
         s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
     } else {
-        /* select LPC precision based on block size */
-        if(     s->blocksize <=   192) s->options.lpc_coeff_precision =  7;
-        else if(s->blocksize <=   384) s->options.lpc_coeff_precision =  8;
-        else if(s->blocksize <=   576) s->options.lpc_coeff_precision =  9;
-        else if(s->blocksize <=  1152) s->options.lpc_coeff_precision = 10;
-        else if(s->blocksize <=  2304) s->options.lpc_coeff_precision = 11;
-        else if(s->blocksize <=  4608) s->options.lpc_coeff_precision = 12;
-        else if(s->blocksize <=  8192) s->options.lpc_coeff_precision = 13;
-        else if(s->blocksize <= 16384) s->options.lpc_coeff_precision = 14;
-        else                           s->options.lpc_coeff_precision = 15;
+        /* default LPC precision */
+        s->options.lpc_coeff_precision = 15;
     }
     av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
            s->options.lpc_coeff_precision);
 
     /* set maximum encoded frame size in verbatim mode */
     if(s->channels == 2) {
-        s->max_framesize = 14 + ((s->blocksize * 33 + 7) >> 3);
+        s->max_framesize = 14 + ((s->avctx->frame_size * 33 + 7) >> 3);
     } else {
-        s->max_framesize = 14 + (s->blocksize * s->channels * 2);
+        s->max_framesize = 14 + (s->avctx->frame_size * s->channels * 2);
     }
 
     streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
@@ -432,7 +398,7 @@ static void init_frame(FlacEncodeContext *s)
     frame = &s->frame;
 
     for(i=0; i<16; i++) {
-        if(s->blocksize == flac_blocksizes[i]) {
+        if(s->avctx->frame_size == flac_blocksizes[i]) {
             frame->blocksize = flac_blocksizes[i];
             frame->bs_code[0] = i;
             frame->bs_code[1] = 0;
@@ -440,7 +406,7 @@ static void init_frame(FlacEncodeContext *s)
         }
     }
     if(i == 16) {
-        frame->blocksize = s->blocksize;
+        frame->blocksize = s->avctx->frame_size;
         if(frame->blocksize <= 256) {
             frame->bs_code[0] = 6;
             frame->bs_code[1] = frame->blocksize-1;
@@ -474,20 +440,19 @@ static void copy_samples(FlacEncodeContext *s, int16_t *samples)
 
 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
 
+/**
+ * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
+ */
 static int find_optimal_param(uint32_t sum, int n)
 {
-    int k, k_opt;
-    uint32_t nbits[MAX_RICE_PARAM+1];
-
-    k_opt = 0;
-    nbits[0] = UINT32_MAX;
-    for(k=0; k<=MAX_RICE_PARAM; k++) {
-        nbits[k] = rice_encode_count(sum, n, k);
-        if(nbits[k] < nbits[k_opt]) {
-            k_opt = k;
-        }
-    }
-    return k_opt;
+    int k;
+    uint32_t sum2;
+
+    if(sum <= n>>1)
+        return 0;
+    sum2 = sum-(n>>1);
+    k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
+    return FFMIN(k, MAX_RICE_PARAM);
 }
 
 static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
@@ -498,16 +463,15 @@ static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
     uint32_t all_bits;
 
     part = (1 << porder);
-    all_bits = 0;
+    all_bits = 4 * part;
 
     cnt = (n >> porder) - pred_order;
     for(i=0; i<part; i++) {
-        if(i == 1) cnt = (n >> porder);
         k = find_optimal_param(sums[i], cnt);
         rc->params[i] = k;
         all_bits += rice_encode_count(sums[i], cnt, k);
+        cnt = n >> porder;
     }
-    all_bits += (4 * part);
 
     rc->porder = porder;
 
@@ -526,10 +490,11 @@ static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
     res = &data[pred_order];
     res_end = &data[n >> pmax];
     for(i=0; i<parts; i++) {
-        sums[pmax][i] = 0;
+        uint32_t sum = 0;
         while(res < res_end){
-            sums[pmax][i] += *(res++);
+            sum += *(res++);
         }
+        sums[pmax][i] = sum;
         res_end+= n >> pmax;
     }
     /* sums for lower levels */
@@ -568,7 +533,7 @@ static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
         bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
         if(bits[i] <= bits[opt_porder]) {
             opt_porder = i;
-            memcpy(rc, &tmp_rc, sizeof(RiceContext));
+            *rc= tmp_rc;
         }
     }
 
@@ -576,11 +541,21 @@ static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
     return bits[opt_porder];
 }
 
+static int get_max_p_order(int max_porder, int n, int order)
+{
+    int porder = FFMIN(max_porder, av_log2(n^(n-1)));
+    if(order > 0)
+        porder = FFMIN(porder, av_log2(n/order));
+    return porder;
+}
+
 static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
                                        int32_t *data, int n, int pred_order,
                                        int bps)
 {
     uint32_t bits;
+    pmin = get_max_p_order(pmin, n, pred_order);
+    pmax = get_max_p_order(pmax, n, pred_order);
     bits = pred_order*bps + 6;
     bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
     return bits;
@@ -591,6 +566,8 @@ static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
                                      int bps, int precision)
 {
     uint32_t bits;
+    pmin = get_max_p_order(pmin, n, pred_order);
+    pmax = get_max_p_order(pmax, n, pred_order);
     bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
     bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
     return bits;
@@ -605,13 +582,19 @@ static void apply_welch_window(const int32_t *data, int len, double *w_data)
     double w;
     double c;
 
+    assert(!(len&1)); //the optimization in r11881 does not support odd len
+                      //if someone wants odd len extend the change in r11881
+
     n2 = (len >> 1);
     c = 2.0 / (len - 1.0);
+
+    w_data+=n2;
+      data+=n2;
     for(i=0; i<n2; i++) {
-        w = c - i - 1.0;
+        w = c - n2 + i;
         w = 1.0 - (w * w);
-        w_data[i] = data[i] * w;
-        w_data[len-1-i] = data[len-1-i] * w;
+        w_data[-i-1] = data[-i-1] * w;
+        w_data[+i  ] = data[+i  ] * w;
     }
 }
 
@@ -619,37 +602,37 @@ static void apply_welch_window(const int32_t *data, int len, double *w_data)
  * Calculates autocorrelation data from audio samples
  * A Welch window function is applied before calculation.
  */
-static void compute_autocorr(const int32_t *data, int len, int lag,
-                             double *autoc)
+void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
+                              double *autoc)
 {
-    int i;
-    double *data1;
-    int lag_ptr, ptr;
+    int i, j;
+    double tmp[len + lag + 1];
+    double *data1= tmp + lag;
 
-    data1 = av_malloc(len * sizeof(double));
     apply_welch_window(data, len, data1);
 
-    for(i=0; i<lag; i++) autoc[i] = 1.0;
+    for(j=0; j<lag; j++)
+        data1[j-lag]= 0.0;
+    data1[len] = 0.0;
 
-    ptr = 0;
-    while(ptr <= lag) {
-        lag_ptr = 0;
-        while(lag_ptr <= ptr) {
-            autoc[ptr-lag_ptr] += data1[ptr] * data1[lag_ptr];
-            lag_ptr++;
+    for(j=0; j<lag; j+=2){
+        double sum0 = 1.0, sum1 = 1.0;
+        for(i=0; i<len; i++){
+            sum0 += data1[i] * data1[i-j];
+            sum1 += data1[i] * data1[i-j-1];
         }
-        ptr++;
+        autoc[j  ] = sum0;
+        autoc[j+1] = sum1;
     }
-    while(ptr < len) {
-        lag_ptr = ptr - lag;
-        while(lag_ptr <= ptr) {
-            autoc[ptr-lag_ptr] += data1[ptr] * data1[lag_ptr];
-            lag_ptr++;
+
+    if(j==lag){
+        double sum = 1.0;
+        for(i=0; i<len; i+=2){
+            sum += data1[i  ] * data1[i-j  ]
+                 + data1[i+1] * data1[i-j+1];
         }
-        ptr++;
+        autoc[j] = sum;
     }
-
-    av_freep(&data1);
 }
 
 /**
@@ -700,7 +683,7 @@ static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
                                int32_t *lpc_out, int *shift)
 {
     int i;
-    double d, cmax;
+    double cmax, error;
     int32_t qmax;
     int sh;
 
@@ -710,18 +693,13 @@ static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
     /* find maximum coefficient value */
     cmax = 0.0;
     for(i=0; i<order; i++) {
-        d = lpc_in[i];
-        if(d < 0) d = -d;
-        if(d > cmax)
-            cmax = d;
+        cmax= FFMAX(cmax, fabs(lpc_in[i]));
     }
 
     /* if maximum value quantizes to zero, return all zeros */
     if(cmax * (1 << MAX_LPC_SHIFT) < 1.0) {
         *shift = 0;
-        for(i=0; i<order; i++) {
-            lpc_out[i] = 0;
-        }
+        memset(lpc_out, 0, sizeof(int32_t) * order);
         return;
     }
 
@@ -741,8 +719,11 @@ static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
     }
 
     /* output quantized coefficients and level shift */
+    error=0;
     for(i=0; i<order; i++) {
-        lpc_out[i] = (int32_t)(lpc_in[i] * (1 << sh));
+        error += lpc_in[i] * (1 << sh);
+        lpc_out[i] = av_clip(lrintf(error), -qmax, qmax);
+        error -= lpc_out[i];
     }
     *shift = sh;
 }
@@ -764,26 +745,71 @@ static int estimate_best_order(double *ref, int max_order)
 /**
  * Calculate LPC coefficients for multiple orders
  */
-static int lpc_calc_coefs(const int32_t *samples, int blocksize, int max_order,
+static int lpc_calc_coefs(FlacEncodeContext *s,
+                          const int32_t *samples, int blocksize, int max_order,
                           int precision, int32_t coefs[][MAX_LPC_ORDER],
-                          int *shift)
+                          int *shift, int use_lpc, int omethod)
 {
     double autoc[MAX_LPC_ORDER+1];
     double ref[MAX_LPC_ORDER];
     double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
-    int i;
+    int i, j, pass;
     int opt_order;
 
     assert(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER);
 
-    compute_autocorr(samples, blocksize, max_order+1, autoc);
+    if(use_lpc == 1){
+        s->dsp.flac_compute_autocorr(samples, blocksize, max_order, autoc);
 
-    compute_lpc_coefs(autoc, max_order, lpc, ref);
+        compute_lpc_coefs(autoc, max_order, lpc, ref);
+    }else{
+        LLSModel m[2];
+        double var[MAX_LPC_ORDER+1], weight;
+
+        for(pass=0; pass<use_lpc-1; pass++){
+            av_init_lls(&m[pass&1], max_order);
+
+            weight=0;
+            for(i=max_order; i<blocksize; i++){
+                for(j=0; j<=max_order; j++)
+                    var[j]= samples[i-j];
+
+                if(pass){
+                    double eval, inv, rinv;
+                    eval= av_evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
+                    eval= (512>>pass) + fabs(eval - var[0]);
+                    inv = 1/eval;
+                    rinv = sqrt(inv);
+                    for(j=0; j<=max_order; j++)
+                        var[j] *= rinv;
+                    weight += inv;
+                }else
+                    weight++;
+
+                av_update_lls(&m[pass&1], var, 1.0);
+            }
+            av_solve_lls(&m[pass&1], 0.001, 0);
+        }
 
-    opt_order = estimate_best_order(ref, max_order);
+        for(i=0; i<max_order; i++){
+            for(j=0; j<max_order; j++)
+                lpc[i][j]= m[(pass-1)&1].coeff[i][j];
+            ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
+        }
+        for(i=max_order-1; i>0; i--)
+            ref[i] = ref[i-1] - ref[i];
+    }
+    opt_order = max_order;
 
-    i = opt_order-1;
-    quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i]);
+    if(omethod == ORDER_METHOD_EST) {
+        opt_order = estimate_best_order(ref, max_order);
+        i = opt_order-1;
+        quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i]);
+    } else {
+        for(i=0; i<max_order; i++) {
+            quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i]);
+        }
+    }
 
     return opt_order;
 }
@@ -811,55 +837,149 @@ static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
         for(i=order; i<n; i++)
             res[i]= smp[i] - smp[i-1];
     }else if(order==2){
-        for(i=order; i<n; i++)
-            res[i]= smp[i] - 2*smp[i-1] + smp[i-2];
+        int a = smp[order-1] - smp[order-2];
+        for(i=order; i<n; i+=2) {
+            int b = smp[i] - smp[i-1];
+            res[i]= b - a;
+            a = smp[i+1] - smp[i];
+            res[i+1]= a - b;
+        }
     }else if(order==3){
-        for(i=order; i<n; i++)
-            res[i]= smp[i] - 3*smp[i-1] + 3*smp[i-2] - smp[i-3];
+        int a = smp[order-1] - smp[order-2];
+        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
+        for(i=order; i<n; i+=2) {
+            int b = smp[i] - smp[i-1];
+            int d = b - a;
+            res[i]= d - c;
+            a = smp[i+1] - smp[i];
+            c = a - b;
+            res[i+1]= c - d;
+        }
     }else{
-        for(i=order; i<n; i++)
-            res[i]= smp[i] - 4*smp[i-1] + 6*smp[i-2] - 4*smp[i-3] + smp[i-4];
+        int a = smp[order-1] - smp[order-2];
+        int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
+        int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
+        for(i=order; i<n; i+=2) {
+            int b = smp[i] - smp[i-1];
+            int d = b - a;
+            int f = d - c;
+            res[i]= f - e;
+            a = smp[i+1] - smp[i];
+            c = a - b;
+            e = c - d;
+            res[i+1]= e - f;
+        }
+    }
+}
+
+#define LPC1(x) {\
+    int c = coefs[(x)-1];\
+    p0 += c*s;\
+    s = smp[i-(x)+1];\
+    p1 += c*s;\
+}
+
+static av_always_inline void encode_residual_lpc_unrolled(
+    int32_t *res, const int32_t *smp, int n,
+    int order, const int32_t *coefs, int shift, int big)
+{
+    int i;
+    for(i=order; i<n; i+=2) {
+        int s = smp[i-order];
+        int p0 = 0, p1 = 0;
+        if(big) {
+            switch(order) {
+                case 32: LPC1(32)
+                case 31: LPC1(31)
+                case 30: LPC1(30)
+                case 29: LPC1(29)
+                case 28: LPC1(28)
+                case 27: LPC1(27)
+                case 26: LPC1(26)
+                case 25: LPC1(25)
+                case 24: LPC1(24)
+                case 23: LPC1(23)
+                case 22: LPC1(22)
+                case 21: LPC1(21)
+                case 20: LPC1(20)
+                case 19: LPC1(19)
+                case 18: LPC1(18)
+                case 17: LPC1(17)
+                case 16: LPC1(16)
+                case 15: LPC1(15)
+                case 14: LPC1(14)
+                case 13: LPC1(13)
+                case 12: LPC1(12)
+                case 11: LPC1(11)
+                case 10: LPC1(10)
+                case  9: LPC1( 9)
+                         LPC1( 8)
+                         LPC1( 7)
+                         LPC1( 6)
+                         LPC1( 5)
+                         LPC1( 4)
+                         LPC1( 3)
+                         LPC1( 2)
+                         LPC1( 1)
+            }
+        } else {
+            switch(order) {
+                case  8: LPC1( 8)
+                case  7: LPC1( 7)
+                case  6: LPC1( 6)
+                case  5: LPC1( 5)
+                case  4: LPC1( 4)
+                case  3: LPC1( 3)
+                case  2: LPC1( 2)
+                case  1: LPC1( 1)
+            }
+        }
+        res[i  ] = smp[i  ] - (p0 >> shift);
+        res[i+1] = smp[i+1] - (p1 >> shift);
     }
 }
 
 static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
                                 int order, const int32_t *coefs, int shift)
 {
-    int i, j;
-    int32_t pred;
-
+    int i;
     for(i=0; i<order; i++) {
         res[i] = smp[i];
     }
-    for(i=order; i<n; i++) {
-        pred = 0;
+#ifdef CONFIG_SMALL
+    for(i=order; i<n; i+=2) {
+        int j;
+        int s = smp[i];
+        int p0 = 0, p1 = 0;
         for(j=0; j<order; j++) {
-            pred += coefs[j] * smp[i-j-1];
-        }
-        res[i] = smp[i] - (pred >> shift);
-    }
-}
-
-static int get_max_p_order(int max_porder, int n, int order)
-{
-    int porder, max_parts;
-
-    porder = max_porder;
-    while(porder > 0) {
-        max_parts = (1 << porder);
-        if(!(n % max_parts) && (n > max_parts*order)) {
-            break;
+            int c = coefs[j];
+            p1 += c*s;
+            s = smp[i-j-1];
+            p0 += c*s;
         }
-        porder--;
-    }
-    return porder;
+        res[i  ] = smp[i  ] - (p0 >> shift);
+        res[i+1] = smp[i+1] - (p1 >> shift);
+    }
+#else
+    switch(order) {
+        case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
+        case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
+        case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
+        case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
+        case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
+        case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
+        case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
+        case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
+        default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
+    }
+#endif
 }
 
 static int encode_residual(FlacEncodeContext *ctx, int ch)
 {
     int i, n;
-    int min_order, max_order, opt_order, precision;
-    int porder, min_porder, max_porder;
+    int min_order, max_order, opt_order, precision, omethod;
+    int min_porder, max_porder;
     FlacFrame *frame;
     FlacSubframe *sub;
     int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
@@ -894,6 +1014,7 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
     min_porder = ctx->options.min_partition_order;
     max_porder = ctx->options.max_partition_order;
     precision = ctx->options.lpc_coeff_precision;
+    omethod = ctx->options.prediction_order_method;
 
     /* FIXED */
     if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
@@ -903,8 +1024,7 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
         bits[0] = UINT32_MAX;
         for(i=min_order; i<=max_order; i++) {
             encode_residual_fixed(res, smp, n, i);
-            porder = get_max_p_order(max_porder, n, i);
-            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, porder, res,
+            bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
                                              n, i, sub->obits);
             if(bits[i] < bits[opt_order]) {
                 opt_order = i;
@@ -915,24 +1035,81 @@ static int encode_residual(FlacEncodeContext *ctx, int ch)
         sub->type_code = sub->type | sub->order;
         if(sub->order != max_order) {
             encode_residual_fixed(res, smp, n, sub->order);
-            porder = get_max_p_order(max_porder, n, sub->order);
-            return calc_rice_params_fixed(&sub->rc, min_porder, porder, res, n,
+            return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
                                           sub->order, sub->obits);
         }
         return bits[sub->order];
     }
 
     /* LPC */
-    sub->order = lpc_calc_coefs(smp, n, max_order, precision, coefs, shift);
+    opt_order = lpc_calc_coefs(ctx, smp, n, max_order, precision, coefs, shift, ctx->options.use_lpc, omethod);
+
+    if(omethod == ORDER_METHOD_2LEVEL ||
+       omethod == ORDER_METHOD_4LEVEL ||
+       omethod == ORDER_METHOD_8LEVEL) {
+        int levels = 1 << omethod;
+        uint32_t bits[levels];
+        int order;
+        int opt_index = levels-1;
+        opt_order = max_order-1;
+        bits[opt_index] = UINT32_MAX;
+        for(i=levels-1; i>=0; i--) {
+            order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
+            if(order < 0) order = 0;
+            encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
+            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
+                                           res, n, order+1, sub->obits, precision);
+            if(bits[i] < bits[opt_index]) {
+                opt_index = i;
+                opt_order = order;
+            }
+        }
+        opt_order++;
+    } else if(omethod == ORDER_METHOD_SEARCH) {
+        // brute-force optimal order search
+        uint32_t bits[MAX_LPC_ORDER];
+        opt_order = 0;
+        bits[0] = UINT32_MAX;
+        for(i=min_order-1; i<max_order; i++) {
+            encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
+            bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
+                                           res, n, i+1, sub->obits, precision);
+            if(bits[i] < bits[opt_order]) {
+                opt_order = i;
+            }
+        }
+        opt_order++;
+    } else if(omethod == ORDER_METHOD_LOG) {
+        uint32_t bits[MAX_LPC_ORDER];
+        int step;
+
+        opt_order= min_order - 1 + (max_order-min_order)/3;
+        memset(bits, -1, sizeof(bits));
+
+        for(step=16 ;step; step>>=1){
+            int last= opt_order;
+            for(i=last-step; i<=last+step; i+= step){
+                if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
+                    continue;
+                encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
+                bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
+                                            res, n, i+1, sub->obits, precision);
+                if(bits[i] < bits[opt_order])
+                    opt_order= i;
+            }
+        }
+        opt_order++;
+    }
+
+    sub->order = opt_order;
     sub->type = FLAC_SUBFRAME_LPC;
     sub->type_code = sub->type | (sub->order-1);
     sub->shift = shift[sub->order-1];
     for(i=0; i<sub->order; i++) {
         sub->coefs[i] = coefs[sub->order-1][i];
     }
-    porder = get_max_p_order(max_porder, n, sub->order);
     encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
-    return calc_rice_params_lpc(&sub->rc, 0, porder, res, n, sub->order,
+    return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
                                 sub->obits, precision);
 }
 
@@ -978,10 +1155,10 @@ static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
     for(i=2; i<n; i++) {
         lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
         rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
-        sum[2] += ABS((lt + rt) >> 1);
-        sum[3] += ABS(lt - rt);
-        sum[0] += ABS(lt);
-        sum[1] += ABS(rt);
+        sum[2] += FFABS((lt + rt) >> 1);
+        sum[3] += FFABS(lt - rt);
+        sum[0] += FFABS(lt);
+        sum[1] += FFABS(rt);
     }
     /* estimate bit counts */
     for(i=0; i<4; i++) {
@@ -1068,20 +1245,8 @@ static void put_sbits(PutBitContext *pb, int bits, int32_t val)
 
 static void write_utf8(PutBitContext *pb, uint32_t val)
 {
-    int bytes, shift;
-
-    if(val < 0x80){
-        put_bits(pb, 8, val);
-        return;
-    }
-
-    bytes= (av_log2(val)+4) / 5;
-    shift = (bytes - 1) * 6;
-    put_bits(pb, 8, (256 - (256>>bytes)) | (val >> shift));
-    while(shift >= 6){
-        shift -= 6;
-        put_bits(pb, 8, 0x80 | ((val >> shift) & 0x3F));
-    }
+    uint8_t tmp;
+    PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
 }
 
 static void output_frame_header(FlacEncodeContext *s)
@@ -1113,7 +1278,8 @@ static void output_frame_header(FlacEncodeContext *s)
         put_bits(&s->pb, 16, s->sr_code[1]);
     }
     flush_put_bits(&s->pb);
-    crc = av_crc(av_crc07, 0, s->pb.buf, put_bits_count(&s->pb)>>3);
+    crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
+                 s->pb.buf, put_bits_count(&s->pb)>>3);
     put_bits(&s->pb, 8, crc);
 }
 
@@ -1255,7 +1421,8 @@ static void output_frame_footer(FlacEncodeContext *s)
 {
     int crc;
     flush_put_bits(&s->pb);
-    crc = bswap_16(av_crc(av_crc8005, 0, s->pb.buf, put_bits_count(&s->pb)>>3));
+    crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
+                          s->pb.buf, put_bits_count(&s->pb)>>3));
     put_bits(&s->pb, 16, crc);
     flush_put_bits(&s->pb);
 }
@@ -1270,7 +1437,6 @@ static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
 
     s = avctx->priv_data;
 
-    s->blocksize = avctx->frame_size;
     init_frame(s);
 
     copy_samples(s, samples);
@@ -1308,7 +1474,7 @@ static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
     return out_bytes;
 }
 
-static int flac_encode_close(AVCodecContext *avctx)
+static av_cold int flac_encode_close(AVCodecContext *avctx)
 {
     av_freep(&avctx->extradata);
     avctx->extradata_size = 0;
@@ -1326,4 +1492,5 @@ AVCodec flac_encoder = {
     flac_encode_close,
     NULL,
     .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
+    .long_name = "FLAC (Free Lossless Audio Codec)",
 };