libavcodec/flacenc.c

   1 /**
   2  * FLAC audio encoder
   3  * Copyright (c) 2006  Justin Ruggles <justin.ruggles@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/crc.h"
  23 #include "libavutil/lls.h"
  24 #include "libavutil/md5.h"
  25 #include "avcodec.h"
  26 #include "bitstream.h"
  27 #include "dsputil.h"
  28 #include "golomb.h"
  29 #include "lpc.h"
  30
  31 #define FLAC_MAX_CH  8
  32 #define FLAC_MIN_BLOCKSIZE  16
  33 #define FLAC_MAX_BLOCKSIZE  65535
  34
  35 #define FLAC_SUBFRAME_CONSTANT  0
  36 #define FLAC_SUBFRAME_VERBATIM  1
  37 #define FLAC_SUBFRAME_FIXED     8
  38 #define FLAC_SUBFRAME_LPC      32
  39
  40 #define FLAC_CHMODE_NOT_STEREO      0
  41 #define FLAC_CHMODE_LEFT_RIGHT      1
  42 #define FLAC_CHMODE_LEFT_SIDE       8
  43 #define FLAC_CHMODE_RIGHT_SIDE      9
  44 #define FLAC_CHMODE_MID_SIDE       10
  45
  46 #define FLAC_STREAMINFO_SIZE  34
  47
  48 #define MAX_FIXED_ORDER     4
  49 #define MAX_PARTITION_ORDER 8
  50 #define MAX_PARTITIONS     (1 << MAX_PARTITION_ORDER)
  51 #define MAX_LPC_PRECISION  15
  52 #define MAX_LPC_SHIFT      15
  53 #define MAX_RICE_PARAM     14
  54
  55 typedef struct CompressionOptions {
  56     int compression_level;
  57     int block_time_ms;
  58     int use_lpc;
  59     int lpc_coeff_precision;
  60     int min_prediction_order;
  61     int max_prediction_order;
  62     int prediction_order_method;
  63     int min_partition_order;
  64     int max_partition_order;
  65 } CompressionOptions;
  66
  67 typedef struct RiceContext {
  68     int porder;
  69     int params[MAX_PARTITIONS];
  70 } RiceContext;
  71
  72 typedef struct FlacSubframe {
  73     int type;
  74     int type_code;
  75     int obits;
  76     int order;
  77     int32_t coefs[MAX_LPC_ORDER];
  78     int shift;
  79     RiceContext rc;
  80     int32_t samples[FLAC_MAX_BLOCKSIZE];
  81     int32_t residual[FLAC_MAX_BLOCKSIZE+1];
  82 } FlacSubframe;
  83
  84 typedef struct FlacFrame {
  85     FlacSubframe subframes[FLAC_MAX_CH];
  86     int blocksize;
  87     int bs_code[2];
  88     uint8_t crc8;
  89     int ch_mode;
  90 } FlacFrame;
  91
  92 typedef struct FlacEncodeContext {
  93     PutBitContext pb;
  94     int channels;
  95     int ch_code;
  96     int samplerate;
  97     int sr_code[2];
  98     int min_framesize;
  99     int min_encoded_framesize;
 100     int max_framesize;
 101     int max_encoded_framesize;
 102     uint32_t frame_count;
 103     uint64_t sample_count;
 104     uint8_t md5sum[16];
 105     FlacFrame frame;
 106     CompressionOptions options;
 107     AVCodecContext *avctx;
 108     DSPContext dsp;
 109     struct AVMD5 *md5ctx;
 110 } FlacEncodeContext;
 111
 112 static const int flac_samplerates[16] = {
 113     0, 0, 0, 0,
 114     8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
 115     0, 0, 0, 0
 116 };
 117
 118 static const int flac_blocksizes[16] = {
 119     0,
 120     192,
 121     576, 1152, 2304, 4608,
 122     0, 0,
 123     256, 512, 1024, 2048, 4096, 8192, 16384, 32768
 124 };
 125
 126 /**
 127  * Writes streaminfo metadata block to byte array
 128  */
 129 static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
 130 {
 131     PutBitContext pb;
 132
 133     memset(header, 0, FLAC_STREAMINFO_SIZE);
 134     init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
 135
 136     /* streaminfo metadata block */
 137     put_bits(&pb, 16, s->avctx->frame_size);
 138     put_bits(&pb, 16, s->avctx->frame_size);
 139     put_bits(&pb, 24, s->min_framesize);
 140     put_bits(&pb, 24, s->max_framesize);
 141     put_bits(&pb, 20, s->samplerate);
 142     put_bits(&pb, 3, s->channels-1);
 143     put_bits(&pb, 5, 15);       /* bits per sample - 1 */
 144     /* write 36-bit sample count in 2 put_bits() calls */
 145     put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
 146     put_bits(&pb, 12,  s->sample_count & 0x000000FFFLL);
 147     flush_put_bits(&pb);
 148     memcpy(&header[18], s->md5sum, 16);
 149 }
 150
 151 /**
 152  * Sets blocksize based on samplerate
 153  * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
 154  */
 155 static int select_blocksize(int samplerate, int block_time_ms)
 156 {
 157     int i;
 158     int target;
 159     int blocksize;
 160
 161     assert(samplerate > 0);
 162     blocksize = flac_blocksizes[1];
 163     target = (samplerate * block_time_ms) / 1000;
 164     for(i=0; i<16; i++) {
 165         if(target >= flac_blocksizes[i] && flac_blocksizes[i] > blocksize) {
 166             blocksize = flac_blocksizes[i];
 167         }
 168     }
 169     return blocksize;
 170 }
 171
 172 static av_cold int flac_encode_init(AVCodecContext *avctx)
 173 {
 174     int freq = avctx->sample_rate;
 175     int channels = avctx->channels;
 176     FlacEncodeContext *s = avctx->priv_data;
 177     int i, level;
 178     uint8_t *streaminfo;
 179
 180     s->avctx = avctx;
 181
 182     dsputil_init(&s->dsp, avctx);
 183
 184     if(avctx->sample_fmt != SAMPLE_FMT_S16) {
 185         return -1;
 186     }
 187
 188     if(channels < 1 || channels > FLAC_MAX_CH) {
 189         return -1;
 190     }
 191     s->channels = channels;
 192     s->ch_code = s->channels-1;
 193
 194     /* find samplerate in table */
 195     if(freq < 1)
 196         return -1;
 197     for(i=4; i<12; i++) {
 198         if(freq == flac_samplerates[i]) {
 199             s->samplerate = flac_samplerates[i];
 200             s->sr_code[0] = i;
 201             s->sr_code[1] = 0;
 202             break;
 203         }
 204     }
 205     /* if not in table, samplerate is non-standard */
 206     if(i == 12) {
 207         if(freq % 1000 == 0 && freq < 255000) {
 208             s->sr_code[0] = 12;
 209             s->sr_code[1] = freq / 1000;
 210         } else if(freq % 10 == 0 && freq < 655350) {
 211             s->sr_code[0] = 14;
 212             s->sr_code[1] = freq / 10;
 213         } else if(freq < 65535) {
 214             s->sr_code[0] = 13;
 215             s->sr_code[1] = freq;
 216         } else {
 217             return -1;
 218         }
 219         s->samplerate = freq;
 220     }
 221
 222     /* set compression option defaults based on avctx->compression_level */
 223     if(avctx->compression_level < 0) {
 224         s->options.compression_level = 5;
 225     } else {
 226         s->options.compression_level = avctx->compression_level;
 227     }
 228     av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
 229
 230     level= s->options.compression_level;
 231     if(level > 12) {
 232         av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
 233                s->options.compression_level);
 234         return -1;
 235     }
 236
 237     s->options.block_time_ms       = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
 238     s->options.use_lpc             = ((int[]){  0,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
 239     s->options.min_prediction_order= ((int[]){  2,  0,  0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1})[level];
 240     s->options.max_prediction_order= ((int[]){  3,  4,  4,  6,  8,  8,  8,  8, 12, 12, 12, 32, 32})[level];
 241     s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
 242                                                    ORDER_METHOD_EST,    ORDER_METHOD_EST,    ORDER_METHOD_EST,
 243                                                    ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG,    ORDER_METHOD_4LEVEL,
 244                                                    ORDER_METHOD_LOG,    ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
 245                                                    ORDER_METHOD_SEARCH})[level];
 246     s->options.min_partition_order = ((int[]){  2,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0})[level];
 247     s->options.max_partition_order = ((int[]){  2,  2,  3,  3,  3,  8,  8,  8,  8,  8,  8,  8,  8})[level];
 248
 249     /* set compression option overrides from AVCodecContext */
 250     if(avctx->use_lpc >= 0) {
 251         s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
 252     }
 253     if(s->options.use_lpc == 1)
 254         av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
 255     else if(s->options.use_lpc > 1)
 256         av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
 257
 258     if(avctx->min_prediction_order >= 0) {
 259         if(s->options.use_lpc) {
 260             if(avctx->min_prediction_order < MIN_LPC_ORDER ||
 261                     avctx->min_prediction_order > MAX_LPC_ORDER) {
 262                 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
 263                        avctx->min_prediction_order);
 264                 return -1;
 265             }
 266         } else {
 267             if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
 268                 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
 269                        avctx->min_prediction_order);
 270                 return -1;
 271             }
 272         }
 273         s->options.min_prediction_order = avctx->min_prediction_order;
 274     }
 275     if(avctx->max_prediction_order >= 0) {
 276         if(s->options.use_lpc) {
 277             if(avctx->max_prediction_order < MIN_LPC_ORDER ||
 278                     avctx->max_prediction_order > MAX_LPC_ORDER) {
 279                 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
 280                        avctx->max_prediction_order);
 281                 return -1;
 282             }
 283         } else {
 284             if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
 285                 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
 286                        avctx->max_prediction_order);
 287                 return -1;
 288             }
 289         }
 290         s->options.max_prediction_order = avctx->max_prediction_order;
 291     }
 292     if(s->options.max_prediction_order < s->options.min_prediction_order) {
 293         av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
 294                s->options.min_prediction_order, s->options.max_prediction_order);
 295         return -1;
 296     }
 297     av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
 298            s->options.min_prediction_order, s->options.max_prediction_order);
 299
 300     if(avctx->prediction_order_method >= 0) {
 301         if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
 302             av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
 303                    avctx->prediction_order_method);
 304             return -1;
 305         }
 306         s->options.prediction_order_method = avctx->prediction_order_method;
 307     }
 308     switch(s->options.prediction_order_method) {
 309         case ORDER_METHOD_EST:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 310                                          "estimate"); break;
 311         case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 312                                          "2-level"); break;
 313         case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 314                                          "4-level"); break;
 315         case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 316                                          "8-level"); break;
 317         case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 318                                          "full search"); break;
 319         case ORDER_METHOD_LOG:    av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
 320                                          "log search"); break;
 321     }
 322
 323     if(avctx->min_partition_order >= 0) {
 324         if(avctx->min_partition_order > MAX_PARTITION_ORDER) {
 325             av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",
 326                    avctx->min_partition_order);
 327             return -1;
 328         }
 329         s->options.min_partition_order = avctx->min_partition_order;
 330     }
 331     if(avctx->max_partition_order >= 0) {
 332         if(avctx->max_partition_order > MAX_PARTITION_ORDER) {
 333             av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",
 334                    avctx->max_partition_order);
 335             return -1;
 336         }
 337         s->options.max_partition_order = avctx->max_partition_order;
 338     }
 339     if(s->options.max_partition_order < s->options.min_partition_order) {
 340         av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
 341                s->options.min_partition_order, s->options.max_partition_order);
 342         return -1;
 343     }
 344     av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
 345            s->options.min_partition_order, s->options.max_partition_order);
 346
 347     if(avctx->frame_size > 0) {
 348         if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
 349                 avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
 350             av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
 351                    avctx->frame_size);
 352             return -1;
 353         }
 354     } else {
 355         s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
 356     }
 357     av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->avctx->frame_size);
 358
 359     /* set LPC precision */
 360     if(avctx->lpc_coeff_precision > 0) {
 361         if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
 362             av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
 363                    avctx->lpc_coeff_precision);
 364             return -1;
 365         }
 366         s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
 367     } else {
 368         /* default LPC precision */
 369         s->options.lpc_coeff_precision = 15;
 370     }
 371     av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
 372            s->options.lpc_coeff_precision);
 373
 374     /* set maximum encoded frame size in verbatim mode */
 375     if(s->channels == 2) {
 376         s->max_framesize = 14 + ((s->avctx->frame_size * 33 + 7) >> 3);
 377     } else {
 378         s->max_framesize = 14 + (s->avctx->frame_size * s->channels * 2);
 379     }
 380     s->min_encoded_framesize = 0xFFFFFF;
 381
 382     /* initialize MD5 context */
 383     s->md5ctx = av_malloc(av_md5_size);
 384     if(!s->md5ctx)
 385         return AVERROR_NOMEM;
 386     av_md5_init(s->md5ctx);
 387
 388     streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
 389     write_streaminfo(s, streaminfo);
 390     avctx->extradata = streaminfo;
 391     avctx->extradata_size = FLAC_STREAMINFO_SIZE;
 392
 393     s->frame_count = 0;
 394
 395     avctx->coded_frame = avcodec_alloc_frame();
 396     avctx->coded_frame->key_frame = 1;
 397
 398     return 0;
 399 }
 400
 401 static void init_frame(FlacEncodeContext *s)
 402 {
 403     int i, ch;
 404     FlacFrame *frame;
 405
 406     frame = &s->frame;
 407
 408     for(i=0; i<16; i++) {
 409         if(s->avctx->frame_size == flac_blocksizes[i]) {
 410             frame->blocksize = flac_blocksizes[i];
 411             frame->bs_code[0] = i;
 412             frame->bs_code[1] = 0;
 413             break;
 414         }
 415     }
 416     if(i == 16) {
 417         frame->blocksize = s->avctx->frame_size;
 418         if(frame->blocksize <= 256) {
 419             frame->bs_code[0] = 6;
 420             frame->bs_code[1] = frame->blocksize-1;
 421         } else {
 422             frame->bs_code[0] = 7;
 423             frame->bs_code[1] = frame->blocksize-1;
 424         }
 425     }
 426
 427     for(ch=0; ch<s->channels; ch++) {
 428         frame->subframes[ch].obits = 16;
 429     }
 430 }
 431
 432 /**
 433  * Copy channel-interleaved input samples into separate subframes
 434  */
 435 static void copy_samples(FlacEncodeContext *s, int16_t *samples)
 436 {
 437     int i, j, ch;
 438     FlacFrame *frame;
 439
 440     frame = &s->frame;
 441     for(i=0,j=0; i<frame->blocksize; i++) {
 442         for(ch=0; ch<s->channels; ch++,j++) {
 443             frame->subframes[ch].samples[i] = samples[j];
 444         }
 445     }
 446 }
 447
 448
 449 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
 450
 451 /**
 452  * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
 453  */
 454 static int find_optimal_param(uint32_t sum, int n)
 455 {
 456     int k;
 457     uint32_t sum2;
 458
 459     if(sum <= n>>1)
 460         return 0;
 461     sum2 = sum-(n>>1);
 462     k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
 463     return FFMIN(k, MAX_RICE_PARAM);
 464 }
 465
 466 static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
 467                                          uint32_t *sums, int n, int pred_order)
 468 {
 469     int i;
 470     int k, cnt, part;
 471     uint32_t all_bits;
 472
 473     part = (1 << porder);
 474     all_bits = 4 * part;
 475
 476     cnt = (n >> porder) - pred_order;
 477     for(i=0; i<part; i++) {
 478         k = find_optimal_param(sums[i], cnt);
 479         rc->params[i] = k;
 480         all_bits += rice_encode_count(sums[i], cnt, k);
 481         cnt = n >> porder;
 482     }
 483
 484     rc->porder = porder;
 485
 486     return all_bits;
 487 }
 488
 489 static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
 490                       uint32_t sums[][MAX_PARTITIONS])
 491 {
 492     int i, j;
 493     int parts;
 494     uint32_t *res, *res_end;
 495
 496     /* sums for highest level */
 497     parts = (1 << pmax);
 498     res = &data[pred_order];
 499     res_end = &data[n >> pmax];
 500     for(i=0; i<parts; i++) {
 501         uint32_t sum = 0;
 502         while(res < res_end){
 503             sum += *(res++);
 504         }
 505         sums[pmax][i] = sum;
 506         res_end+= n >> pmax;
 507     }
 508     /* sums for lower levels */
 509     for(i=pmax-1; i>=pmin; i--) {
 510         parts = (1 << i);
 511         for(j=0; j<parts; j++) {
 512             sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
 513         }
 514     }
 515 }
 516
 517 static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
 518                                  int32_t *data, int n, int pred_order)
 519 {
 520     int i;
 521     uint32_t bits[MAX_PARTITION_ORDER+1];
 522     int opt_porder;
 523     RiceContext tmp_rc;
 524     uint32_t *udata;
 525     uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
 526
 527     assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
 528     assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
 529     assert(pmin <= pmax);
 530
 531     udata = av_malloc(n * sizeof(uint32_t));
 532     for(i=0; i<n; i++) {
 533         udata[i] = (2*data[i]) ^ (data[i]>>31);
 534     }
 535
 536     calc_sums(pmin, pmax, udata, n, pred_order, sums);
 537
 538     opt_porder = pmin;
 539     bits[pmin] = UINT32_MAX;
 540     for(i=pmin; i<=pmax; i++) {
 541         bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
 542         if(bits[i] <= bits[opt_porder]) {
 543             opt_porder = i;
 544             *rc= tmp_rc;
 545         }
 546     }
 547
 548     av_freep(&udata);
 549     return bits[opt_porder];
 550 }
 551
 552 static int get_max_p_order(int max_porder, int n, int order)
 553 {
 554     int porder = FFMIN(max_porder, av_log2(n^(n-1)));
 555     if(order > 0)
 556         porder = FFMIN(porder, av_log2(n/order));
 557     return porder;
 558 }
 559
 560 static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
 561                                        int32_t *data, int n, int pred_order,
 562                                        int bps)
 563 {
 564     uint32_t bits;
 565     pmin = get_max_p_order(pmin, n, pred_order);
 566     pmax = get_max_p_order(pmax, n, pred_order);
 567     bits = pred_order*bps + 6;
 568     bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
 569     return bits;
 570 }
 571
 572 static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
 573                                      int32_t *data, int n, int pred_order,
 574                                      int bps, int precision)
 575 {
 576     uint32_t bits;
 577     pmin = get_max_p_order(pmin, n, pred_order);
 578     pmax = get_max_p_order(pmax, n, pred_order);
 579     bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
 580     bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
 581     return bits;
 582 }
 583
 584 /**
 585  * Apply Welch window function to audio block
 586  */
 587 static void apply_welch_window(const int32_t *data, int len, double *w_data)
 588 {
 589     int i, n2;
 590     double w;
 591     double c;
 592
 593     assert(!(len&1)); //the optimization in r11881 does not support odd len
 594                       //if someone wants odd len extend the change in r11881
 595
 596     n2 = (len >> 1);
 597     c = 2.0 / (len - 1.0);
 598
 599     w_data+=n2;
 600       data+=n2;
 601     for(i=0; i<n2; i++) {
 602         w = c - n2 + i;
 603         w = 1.0 - (w * w);
 604         w_data[-i-1] = data[-i-1] * w;
 605         w_data[+i  ] = data[+i  ] * w;
 606     }
 607 }
 608
 609 /**
 610  * Calculates autocorrelation data from audio samples
 611  * A Welch window function is applied before calculation.
 612  */
 613 void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
 614                               double *autoc)
 615 {
 616     int i, j;
 617     double tmp[len + lag + 1];
 618     double *data1= tmp + lag;
 619
 620     apply_welch_window(data, len, data1);
 621
 622     for(j=0; j<lag; j++)
 623         data1[j-lag]= 0.0;
 624     data1[len] = 0.0;
 625
 626     for(j=0; j<lag; j+=2){
 627         double sum0 = 1.0, sum1 = 1.0;
 628         for(i=0; i<len; i++){
 629             sum0 += data1[i] * data1[i-j];
 630             sum1 += data1[i] * data1[i-j-1];
 631         }
 632         autoc[j  ] = sum0;
 633         autoc[j+1] = sum1;
 634     }
 635
 636     if(j==lag){
 637         double sum = 1.0;
 638         for(i=0; i<len; i+=2){
 639             sum += data1[i  ] * data1[i-j  ]
 640                  + data1[i+1] * data1[i-j+1];
 641         }
 642         autoc[j] = sum;
 643     }
 644 }
 645
 646
 647 static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
 648 {
 649     assert(n > 0);
 650     memcpy(res, smp, n * sizeof(int32_t));
 651 }
 652
 653 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
 654                                   int order)
 655 {
 656     int i;
 657
 658     for(i=0; i<order; i++) {
 659         res[i] = smp[i];
 660     }
 661
 662     if(order==0){
 663         for(i=order; i<n; i++)
 664             res[i]= smp[i];
 665     }else if(order==1){
 666         for(i=order; i<n; i++)
 667             res[i]= smp[i] - smp[i-1];
 668     }else if(order==2){
 669         int a = smp[order-1] - smp[order-2];
 670         for(i=order; i<n; i+=2) {
 671             int b = smp[i] - smp[i-1];
 672             res[i]= b - a;
 673             a = smp[i+1] - smp[i];
 674             res[i+1]= a - b;
 675         }
 676     }else if(order==3){
 677         int a = smp[order-1] - smp[order-2];
 678         int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
 679         for(i=order; i<n; i+=2) {
 680             int b = smp[i] - smp[i-1];
 681             int d = b - a;
 682             res[i]= d - c;
 683             a = smp[i+1] - smp[i];
 684             c = a - b;
 685             res[i+1]= c - d;
 686         }
 687     }else{
 688         int a = smp[order-1] - smp[order-2];
 689         int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
 690         int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
 691         for(i=order; i<n; i+=2) {
 692             int b = smp[i] - smp[i-1];
 693             int d = b - a;
 694             int f = d - c;
 695             res[i]= f - e;
 696             a = smp[i+1] - smp[i];
 697             c = a - b;
 698             e = c - d;
 699             res[i+1]= e - f;
 700         }
 701     }
 702 }
 703
 704 #define LPC1(x) {\
 705     int c = coefs[(x)-1];\
 706     p0 += c*s;\
 707     s = smp[i-(x)+1];\
 708     p1 += c*s;\
 709 }
 710
 711 static av_always_inline void encode_residual_lpc_unrolled(
 712     int32_t *res, const int32_t *smp, int n,
 713     int order, const int32_t *coefs, int shift, int big)
 714 {
 715     int i;
 716     for(i=order; i<n; i+=2) {
 717         int s = smp[i-order];
 718         int p0 = 0, p1 = 0;
 719         if(big) {
 720             switch(order) {
 721                 case 32: LPC1(32)
 722                 case 31: LPC1(31)
 723                 case 30: LPC1(30)
 724                 case 29: LPC1(29)
 725                 case 28: LPC1(28)
 726                 case 27: LPC1(27)
 727                 case 26: LPC1(26)
 728                 case 25: LPC1(25)
 729                 case 24: LPC1(24)
 730                 case 23: LPC1(23)
 731                 case 22: LPC1(22)
 732                 case 21: LPC1(21)
 733                 case 20: LPC1(20)
 734                 case 19: LPC1(19)
 735                 case 18: LPC1(18)
 736                 case 17: LPC1(17)
 737                 case 16: LPC1(16)
 738                 case 15: LPC1(15)
 739                 case 14: LPC1(14)
 740                 case 13: LPC1(13)
 741                 case 12: LPC1(12)
 742                 case 11: LPC1(11)
 743                 case 10: LPC1(10)
 744                 case  9: LPC1( 9)
 745                          LPC1( 8)
 746                          LPC1( 7)
 747                          LPC1( 6)
 748                          LPC1( 5)
 749                          LPC1( 4)
 750                          LPC1( 3)
 751                          LPC1( 2)
 752                          LPC1( 1)
 753             }
 754         } else {
 755             switch(order) {
 756                 case  8: LPC1( 8)
 757                 case  7: LPC1( 7)
 758                 case  6: LPC1( 6)
 759                 case  5: LPC1( 5)
 760                 case  4: LPC1( 4)
 761                 case  3: LPC1( 3)
 762                 case  2: LPC1( 2)
 763                 case  1: LPC1( 1)
 764             }
 765         }
 766         res[i  ] = smp[i  ] - (p0 >> shift);
 767         res[i+1] = smp[i+1] - (p1 >> shift);
 768     }
 769 }
 770
 771 static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
 772                                 int order, const int32_t *coefs, int shift)
 773 {
 774     int i;
 775     for(i=0; i<order; i++) {
 776         res[i] = smp[i];
 777     }
 778 #ifdef CONFIG_SMALL
 779     for(i=order; i<n; i+=2) {
 780         int j;
 781         int s = smp[i];
 782         int p0 = 0, p1 = 0;
 783         for(j=0; j<order; j++) {
 784             int c = coefs[j];
 785             p1 += c*s;
 786             s = smp[i-j-1];
 787             p0 += c*s;
 788         }
 789         res[i  ] = smp[i  ] - (p0 >> shift);
 790         res[i+1] = smp[i+1] - (p1 >> shift);
 791     }
 792 #else
 793     switch(order) {
 794         case  1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
 795         case  2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
 796         case  3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
 797         case  4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
 798         case  5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
 799         case  6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
 800         case  7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
 801         case  8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
 802         default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
 803     }
 804 #endif
 805 }
 806
 807 static int encode_residual(FlacEncodeContext *ctx, int ch)
 808 {
 809     int i, n;
 810     int min_order, max_order, opt_order, precision, omethod;
 811     int min_porder, max_porder;
 812     FlacFrame *frame;
 813     FlacSubframe *sub;
 814     int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
 815     int shift[MAX_LPC_ORDER];
 816     int32_t *res, *smp;
 817
 818     frame = &ctx->frame;
 819     sub = &frame->subframes[ch];
 820     res = sub->residual;
 821     smp = sub->samples;
 822     n = frame->blocksize;
 823
 824     /* CONSTANT */
 825     for(i=1; i<n; i++) {
 826         if(smp[i] != smp[0]) break;
 827     }
 828     if(i == n) {
 829         sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
 830         res[0] = smp[0];
 831         return sub->obits;
 832     }
 833
 834     /* VERBATIM */
 835     if(n < 5) {
 836         sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
 837         encode_residual_verbatim(res, smp, n);
 838         return sub->obits * n;
 839     }
 840
 841     min_order = ctx->options.min_prediction_order;
 842     max_order = ctx->options.max_prediction_order;
 843     min_porder = ctx->options.min_partition_order;
 844     max_porder = ctx->options.max_partition_order;
 845     precision = ctx->options.lpc_coeff_precision;
 846     omethod = ctx->options.prediction_order_method;
 847
 848     /* FIXED */
 849     if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
 850         uint32_t bits[MAX_FIXED_ORDER+1];
 851         if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
 852         opt_order = 0;
 853         bits[0] = UINT32_MAX;
 854         for(i=min_order; i<=max_order; i++) {
 855             encode_residual_fixed(res, smp, n, i);
 856             bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
 857                                              n, i, sub->obits);
 858             if(bits[i] < bits[opt_order]) {
 859                 opt_order = i;
 860             }
 861         }
 862         sub->order = opt_order;
 863         sub->type = FLAC_SUBFRAME_FIXED;
 864         sub->type_code = sub->type | sub->order;
 865         if(sub->order != max_order) {
 866             encode_residual_fixed(res, smp, n, sub->order);
 867             return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
 868                                           sub->order, sub->obits);
 869         }
 870         return bits[sub->order];
 871     }
 872
 873     /* LPC */
 874     opt_order = ff_lpc_calc_coefs(&ctx->dsp, smp, n, min_order, max_order,
 875                                   precision, coefs, shift, ctx->options.use_lpc,
 876                                   omethod, MAX_LPC_SHIFT, 0);
 877
 878     if(omethod == ORDER_METHOD_2LEVEL ||
 879        omethod == ORDER_METHOD_4LEVEL ||
 880        omethod == ORDER_METHOD_8LEVEL) {
 881         int levels = 1 << omethod;
 882         uint32_t bits[levels];
 883         int order;
 884         int opt_index = levels-1;
 885         opt_order = max_order-1;
 886         bits[opt_index] = UINT32_MAX;
 887         for(i=levels-1; i>=0; i--) {
 888             order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
 889             if(order < 0) order = 0;
 890             encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
 891             bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
 892                                            res, n, order+1, sub->obits, precision);
 893             if(bits[i] < bits[opt_index]) {
 894                 opt_index = i;
 895                 opt_order = order;
 896             }
 897         }
 898         opt_order++;
 899     } else if(omethod == ORDER_METHOD_SEARCH) {
 900         // brute-force optimal order search
 901         uint32_t bits[MAX_LPC_ORDER];
 902         opt_order = 0;
 903         bits[0] = UINT32_MAX;
 904         for(i=min_order-1; i<max_order; i++) {
 905             encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
 906             bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
 907                                            res, n, i+1, sub->obits, precision);
 908             if(bits[i] < bits[opt_order]) {
 909                 opt_order = i;
 910             }
 911         }
 912         opt_order++;
 913     } else if(omethod == ORDER_METHOD_LOG) {
 914         uint32_t bits[MAX_LPC_ORDER];
 915         int step;
 916
 917         opt_order= min_order - 1 + (max_order-min_order)/3;
 918         memset(bits, -1, sizeof(bits));
 919
 920         for(step=16 ;step; step>>=1){
 921             int last= opt_order;
 922             for(i=last-step; i<=last+step; i+= step){
 923                 if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
 924                     continue;
 925                 encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
 926                 bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
 927                                             res, n, i+1, sub->obits, precision);
 928                 if(bits[i] < bits[opt_order])
 929                     opt_order= i;
 930             }
 931         }
 932         opt_order++;
 933     }
 934
 935     sub->order = opt_order;
 936     sub->type = FLAC_SUBFRAME_LPC;
 937     sub->type_code = sub->type | (sub->order-1);
 938     sub->shift = shift[sub->order-1];
 939     for(i=0; i<sub->order; i++) {
 940         sub->coefs[i] = coefs[sub->order-1][i];
 941     }
 942     encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
 943     return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
 944                                 sub->obits, precision);
 945 }
 946
 947 static int encode_residual_v(FlacEncodeContext *ctx, int ch)
 948 {
 949     int i, n;
 950     FlacFrame *frame;
 951     FlacSubframe *sub;
 952     int32_t *res, *smp;
 953
 954     frame = &ctx->frame;
 955     sub = &frame->subframes[ch];
 956     res = sub->residual;
 957     smp = sub->samples;
 958     n = frame->blocksize;
 959
 960     /* CONSTANT */
 961     for(i=1; i<n; i++) {
 962         if(smp[i] != smp[0]) break;
 963     }
 964     if(i == n) {
 965         sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
 966         res[0] = smp[0];
 967         return sub->obits;
 968     }
 969
 970     /* VERBATIM */
 971     sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
 972     encode_residual_verbatim(res, smp, n);
 973     return sub->obits * n;
 974 }
 975
 976 static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
 977 {
 978     int i, best;
 979     int32_t lt, rt;
 980     uint64_t sum[4];
 981     uint64_t score[4];
 982     int k;
 983
 984     /* calculate sum of 2nd order residual for each channel */
 985     sum[0] = sum[1] = sum[2] = sum[3] = 0;
 986     for(i=2; i<n; i++) {
 987         lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
 988         rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
 989         sum[2] += FFABS((lt + rt) >> 1);
 990         sum[3] += FFABS(lt - rt);
 991         sum[0] += FFABS(lt);
 992         sum[1] += FFABS(rt);
 993     }
 994     /* estimate bit counts */
 995     for(i=0; i<4; i++) {
 996         k = find_optimal_param(2*sum[i], n);
 997         sum[i] = rice_encode_count(2*sum[i], n, k);
 998     }
 999
1000     /* calculate score for each mode */
1001     score[0] = sum[0] + sum[1];
1002     score[1] = sum[0] + sum[3];
1003     score[2] = sum[1] + sum[3];
1004     score[3] = sum[2] + sum[3];
1005
1006     /* return mode with lowest score */
1007     best = 0;
1008     for(i=1; i<4; i++) {
1009         if(score[i] < score[best]) {
1010             best = i;
1011         }
1012     }
1013     if(best == 0) {
1014         return FLAC_CHMODE_LEFT_RIGHT;
1015     } else if(best == 1) {
1016         return FLAC_CHMODE_LEFT_SIDE;
1017     } else if(best == 2) {
1018         return FLAC_CHMODE_RIGHT_SIDE;
1019     } else {
1020         return FLAC_CHMODE_MID_SIDE;
1021     }
1022 }
1023
1024 /**
1025  * Perform stereo channel decorrelation
1026  */
1027 static void channel_decorrelation(FlacEncodeContext *ctx)
1028 {
1029     FlacFrame *frame;
1030     int32_t *left, *right;
1031     int i, n;
1032
1033     frame = &ctx->frame;
1034     n = frame->blocksize;
1035     left  = frame->subframes[0].samples;
1036     right = frame->subframes[1].samples;
1037
1038     if(ctx->channels != 2) {
1039         frame->ch_mode = FLAC_CHMODE_NOT_STEREO;
1040         return;
1041     }
1042
1043     frame->ch_mode = estimate_stereo_mode(left, right, n);
1044
1045     /* perform decorrelation and adjust bits-per-sample */
1046     if(frame->ch_mode == FLAC_CHMODE_LEFT_RIGHT) {
1047         return;
1048     }
1049     if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1050         int32_t tmp;
1051         for(i=0; i<n; i++) {
1052             tmp = left[i];
1053             left[i] = (tmp + right[i]) >> 1;
1054             right[i] = tmp - right[i];
1055         }
1056         frame->subframes[1].obits++;
1057     } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1058         for(i=0; i<n; i++) {
1059             right[i] = left[i] - right[i];
1060         }
1061         frame->subframes[1].obits++;
1062     } else {
1063         for(i=0; i<n; i++) {
1064             left[i] -= right[i];
1065         }
1066         frame->subframes[0].obits++;
1067     }
1068 }
1069
1070 static void write_utf8(PutBitContext *pb, uint32_t val)
1071 {
1072     uint8_t tmp;
1073     PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1074 }
1075
1076 static void output_frame_header(FlacEncodeContext *s)
1077 {
1078     FlacFrame *frame;
1079     int crc;
1080
1081     frame = &s->frame;
1082
1083     put_bits(&s->pb, 16, 0xFFF8);
1084     put_bits(&s->pb, 4, frame->bs_code[0]);
1085     put_bits(&s->pb, 4, s->sr_code[0]);
1086     if(frame->ch_mode == FLAC_CHMODE_NOT_STEREO) {
1087         put_bits(&s->pb, 4, s->ch_code);
1088     } else {
1089         put_bits(&s->pb, 4, frame->ch_mode);
1090     }
1091     put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1092     put_bits(&s->pb, 1, 0);
1093     write_utf8(&s->pb, s->frame_count);
1094     if(frame->bs_code[0] == 6) {
1095         put_bits(&s->pb, 8, frame->bs_code[1]);
1096     } else if(frame->bs_code[0] == 7) {
1097         put_bits(&s->pb, 16, frame->bs_code[1]);
1098     }
1099     if(s->sr_code[0] == 12) {
1100         put_bits(&s->pb, 8, s->sr_code[1]);
1101     } else if(s->sr_code[0] > 12) {
1102         put_bits(&s->pb, 16, s->sr_code[1]);
1103     }
1104     flush_put_bits(&s->pb);
1105     crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,
1106                  s->pb.buf, put_bits_count(&s->pb)>>3);
1107     put_bits(&s->pb, 8, crc);
1108 }
1109
1110 static void output_subframe_constant(FlacEncodeContext *s, int ch)
1111 {
1112     FlacSubframe *sub;
1113     int32_t res;
1114
1115     sub = &s->frame.subframes[ch];
1116     res = sub->residual[0];
1117     put_sbits(&s->pb, sub->obits, res);
1118 }
1119
1120 static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1121 {
1122     int i;
1123     FlacFrame *frame;
1124     FlacSubframe *sub;
1125     int32_t res;
1126
1127     frame = &s->frame;
1128     sub = &frame->subframes[ch];
1129
1130     for(i=0; i<frame->blocksize; i++) {
1131         res = sub->residual[i];
1132         put_sbits(&s->pb, sub->obits, res);
1133     }
1134 }
1135
1136 static void output_residual(FlacEncodeContext *ctx, int ch)
1137 {
1138     int i, j, p, n, parts;
1139     int k, porder, psize, res_cnt;
1140     FlacFrame *frame;
1141     FlacSubframe *sub;
1142     int32_t *res;
1143
1144     frame = &ctx->frame;
1145     sub = &frame->subframes[ch];
1146     res = sub->residual;
1147     n = frame->blocksize;
1148
1149     /* rice-encoded block */
1150     put_bits(&ctx->pb, 2, 0);
1151
1152     /* partition order */
1153     porder = sub->rc.porder;
1154     psize = n >> porder;
1155     parts = (1 << porder);
1156     put_bits(&ctx->pb, 4, porder);
1157     res_cnt = psize - sub->order;
1158
1159     /* residual */
1160     j = sub->order;
1161     for(p=0; p<parts; p++) {
1162         k = sub->rc.params[p];
1163         put_bits(&ctx->pb, 4, k);
1164         if(p == 1) res_cnt = psize;
1165         for(i=0; i<res_cnt && j<n; i++, j++) {
1166             set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
1167         }
1168     }
1169 }
1170
1171 static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
1172 {
1173     int i;
1174     FlacFrame *frame;
1175     FlacSubframe *sub;
1176
1177     frame = &ctx->frame;
1178     sub = &frame->subframes[ch];
1179
1180     /* warm-up samples */
1181     for(i=0; i<sub->order; i++) {
1182         put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1183     }
1184
1185     /* residual */
1186     output_residual(ctx, ch);
1187 }
1188
1189 static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1190 {
1191     int i, cbits;
1192     FlacFrame *frame;
1193     FlacSubframe *sub;
1194
1195     frame = &ctx->frame;
1196     sub = &frame->subframes[ch];
1197
1198     /* warm-up samples */
1199     for(i=0; i<sub->order; i++) {
1200         put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1201     }
1202
1203     /* LPC coefficients */
1204     cbits = ctx->options.lpc_coeff_precision;
1205     put_bits(&ctx->pb, 4, cbits-1);
1206     put_sbits(&ctx->pb, 5, sub->shift);
1207     for(i=0; i<sub->order; i++) {
1208         put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1209     }
1210
1211     /* residual */
1212     output_residual(ctx, ch);
1213 }
1214
1215 static void output_subframes(FlacEncodeContext *s)
1216 {
1217     FlacFrame *frame;
1218     FlacSubframe *sub;
1219     int ch;
1220
1221     frame = &s->frame;
1222
1223     for(ch=0; ch<s->channels; ch++) {
1224         sub = &frame->subframes[ch];
1225
1226         /* subframe header */
1227         put_bits(&s->pb, 1, 0);
1228         put_bits(&s->pb, 6, sub->type_code);
1229         put_bits(&s->pb, 1, 0); /* no wasted bits */
1230
1231         /* subframe */
1232         if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1233             output_subframe_constant(s, ch);
1234         } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
1235             output_subframe_verbatim(s, ch);
1236         } else if(sub->type == FLAC_SUBFRAME_FIXED) {
1237             output_subframe_fixed(s, ch);
1238         } else if(sub->type == FLAC_SUBFRAME_LPC) {
1239             output_subframe_lpc(s, ch);
1240         }
1241     }
1242 }
1243
1244 static void output_frame_footer(FlacEncodeContext *s)
1245 {
1246     int crc;
1247     flush_put_bits(&s->pb);
1248     crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,
1249                           s->pb.buf, put_bits_count(&s->pb)>>3));
1250     put_bits(&s->pb, 16, crc);
1251     flush_put_bits(&s->pb);
1252 }
1253
1254 static void update_md5_sum(FlacEncodeContext *s, int16_t *samples)
1255 {
1256 #ifdef WORDS_BIGENDIAN
1257     int i;
1258     for(i = 0; i < s->frame.blocksize*s->channels; i++) {
1259         int16_t smp = le2me_16(samples[i]);
1260         av_md5_update(s->md5ctx, (uint8_t *)&smp, 2);
1261     }
1262 #else
1263     av_md5_update(s->md5ctx, (uint8_t *)samples, s->frame.blocksize*s->channels*2);
1264 #endif
1265 }
1266
1267 static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1268                              int buf_size, void *data)
1269 {
1270     int ch;
1271     FlacEncodeContext *s;
1272     int16_t *samples = data;
1273     int out_bytes;
1274     int reencoded=0;
1275
1276     s = avctx->priv_data;
1277
1278     if(buf_size < s->max_framesize*2) {
1279         av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
1280         return 0;
1281     }
1282
1283     /* when the last block is reached, update the header in extradata */
1284     if (!data) {
1285         s->min_framesize = s->min_encoded_framesize;
1286         s->max_framesize = s->max_encoded_framesize;
1287         av_md5_final(s->md5ctx, s->md5sum);
1288         write_streaminfo(s, avctx->extradata);
1289         return 0;
1290     }
1291
1292     init_frame(s);
1293
1294     copy_samples(s, samples);
1295
1296     channel_decorrelation(s);
1297
1298     for(ch=0; ch<s->channels; ch++) {
1299         encode_residual(s, ch);
1300     }
1301
1302 write_frame:
1303     init_put_bits(&s->pb, frame, buf_size);
1304     output_frame_header(s);
1305     output_subframes(s);
1306     output_frame_footer(s);
1307     out_bytes = put_bits_count(&s->pb) >> 3;
1308
1309     if(out_bytes > s->max_framesize) {
1310         if(reencoded) {
1311             /* still too large. must be an error. */
1312             av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1313             return -1;
1314         }
1315
1316         /* frame too large. use verbatim mode */
1317         for(ch=0; ch<s->channels; ch++) {
1318             encode_residual_v(s, ch);
1319         }
1320         reencoded = 1;
1321         goto write_frame;
1322     }
1323
1324     s->frame_count++;
1325     s->sample_count += avctx->frame_size;
1326     update_md5_sum(s, samples);
1327     if (out_bytes > s->max_encoded_framesize)
1328         s->max_encoded_framesize = out_bytes;
1329     if (out_bytes < s->min_encoded_framesize)
1330         s->min_encoded_framesize = out_bytes;
1331
1332     return out_bytes;
1333 }
1334
1335 static av_cold int flac_encode_close(AVCodecContext *avctx)
1336 {
1337     if (avctx->priv_data) {
1338         FlacEncodeContext *s = avctx->priv_data;
1339         av_freep(&s->md5ctx);
1340     }
1341     av_freep(&avctx->extradata);
1342     avctx->extradata_size = 0;
1343     av_freep(&avctx->coded_frame);
1344     return 0;
1345 }
1346
1347 AVCodec flac_encoder = {
1348     "flac",
1349     CODEC_TYPE_AUDIO,
1350     CODEC_ID_FLAC,
1351     sizeof(FlacEncodeContext),
1352     flac_encode_init,
1353     flac_encode_frame,
1354     flac_encode_close,
1355     NULL,
1356     .capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY,
1357     .sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},
1358     .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1359 };