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/avassert.h" 23#include "libavutil/channel_layout.h" 24#include "libavutil/crc.h" 25#include "libavutil/intmath.h" 26#include "libavutil/md5.h" 27#include "libavutil/opt.h" 28 29#include "avcodec.h" 30#include "bswapdsp.h" 31#include "codec_internal.h" 32#include "encode.h" 33#include "put_bits.h" 34#include "put_golomb.h" 35#include "internal.h" 36#include "lpc.h" 37#include "flac.h" 38#include "flacdata.h" 39#include "flacdsp.h" 40 41#define FLAC_SUBFRAME_CONSTANT 0 42#define FLAC_SUBFRAME_VERBATIM 1 43#define FLAC_SUBFRAME_FIXED 8 44#define FLAC_SUBFRAME_LPC 32 45 46#define MAX_FIXED_ORDER 4 47#define MAX_PARTITION_ORDER 8 48#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER) 49#define MAX_LPC_PRECISION 15 50#define MIN_LPC_SHIFT 0 51#define MAX_LPC_SHIFT 15 52 53enum CodingMode { 54 CODING_MODE_RICE = 4, 55 CODING_MODE_RICE2 = 5, 56}; 57 58typedef struct CompressionOptions { 59 int compression_level; 60 int block_time_ms; 61 enum FFLPCType lpc_type; 62 int lpc_passes; 63 int lpc_coeff_precision; 64 int min_prediction_order; 65 int max_prediction_order; 66 int prediction_order_method; 67 int min_partition_order; 68 int max_partition_order; 69 int ch_mode; 70 int exact_rice_parameters; 71 int multi_dim_quant; 72} CompressionOptions; 73 74typedef struct RiceContext { 75 enum CodingMode coding_mode; 76 int porder; 77 int params[MAX_PARTITIONS]; 78} RiceContext; 79 80typedef struct FlacSubframe { 81 int type; 82 int type_code; 83 int obits; 84 int wasted; 85 int order; 86 int32_t coefs[MAX_LPC_ORDER]; 87 int shift; 88 89 RiceContext rc; 90 uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]; 91 uint64_t rc_sums[32][MAX_PARTITIONS]; 92 93 int32_t samples[FLAC_MAX_BLOCKSIZE]; 94 int32_t residual[FLAC_MAX_BLOCKSIZE+11]; 95} FlacSubframe; 96 97typedef struct FlacFrame { 98 FlacSubframe subframes[FLAC_MAX_CHANNELS]; 99 int blocksize; 100 int bs_code[2]; 101 uint8_t crc8; 102 int ch_mode; 103 int verbatim_only; 104} FlacFrame; 105 106typedef struct FlacEncodeContext { 107 AVClass *class; 108 PutBitContext pb; 109 int channels; 110 int samplerate; 111 int sr_code[2]; 112 int bps_code; 113 int max_blocksize; 114 int min_framesize; 115 int max_framesize; 116 int max_encoded_framesize; 117 uint32_t frame_count; 118 uint64_t sample_count; 119 uint8_t md5sum[16]; 120 FlacFrame frame; 121 CompressionOptions options; 122 AVCodecContext *avctx; 123 LPCContext lpc_ctx; 124 struct AVMD5 *md5ctx; 125 uint8_t *md5_buffer; 126 unsigned int md5_buffer_size; 127 BswapDSPContext bdsp; 128 FLACDSPContext flac_dsp; 129 130 int flushed; 131 int64_t next_pts; 132} FlacEncodeContext; 133 134 135/** 136 * Write streaminfo metadata block to byte array. 137 */ 138static void write_streaminfo(FlacEncodeContext *s, uint8_t *header) 139{ 140 PutBitContext pb; 141 142 memset(header, 0, FLAC_STREAMINFO_SIZE); 143 init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE); 144 145 /* streaminfo metadata block */ 146 put_bits(&pb, 16, s->max_blocksize); 147 put_bits(&pb, 16, s->max_blocksize); 148 put_bits(&pb, 24, s->min_framesize); 149 put_bits(&pb, 24, s->max_framesize); 150 put_bits(&pb, 20, s->samplerate); 151 put_bits(&pb, 3, s->channels-1); 152 put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1); 153 /* write 36-bit sample count in 2 put_bits() calls */ 154 put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12); 155 put_bits(&pb, 12, s->sample_count & 0x000000FFFLL); 156 flush_put_bits(&pb); 157 memcpy(&header[18], s->md5sum, 16); 158} 159 160 161/** 162 * Set blocksize based on samplerate. 163 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds. 164 */ 165static int select_blocksize(int samplerate, int block_time_ms) 166{ 167 int i; 168 int target; 169 int blocksize; 170 171 av_assert0(samplerate > 0); 172 blocksize = ff_flac_blocksize_table[1]; 173 target = (samplerate * block_time_ms) / 1000; 174 for (i = 0; i < 16; i++) { 175 if (target >= ff_flac_blocksize_table[i] && 176 ff_flac_blocksize_table[i] > blocksize) { 177 blocksize = ff_flac_blocksize_table[i]; 178 } 179 } 180 return blocksize; 181} 182 183 184static av_cold void dprint_compression_options(FlacEncodeContext *s) 185{ 186 AVCodecContext *avctx = s->avctx; 187 CompressionOptions *opt = &s->options; 188 189 av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level); 190 191 switch (opt->lpc_type) { 192 case FF_LPC_TYPE_NONE: 193 av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n"); 194 break; 195 case FF_LPC_TYPE_FIXED: 196 av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n"); 197 break; 198 case FF_LPC_TYPE_LEVINSON: 199 av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n"); 200 break; 201 case FF_LPC_TYPE_CHOLESKY: 202 av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n", 203 opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es"); 204 break; 205 } 206 207 av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n", 208 opt->min_prediction_order, opt->max_prediction_order); 209 210 switch (opt->prediction_order_method) { 211 case ORDER_METHOD_EST: 212 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate"); 213 break; 214 case ORDER_METHOD_2LEVEL: 215 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level"); 216 break; 217 case ORDER_METHOD_4LEVEL: 218 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level"); 219 break; 220 case ORDER_METHOD_8LEVEL: 221 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level"); 222 break; 223 case ORDER_METHOD_SEARCH: 224 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search"); 225 break; 226 case ORDER_METHOD_LOG: 227 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search"); 228 break; 229 } 230 231 232 av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n", 233 opt->min_partition_order, opt->max_partition_order); 234 235 av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size); 236 237 av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n", 238 opt->lpc_coeff_precision); 239} 240 241 242static av_cold int flac_encode_init(AVCodecContext *avctx) 243{ 244 int freq = avctx->sample_rate; 245 int channels = avctx->ch_layout.nb_channels; 246 FlacEncodeContext *s = avctx->priv_data; 247 int i, level, ret; 248 uint8_t *streaminfo; 249 250 s->avctx = avctx; 251 252 switch (avctx->sample_fmt) { 253 case AV_SAMPLE_FMT_S16: 254 avctx->bits_per_raw_sample = 16; 255 s->bps_code = 4; 256 break; 257 case AV_SAMPLE_FMT_S32: 258 if (avctx->bits_per_raw_sample != 24) 259 av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n"); 260 avctx->bits_per_raw_sample = 24; 261 s->bps_code = 6; 262 break; 263 } 264 265 if (channels < 1 || channels > FLAC_MAX_CHANNELS) { 266 av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n", 267 channels, FLAC_MAX_CHANNELS); 268 return AVERROR(EINVAL); 269 } 270 s->channels = channels; 271 272 /* find samplerate in table */ 273 if (freq < 1) 274 return AVERROR(EINVAL); 275 for (i = 4; i < 12; i++) { 276 if (freq == ff_flac_sample_rate_table[i]) { 277 s->samplerate = ff_flac_sample_rate_table[i]; 278 s->sr_code[0] = i; 279 s->sr_code[1] = 0; 280 break; 281 } 282 } 283 /* if not in table, samplerate is non-standard */ 284 if (i == 12) { 285 if (freq % 1000 == 0 && freq < 255000) { 286 s->sr_code[0] = 12; 287 s->sr_code[1] = freq / 1000; 288 } else if (freq % 10 == 0 && freq < 655350) { 289 s->sr_code[0] = 14; 290 s->sr_code[1] = freq / 10; 291 } else if (freq < 65535) { 292 s->sr_code[0] = 13; 293 s->sr_code[1] = freq; 294 } else { 295 av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq); 296 return AVERROR(EINVAL); 297 } 298 s->samplerate = freq; 299 } 300 301 /* set compression option defaults based on avctx->compression_level */ 302 if (avctx->compression_level < 0) 303 s->options.compression_level = 5; 304 else 305 s->options.compression_level = avctx->compression_level; 306 307 level = s->options.compression_level; 308 if (level > 12) { 309 av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n", 310 s->options.compression_level); 311 return AVERROR(EINVAL); 312 } 313 314 s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level]; 315 316 if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT) 317 s->options.lpc_type = ((int[]){ FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, 318 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, 319 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, 320 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, 321 FF_LPC_TYPE_LEVINSON})[level]; 322 323 if (s->options.min_prediction_order < 0) 324 s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level]; 325 if (s->options.max_prediction_order < 0) 326 s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level]; 327 328 if (s->options.prediction_order_method < 0) 329 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, 330 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, 331 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL, 332 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG, 333 ORDER_METHOD_SEARCH})[level]; 334 335 if (s->options.min_partition_order > s->options.max_partition_order) { 336 av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n", 337 s->options.min_partition_order, s->options.max_partition_order); 338 return AVERROR(EINVAL); 339 } 340 if (s->options.min_partition_order < 0) 341 s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level]; 342 if (s->options.max_partition_order < 0) 343 s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level]; 344 345 if (s->options.lpc_type == FF_LPC_TYPE_NONE) { 346 s->options.min_prediction_order = 0; 347 s->options.max_prediction_order = 0; 348 } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) { 349 if (s->options.min_prediction_order > MAX_FIXED_ORDER) { 350 av_log(avctx, AV_LOG_WARNING, 351 "invalid min prediction order %d, clamped to %d\n", 352 s->options.min_prediction_order, MAX_FIXED_ORDER); 353 s->options.min_prediction_order = MAX_FIXED_ORDER; 354 } 355 if (s->options.max_prediction_order > MAX_FIXED_ORDER) { 356 av_log(avctx, AV_LOG_WARNING, 357 "invalid max prediction order %d, clamped to %d\n", 358 s->options.max_prediction_order, MAX_FIXED_ORDER); 359 s->options.max_prediction_order = MAX_FIXED_ORDER; 360 } 361 } 362 363 if (s->options.max_prediction_order < s->options.min_prediction_order) { 364 av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n", 365 s->options.min_prediction_order, s->options.max_prediction_order); 366 return AVERROR(EINVAL); 367 } 368 369 if (avctx->frame_size > 0) { 370 if (avctx->frame_size < FLAC_MIN_BLOCKSIZE || 371 avctx->frame_size > FLAC_MAX_BLOCKSIZE) { 372 av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n", 373 avctx->frame_size); 374 return AVERROR(EINVAL); 375 } 376 } else { 377 s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms); 378 } 379 s->max_blocksize = s->avctx->frame_size; 380 381 /* set maximum encoded frame size in verbatim mode */ 382 s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size, 383 s->channels, 384 s->avctx->bits_per_raw_sample); 385 386 /* initialize MD5 context */ 387 s->md5ctx = av_md5_alloc(); 388 if (!s->md5ctx) 389 return AVERROR(ENOMEM); 390 av_md5_init(s->md5ctx); 391 392 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); 393 if (!streaminfo) 394 return AVERROR(ENOMEM); 395 write_streaminfo(s, streaminfo); 396 avctx->extradata = streaminfo; 397 avctx->extradata_size = FLAC_STREAMINFO_SIZE; 398 399 s->frame_count = 0; 400 s->min_framesize = s->max_framesize; 401 402 if ((channels == 3 && 403 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_SURROUND)) || 404 (channels == 4 && 405 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_2_2) && 406 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_QUAD)) || 407 (channels == 5 && 408 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0) && 409 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0_BACK)) || 410 (channels == 6 && 411 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1) && 412 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK))) { 413 if (avctx->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) { 414 av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, " 415 "output stream will have incorrect " 416 "channel layout.\n"); 417 } else { 418 av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder " 419 "will use Flac channel layout for " 420 "%d channels.\n", channels); 421 } 422 } 423 424 ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size, 425 s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON); 426 427 ff_bswapdsp_init(&s->bdsp); 428 ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, channels, 429 avctx->bits_per_raw_sample); 430 431 dprint_compression_options(s); 432 433 return ret; 434} 435 436 437static void init_frame(FlacEncodeContext *s, int nb_samples) 438{ 439 int i, ch; 440 FlacFrame *frame; 441 442 frame = &s->frame; 443 444 for (i = 0; i < 16; i++) { 445 if (nb_samples == ff_flac_blocksize_table[i]) { 446 frame->blocksize = ff_flac_blocksize_table[i]; 447 frame->bs_code[0] = i; 448 frame->bs_code[1] = 0; 449 break; 450 } 451 } 452 if (i == 16) { 453 frame->blocksize = nb_samples; 454 if (frame->blocksize <= 256) { 455 frame->bs_code[0] = 6; 456 frame->bs_code[1] = frame->blocksize-1; 457 } else { 458 frame->bs_code[0] = 7; 459 frame->bs_code[1] = frame->blocksize-1; 460 } 461 } 462 463 for (ch = 0; ch < s->channels; ch++) { 464 FlacSubframe *sub = &frame->subframes[ch]; 465 466 sub->wasted = 0; 467 sub->obits = s->avctx->bits_per_raw_sample; 468 469 if (sub->obits > 16) 470 sub->rc.coding_mode = CODING_MODE_RICE2; 471 else 472 sub->rc.coding_mode = CODING_MODE_RICE; 473 } 474 475 frame->verbatim_only = 0; 476} 477 478 479/** 480 * Copy channel-interleaved input samples into separate subframes. 481 */ 482static void copy_samples(FlacEncodeContext *s, const void *samples) 483{ 484 int i, j, ch; 485 FlacFrame *frame; 486 int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 - 487 s->avctx->bits_per_raw_sample; 488 489#define COPY_SAMPLES(bits) do { \ 490 const int ## bits ## _t *samples0 = samples; \ 491 frame = &s->frame; \ 492 for (i = 0, j = 0; i < frame->blocksize; i++) \ 493 for (ch = 0; ch < s->channels; ch++, j++) \ 494 frame->subframes[ch].samples[i] = samples0[j] >> shift; \ 495} while (0) 496 497 if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16) 498 COPY_SAMPLES(16); 499 else 500 COPY_SAMPLES(32); 501} 502 503 504static uint64_t rice_count_exact(const int32_t *res, int n, int k) 505{ 506 int i; 507 uint64_t count = 0; 508 509 for (i = 0; i < n; i++) { 510 int32_t v = -2 * res[i] - 1; 511 v ^= v >> 31; 512 count += (v >> k) + 1 + k; 513 } 514 return count; 515} 516 517 518static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, 519 int pred_order) 520{ 521 int p, porder, psize; 522 int i, part_end; 523 uint64_t count = 0; 524 525 /* subframe header */ 526 count += 8; 527 528 if (sub->wasted) 529 count += sub->wasted; 530 531 /* subframe */ 532 if (sub->type == FLAC_SUBFRAME_CONSTANT) { 533 count += sub->obits; 534 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { 535 count += s->frame.blocksize * sub->obits; 536 } else { 537 /* warm-up samples */ 538 count += pred_order * sub->obits; 539 540 /* LPC coefficients */ 541 if (sub->type == FLAC_SUBFRAME_LPC) 542 count += 4 + 5 + pred_order * s->options.lpc_coeff_precision; 543 544 /* rice-encoded block */ 545 count += 2; 546 547 /* partition order */ 548 porder = sub->rc.porder; 549 psize = s->frame.blocksize >> porder; 550 count += 4; 551 552 /* residual */ 553 i = pred_order; 554 part_end = psize; 555 for (p = 0; p < 1 << porder; p++) { 556 int k = sub->rc.params[p]; 557 count += sub->rc.coding_mode; 558 count += rice_count_exact(&sub->residual[i], part_end - i, k); 559 i = part_end; 560 part_end = FFMIN(s->frame.blocksize, part_end + psize); 561 } 562 } 563 564 return count; 565} 566 567 568#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k))) 569 570/** 571 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0. 572 */ 573static int find_optimal_param(uint64_t sum, int n, int max_param) 574{ 575 int k; 576 uint64_t sum2; 577 578 if (sum <= n >> 1) 579 return 0; 580 sum2 = sum - (n >> 1); 581 k = av_log2(av_clipl_int32(sum2 / n)); 582 return FFMIN(k, max_param); 583} 584 585static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param) 586{ 587 int bestk = 0; 588 int64_t bestbits = INT64_MAX; 589 int k; 590 591 for (k = 0; k <= max_param; k++) { 592 int64_t bits = sums[k][i]; 593 if (bits < bestbits) { 594 bestbits = bits; 595 bestk = k; 596 } 597 } 598 599 return bestk; 600} 601 602static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder, 603 uint64_t sums[32][MAX_PARTITIONS], 604 int n, int pred_order, int max_param, int exact) 605{ 606 int i; 607 int k, cnt, part; 608 uint64_t all_bits; 609 610 part = (1 << porder); 611 all_bits = 4 * part; 612 613 cnt = (n >> porder) - pred_order; 614 for (i = 0; i < part; i++) { 615 if (exact) { 616 k = find_optimal_param_exact(sums, i, max_param); 617 all_bits += sums[k][i]; 618 } else { 619 k = find_optimal_param(sums[0][i], cnt, max_param); 620 all_bits += rice_encode_count(sums[0][i], cnt, k); 621 } 622 rc->params[i] = k; 623 cnt = n >> porder; 624 } 625 626 rc->porder = porder; 627 628 return all_bits; 629} 630 631 632static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order, 633 uint64_t sums[32][MAX_PARTITIONS]) 634{ 635 int i, k; 636 int parts; 637 const uint32_t *res, *res_end; 638 639 /* sums for highest level */ 640 parts = (1 << pmax); 641 642 for (k = 0; k <= kmax; k++) { 643 res = &data[pred_order]; 644 res_end = &data[n >> pmax]; 645 for (i = 0; i < parts; i++) { 646 if (kmax) { 647 uint64_t sum = (1LL + k) * (res_end - res); 648 while (res < res_end) 649 sum += *(res++) >> k; 650 sums[k][i] = sum; 651 } else { 652 uint64_t sum = 0; 653 while (res < res_end) 654 sum += *(res++); 655 sums[k][i] = sum; 656 } 657 res_end += n >> pmax; 658 } 659 } 660} 661 662static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax) 663{ 664 int i, k; 665 int parts = (1 << level); 666 for (i = 0; i < parts; i++) { 667 for (k=0; k<=kmax; k++) 668 sums[k][i] = sums[k][2*i] + sums[k][2*i+1]; 669 } 670} 671 672static uint64_t calc_rice_params(RiceContext *rc, 673 uint32_t udata[FLAC_MAX_BLOCKSIZE], 674 uint64_t sums[32][MAX_PARTITIONS], 675 int pmin, int pmax, 676 const int32_t *data, int n, int pred_order, int exact) 677{ 678 int i; 679 uint64_t bits[MAX_PARTITION_ORDER+1]; 680 int opt_porder; 681 RiceContext tmp_rc; 682 int kmax = (1 << rc->coding_mode) - 2; 683 684 av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER); 685 av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER); 686 av_assert1(pmin <= pmax); 687 688 tmp_rc.coding_mode = rc->coding_mode; 689 690 for (i = 0; i < n; i++) 691 udata[i] = (2 * data[i]) ^ (data[i] >> 31); 692 693 calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums); 694 695 opt_porder = pmin; 696 bits[pmin] = UINT32_MAX; 697 for (i = pmax; ; ) { 698 bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact); 699 if (bits[i] < bits[opt_porder] || pmax == pmin) { 700 opt_porder = i; 701 *rc = tmp_rc; 702 } 703 if (i == pmin) 704 break; 705 calc_sum_next(--i, sums, exact ? kmax : 0); 706 } 707 708 return bits[opt_porder]; 709} 710 711 712static int get_max_p_order(int max_porder, int n, int order) 713{ 714 int porder = FFMIN(max_porder, av_log2(n^(n-1))); 715 if (order > 0) 716 porder = FFMIN(porder, av_log2(n/order)); 717 return porder; 718} 719 720 721static uint64_t find_subframe_rice_params(FlacEncodeContext *s, 722 FlacSubframe *sub, int pred_order) 723{ 724 int pmin = get_max_p_order(s->options.min_partition_order, 725 s->frame.blocksize, pred_order); 726 int pmax = get_max_p_order(s->options.max_partition_order, 727 s->frame.blocksize, pred_order); 728 729 uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode; 730 if (sub->type == FLAC_SUBFRAME_LPC) 731 bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision; 732 bits += calc_rice_params(&sub->rc, sub->rc_udata, sub->rc_sums, pmin, pmax, sub->residual, 733 s->frame.blocksize, pred_order, s->options.exact_rice_parameters); 734 return bits; 735} 736 737 738static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, 739 int order) 740{ 741 int i; 742 743 for (i = 0; i < order; i++) 744 res[i] = smp[i]; 745 746 if (order == 0) { 747 for (i = order; i < n; i++) 748 res[i] = smp[i]; 749 } else if (order == 1) { 750 for (i = order; i < n; i++) 751 res[i] = smp[i] - smp[i-1]; 752 } else if (order == 2) { 753 int a = smp[order-1] - smp[order-2]; 754 for (i = order; i < n; i += 2) { 755 int b = smp[i ] - smp[i-1]; 756 res[i] = b - a; 757 a = smp[i+1] - smp[i ]; 758 res[i+1] = a - b; 759 } 760 } else if (order == 3) { 761 int a = smp[order-1] - smp[order-2]; 762 int c = smp[order-1] - 2*smp[order-2] + smp[order-3]; 763 for (i = order; i < n; i += 2) { 764 int b = smp[i ] - smp[i-1]; 765 int d = b - a; 766 res[i] = d - c; 767 a = smp[i+1] - smp[i ]; 768 c = a - b; 769 res[i+1] = c - d; 770 } 771 } else { 772 int a = smp[order-1] - smp[order-2]; 773 int c = smp[order-1] - 2*smp[order-2] + smp[order-3]; 774 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4]; 775 for (i = order; i < n; i += 2) { 776 int b = smp[i ] - smp[i-1]; 777 int d = b - a; 778 int f = d - c; 779 res[i ] = f - e; 780 a = smp[i+1] - smp[i ]; 781 c = a - b; 782 e = c - d; 783 res[i+1] = e - f; 784 } 785 } 786} 787 788 789static int encode_residual_ch(FlacEncodeContext *s, int ch) 790{ 791 int i, n; 792 int min_order, max_order, opt_order, omethod; 793 FlacFrame *frame; 794 FlacSubframe *sub; 795 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; 796 int shift[MAX_LPC_ORDER]; 797 int32_t *res, *smp; 798 799 frame = &s->frame; 800 sub = &frame->subframes[ch]; 801 res = sub->residual; 802 smp = sub->samples; 803 n = frame->blocksize; 804 805 /* CONSTANT */ 806 for (i = 1; i < n; i++) 807 if(smp[i] != smp[0]) 808 break; 809 if (i == n) { 810 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; 811 res[0] = smp[0]; 812 return subframe_count_exact(s, sub, 0); 813 } 814 815 /* VERBATIM */ 816 if (frame->verbatim_only || n < 5) { 817 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; 818 memcpy(res, smp, n * sizeof(int32_t)); 819 return subframe_count_exact(s, sub, 0); 820 } 821 822 min_order = s->options.min_prediction_order; 823 max_order = s->options.max_prediction_order; 824 omethod = s->options.prediction_order_method; 825 826 /* FIXED */ 827 sub->type = FLAC_SUBFRAME_FIXED; 828 if (s->options.lpc_type == FF_LPC_TYPE_NONE || 829 s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) { 830 uint64_t bits[MAX_FIXED_ORDER+1]; 831 if (max_order > MAX_FIXED_ORDER) 832 max_order = MAX_FIXED_ORDER; 833 opt_order = 0; 834 bits[0] = UINT32_MAX; 835 for (i = min_order; i <= max_order; i++) { 836 encode_residual_fixed(res, smp, n, i); 837 bits[i] = find_subframe_rice_params(s, sub, i); 838 if (bits[i] < bits[opt_order]) 839 opt_order = i; 840 } 841 sub->order = opt_order; 842 sub->type_code = sub->type | sub->order; 843 if (sub->order != max_order) { 844 encode_residual_fixed(res, smp, n, sub->order); 845 find_subframe_rice_params(s, sub, sub->order); 846 } 847 return subframe_count_exact(s, sub, sub->order); 848 } 849 850 /* LPC */ 851 sub->type = FLAC_SUBFRAME_LPC; 852 opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order, 853 s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type, 854 s->options.lpc_passes, omethod, 855 MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0); 856 857 if (omethod == ORDER_METHOD_2LEVEL || 858 omethod == ORDER_METHOD_4LEVEL || 859 omethod == ORDER_METHOD_8LEVEL) { 860 int levels = 1 << omethod; 861 uint64_t bits[1 << ORDER_METHOD_8LEVEL]; 862 int order = -1; 863 int opt_index = levels-1; 864 opt_order = max_order-1; 865 bits[opt_index] = UINT32_MAX; 866 for (i = levels-1; i >= 0; i--) { 867 int last_order = order; 868 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1; 869 order = av_clip(order, min_order - 1, max_order - 1); 870 if (order == last_order) 871 continue; 872 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(order) <= 32) { 873 s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order], 874 shift[order]); 875 } else { 876 s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order], 877 shift[order]); 878 } 879 bits[i] = find_subframe_rice_params(s, sub, order+1); 880 if (bits[i] < bits[opt_index]) { 881 opt_index = i; 882 opt_order = order; 883 } 884 } 885 opt_order++; 886 } else if (omethod == ORDER_METHOD_SEARCH) { 887 // brute-force optimal order search 888 uint64_t bits[MAX_LPC_ORDER]; 889 opt_order = 0; 890 bits[0] = UINT32_MAX; 891 for (i = min_order-1; i < max_order; i++) { 892 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) { 893 s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]); 894 } else { 895 s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]); 896 } 897 bits[i] = find_subframe_rice_params(s, sub, i+1); 898 if (bits[i] < bits[opt_order]) 899 opt_order = i; 900 } 901 opt_order++; 902 } else if (omethod == ORDER_METHOD_LOG) { 903 uint64_t bits[MAX_LPC_ORDER]; 904 int step; 905 906 opt_order = min_order - 1 + (max_order-min_order)/3; 907 memset(bits, -1, sizeof(bits)); 908 909 for (step = 16; step; step >>= 1) { 910 int last = opt_order; 911 for (i = last-step; i <= last+step; i += step) { 912 if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX) 913 continue; 914 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) { 915 s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]); 916 } else { 917 s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]); 918 } 919 bits[i] = find_subframe_rice_params(s, sub, i+1); 920 if (bits[i] < bits[opt_order]) 921 opt_order = i; 922 } 923 } 924 opt_order++; 925 } 926 927 if (s->options.multi_dim_quant) { 928 int allsteps = 1; 929 int i, step, improved; 930 int64_t best_score = INT64_MAX; 931 int32_t qmax; 932 933 qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1; 934 935 for (i=0; i<opt_order; i++) 936 allsteps *= 3; 937 938 do { 939 improved = 0; 940 for (step = 0; step < allsteps; step++) { 941 int tmp = step; 942 int32_t lpc_try[MAX_LPC_ORDER]; 943 int64_t score = 0; 944 int diffsum = 0; 945 946 for (i=0; i<opt_order; i++) { 947 int diff = ((tmp + 1) % 3) - 1; 948 lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax); 949 tmp /= 3; 950 diffsum += !!diff; 951 } 952 if (diffsum >8) 953 continue; 954 955 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order - 1) <= 32) { 956 s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]); 957 } else { 958 s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]); 959 } 960 score = find_subframe_rice_params(s, sub, opt_order); 961 if (score < best_score) { 962 best_score = score; 963 memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs)); 964 improved=1; 965 } 966 } 967 } while(improved); 968 } 969 970 sub->order = opt_order; 971 sub->type_code = sub->type | (sub->order-1); 972 sub->shift = shift[sub->order-1]; 973 for (i = 0; i < sub->order; i++) 974 sub->coefs[i] = coefs[sub->order-1][i]; 975 976 if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order) <= 32) { 977 s->flac_dsp.lpc16_encode(res, smp, n, sub->order, sub->coefs, sub->shift); 978 } else { 979 s->flac_dsp.lpc32_encode(res, smp, n, sub->order, sub->coefs, sub->shift); 980 } 981 982 find_subframe_rice_params(s, sub, sub->order); 983 984 return subframe_count_exact(s, sub, sub->order); 985} 986 987 988static int count_frame_header(FlacEncodeContext *s) 989{ 990 uint8_t av_unused tmp; 991 int count; 992 993 /* 994 <14> Sync code 995 <1> Reserved 996 <1> Blocking strategy 997 <4> Block size in inter-channel samples 998 <4> Sample rate 999 <4> Channel assignment 1000 <3> Sample size in bits 1001 <1> Reserved 1002 */ 1003 count = 32; 1004 1005 /* coded frame number */ 1006 PUT_UTF8(s->frame_count, tmp, count += 8;) 1007 1008 /* explicit block size */ 1009 if (s->frame.bs_code[0] == 6) 1010 count += 8; 1011 else if (s->frame.bs_code[0] == 7) 1012 count += 16; 1013 1014 /* explicit sample rate */ 1015 count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8; 1016 1017 /* frame header CRC-8 */ 1018 count += 8; 1019 1020 return count; 1021} 1022 1023 1024static int encode_frame(FlacEncodeContext *s) 1025{ 1026 int ch; 1027 uint64_t count; 1028 1029 count = count_frame_header(s); 1030 1031 for (ch = 0; ch < s->channels; ch++) 1032 count += encode_residual_ch(s, ch); 1033 1034 count += (8 - (count & 7)) & 7; // byte alignment 1035 count += 16; // CRC-16 1036 1037 count >>= 3; 1038 if (count > INT_MAX) 1039 return AVERROR_BUG; 1040 return count; 1041} 1042 1043 1044static void remove_wasted_bits(FlacEncodeContext *s) 1045{ 1046 int ch, i; 1047 1048 for (ch = 0; ch < s->channels; ch++) { 1049 FlacSubframe *sub = &s->frame.subframes[ch]; 1050 int32_t v = 0; 1051 1052 for (i = 0; i < s->frame.blocksize; i++) { 1053 v |= sub->samples[i]; 1054 if (v & 1) 1055 break; 1056 } 1057 1058 if (v && !(v & 1)) { 1059 v = ff_ctz(v); 1060 1061 for (i = 0; i < s->frame.blocksize; i++) 1062 sub->samples[i] >>= v; 1063 1064 sub->wasted = v; 1065 sub->obits -= v; 1066 1067 /* for 24-bit, check if removing wasted bits makes the range better 1068 suited for using RICE instead of RICE2 for entropy coding */ 1069 if (sub->obits <= 17) 1070 sub->rc.coding_mode = CODING_MODE_RICE; 1071 } 1072 } 1073} 1074 1075 1076static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, 1077 int max_rice_param) 1078{ 1079 int i, best; 1080 int32_t lt, rt; 1081 uint64_t sum[4]; 1082 uint64_t score[4]; 1083 int k; 1084 1085 /* calculate sum of 2nd order residual for each channel */ 1086 sum[0] = sum[1] = sum[2] = sum[3] = 0; 1087 for (i = 2; i < n; i++) { 1088 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2]; 1089 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2]; 1090 sum[2] += FFABS((lt + rt) >> 1); 1091 sum[3] += FFABS(lt - rt); 1092 sum[0] += FFABS(lt); 1093 sum[1] += FFABS(rt); 1094 } 1095 /* estimate bit counts */ 1096 for (i = 0; i < 4; i++) { 1097 k = find_optimal_param(2 * sum[i], n, max_rice_param); 1098 sum[i] = rice_encode_count( 2 * sum[i], n, k); 1099 } 1100 1101 /* calculate score for each mode */ 1102 score[0] = sum[0] + sum[1]; 1103 score[1] = sum[0] + sum[3]; 1104 score[2] = sum[1] + sum[3]; 1105 score[3] = sum[2] + sum[3]; 1106 1107 /* return mode with lowest score */ 1108 best = 0; 1109 for (i = 1; i < 4; i++) 1110 if (score[i] < score[best]) 1111 best = i; 1112 1113 return best; 1114} 1115 1116 1117/** 1118 * Perform stereo channel decorrelation. 1119 */ 1120static void channel_decorrelation(FlacEncodeContext *s) 1121{ 1122 FlacFrame *frame; 1123 int32_t *left, *right; 1124 int i, n; 1125 1126 frame = &s->frame; 1127 n = frame->blocksize; 1128 left = frame->subframes[0].samples; 1129 right = frame->subframes[1].samples; 1130 1131 if (s->channels != 2) { 1132 frame->ch_mode = FLAC_CHMODE_INDEPENDENT; 1133 return; 1134 } 1135 1136 if (s->options.ch_mode < 0) { 1137 int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2; 1138 frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param); 1139 } else 1140 frame->ch_mode = s->options.ch_mode; 1141 1142 /* perform decorrelation and adjust bits-per-sample */ 1143 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) 1144 return; 1145 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { 1146 int32_t tmp; 1147 for (i = 0; i < n; i++) { 1148 tmp = left[i]; 1149 left[i] = (tmp + right[i]) >> 1; 1150 right[i] = tmp - right[i]; 1151 } 1152 frame->subframes[1].obits++; 1153 } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) { 1154 for (i = 0; i < n; i++) 1155 right[i] = left[i] - right[i]; 1156 frame->subframes[1].obits++; 1157 } else { 1158 for (i = 0; i < n; i++) 1159 left[i] -= right[i]; 1160 frame->subframes[0].obits++; 1161 } 1162} 1163 1164 1165static void write_utf8(PutBitContext *pb, uint32_t val) 1166{ 1167 uint8_t tmp; 1168 PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);) 1169} 1170 1171 1172static void write_frame_header(FlacEncodeContext *s) 1173{ 1174 FlacFrame *frame; 1175 int crc; 1176 1177 frame = &s->frame; 1178 1179 put_bits(&s->pb, 16, 0xFFF8); 1180 put_bits(&s->pb, 4, frame->bs_code[0]); 1181 put_bits(&s->pb, 4, s->sr_code[0]); 1182 1183 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) 1184 put_bits(&s->pb, 4, s->channels-1); 1185 else 1186 put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1); 1187 1188 put_bits(&s->pb, 3, s->bps_code); 1189 put_bits(&s->pb, 1, 0); 1190 write_utf8(&s->pb, s->frame_count); 1191 1192 if (frame->bs_code[0] == 6) 1193 put_bits(&s->pb, 8, frame->bs_code[1]); 1194 else if (frame->bs_code[0] == 7) 1195 put_bits(&s->pb, 16, frame->bs_code[1]); 1196 1197 if (s->sr_code[0] == 12) 1198 put_bits(&s->pb, 8, s->sr_code[1]); 1199 else if (s->sr_code[0] > 12) 1200 put_bits(&s->pb, 16, s->sr_code[1]); 1201 1202 flush_put_bits(&s->pb); 1203 crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf, 1204 put_bytes_output(&s->pb)); 1205 put_bits(&s->pb, 8, crc); 1206} 1207 1208 1209static void write_subframes(FlacEncodeContext *s) 1210{ 1211 int ch; 1212 1213 for (ch = 0; ch < s->channels; ch++) { 1214 FlacSubframe *sub = &s->frame.subframes[ch]; 1215 int i, p, porder, psize; 1216 int32_t *part_end; 1217 int32_t *res = sub->residual; 1218 int32_t *frame_end = &sub->residual[s->frame.blocksize]; 1219 1220 /* subframe header */ 1221 put_bits(&s->pb, 1, 0); 1222 put_bits(&s->pb, 6, sub->type_code); 1223 put_bits(&s->pb, 1, !!sub->wasted); 1224 if (sub->wasted) 1225 put_bits(&s->pb, sub->wasted, 1); 1226 1227 /* subframe */ 1228 if (sub->type == FLAC_SUBFRAME_CONSTANT) { 1229 put_sbits(&s->pb, sub->obits, res[0]); 1230 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { 1231 while (res < frame_end) 1232 put_sbits(&s->pb, sub->obits, *res++); 1233 } else { 1234 /* warm-up samples */ 1235 for (i = 0; i < sub->order; i++) 1236 put_sbits(&s->pb, sub->obits, *res++); 1237 1238 /* LPC coefficients */ 1239 if (sub->type == FLAC_SUBFRAME_LPC) { 1240 int cbits = s->options.lpc_coeff_precision; 1241 put_bits( &s->pb, 4, cbits-1); 1242 put_sbits(&s->pb, 5, sub->shift); 1243 for (i = 0; i < sub->order; i++) 1244 put_sbits(&s->pb, cbits, sub->coefs[i]); 1245 } 1246 1247 /* rice-encoded block */ 1248 put_bits(&s->pb, 2, sub->rc.coding_mode - 4); 1249 1250 /* partition order */ 1251 porder = sub->rc.porder; 1252 psize = s->frame.blocksize >> porder; 1253 put_bits(&s->pb, 4, porder); 1254 1255 /* residual */ 1256 part_end = &sub->residual[psize]; 1257 for (p = 0; p < 1 << porder; p++) { 1258 int k = sub->rc.params[p]; 1259 put_bits(&s->pb, sub->rc.coding_mode, k); 1260 while (res < part_end) 1261 set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0); 1262 part_end = FFMIN(frame_end, part_end + psize); 1263 } 1264 } 1265 } 1266} 1267 1268 1269static void write_frame_footer(FlacEncodeContext *s) 1270{ 1271 int crc; 1272 flush_put_bits(&s->pb); 1273 crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf, 1274 put_bytes_output(&s->pb))); 1275 put_bits(&s->pb, 16, crc); 1276 flush_put_bits(&s->pb); 1277} 1278 1279 1280static int write_frame(FlacEncodeContext *s, AVPacket *avpkt) 1281{ 1282 init_put_bits(&s->pb, avpkt->data, avpkt->size); 1283 write_frame_header(s); 1284 write_subframes(s); 1285 write_frame_footer(s); 1286 return put_bytes_output(&s->pb); 1287} 1288 1289 1290static int update_md5_sum(FlacEncodeContext *s, const void *samples) 1291{ 1292 const uint8_t *buf; 1293 int buf_size = s->frame.blocksize * s->channels * 1294 ((s->avctx->bits_per_raw_sample + 7) / 8); 1295 1296 if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) { 1297 av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size); 1298 if (!s->md5_buffer) 1299 return AVERROR(ENOMEM); 1300 } 1301 1302 if (s->avctx->bits_per_raw_sample <= 16) { 1303 buf = (const uint8_t *)samples; 1304#if HAVE_BIGENDIAN 1305 s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer, 1306 (const uint16_t *) samples, buf_size / 2); 1307 buf = s->md5_buffer; 1308#endif 1309 } else { 1310 int i; 1311 const int32_t *samples0 = samples; 1312 uint8_t *tmp = s->md5_buffer; 1313 1314 for (i = 0; i < s->frame.blocksize * s->channels; i++) { 1315 int32_t v = samples0[i] >> 8; 1316 AV_WL24(tmp + 3*i, v); 1317 } 1318 buf = s->md5_buffer; 1319 } 1320 av_md5_update(s->md5ctx, buf, buf_size); 1321 1322 return 0; 1323} 1324 1325 1326static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, 1327 const AVFrame *frame, int *got_packet_ptr) 1328{ 1329 FlacEncodeContext *s; 1330 int frame_bytes, out_bytes, ret; 1331 1332 s = avctx->priv_data; 1333 1334 /* when the last block is reached, update the header in extradata */ 1335 if (!frame) { 1336 s->max_framesize = s->max_encoded_framesize; 1337 av_md5_final(s->md5ctx, s->md5sum); 1338 write_streaminfo(s, avctx->extradata); 1339 1340 if (!s->flushed) { 1341 uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, 1342 avctx->extradata_size); 1343 if (!side_data) 1344 return AVERROR(ENOMEM); 1345 memcpy(side_data, avctx->extradata, avctx->extradata_size); 1346 1347 avpkt->pts = s->next_pts; 1348 1349 *got_packet_ptr = 1; 1350 s->flushed = 1; 1351 } 1352 1353 return 0; 1354 } 1355 1356 /* change max_framesize for small final frame */ 1357 if (frame->nb_samples < s->frame.blocksize) { 1358 s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples, 1359 s->channels, 1360 avctx->bits_per_raw_sample); 1361 } 1362 1363 init_frame(s, frame->nb_samples); 1364 1365 copy_samples(s, frame->data[0]); 1366 1367 channel_decorrelation(s); 1368 1369 remove_wasted_bits(s); 1370 1371 frame_bytes = encode_frame(s); 1372 1373 /* Fall back on verbatim mode if the compressed frame is larger than it 1374 would be if encoded uncompressed. */ 1375 if (frame_bytes < 0 || frame_bytes > s->max_framesize) { 1376 s->frame.verbatim_only = 1; 1377 frame_bytes = encode_frame(s); 1378 if (frame_bytes < 0) { 1379 av_log(avctx, AV_LOG_ERROR, "Bad frame count\n"); 1380 return frame_bytes; 1381 } 1382 } 1383 1384 if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_bytes, 0)) < 0) 1385 return ret; 1386 1387 out_bytes = write_frame(s, avpkt); 1388 1389 s->frame_count++; 1390 s->sample_count += frame->nb_samples; 1391 if ((ret = update_md5_sum(s, frame->data[0])) < 0) { 1392 av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n"); 1393 return ret; 1394 } 1395 if (out_bytes > s->max_encoded_framesize) 1396 s->max_encoded_framesize = out_bytes; 1397 if (out_bytes < s->min_framesize) 1398 s->min_framesize = out_bytes; 1399 1400 avpkt->pts = frame->pts; 1401 avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples); 1402 1403 s->next_pts = avpkt->pts + avpkt->duration; 1404 1405 av_shrink_packet(avpkt, out_bytes); 1406 1407 *got_packet_ptr = 1; 1408 return 0; 1409} 1410 1411 1412static av_cold int flac_encode_close(AVCodecContext *avctx) 1413{ 1414 FlacEncodeContext *s = avctx->priv_data; 1415 1416 av_freep(&s->md5ctx); 1417 av_freep(&s->md5_buffer); 1418 ff_lpc_end(&s->lpc_ctx); 1419 return 0; 1420} 1421 1422#define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM 1423static const AVOption options[] = { 1424{ "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext, options.lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, MAX_LPC_PRECISION, FLAGS }, 1425{ "lpc_type", "LPC algorithm", offsetof(FlacEncodeContext, options.lpc_type), AV_OPT_TYPE_INT, {.i64 = FF_LPC_TYPE_DEFAULT }, FF_LPC_TYPE_DEFAULT, FF_LPC_TYPE_NB-1, FLAGS, "lpc_type" }, 1426{ "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE }, INT_MIN, INT_MAX, FLAGS, "lpc_type" }, 1427{ "fixed", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED }, INT_MIN, INT_MAX, FLAGS, "lpc_type" }, 1428{ "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, "lpc_type" }, 1429{ "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, "lpc_type" }, 1430{ "lpc_passes", "Number of passes to use for Cholesky factorization during LPC analysis", offsetof(FlacEncodeContext, options.lpc_passes), AV_OPT_TYPE_INT, {.i64 = 2 }, 1, INT_MAX, FLAGS }, 1431{ "min_partition_order", NULL, offsetof(FlacEncodeContext, options.min_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS }, 1432{ "max_partition_order", NULL, offsetof(FlacEncodeContext, options.max_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS }, 1433{ "prediction_order_method", "Search method for selecting prediction order", offsetof(FlacEncodeContext, options.prediction_order_method), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, ORDER_METHOD_LOG, FLAGS, "predm" }, 1434{ "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1435{ "2level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1436{ "4level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1437{ "8level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1438{ "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1439{ "log", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG }, INT_MIN, INT_MAX, FLAGS, "predm" }, 1440{ "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, "ch_mode" }, 1441{ "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, FLAGS, "ch_mode" }, 1442{ "indep", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, "ch_mode" }, 1443{ "left_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" }, 1444{ "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" }, 1445{ "mid_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" }, 1446{ "exact_rice_parameters", "Calculate rice parameters exactly", offsetof(FlacEncodeContext, options.exact_rice_parameters), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, 1447{ "multi_dim_quant", "Multi-dimensional quantization", offsetof(FlacEncodeContext, options.multi_dim_quant), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, 1448{ "min_prediction_order", NULL, offsetof(FlacEncodeContext, options.min_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS }, 1449{ "max_prediction_order", NULL, offsetof(FlacEncodeContext, options.max_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS }, 1450 1451{ NULL }, 1452}; 1453 1454static const AVClass flac_encoder_class = { 1455 .class_name = "FLAC encoder", 1456 .item_name = av_default_item_name, 1457 .option = options, 1458 .version = LIBAVUTIL_VERSION_INT, 1459}; 1460 1461const FFCodec ff_flac_encoder = { 1462 .p.name = "flac", 1463 .p.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 1464 .p.type = AVMEDIA_TYPE_AUDIO, 1465 .p.id = AV_CODEC_ID_FLAC, 1466 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | 1467 AV_CODEC_CAP_SMALL_LAST_FRAME, 1468 .priv_data_size = sizeof(FlacEncodeContext), 1469 .init = flac_encode_init, 1470 FF_CODEC_ENCODE_CB(flac_encode_frame), 1471 .close = flac_encode_close, 1472 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16, 1473 AV_SAMPLE_FMT_S32, 1474 AV_SAMPLE_FMT_NONE }, 1475 .p.priv_class = &flac_encoder_class, 1476 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP, 1477}; 1478