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 "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 
53 enum CodingMode {
56 };
57 
58 typedef struct CompressionOptions {
69  int ch_mode;
73 
74 typedef struct RiceContext {
76  int porder;
78 } RiceContext;
79 
80 typedef struct FlacSubframe {
81  int type;
82  int type_code;
83  int obits;
84  int wasted;
85  int order;
87  int shift;
88 
91  uint64_t rc_sums[32][MAX_PARTITIONS];
92 
95 } FlacSubframe;
96 
97 typedef struct FlacFrame {
99  int blocksize;
100  int bs_code[2];
101  uint8_t crc8;
102  int ch_mode;
104 } FlacFrame;
105 
106 typedef struct FlacEncodeContext {
107  AVClass *class;
109  int channels;
111  int sr_code[2];
112  int bps_code;
117  uint32_t frame_count;
118  uint64_t sample_count;
119  uint8_t md5sum[16];
124  struct AVMD5 *md5ctx;
125  uint8_t *md5_buffer;
126  unsigned int md5_buffer_size;
129 
130  int flushed;
131  int64_t next_pts;
133 
134 
135 /**
136  * Write streaminfo metadata block to byte array.
137  */
139 {
140  PutBitContext pb;
141 
142  memset(header, 0, 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  */
165 static 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 
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;
199  av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");
200  break;
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",
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",
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 
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 
266  av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",
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,
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,
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;
398 
399  s->frame_count = 0;
400  s->min_framesize = s->max_framesize;
401 
402  if ((channels == 3 &&
404  (channels == 4 &&
407  (channels == 5 &&
410  (channels == 6 &&
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 
432 
433  return ret;
434 }
435 
436 
437 static 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  */
482 static 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 
504 static 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 
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  */
573 static 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 
585 static 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 
602 static 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 
632 static 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 
662 static 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 
672 static 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 
712 static 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 
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 
738 static 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 
790 {
791  int i, n;
792  int min_order, max_order, opt_order, omethod;
793  FlacFrame *frame;
794  FlacSubframe *sub;
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);
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);
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,
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  }
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  }
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 
983 
984  return subframe_count_exact(s, sub, sub->order);
985 }
986 
987 
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 
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 
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 
1076 static 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  */
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 
1165 static 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 
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 
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 
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 
1281 {
1282  init_put_bits(&s->pb, avpkt->data, avpkt->size);
1284  write_subframes(s);
1286  return put_bytes_output(&s->pb);
1287 }
1288 
1289 
1290 static 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 
1326 static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1327  const AVFrame *frame, int *got_packet_ptr)
1328 {
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 
1368 
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 
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
1423 static 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 
1454 static 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 
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 |
1468  .priv_data_size = sizeof(FlacEncodeContext),
1471  .close = flac_encode_close,
1472  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
1475  .p.priv_class = &flac_encoder_class,
1477 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1026
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:522
FFLPCType
FFLPCType
LPC analysis type.
Definition: lpc.h:43
level
uint8_t level
Definition: svq3.c:206
FlacSubframe::samples
int32_t samples[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:93
av_clip
#define av_clip
Definition: common.h:95
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: codec_internal.h:39
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:242
ff_ctz
#define ff_ctz
Definition: intmath.h:106
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
FLAC_CHMODE_LEFT_SIDE
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:42
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:998
CompressionOptions::exact_rice_parameters
int exact_rice_parameters
Definition: flacenc.c:70
MAX_PARTITION_ORDER
#define MAX_PARTITION_ORDER
Definition: flacenc.c:47
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:364
FlacEncodeContext::bdsp
BswapDSPContext bdsp
Definition: flacenc.c:127
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
CompressionOptions::max_prediction_order
int max_prediction_order
Definition: flacenc.c:65
CompressionOptions::ch_mode
int ch_mode
Definition: flacenc.c:69
MAX_LPC_SHIFT
#define MAX_LPC_SHIFT
Definition: flacenc.c:51
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
flac_encode_frame
static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: flacenc.c:1326
FlacEncodeContext::md5sum
uint8_t md5sum[16]
Definition: flacenc.c:119
RiceContext
Definition: alacenc.c:50
av_unused
#define av_unused
Definition: attributes.h:131
FlacEncodeContext::avctx
AVCodecContext * avctx
Definition: flacenc.c:122
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
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:68
FF_LPC_TYPE_CHOLESKY
@ FF_LPC_TYPE_CHOLESKY
Cholesky factorization.
Definition: lpc.h:48
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
ff_flacdsp_init
av_cold void ff_flacdsp_init(FLACDSPContext *c, enum AVSampleFormat fmt, int channels, int bps)
Definition: flacdsp.c:89
AVOption
AVOption.
Definition: opt.h:251
encode.h
FlacEncodeContext
Definition: flacenc.c:106
b
#define b
Definition: input.c:34
data
const char data[16]
Definition: mxf.c:143
FFCodec
Definition: codec_internal.h:112
CompressionOptions::prediction_order_method
int prediction_order_method
Definition: flacenc.c:66
FlacFrame
Definition: flacenc.c:97
select_blocksize
static int select_blocksize(int samplerate, int block_time_ms)
Set blocksize based on samplerate.
Definition: flacenc.c:165
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
CODING_MODE_RICE
@ CODING_MODE_RICE
Definition: flacenc.c:54
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:437
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:295
flacdsp.h
lpc.h
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
CompressionOptions::compression_level
int compression_level
Definition: flacenc.c:59
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:363
FlacEncodeContext::pb
PutBitContext pb
Definition: flacenc.c:108
init
static int init
Definition: av_tx.c:47
crc.h
LPCContext
Definition: lpc.h:52
find_subframe_rice_params
static uint64_t find_subframe_rice_params(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
Definition: flacenc.c:721
ORDER_METHOD_4LEVEL
#define ORDER_METHOD_4LEVEL
Definition: lpc.h:32
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
FlacSubframe::wasted
int wasted
Definition: flacenc.c:84
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2057
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
FlacEncodeContext::frame_count
uint32_t frame_count
Definition: flacenc.c:117
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:357
CompressionOptions::lpc_coeff_precision
int lpc_coeff_precision
Definition: flacenc.c:63
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:263
AVMD5
Definition: md5.c:40
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
FLAC_CHMODE_RIGHT_SIDE
@ FLAC_CHMODE_RIGHT_SIDE
Definition: flac.h:43
avassert.h
put_golomb.h
exp golomb vlc writing stuff
FlacFrame::ch_mode
int ch_mode
Definition: flacenc.c:102
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:173
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:1209
av_cold
#define av_cold
Definition: attributes.h:90
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:361
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:491
s
#define s(width, name)
Definition: cbs_vp9.c:256
FlacSubframe::type_code
int type_code
Definition: flacenc.c:82
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
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:106
FlacSubframe::obits
int obits
Definition: flacenc.c:83
FlacEncodeContext::max_framesize
int max_framesize
Definition: flacenc.c:115
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
CompressionOptions::multi_dim_quant
int multi_dim_quant
Definition: flacenc.c:71
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:85
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1448
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:1044
channels
channels
Definition: aptx.h:32
FlacSubframe::rc
RiceContext rc
Definition: flacenc.c:89
FLAC_SUBFRAME_LPC
#define FLAC_SUBFRAME_LPC
Definition: flacenc.c:44
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: put_golomb.h:157
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:602
CompressionOptions
Definition: dcaenc.c:59
FLAC_SUBFRAME_VERBATIM
#define FLAC_SUBFRAME_VERBATIM
Definition: flacenc.c:42
PutBitContext
Definition: put_bits.h:50
RiceContext::porder
int porder
Definition: flacenc.c:76
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
FLAC_SUBFRAME_CONSTANT
#define FLAC_SUBFRAME_CONSTANT
Definition: flacenc.c:41
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:98
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:43
FlacEncodeContext::lpc_ctx
LPCContext lpc_ctx
Definition: flacenc.c:123
MIN_LPC_SHIFT
#define MIN_LPC_SHIFT
Definition: flacenc.c:50
FlacEncodeContext::max_blocksize
int max_blocksize
Definition: flacenc.c:113
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:237
FLAGS
#define FLAGS
Definition: flacenc.c:1422
FlacEncodeContext::next_pts
int64_t next_pts
Definition: flacenc.c:131
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:930
FLAC_STREAMINFO_SIZE
#define FLAC_STREAMINFO_SIZE
Definition: flac.h:34
FlacEncodeContext::md5_buffer
uint8_t * md5_buffer
Definition: flacenc.c:125
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
CompressionOptions::lpc_passes
int lpc_passes
Definition: flacenc.c:62
FlacEncodeContext::channels
int channels
Definition: flacenc.c:109
FlacEncodeContext::flac_dsp
FLACDSPContext flac_dsp
Definition: flacenc.c:128
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
rice_count_exact
static uint64_t rice_count_exact(const int32_t *res, int n, int k)
Definition: flacenc.c:504
FlacEncodeContext::max_encoded_framesize
int max_encoded_framesize
Definition: flacenc.c:116
encode_residual_ch
static int encode_residual_ch(FlacEncodeContext *s, int ch)
Definition: flacenc.c:789
get_max_p_order
static int get_max_p_order(int max_porder, int n, int order)
Definition: flacenc.c:712
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:585
FlacEncodeContext::flushed
int flushed
Definition: flacenc.c:130
f
f
Definition: af_crystalizer.c:122
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:375
FlacEncodeContext::md5_buffer_size
unsigned int md5_buffer_size
Definition: flacenc.c:126
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
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
codec_internal.h
av_clipl_int32
#define av_clipl_int32
Definition: common.h:113
channel_decorrelation
static void channel_decorrelation(FlacEncodeContext *s)
Perform stereo channel decorrelation.
Definition: flacenc.c:1120
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:1014
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
flacdata.h
encode_frame
static int encode_frame(FlacEncodeContext *s)
Definition: flacenc.c:1024
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:632
FlacFrame::crc8
uint8_t crc8
Definition: flacenc.c:101
FlacEncodeContext::frame
FlacFrame frame
Definition: flacenc.c:120
FlacFrame::bs_code
int bs_code[2]
Definition: flacenc.c:100
FlacSubframe::residual
int32_t residual[FLAC_MAX_BLOCKSIZE+11]
Definition: flacenc.c:94
FlacEncodeContext::options
CompressionOptions options
Definition: flacenc.c:121
header
static const uint8_t header[24]
Definition: sdr2.c:67
FlacEncodeContext::samplerate
int samplerate
Definition: flacenc.c:110
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:114
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
write_frame
static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
Definition: flacenc.c:1280
av_bswap16
#define av_bswap16
Definition: bswap.h:31
FlacSubframe::type
int type
Definition: flacenc.c:81
ORDER_METHOD_EST
#define ORDER_METHOD_EST
Definition: lpc.h:30
options
static const AVOption options[]
Definition: flacenc.c:1423
FlacSubframe
Definition: flacenc.c:80
FlacSubframe::coefs
int32_t coefs[MAX_LPC_ORDER]
Definition: flacenc.c:86
ff_lpc_end
av_cold void ff_lpc_end(LPCContext *s)
Uninitialize LPCContext.
Definition: lpc.c:323
calc_sum_next
static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
Definition: flacenc.c:662
av_md5_init
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:141
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:490
write_utf8
static void write_utf8(PutBitContext *pb, uint32_t val)
Definition: flacenc.c:1165
CompressionOptions::min_partition_order
int min_partition_order
Definition: flacenc.c:67
count_frame_header
static int count_frame_header(FlacEncodeContext *s)
Definition: flacenc.c:988
ff_flac_encoder
const FFCodec ff_flac_encoder
Definition: flacenc.c:1461
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:55
write_frame_header
static void write_frame_header(FlacEncodeContext *s)
Definition: flacenc.c:1172
md5.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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: codec_internal.h:31
write_frame_footer
static void write_frame_footer(FlacEncodeContext *s)
Definition: flacenc.c:1269
AV_SAMPLE_FMT_S16
@ AV_SAMPLE_FMT_S16
signed 16 bits
Definition: samplefmt.h:58
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
copy_samples
static void copy_samples(FlacEncodeContext *s, const void *samples)
Copy channel-interleaved input samples into separate subframes.
Definition: flacenc.c:482
av_md5_final
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:186
MAX_PARTITIONS
#define MAX_PARTITIONS
Definition: flacenc.c:48
avcodec.h
CompressionOptions::lpc_type
enum FFLPCType lpc_type
Definition: flacenc.c:61
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:1076
FlacEncodeContext::sample_count
uint64_t sample_count
Definition: flacenc.c:118
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:672
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
encode_residual_fixed
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, int order)
Definition: flacenc.c:738
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
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:365
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:35
MAX_LPC_PRECISION
#define MAX_LPC_PRECISION
Definition: flacenc.c:49
AVCodecContext
main external API structure.
Definition: avcodec.h:389
FlacEncodeContext::bps_code
int bps_code
Definition: flacenc.c:112
FlacSubframe::rc_sums
uint64_t rc_sums[32][MAX_PARTITIONS]
Definition: flacenc.c:91
channel_layout.h
FlacSubframe::rc_udata
uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:90
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:230
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:79
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:56
subframe_count_exact
static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, int pred_order)
Definition: flacenc.c:518
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
frame_end
static void frame_end(MpegEncContext *s)
Definition: mpegvideo_enc.c:1537
FlacEncodeContext::sr_code
int sr_code[2]
Definition: flacenc.c:111
CompressionOptions::min_prediction_order
int min_prediction_order
Definition: flacenc.c:64
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:82
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:87
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
Update hash value.
Definition: md5.c:151
FLAC_CHMODE_MID_SIDE
@ FLAC_CHMODE_MID_SIDE
Definition: flac.h:44
init_frame
static void init_frame(FlacEncodeContext *s, int nb_samples)
Definition: flacenc.c:437
RiceContext::params
int params[MAX_PARTITIONS]
Definition: flacenc.c:77
shift
static int shift(int a, int b)
Definition: sonic.c:88
FLAC_MAX_BLOCKSIZE
#define FLAC_MAX_BLOCKSIZE
Definition: flac.h:37
FLAC_CHMODE_INDEPENDENT
@ FLAC_CHMODE_INDEPENDENT
Definition: flac.h:41
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:143
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:416
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
RiceContext::coding_mode
enum CodingMode coding_mode
Definition: flacenc.c:75
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:561
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:573
dprint_compression_options
static av_cold void dprint_compression_options(FlacEncodeContext *s)
Definition: flacenc.c:184
update_md5_sum
static int update_md5_sum(FlacEncodeContext *s, const void *samples)
Definition: flacenc.c:1290
flac_encode_close
static av_cold int flac_encode_close(AVCodecContext *avctx)
Definition: flacenc.c:1412
d
d
Definition: ffmpeg_filter.c:153
CODING_MODE_RICE2
@ CODING_MODE_RICE2
Definition: flacenc.c:55
int32_t
int32_t
Definition: audioconvert.c:56
CompressionOptions::block_time_ms
int block_time_ms
Definition: flacenc.c:60
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:27
flac_encoder_class
static const AVClass flac_encoder_class
Definition: flacenc.c:1454
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:138
MAX_FIXED_ORDER
#define MAX_FIXED_ORDER
Definition: flacenc.c:46
ORDER_METHOD_2LEVEL
#define ORDER_METHOD_2LEVEL
Definition: lpc.h:31
FLAC_MIN_BLOCKSIZE
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:36
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:362
flac.h
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:366
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:87
FlacFrame::verbatim_only
int verbatim_only
Definition: flacenc.c:103
put_bits.h
FlacEncodeContext::md5ctx
struct AVMD5 * md5ctx
Definition: flacenc.c:124
AV_SAMPLE_FMT_S32
@ AV_SAMPLE_FMT_S32
signed 32 bits
Definition: samplefmt.h:59
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
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
FlacFrame::blocksize
int blocksize
Definition: flacenc.c:99
CodingMode
CodingMode
Definition: flacenc.c:53
rice_encode_count
#define rice_encode_count(sum, n, k)
Definition: flacenc.c:568
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:461
FF_LPC_TYPE_FIXED
@ FF_LPC_TYPE_FIXED
fixed LPC coefficients
Definition: lpc.h:46
intmath.h