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