FFmpeg
flacenc.c
Go to the documentation of this file.
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"
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 "encode.h"
32 #include "put_bits.h"
33 #include "golomb.h"
34 #include "internal.h"
35 #include "lpc.h"
36 #include "flac.h"
37 #include "flacdata.h"
38 #include "flacdsp.h"
39 
40 #define FLAC_SUBFRAME_CONSTANT 0
41 #define FLAC_SUBFRAME_VERBATIM 1
42 #define FLAC_SUBFRAME_FIXED 8
43 #define FLAC_SUBFRAME_LPC 32
44 
45 #define MAX_FIXED_ORDER 4
46 #define MAX_PARTITION_ORDER 8
47 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
48 #define MAX_LPC_PRECISION 15
49 #define MIN_LPC_SHIFT 0
50 #define MAX_LPC_SHIFT 15
51 
52 enum CodingMode {
55 };
56 
57 typedef struct CompressionOptions {
68  int ch_mode;
72 
73 typedef struct RiceContext {
75  int porder;
77 } RiceContext;
78 
79 typedef struct FlacSubframe {
80  int type;
81  int type_code;
82  int obits;
83  int wasted;
84  int order;
86  int shift;
87 
90  uint64_t rc_sums[32][MAX_PARTITIONS];
91 
94 } FlacSubframe;
95 
96 typedef struct FlacFrame {
98  int blocksize;
99  int bs_code[2];
100  uint8_t crc8;
101  int ch_mode;
103 } FlacFrame;
104 
105 typedef struct FlacEncodeContext {
106  AVClass *class;
108  int channels;
110  int sr_code[2];
111  int bps_code;
116  uint32_t frame_count;
117  uint64_t sample_count;
118  uint8_t md5sum[16];
123  struct AVMD5 *md5ctx;
124  uint8_t *md5_buffer;
125  unsigned int md5_buffer_size;
128 
129  int flushed;
130  int64_t next_pts;
132 
133 
134 /**
135  * Write streaminfo metadata block to byte array.
136  */
138 {
139  PutBitContext pb;
140 
141  memset(header, 0, FLAC_STREAMINFO_SIZE);
143 
144  /* streaminfo metadata block */
145  put_bits(&pb, 16, s->max_blocksize);
146  put_bits(&pb, 16, s->max_blocksize);
147  put_bits(&pb, 24, s->min_framesize);
148  put_bits(&pb, 24, s->max_framesize);
149  put_bits(&pb, 20, s->samplerate);
150  put_bits(&pb, 3, s->channels-1);
151  put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1);
152  /* write 36-bit sample count in 2 put_bits() calls */
153  put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
154  put_bits(&pb, 12, s->sample_count & 0x000000FFFLL);
155  flush_put_bits(&pb);
156  memcpy(&header[18], s->md5sum, 16);
157 }
158 
159 
160 /**
161  * Set blocksize based on samplerate.
162  * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
163  */
164 static int select_blocksize(int samplerate, int block_time_ms)
165 {
166  int i;
167  int target;
168  int blocksize;
169 
170  av_assert0(samplerate > 0);
171  blocksize = ff_flac_blocksize_table[1];
172  target = (samplerate * block_time_ms) / 1000;
173  for (i = 0; i < 16; i++) {
174  if (target >= ff_flac_blocksize_table[i] &&
175  ff_flac_blocksize_table[i] > blocksize) {
176  blocksize = ff_flac_blocksize_table[i];
177  }
178  }
179  return blocksize;
180 }
181 
182 
184 {
185  AVCodecContext *avctx = s->avctx;
186  CompressionOptions *opt = &s->options;
187 
188  av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level);
189 
190  switch (opt->lpc_type) {
191  case FF_LPC_TYPE_NONE:
192  av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");
193  break;
194  case FF_LPC_TYPE_FIXED:
195  av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n");
196  break;
198  av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");
199  break;
201  av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",
202  opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es");
203  break;
204  }
205 
206  av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
208 
209  switch (opt->prediction_order_method) {
210  case ORDER_METHOD_EST:
211  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate");
212  break;
213  case ORDER_METHOD_2LEVEL:
214  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level");
215  break;
216  case ORDER_METHOD_4LEVEL:
217  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level");
218  break;
219  case ORDER_METHOD_8LEVEL:
220  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level");
221  break;
222  case ORDER_METHOD_SEARCH:
223  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search");
224  break;
225  case ORDER_METHOD_LOG:
226  av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search");
227  break;
228  }
229 
230 
231  av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
233 
234  av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size);
235 
236  av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
237  opt->lpc_coeff_precision);
238 }
239 
240 
242 {
243  int freq = avctx->sample_rate;
244  int channels = avctx->channels;
245  FlacEncodeContext *s = avctx->priv_data;
246  int i, level, ret;
247  uint8_t *streaminfo;
248 
249  s->avctx = avctx;
250 
251  switch (avctx->sample_fmt) {
252  case AV_SAMPLE_FMT_S16:
253  avctx->bits_per_raw_sample = 16;
254  s->bps_code = 4;
255  break;
256  case AV_SAMPLE_FMT_S32:
257  if (avctx->bits_per_raw_sample != 24)
258  av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
259  avctx->bits_per_raw_sample = 24;
260  s->bps_code = 6;
261  break;
262  }
263 
265  av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",
267  return AVERROR(EINVAL);
268  }
269  s->channels = channels;
270 
271  /* find samplerate in table */
272  if (freq < 1)
273  return AVERROR(EINVAL);
274  for (i = 4; i < 12; i++) {
275  if (freq == ff_flac_sample_rate_table[i]) {
276  s->samplerate = ff_flac_sample_rate_table[i];
277  s->sr_code[0] = i;
278  s->sr_code[1] = 0;
279  break;
280  }
281  }
282  /* if not in table, samplerate is non-standard */
283  if (i == 12) {
284  if (freq % 1000 == 0 && freq < 255000) {
285  s->sr_code[0] = 12;
286  s->sr_code[1] = freq / 1000;
287  } else if (freq % 10 == 0 && freq < 655350) {
288  s->sr_code[0] = 14;
289  s->sr_code[1] = freq / 10;
290  } else if (freq < 65535) {
291  s->sr_code[0] = 13;
292  s->sr_code[1] = freq;
293  } else {
294  av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq);
295  return AVERROR(EINVAL);
296  }
297  s->samplerate = freq;
298  }
299 
300  /* set compression option defaults based on avctx->compression_level */
301  if (avctx->compression_level < 0)
302  s->options.compression_level = 5;
303  else
304  s->options.compression_level = avctx->compression_level;
305 
306  level = s->options.compression_level;
307  if (level > 12) {
308  av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
309  s->options.compression_level);
310  return AVERROR(EINVAL);
311  }
312 
313  s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
314 
315  if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT)
316  s->options.lpc_type = ((int[]){ FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED,
321 
322  if (s->options.min_prediction_order < 0)
323  s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
324  if (s->options.max_prediction_order < 0)
325  s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
326 
327  if (s->options.prediction_order_method < 0)
328  s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
333 
334  if (s->options.min_partition_order > s->options.max_partition_order) {
335  av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
336  s->options.min_partition_order, s->options.max_partition_order);
337  return AVERROR(EINVAL);
338  }
339  if (s->options.min_partition_order < 0)
340  s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
341  if (s->options.max_partition_order < 0)
342  s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
343 
344  if (s->options.lpc_type == FF_LPC_TYPE_NONE) {
345  s->options.min_prediction_order = 0;
346  s->options.max_prediction_order = 0;
347  } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
348  if (s->options.min_prediction_order > MAX_FIXED_ORDER) {
349  av_log(avctx, AV_LOG_WARNING,
350  "invalid min prediction order %d, clamped to %d\n",
351  s->options.min_prediction_order, MAX_FIXED_ORDER);
352  s->options.min_prediction_order = MAX_FIXED_ORDER;
353  }
354  if (s->options.max_prediction_order > MAX_FIXED_ORDER) {
355  av_log(avctx, AV_LOG_WARNING,
356  "invalid max prediction order %d, clamped to %d\n",
357  s->options.max_prediction_order, MAX_FIXED_ORDER);
358  s->options.max_prediction_order = MAX_FIXED_ORDER;
359  }
360  }
361 
362  if (s->options.max_prediction_order < s->options.min_prediction_order) {
363  av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
364  s->options.min_prediction_order, s->options.max_prediction_order);
365  return AVERROR(EINVAL);
366  }
367 
368  if (avctx->frame_size > 0) {
369  if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
370  avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
371  av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
372  avctx->frame_size);
373  return AVERROR(EINVAL);
374  }
375  } else {
376  s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
377  }
378  s->max_blocksize = s->avctx->frame_size;
379 
380  /* set maximum encoded frame size in verbatim mode */
381  s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size,
382  s->channels,
383  s->avctx->bits_per_raw_sample);
384 
385  /* initialize MD5 context */
386  s->md5ctx = av_md5_alloc();
387  if (!s->md5ctx)
388  return AVERROR(ENOMEM);
389  av_md5_init(s->md5ctx);
390 
391  streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
392  if (!streaminfo)
393  return AVERROR(ENOMEM);
394  write_streaminfo(s, streaminfo);
395  avctx->extradata = streaminfo;
397 
398  s->frame_count = 0;
399  s->min_framesize = s->max_framesize;
400 
401  if (channels == 3 &&
403  channels == 4 &&
404  avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
405  avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
406  channels == 5 &&
409  channels == 6 &&
412  if (avctx->channel_layout) {
413  av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "
414  "output stream will have incorrect "
415  "channel layout.\n");
416  } else {
417  av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
418  "will use Flac channel layout for "
419  "%d channels.\n", channels);
420  }
421  }
422 
423  ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
424  s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
425 
426  ff_bswapdsp_init(&s->bdsp);
427  ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, channels,
428  avctx->bits_per_raw_sample);
429 
431 
432  return ret;
433 }
434 
435 
436 static void init_frame(FlacEncodeContext *s, int nb_samples)
437 {
438  int i, ch;
439  FlacFrame *frame;
440 
441  frame = &s->frame;
442 
443  for (i = 0; i < 16; i++) {
444  if (nb_samples == ff_flac_blocksize_table[i]) {
445  frame->blocksize = ff_flac_blocksize_table[i];
446  frame->bs_code[0] = i;
447  frame->bs_code[1] = 0;
448  break;
449  }
450  }
451  if (i == 16) {
452  frame->blocksize = nb_samples;
453  if (frame->blocksize <= 256) {
454  frame->bs_code[0] = 6;
455  frame->bs_code[1] = frame->blocksize-1;
456  } else {
457  frame->bs_code[0] = 7;
458  frame->bs_code[1] = frame->blocksize-1;
459  }
460  }
461 
462  for (ch = 0; ch < s->channels; ch++) {
463  FlacSubframe *sub = &frame->subframes[ch];
464 
465  sub->wasted = 0;
466  sub->obits = s->avctx->bits_per_raw_sample;
467 
468  if (sub->obits > 16)
469  sub->rc.coding_mode = CODING_MODE_RICE2;
470  else
471  sub->rc.coding_mode = CODING_MODE_RICE;
472  }
473 
474  frame->verbatim_only = 0;
475 }
476 
477 
478 /**
479  * Copy channel-interleaved input samples into separate subframes.
480  */
481 static void copy_samples(FlacEncodeContext *s, const void *samples)
482 {
483  int i, j, ch;
484  FlacFrame *frame;
485  int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
486  s->avctx->bits_per_raw_sample;
487 
488 #define COPY_SAMPLES(bits) do { \
489  const int ## bits ## _t *samples0 = samples; \
490  frame = &s->frame; \
491  for (i = 0, j = 0; i < frame->blocksize; i++) \
492  for (ch = 0; ch < s->channels; ch++, j++) \
493  frame->subframes[ch].samples[i] = samples0[j] >> shift; \
494 } while (0)
495 
496  if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
497  COPY_SAMPLES(16);
498  else
499  COPY_SAMPLES(32);
500 }
501 
502 
503 static uint64_t rice_count_exact(const int32_t *res, int n, int k)
504 {
505  int i;
506  uint64_t count = 0;
507 
508  for (i = 0; i < n; i++) {
509  int32_t v = -2 * res[i] - 1;
510  v ^= v >> 31;
511  count += (v >> k) + 1 + k;
512  }
513  return count;
514 }
515 
516 
518  int pred_order)
519 {
520  int p, porder, psize;
521  int i, part_end;
522  uint64_t count = 0;
523 
524  /* subframe header */
525  count += 8;
526 
527  if (sub->wasted)
528  count += sub->wasted;
529 
530  /* subframe */
531  if (sub->type == FLAC_SUBFRAME_CONSTANT) {
532  count += sub->obits;
533  } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
534  count += s->frame.blocksize * sub->obits;
535  } else {
536  /* warm-up samples */
537  count += pred_order * sub->obits;
538 
539  /* LPC coefficients */
540  if (sub->type == FLAC_SUBFRAME_LPC)
541  count += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
542 
543  /* rice-encoded block */
544  count += 2;
545 
546  /* partition order */
547  porder = sub->rc.porder;
548  psize = s->frame.blocksize >> porder;
549  count += 4;
550 
551  /* residual */
552  i = pred_order;
553  part_end = psize;
554  for (p = 0; p < 1 << porder; p++) {
555  int k = sub->rc.params[p];
556  count += sub->rc.coding_mode;
557  count += rice_count_exact(&sub->residual[i], part_end - i, k);
558  i = part_end;
559  part_end = FFMIN(s->frame.blocksize, part_end + psize);
560  }
561  }
562 
563  return count;
564 }
565 
566 
567 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
568 
569 /**
570  * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
571  */
572 static int find_optimal_param(uint64_t sum, int n, int max_param)
573 {
574  int k;
575  uint64_t sum2;
576 
577  if (sum <= n >> 1)
578  return 0;
579  sum2 = sum - (n >> 1);
580  k = av_log2(av_clipl_int32(sum2 / n));
581  return FFMIN(k, max_param);
582 }
583 
584 static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
585 {
586  int bestk = 0;
587  int64_t bestbits = INT64_MAX;
588  int k;
589 
590  for (k = 0; k <= max_param; k++) {
591  int64_t bits = sums[k][i];
592  if (bits < bestbits) {
593  bestbits = bits;
594  bestk = k;
595  }
596  }
597 
598  return bestk;
599 }
600 
601 static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder,
602  uint64_t sums[32][MAX_PARTITIONS],
603  int n, int pred_order, int max_param, int exact)
604 {
605  int i;
606  int k, cnt, part;
607  uint64_t all_bits;
608 
609  part = (1 << porder);
610  all_bits = 4 * part;
611 
612  cnt = (n >> porder) - pred_order;
613  for (i = 0; i < part; i++) {
614  if (exact) {
615  k = find_optimal_param_exact(sums, i, max_param);
616  all_bits += sums[k][i];
617  } else {
618  k = find_optimal_param(sums[0][i], cnt, max_param);
619  all_bits += rice_encode_count(sums[0][i], cnt, k);
620  }
621  rc->params[i] = k;
622  cnt = n >> porder;
623  }
624 
625  rc->porder = porder;
626 
627  return all_bits;
628 }
629 
630 
631 static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order,
632  uint64_t sums[32][MAX_PARTITIONS])
633 {
634  int i, k;
635  int parts;
636  const uint32_t *res, *res_end;
637 
638  /* sums for highest level */
639  parts = (1 << pmax);
640 
641  for (k = 0; k <= kmax; k++) {
642  res = &data[pred_order];
643  res_end = &data[n >> pmax];
644  for (i = 0; i < parts; i++) {
645  if (kmax) {
646  uint64_t sum = (1LL + k) * (res_end - res);
647  while (res < res_end)
648  sum += *(res++) >> k;
649  sums[k][i] = sum;
650  } else {
651  uint64_t sum = 0;
652  while (res < res_end)
653  sum += *(res++);
654  sums[k][i] = sum;
655  }
656  res_end += n >> pmax;
657  }
658  }
659 }
660 
661 static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
662 {
663  int i, k;
664  int parts = (1 << level);
665  for (i = 0; i < parts; i++) {
666  for (k=0; k<=kmax; k++)
667  sums[k][i] = sums[k][2*i] + sums[k][2*i+1];
668  }
669 }
670 
671 static uint64_t calc_rice_params(RiceContext *rc,
672  uint32_t udata[FLAC_MAX_BLOCKSIZE],
673  uint64_t sums[32][MAX_PARTITIONS],
674  int pmin, int pmax,
675  const int32_t *data, int n, int pred_order, int exact)
676 {
677  int i;
678  uint64_t bits[MAX_PARTITION_ORDER+1];
679  int opt_porder;
680  RiceContext tmp_rc;
681  int kmax = (1 << rc->coding_mode) - 2;
682 
683  av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
684  av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
685  av_assert1(pmin <= pmax);
686 
687  tmp_rc.coding_mode = rc->coding_mode;
688 
689  for (i = 0; i < n; i++)
690  udata[i] = (2 * data[i]) ^ (data[i] >> 31);
691 
692  calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);
693 
694  opt_porder = pmin;
695  bits[pmin] = UINT32_MAX;
696  for (i = pmax; ; ) {
697  bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact);
698  if (bits[i] < bits[opt_porder] || pmax == pmin) {
699  opt_porder = i;
700  *rc = tmp_rc;
701  }
702  if (i == pmin)
703  break;
704  calc_sum_next(--i, sums, exact ? kmax : 0);
705  }
706 
707  return bits[opt_porder];
708 }
709 
710 
711 static int get_max_p_order(int max_porder, int n, int order)
712 {
713  int porder = FFMIN(max_porder, av_log2(n^(n-1)));
714  if (order > 0)
715  porder = FFMIN(porder, av_log2(n/order));
716  return porder;
717 }
718 
719 
721  FlacSubframe *sub, int pred_order)
722 {
723  int pmin = get_max_p_order(s->options.min_partition_order,
724  s->frame.blocksize, pred_order);
725  int pmax = get_max_p_order(s->options.max_partition_order,
726  s->frame.blocksize, pred_order);
727 
728  uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
729  if (sub->type == FLAC_SUBFRAME_LPC)
730  bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
731  bits += calc_rice_params(&sub->rc, sub->rc_udata, sub->rc_sums, pmin, pmax, sub->residual,
732  s->frame.blocksize, pred_order, s->options.exact_rice_parameters);
733  return bits;
734 }
735 
736 
737 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
738  int order)
739 {
740  int i;
741 
742  for (i = 0; i < order; i++)
743  res[i] = smp[i];
744 
745  if (order == 0) {
746  for (i = order; i < n; i++)
747  res[i] = smp[i];
748  } else if (order == 1) {
749  for (i = order; i < n; i++)
750  res[i] = smp[i] - smp[i-1];
751  } else if (order == 2) {
752  int a = smp[order-1] - smp[order-2];
753  for (i = order; i < n; i += 2) {
754  int b = smp[i ] - smp[i-1];
755  res[i] = b - a;
756  a = smp[i+1] - smp[i ];
757  res[i+1] = a - b;
758  }
759  } else if (order == 3) {
760  int a = smp[order-1] - smp[order-2];
761  int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
762  for (i = order; i < n; i += 2) {
763  int b = smp[i ] - smp[i-1];
764  int d = b - a;
765  res[i] = d - c;
766  a = smp[i+1] - smp[i ];
767  c = a - b;
768  res[i+1] = c - d;
769  }
770  } else {
771  int a = smp[order-1] - smp[order-2];
772  int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
773  int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
774  for (i = order; i < n; i += 2) {
775  int b = smp[i ] - smp[i-1];
776  int d = b - a;
777  int f = d - c;
778  res[i ] = f - e;
779  a = smp[i+1] - smp[i ];
780  c = a - b;
781  e = c - d;
782  res[i+1] = e - f;
783  }
784  }
785 }
786 
787 
789 {
790  int i, n;
791  int min_order, max_order, opt_order, omethod;
792  FlacFrame *frame;
793  FlacSubframe *sub;
795  int shift[MAX_LPC_ORDER];
796  int32_t *res, *smp;
797 
798  frame = &s->frame;
799  sub = &frame->subframes[ch];
800  res = sub->residual;
801  smp = sub->samples;
802  n = frame->blocksize;
803 
804  /* CONSTANT */
805  for (i = 1; i < n; i++)
806  if(smp[i] != smp[0])
807  break;
808  if (i == n) {
809  sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
810  res[0] = smp[0];
811  return subframe_count_exact(s, sub, 0);
812  }
813 
814  /* VERBATIM */
815  if (frame->verbatim_only || n < 5) {
816  sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
817  memcpy(res, smp, n * sizeof(int32_t));
818  return subframe_count_exact(s, sub, 0);
819  }
820 
821  min_order = s->options.min_prediction_order;
822  max_order = s->options.max_prediction_order;
823  omethod = s->options.prediction_order_method;
824 
825  /* FIXED */
826  sub->type = FLAC_SUBFRAME_FIXED;
827  if (s->options.lpc_type == FF_LPC_TYPE_NONE ||
828  s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) {
829  uint64_t bits[MAX_FIXED_ORDER+1];
830  if (max_order > MAX_FIXED_ORDER)
831  max_order = MAX_FIXED_ORDER;
832  opt_order = 0;
833  bits[0] = UINT32_MAX;
834  for (i = min_order; i <= max_order; i++) {
835  encode_residual_fixed(res, smp, n, i);
837  if (bits[i] < bits[opt_order])
838  opt_order = i;
839  }
840  sub->order = opt_order;
841  sub->type_code = sub->type | sub->order;
842  if (sub->order != max_order) {
843  encode_residual_fixed(res, smp, n, sub->order);
845  }
846  return subframe_count_exact(s, sub, sub->order);
847  }
848 
849  /* LPC */
850  sub->type = FLAC_SUBFRAME_LPC;
851  opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order,
852  s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type,
853  s->options.lpc_passes, omethod,
855 
856  if (omethod == ORDER_METHOD_2LEVEL ||
857  omethod == ORDER_METHOD_4LEVEL ||
858  omethod == ORDER_METHOD_8LEVEL) {
859  int levels = 1 << omethod;
860  uint64_t bits[1 << ORDER_METHOD_8LEVEL];
861  int order = -1;
862  int opt_index = levels-1;
863  opt_order = max_order-1;
864  bits[opt_index] = UINT32_MAX;
865  for (i = levels-1; i >= 0; i--) {
866  int last_order = order;
867  order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
868  order = av_clip(order, min_order - 1, max_order - 1);
869  if (order == last_order)
870  continue;
871  if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(order) <= 32) {
872  s->flac_dsp.lpc16_encode(res, smp, n, order+1, coefs[order],
873  shift[order]);
874  } else {
875  s->flac_dsp.lpc32_encode(res, smp, n, order+1, coefs[order],
876  shift[order]);
877  }
878  bits[i] = find_subframe_rice_params(s, sub, order+1);
879  if (bits[i] < bits[opt_index]) {
880  opt_index = i;
881  opt_order = order;
882  }
883  }
884  opt_order++;
885  } else if (omethod == ORDER_METHOD_SEARCH) {
886  // brute-force optimal order search
887  uint64_t bits[MAX_LPC_ORDER];
888  opt_order = 0;
889  bits[0] = UINT32_MAX;
890  for (i = min_order-1; i < max_order; i++) {
891  if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {
892  s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);
893  } else {
894  s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);
895  }
897  if (bits[i] < bits[opt_order])
898  opt_order = i;
899  }
900  opt_order++;
901  } else if (omethod == ORDER_METHOD_LOG) {
902  uint64_t bits[MAX_LPC_ORDER];
903  int step;
904 
905  opt_order = min_order - 1 + (max_order-min_order)/3;
906  memset(bits, -1, sizeof(bits));
907 
908  for (step = 16; step; step >>= 1) {
909  int last = opt_order;
910  for (i = last-step; i <= last+step; i += step) {
911  if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)
912  continue;
913  if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(i) <= 32) {
914  s->flac_dsp.lpc32_encode(res, smp, n, i+1, coefs[i], shift[i]);
915  } else {
916  s->flac_dsp.lpc16_encode(res, smp, n, i+1, coefs[i], shift[i]);
917  }
919  if (bits[i] < bits[opt_order])
920  opt_order = i;
921  }
922  }
923  opt_order++;
924  }
925 
926  if (s->options.multi_dim_quant) {
927  int allsteps = 1;
928  int i, step, improved;
929  int64_t best_score = INT64_MAX;
930  int32_t qmax;
931 
932  qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1;
933 
934  for (i=0; i<opt_order; i++)
935  allsteps *= 3;
936 
937  do {
938  improved = 0;
939  for (step = 0; step < allsteps; step++) {
940  int tmp = step;
941  int32_t lpc_try[MAX_LPC_ORDER];
942  int64_t score = 0;
943  int diffsum = 0;
944 
945  for (i=0; i<opt_order; i++) {
946  int diff = ((tmp + 1) % 3) - 1;
947  lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax);
948  tmp /= 3;
949  diffsum += !!diff;
950  }
951  if (diffsum >8)
952  continue;
953 
954  if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order - 1) <= 32) {
955  s->flac_dsp.lpc16_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);
956  } else {
957  s->flac_dsp.lpc32_encode(res, smp, n, opt_order, lpc_try, shift[opt_order-1]);
958  }
959  score = find_subframe_rice_params(s, sub, opt_order);
960  if (score < best_score) {
961  best_score = score;
962  memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs));
963  improved=1;
964  }
965  }
966  } while(improved);
967  }
968 
969  sub->order = opt_order;
970  sub->type_code = sub->type | (sub->order-1);
971  sub->shift = shift[sub->order-1];
972  for (i = 0; i < sub->order; i++)
973  sub->coefs[i] = coefs[sub->order-1][i];
974 
975  if (s->bps_code * 4 + s->options.lpc_coeff_precision + av_log2(opt_order) <= 32) {
976  s->flac_dsp.lpc16_encode(res, smp, n, sub->order, sub->coefs, sub->shift);
977  } else {
978  s->flac_dsp.lpc32_encode(res, smp, n, sub->order, sub->coefs, sub->shift);
979  }
980 
982 
983  return subframe_count_exact(s, sub, sub->order);
984 }
985 
986 
988 {
989  uint8_t av_unused tmp;
990  int count;
991 
992  /*
993  <14> Sync code
994  <1> Reserved
995  <1> Blocking strategy
996  <4> Block size in inter-channel samples
997  <4> Sample rate
998  <4> Channel assignment
999  <3> Sample size in bits
1000  <1> Reserved
1001  */
1002  count = 32;
1003 
1004  /* coded frame number */
1005  PUT_UTF8(s->frame_count, tmp, count += 8;)
1006 
1007  /* explicit block size */
1008  if (s->frame.bs_code[0] == 6)
1009  count += 8;
1010  else if (s->frame.bs_code[0] == 7)
1011  count += 16;
1012 
1013  /* explicit sample rate */
1014  count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8;
1015 
1016  /* frame header CRC-8 */
1017  count += 8;
1018 
1019  return count;
1020 }
1021 
1022 
1024 {
1025  int ch;
1026  uint64_t count;
1027 
1028  count = count_frame_header(s);
1029 
1030  for (ch = 0; ch < s->channels; ch++)
1031  count += encode_residual_ch(s, ch);
1032 
1033  count += (8 - (count & 7)) & 7; // byte alignment
1034  count += 16; // CRC-16
1035 
1036  count >>= 3;
1037  if (count > INT_MAX)
1038  return AVERROR_BUG;
1039  return count;
1040 }
1041 
1042 
1044 {
1045  int ch, i;
1046 
1047  for (ch = 0; ch < s->channels; ch++) {
1048  FlacSubframe *sub = &s->frame.subframes[ch];
1049  int32_t v = 0;
1050 
1051  for (i = 0; i < s->frame.blocksize; i++) {
1052  v |= sub->samples[i];
1053  if (v & 1)
1054  break;
1055  }
1056 
1057  if (v && !(v & 1)) {
1058  v = ff_ctz(v);
1059 
1060  for (i = 0; i < s->frame.blocksize; i++)
1061  sub->samples[i] >>= v;
1062 
1063  sub->wasted = v;
1064  sub->obits -= v;
1065 
1066  /* for 24-bit, check if removing wasted bits makes the range better
1067  suited for using RICE instead of RICE2 for entropy coding */
1068  if (sub->obits <= 17)
1069  sub->rc.coding_mode = CODING_MODE_RICE;
1070  }
1071  }
1072 }
1073 
1074 
1075 static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n,
1076  int max_rice_param)
1077 {
1078  int i, best;
1079  int32_t lt, rt;
1080  uint64_t sum[4];
1081  uint64_t score[4];
1082  int k;
1083 
1084  /* calculate sum of 2nd order residual for each channel */
1085  sum[0] = sum[1] = sum[2] = sum[3] = 0;
1086  for (i = 2; i < n; i++) {
1087  lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1088  rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
1089  sum[2] += FFABS((lt + rt) >> 1);
1090  sum[3] += FFABS(lt - rt);
1091  sum[0] += FFABS(lt);
1092  sum[1] += FFABS(rt);
1093  }
1094  /* estimate bit counts */
1095  for (i = 0; i < 4; i++) {
1096  k = find_optimal_param(2 * sum[i], n, max_rice_param);
1097  sum[i] = rice_encode_count( 2 * sum[i], n, k);
1098  }
1099 
1100  /* calculate score for each mode */
1101  score[0] = sum[0] + sum[1];
1102  score[1] = sum[0] + sum[3];
1103  score[2] = sum[1] + sum[3];
1104  score[3] = sum[2] + sum[3];
1105 
1106  /* return mode with lowest score */
1107  best = 0;
1108  for (i = 1; i < 4; i++)
1109  if (score[i] < score[best])
1110  best = i;
1111 
1112  return best;
1113 }
1114 
1115 
1116 /**
1117  * Perform stereo channel decorrelation.
1118  */
1120 {
1121  FlacFrame *frame;
1122  int32_t *left, *right;
1123  int i, n;
1124 
1125  frame = &s->frame;
1126  n = frame->blocksize;
1127  left = frame->subframes[0].samples;
1128  right = frame->subframes[1].samples;
1129 
1130  if (s->channels != 2) {
1131  frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1132  return;
1133  }
1134 
1135  if (s->options.ch_mode < 0) {
1136  int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;
1137  frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param);
1138  } else
1139  frame->ch_mode = s->options.ch_mode;
1140 
1141  /* perform decorrelation and adjust bits-per-sample */
1142  if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1143  return;
1144  if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1145  int32_t tmp;
1146  for (i = 0; i < n; i++) {
1147  tmp = left[i];
1148  left[i] = (tmp + right[i]) >> 1;
1149  right[i] = tmp - right[i];
1150  }
1151  frame->subframes[1].obits++;
1152  } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1153  for (i = 0; i < n; i++)
1154  right[i] = left[i] - right[i];
1155  frame->subframes[1].obits++;
1156  } else {
1157  for (i = 0; i < n; i++)
1158  left[i] -= right[i];
1159  frame->subframes[0].obits++;
1160  }
1161 }
1162 
1163 
1164 static void write_utf8(PutBitContext *pb, uint32_t val)
1165 {
1166  uint8_t tmp;
1167  PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1168 }
1169 
1170 
1172 {
1173  FlacFrame *frame;
1174  int crc;
1175 
1176  frame = &s->frame;
1177 
1178  put_bits(&s->pb, 16, 0xFFF8);
1179  put_bits(&s->pb, 4, frame->bs_code[0]);
1180  put_bits(&s->pb, 4, s->sr_code[0]);
1181 
1182  if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1183  put_bits(&s->pb, 4, s->channels-1);
1184  else
1185  put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
1186 
1187  put_bits(&s->pb, 3, s->bps_code);
1188  put_bits(&s->pb, 1, 0);
1189  write_utf8(&s->pb, s->frame_count);
1190 
1191  if (frame->bs_code[0] == 6)
1192  put_bits(&s->pb, 8, frame->bs_code[1]);
1193  else if (frame->bs_code[0] == 7)
1194  put_bits(&s->pb, 16, frame->bs_code[1]);
1195 
1196  if (s->sr_code[0] == 12)
1197  put_bits(&s->pb, 8, s->sr_code[1]);
1198  else if (s->sr_code[0] > 12)
1199  put_bits(&s->pb, 16, s->sr_code[1]);
1200 
1201  flush_put_bits(&s->pb);
1202  crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,
1203  put_bytes_output(&s->pb));
1204  put_bits(&s->pb, 8, crc);
1205 }
1206 
1207 
1209 {
1210  int ch;
1211 
1212  for (ch = 0; ch < s->channels; ch++) {
1213  FlacSubframe *sub = &s->frame.subframes[ch];
1214  int i, p, porder, psize;
1215  int32_t *part_end;
1216  int32_t *res = sub->residual;
1217  int32_t *frame_end = &sub->residual[s->frame.blocksize];
1218 
1219  /* subframe header */
1220  put_bits(&s->pb, 1, 0);
1221  put_bits(&s->pb, 6, sub->type_code);
1222  put_bits(&s->pb, 1, !!sub->wasted);
1223  if (sub->wasted)
1224  put_bits(&s->pb, sub->wasted, 1);
1225 
1226  /* subframe */
1227  if (sub->type == FLAC_SUBFRAME_CONSTANT) {
1228  put_sbits(&s->pb, sub->obits, res[0]);
1229  } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
1230  while (res < frame_end)
1231  put_sbits(&s->pb, sub->obits, *res++);
1232  } else {
1233  /* warm-up samples */
1234  for (i = 0; i < sub->order; i++)
1235  put_sbits(&s->pb, sub->obits, *res++);
1236 
1237  /* LPC coefficients */
1238  if (sub->type == FLAC_SUBFRAME_LPC) {
1239  int cbits = s->options.lpc_coeff_precision;
1240  put_bits( &s->pb, 4, cbits-1);
1241  put_sbits(&s->pb, 5, sub->shift);
1242  for (i = 0; i < sub->order; i++)
1243  put_sbits(&s->pb, cbits, sub->coefs[i]);
1244  }
1245 
1246  /* rice-encoded block */
1247  put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
1248 
1249  /* partition order */
1250  porder = sub->rc.porder;
1251  psize = s->frame.blocksize >> porder;
1252  put_bits(&s->pb, 4, porder);
1253 
1254  /* residual */
1255  part_end = &sub->residual[psize];
1256  for (p = 0; p < 1 << porder; p++) {
1257  int k = sub->rc.params[p];
1258  put_bits(&s->pb, sub->rc.coding_mode, k);
1259  while (res < part_end)
1260  set_sr_golomb_flac(&s->pb, *res++, k, INT32_MAX, 0);
1261  part_end = FFMIN(frame_end, part_end + psize);
1262  }
1263  }
1264  }
1265 }
1266 
1267 
1269 {
1270  int crc;
1271  flush_put_bits(&s->pb);
1272  crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,
1273  put_bytes_output(&s->pb)));
1274  put_bits(&s->pb, 16, crc);
1275  flush_put_bits(&s->pb);
1276 }
1277 
1278 
1280 {
1281  init_put_bits(&s->pb, avpkt->data, avpkt->size);
1283  write_subframes(s);
1285  return put_bytes_output(&s->pb);
1286 }
1287 
1288 
1289 static int update_md5_sum(FlacEncodeContext *s, const void *samples)
1290 {
1291  const uint8_t *buf;
1292  int buf_size = s->frame.blocksize * s->channels *
1293  ((s->avctx->bits_per_raw_sample + 7) / 8);
1294 
1295  if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
1296  av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
1297  if (!s->md5_buffer)
1298  return AVERROR(ENOMEM);
1299  }
1300 
1301  if (s->avctx->bits_per_raw_sample <= 16) {
1302  buf = (const uint8_t *)samples;
1303 #if HAVE_BIGENDIAN
1304  s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer,
1305  (const uint16_t *) samples, buf_size / 2);
1306  buf = s->md5_buffer;
1307 #endif
1308  } else {
1309  int i;
1310  const int32_t *samples0 = samples;
1311  uint8_t *tmp = s->md5_buffer;
1312 
1313  for (i = 0; i < s->frame.blocksize * s->channels; i++) {
1314  int32_t v = samples0[i] >> 8;
1315  AV_WL24(tmp + 3*i, v);
1316  }
1317  buf = s->md5_buffer;
1318  }
1319  av_md5_update(s->md5ctx, buf, buf_size);
1320 
1321  return 0;
1322 }
1323 
1324 
1325 static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1326  const AVFrame *frame, int *got_packet_ptr)
1327 {
1329  int frame_bytes, out_bytes, ret;
1330 
1331  s = avctx->priv_data;
1332 
1333  /* when the last block is reached, update the header in extradata */
1334  if (!frame) {
1335  s->max_framesize = s->max_encoded_framesize;
1336  av_md5_final(s->md5ctx, s->md5sum);
1337  write_streaminfo(s, avctx->extradata);
1338 
1339  if (!s->flushed) {
1340  uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
1341  avctx->extradata_size);
1342  if (!side_data)
1343  return AVERROR(ENOMEM);
1344  memcpy(side_data, avctx->extradata, avctx->extradata_size);
1345 
1346  avpkt->pts = s->next_pts;
1347 
1348  *got_packet_ptr = 1;
1349  s->flushed = 1;
1350  }
1351 
1352  return 0;
1353  }
1354 
1355  /* change max_framesize for small final frame */
1356  if (frame->nb_samples < s->frame.blocksize) {
1357  s->max_framesize = ff_flac_get_max_frame_size(frame->nb_samples,
1358  s->channels,
1359  avctx->bits_per_raw_sample);
1360  }
1361 
1362  init_frame(s, frame->nb_samples);
1363 
1364  copy_samples(s, frame->data[0]);
1365 
1367 
1369 
1370  frame_bytes = encode_frame(s);
1371 
1372  /* Fall back on verbatim mode if the compressed frame is larger than it
1373  would be if encoded uncompressed. */
1374  if (frame_bytes < 0 || frame_bytes > s->max_framesize) {
1375  s->frame.verbatim_only = 1;
1376  frame_bytes = encode_frame(s);
1377  if (frame_bytes < 0) {
1378  av_log(avctx, AV_LOG_ERROR, "Bad frame count\n");
1379  return frame_bytes;
1380  }
1381  }
1382 
1383  if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_bytes, 0)) < 0)
1384  return ret;
1385 
1386  out_bytes = write_frame(s, avpkt);
1387 
1388  s->frame_count++;
1389  s->sample_count += frame->nb_samples;
1390  if ((ret = update_md5_sum(s, frame->data[0])) < 0) {
1391  av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");
1392  return ret;
1393  }
1394  if (out_bytes > s->max_encoded_framesize)
1395  s->max_encoded_framesize = out_bytes;
1396  if (out_bytes < s->min_framesize)
1397  s->min_framesize = out_bytes;
1398 
1399  avpkt->pts = frame->pts;
1400  avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples);
1401 
1402  s->next_pts = avpkt->pts + avpkt->duration;
1403 
1404  av_shrink_packet(avpkt, out_bytes);
1405 
1406  *got_packet_ptr = 1;
1407  return 0;
1408 }
1409 
1410 
1412 {
1413  FlacEncodeContext *s = avctx->priv_data;
1414 
1415  av_freep(&s->md5ctx);
1416  av_freep(&s->md5_buffer);
1417  ff_lpc_end(&s->lpc_ctx);
1418  return 0;
1419 }
1420 
1421 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1422 static const AVOption options[] = {
1423 { "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext, options.lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, MAX_LPC_PRECISION, FLAGS },
1424 { "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" },
1425 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1426 { "fixed", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1427 { "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1428 { "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1429 { "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 },
1430 { "min_partition_order", NULL, offsetof(FlacEncodeContext, options.min_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },
1431 { "max_partition_order", NULL, offsetof(FlacEncodeContext, options.max_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },
1432 { "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" },
1433 { "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, INT_MIN, INT_MAX, FLAGS, "predm" },
1434 { "2level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1435 { "4level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1436 { "8level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1437 { "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, "predm" },
1438 { "log", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG }, INT_MIN, INT_MAX, FLAGS, "predm" },
1439 { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, "ch_mode" },
1440 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1441 { "indep", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1442 { "left_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1443 { "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1444 { "mid_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1445 { "exact_rice_parameters", "Calculate rice parameters exactly", offsetof(FlacEncodeContext, options.exact_rice_parameters), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1446 { "multi_dim_quant", "Multi-dimensional quantization", offsetof(FlacEncodeContext, options.multi_dim_quant), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1447 { "min_prediction_order", NULL, offsetof(FlacEncodeContext, options.min_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
1448 { "max_prediction_order", NULL, offsetof(FlacEncodeContext, options.max_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
1449 
1450 { NULL },
1451 };
1452 
1453 static const AVClass flac_encoder_class = {
1454  .class_name = "FLAC encoder",
1455  .item_name = av_default_item_name,
1456  .option = options,
1457  .version = LIBAVUTIL_VERSION_INT,
1458 };
1459 
1461  .name = "flac",
1462  .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1463  .type = AVMEDIA_TYPE_AUDIO,
1464  .id = AV_CODEC_ID_FLAC,
1465  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1467  .priv_data_size = sizeof(FlacEncodeContext),
1469  .encode2 = flac_encode_frame,
1470  .close = flac_encode_close,
1471  .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
1474  .priv_class = &flac_encoder_class,
1476 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1008
AVCodec
AVCodec.
Definition: codec.h:197
bswapdsp.h
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
PUT_UTF8
#define PUT_UTF8(val, tmp, PUT_BYTE)
Definition: common.h:523
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
FFLPCType
FFLPCType
LPC analysis type.
Definition: lpc.h:43
AV_CH_LAYOUT_5POINT0_BACK
#define AV_CH_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:102
level
uint8_t level
Definition: svq3.c:204
FlacSubframe::samples
int32_t samples[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:92
av_clip
#define av_clip
Definition: common.h:96
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
flac_encode_init
static av_cold int flac_encode_init(AVCodecContext *avctx)
Definition: flacenc.c:241
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1039
ff_ctz
#define ff_ctz
Definition: intmath.h:106
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:988
set_sr_golomb_flac
static void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (flac).
Definition: golomb.h:738
CompressionOptions::exact_rice_parameters
int exact_rice_parameters
Definition: flacenc.c:69
MAX_PARTITION_ORDER
#define MAX_PARTITION_ORDER
Definition: flacenc.c:46
FlacEncodeContext::bdsp
BswapDSPContext bdsp
Definition: flacenc.c:126
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
CompressionOptions::max_prediction_order
int max_prediction_order
Definition: flacenc.c:64
CompressionOptions::ch_mode
int ch_mode
Definition: flacenc.c:68
MAX_LPC_SHIFT
#define MAX_LPC_SHIFT
Definition: flacenc.c:50
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:280
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
flac_encode_frame
static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: flacenc.c:1325
FlacEncodeContext::md5sum
uint8_t md5sum[16]
Definition: flacenc.c:118
RiceContext
Definition: alacenc.c:50
av_unused
#define av_unused
Definition: attributes.h:131
FlacEncodeContext::avctx
AVCodecContext * avctx
Definition: flacenc.c:121
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
CompressionOptions::max_partition_order
int max_partition_order
Definition: flacenc.c:67
FF_LPC_TYPE_CHOLESKY
@ FF_LPC_TYPE_CHOLESKY
Cholesky factorization.
Definition: lpc.h:48
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
ff_flacdsp_init
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:88
AVOption
AVOption.
Definition: opt.h:247
encode.h
FlacEncodeContext
Definition: flacenc.c:105
b
#define b
Definition: input.c:40
data
const char data[16]
Definition: mxf.c:143
CompressionOptions::prediction_order_method
int prediction_order_method
Definition: flacenc.c:65
FlacFrame
Definition: flacenc.c:96
select_blocksize
static int select_blocksize(int samplerate, int block_time_ms)
Set blocksize based on samplerate.
Definition: flacenc.c:164
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:391
CODING_MODE_RICE
@ CODING_MODE_RICE
Definition: flacenc.c:53
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:434
flacdsp.h
lpc.h
CompressionOptions::compression_level
int compression_level
Definition: flacenc.c:58
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
FlacEncodeContext::pb
PutBitContext pb
Definition: flacenc.c:107
crc.h
golomb.h
exp golomb vlc stuff
LPCContext
Definition: lpc.h:52
FLAC_CHMODE_LEFT_SIDE
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:42
find_subframe_rice_params
static uint64_t find_subframe_rice_params(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
Definition: flacenc.c:720
ORDER_METHOD_4LEVEL
#define ORDER_METHOD_4LEVEL
Definition: lpc.h:32
FlacSubframe::wasted
int wasted
Definition: flacenc.c:83
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
FlacEncodeContext::frame_count
uint32_t frame_count
Definition: flacenc.c:116
CompressionOptions::lpc_coeff_precision
int lpc_coeff_precision
Definition: flacenc.c:62
val
static double val(void *priv, double ch)
Definition: aeval.c:75
AVMD5
Definition: md5.c:40
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
AV_CH_LAYOUT_QUAD
#define AV_CH_LAYOUT_QUAD
Definition: channel_layout.h:99
FF_LPC_TYPE_DEFAULT
@ FF_LPC_TYPE_DEFAULT
use the codec default LPC type
Definition: lpc.h:44
ff_flac_blocksize_table
const int32_t ff_flac_blocksize_table[16]
Definition: flacdata.c:30
avassert.h
FlacFrame::ch_mode
int ch_mode
Definition: flacenc.c:101
ff_samples_to_time_base
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:240
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
write_subframes
static void write_subframes(FlacEncodeContext *s)
Definition: flacenc.c:1208
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:481
s
#define s(width, name)
Definition: cbs_vp9.c:257
FlacSubframe::type_code
int type_code
Definition: flacenc.c:81
ff_flac_get_max_frame_size
int ff_flac_get_max_frame_size(int blocksize, int ch, int bps)
Calculate an estimate for the maximum frame size based on verbatim mode.
Definition: flac.c:148
FlacSubframe::obits
int obits
Definition: flacenc.c:82
FlacEncodeContext::max_framesize
int max_framesize
Definition: flacenc.c:114
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
CompressionOptions::multi_dim_quant
int multi_dim_quant
Definition: flacenc.c:70
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FlacSubframe::order
int order
Definition: flacenc.c:84
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1421
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
remove_wasted_bits
static void remove_wasted_bits(FlacEncodeContext *s)
Definition: flacenc.c:1043
channels
channels
Definition: aptx.h:33
FlacSubframe::rc
RiceContext rc
Definition: flacenc.c:88
FLAC_SUBFRAME_LPC
#define FLAC_SUBFRAME_LPC
Definition: flacenc.c:43
COPY_SAMPLES
#define COPY_SAMPLES(bits)
calc_optimal_rice_params
static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder, uint64_t sums[32][MAX_PARTITIONS], int n, int pred_order, int max_param, int exact)
Definition: flacenc.c:601
CompressionOptions
Definition: dcaenc.c:59
FLAC_SUBFRAME_VERBATIM
#define FLAC_SUBFRAME_VERBATIM
Definition: flacenc.c:41
f
#define f(width, name)
Definition: cbs_vp9.c:255
PutBitContext
Definition: put_bits.h:49
RiceContext::porder
int porder
Definition: flacenc.c:75
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
FLAC_SUBFRAME_CONSTANT
#define FLAC_SUBFRAME_CONSTANT
Definition: flacenc.c:40
if
if(ret)
Definition: filter_design.txt:179
ff_flac_sample_rate_table
const int ff_flac_sample_rate_table[16]
Definition: flacdata.c:24
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:50
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
FlacFrame::subframes
FlacSubframe subframes[FLAC_MAX_CHANNELS]
Definition: flacenc.c:97
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
FLAC_SUBFRAME_FIXED
#define FLAC_SUBFRAME_FIXED
Definition: flacenc.c:42
FlacEncodeContext::lpc_ctx
LPCContext lpc_ctx
Definition: flacenc.c:122
MIN_LPC_SHIFT
#define MIN_LPC_SHIFT
Definition: flacenc.c:49
FlacEncodeContext::max_blocksize
int max_blocksize
Definition: flacenc.c:112
AV_WL24
#define AV_WL24(p, d)
Definition: intreadwrite.h:464
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
FLAGS
#define FLAGS
Definition: flacenc.c:1421
FlacEncodeContext::next_pts
int64_t next_pts
Definition: flacenc.c:130
AV_CH_LAYOUT_5POINT1
#define AV_CH_LAYOUT_5POINT1
Definition: channel_layout.h:101
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
FlacEncodeContext::md5_buffer
uint8_t * md5_buffer
Definition: flacenc.c:124
ORDER_METHOD_SEARCH
#define ORDER_METHOD_SEARCH
Definition: lpc.h:34
ff_lpc_calc_coefs
int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)
Calculate LPC coefficients for multiple orders.
Definition: lpc.c:201
AV_CH_FRONT_CENTER
#define AV_CH_FRONT_CENTER
Definition: channel_layout.h:51
CompressionOptions::lpc_passes
int lpc_passes
Definition: flacenc.c:61
FlacEncodeContext::channels
int channels
Definition: flacenc.c:108
FlacEncodeContext::flac_dsp
FLACDSPContext flac_dsp
Definition: flacenc.c:127
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FLAC_CHMODE_MID_SIDE
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:44
rice_count_exact
static uint64_t rice_count_exact(const int32_t *res, int n, int k)
Definition: flacenc.c:503
FlacEncodeContext::max_encoded_framesize
int max_encoded_framesize
Definition: flacenc.c:115
encode_residual_ch
static int encode_residual_ch(FlacEncodeContext *s, int ch)
Definition: flacenc.c:788
get_max_p_order
static int get_max_p_order(int max_porder, int n, int order)
Definition: flacenc.c:711
ORDER_METHOD_8LEVEL
#define ORDER_METHOD_8LEVEL
Definition: lpc.h:33
find_optimal_param_exact
static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
Definition: flacenc.c:584
FlacEncodeContext::flushed
int flushed
Definition: flacenc.c:129
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
FlacEncodeContext::md5_buffer_size
unsigned int md5_buffer_size
Definition: flacenc.c:125
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
av_clipl_int32
#define av_clipl_int32
Definition: common.h:114
channel_decorrelation
static void channel_decorrelation(FlacEncodeContext *s)
Perform stereo channel decorrelation.
Definition: flacenc.c:1119
FF_LPC_TYPE_NB
@ FF_LPC_TYPE_NB
Not part of ABI.
Definition: lpc.h:49
MAX_LPC_ORDER
#define MAX_LPC_ORDER
Definition: lpc.h:38
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:996
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
flacdata.h
encode_frame
static int encode_frame(FlacEncodeContext *s)
Definition: flacenc.c:1023
calc_sum_top
static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order, uint64_t sums[32][MAX_PARTITIONS])
Definition: flacenc.c:631
FlacFrame::crc8
uint8_t crc8
Definition: flacenc.c:100
FlacEncodeContext::frame
FlacFrame frame
Definition: flacenc.c:119
FLAC_CHMODE_RIGHT_SIDE
@ FLAC_CHMODE_RIGHT_SIDE
Definition: flac.h:43
FlacFrame::bs_code
int bs_code[2]
Definition: flacenc.c:99
FlacSubframe::residual
int32_t residual[FLAC_MAX_BLOCKSIZE+11]
Definition: flacenc.c:93
FlacEncodeContext::options
CompressionOptions options
Definition: flacenc.c:120
header
static const uint8_t header[24]
Definition: sdr2.c:67
FlacEncodeContext::samplerate
int samplerate
Definition: flacenc.c:109
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
FlacEncodeContext::min_framesize
int min_framesize
Definition: flacenc.c:113
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AV_CH_LAYOUT_5POINT1_BACK
#define AV_CH_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:103
write_frame
static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
Definition: flacenc.c:1279
av_bswap16
#define av_bswap16
Definition: bswap.h:31
FlacSubframe::type
int type
Definition: flacenc.c:80
ORDER_METHOD_EST
#define ORDER_METHOD_EST
Definition: lpc.h:30
options
static const AVOption options[]
Definition: flacenc.c:1422
FlacSubframe
Definition: flacenc.c:79
FlacSubframe::coefs
int32_t coefs[MAX_LPC_ORDER]
Definition: flacenc.c:85
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:323
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:989
AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_5POINT0
Definition: channel_layout.h:100
calc_sum_next
static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
Definition: flacenc.c:661
av_md5_init
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:142
i
int i
Definition: input.c:406
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:480
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
write_utf8
static void write_utf8(PutBitContext *pb, uint32_t val)
Definition: flacenc.c:1164
CompressionOptions::min_partition_order
int min_partition_order
Definition: flacenc.c:66
count_frame_header
static int count_frame_header(FlacEncodeContext *s)
Definition: flacenc.c:987
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
write_frame_header
static void write_frame_header(FlacEncodeContext *s)
Definition: flacenc.c:1171
md5.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
write_frame_footer
static void write_frame_footer(FlacEncodeContext *s)
Definition: flacenc.c:1268
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:61
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
copy_samples
static void copy_samples(FlacEncodeContext *s, const void *samples)
Copy channel-interleaved input samples into separate subframes.
Definition: flacenc.c:481
av_md5_final
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:187
MAX_PARTITIONS
#define MAX_PARTITIONS
Definition: flacenc.c:47
avcodec.h
CompressionOptions::lpc_type
enum FFLPCType lpc_type
Definition: flacenc.c:60
estimate_stereo_mode
static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, int max_rice_param)
Definition: flacenc.c:1075
FlacEncodeContext::sample_count
uint64_t sample_count
Definition: flacenc.c:117
calc_rice_params
static uint64_t calc_rice_params(RiceContext *rc, uint32_t udata[FLAC_MAX_BLOCKSIZE], uint64_t sums[32][MAX_PARTITIONS], int pmin, int pmax, const int32_t *data, int n, int pred_order, int exact)
Definition: flacenc.c:671
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_flac_encoder
const AVCodec ff_flac_encoder
Definition: flacenc.c:1460
encode_residual_fixed
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, int order)
Definition: flacenc.c:737
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
MAX_LPC_PRECISION
#define MAX_LPC_PRECISION
Definition: flacenc.c:48
AVCodecContext
main external API structure.
Definition: avcodec.h:379
FlacEncodeContext::bps_code
int bps_code
Definition: flacenc.c:111
FlacSubframe::rc_sums
uint64_t rc_sums[32][MAX_PARTITIONS]
Definition: flacenc.c:90
channel_layout.h
FlacSubframe::rc_udata
uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:89
ORDER_METHOD_LOG
#define ORDER_METHOD_LOG
Definition: lpc.h:35
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:225
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:78
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
av_md5_alloc
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
AV_PKT_DATA_NEW_EXTRADATA
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
Definition: packet.h:55
subframe_count_exact
static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
Definition: flacenc.c:517
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
frame_end
static void frame_end(MpegEncContext *s)
Definition: mpegvideo_enc.c:1578
FlacEncodeContext::sr_code
int sr_code[2]
Definition: flacenc.c:110
CompressionOptions::min_prediction_order
int min_prediction_order
Definition: flacenc.c:63
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
FlacSubframe::shift
int shift
Definition: flacenc.c:86
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
Update hash value.
Definition: md5.c:152
init_frame
static void init_frame(FlacEncodeContext *s, int nb_samples)
Definition: flacenc.c:436
RiceContext::params
int params[MAX_PARTITIONS]
Definition: flacenc.c:76
shift
static int shift(int a, int b)
Definition: sonic.c:83
FLAC_MAX_BLOCKSIZE
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
AV_CRC_8_ATM
@ AV_CRC_8_ATM
Definition: crc.h:49
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
RiceContext::coding_mode
enum CodingMode coding_mode
Definition: flacenc.c:74
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:540
find_optimal_param
static int find_optimal_param(uint64_t sum, int n, int max_param)
Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
Definition: flacenc.c:572
dprint_compression_options
static av_cold void dprint_compression_options(FlacEncodeContext *s)
Definition: flacenc.c:183
update_md5_sum
static int update_md5_sum(FlacEncodeContext *s, const void *samples)
Definition: flacenc.c:1289
flac_encode_close
static av_cold int flac_encode_close(AVCodecContext *avctx)
Definition: flacenc.c:1411
d
d
Definition: ffmpeg_filter.c:156
CODING_MODE_RICE2
@ CODING_MODE_RICE2
Definition: flacenc.c:54
int32_t
int32_t
Definition: audioconvert.c:56
CompressionOptions::block_time_ms
int block_time_ms
Definition: flacenc.c:59
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
flac_encoder_class
static const AVClass flac_encoder_class
Definition: flacenc.c:1453
FLAC_CHMODE_INDEPENDENT
@ FLAC_CHMODE_INDEPENDENT
Definition: flac.h:41
BswapDSPContext
Definition: bswapdsp.h:24
write_streaminfo
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
Write streaminfo metadata block to byte array.
Definition: flacenc.c:137
MAX_FIXED_ORDER
#define MAX_FIXED_ORDER
Definition: flacenc.c:45
ORDER_METHOD_2LEVEL
#define ORDER_METHOD_2LEVEL
Definition: lpc.h:31
FLAC_MIN_BLOCKSIZE
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:36
flac.h
FF_LPC_TYPE_NONE
@ FF_LPC_TYPE_NONE
do not use LPC prediction or use all zero coefficients
Definition: lpc.h:45
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:82
FlacFrame::verbatim_only
int verbatim_only
Definition: flacenc.c:102
put_bits.h
FlacEncodeContext::md5ctx
struct AVMD5 * md5ctx
Definition: flacenc.c:123
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:62
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
FLACDSPContext
Definition: flacdsp.h:26
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FF_LPC_TYPE_LEVINSON
@ FF_LPC_TYPE_LEVINSON
Levinson-Durbin recursion.
Definition: lpc.h:47
AV_CH_LAYOUT_2_2
#define AV_CH_LAYOUT_2_2
Definition: channel_layout.h:98
FlacFrame::blocksize
int blocksize
Definition: flacenc.c:98
CodingMode
CodingMode
Definition: flacenc.c:52
rice_encode_count
#define rice_encode_count(sum, n, k)
Definition: flacenc.c:567
ff_lpc_init
av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)
Initialize LPCContext.
Definition: lpc.c:301
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:451
FF_LPC_TYPE_FIXED
@ FF_LPC_TYPE_FIXED
fixed LPC coefficients
Definition: lpc.h:46
intmath.h