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