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 "lpc.h"
35 #include "flac.h"
36 #include "flacdata.h"
37 #include "flacencdsp.h"
38 
39 #define FLAC_SUBFRAME_CONSTANT 0
40 #define FLAC_SUBFRAME_VERBATIM 1
41 #define FLAC_SUBFRAME_FIXED 8
42 #define FLAC_SUBFRAME_LPC 32
43 
44 #define MAX_FIXED_ORDER 4
45 #define MAX_PARTITION_ORDER 8
46 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
47 #define MAX_LPC_PRECISION 15
48 #define MIN_LPC_SHIFT 0
49 #define MAX_LPC_SHIFT 15
50 
51 enum CodingMode {
54 };
55 
56 typedef struct CompressionOptions {
67  int ch_mode;
71 
72 typedef struct RiceContext {
74  int porder;
76 } RiceContext;
77 
78 typedef struct FlacSubframe {
79  int type;
80  int type_code;
81  int obits;
82  int wasted;
83  int order;
85  int shift;
86 
89  uint64_t rc_sums[32][MAX_PARTITIONS];
90 
93 } FlacSubframe;
94 
95 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  if (avctx->bits_per_raw_sample < 24)
287  av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
288  avctx->bits_per_raw_sample = 24;
289  s->bps_code = 6;
291  av_log(avctx, AV_LOG_WARNING,
292  "encoding as 24 bits-per-sample, more is considered "
293  "experimental. Add -strict experimental if you want "
294  "to encode more than 24 bits-per-sample\n");
295  avctx->bits_per_raw_sample = 24;
296  s->bps_code = 6;
297  } else {
298  avctx->bits_per_raw_sample = 32;
299  s->bps_code = 7;
300  }
301  break;
302  }
303 
305  av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",
307  return AVERROR(EINVAL);
308  }
309  s->channels = channels;
310 
311  /* find samplerate in table */
312  if (freq < 1)
313  return AVERROR(EINVAL);
314  for (i = 1; i < 12; i++) {
315  if (freq == ff_flac_sample_rate_table[i]) {
316  s->samplerate = ff_flac_sample_rate_table[i];
317  s->sr_code[0] = i;
318  s->sr_code[1] = 0;
319  break;
320  }
321  }
322  /* if not in table, samplerate is non-standard */
323  if (i == 12) {
324  if (freq % 1000 == 0 && freq < 255000) {
325  s->sr_code[0] = 12;
326  s->sr_code[1] = freq / 1000;
327  } else if (freq % 10 == 0 && freq < 655350) {
328  s->sr_code[0] = 14;
329  s->sr_code[1] = freq / 10;
330  } else if (freq < 65535) {
331  s->sr_code[0] = 13;
332  s->sr_code[1] = freq;
333  } else if (freq < 1048576) {
334  s->sr_code[0] = 0;
335  s->sr_code[1] = 0;
336  } else {
337  av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq);
338  return AVERROR(EINVAL);
339  }
340  s->samplerate = freq;
341  }
342 
343  /* set compression option defaults based on avctx->compression_level */
344  if (avctx->compression_level < 0)
345  s->options.compression_level = 5;
346  else
347  s->options.compression_level = avctx->compression_level;
348 
349  level = s->options.compression_level;
350  if (level > 12) {
351  av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
352  s->options.compression_level);
353  return AVERROR(EINVAL);
354  }
355 
356  s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
357 
358  if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT)
359  s->options.lpc_type = ((int[]){ FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED,
364 
365  if (s->options.min_prediction_order < 0)
366  s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
367  if (s->options.max_prediction_order < 0)
368  s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
369 
370  if (s->options.prediction_order_method < 0)
371  s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
376 
377  if (s->options.min_partition_order > s->options.max_partition_order) {
378  av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
379  s->options.min_partition_order, s->options.max_partition_order);
380  return AVERROR(EINVAL);
381  }
382  if (s->options.min_partition_order < 0)
383  s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
384  if (s->options.max_partition_order < 0)
385  s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
386 
387  if (s->options.lpc_type == FF_LPC_TYPE_NONE) {
388  s->options.min_prediction_order = 0;
389  s->options.max_prediction_order = 0;
390  } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
391  if (s->options.min_prediction_order > MAX_FIXED_ORDER) {
392  av_log(avctx, AV_LOG_WARNING,
393  "invalid min prediction order %d, clamped to %d\n",
394  s->options.min_prediction_order, MAX_FIXED_ORDER);
395  s->options.min_prediction_order = MAX_FIXED_ORDER;
396  }
397  if (s->options.max_prediction_order > MAX_FIXED_ORDER) {
398  av_log(avctx, AV_LOG_WARNING,
399  "invalid max prediction order %d, clamped to %d\n",
400  s->options.max_prediction_order, MAX_FIXED_ORDER);
401  s->options.max_prediction_order = MAX_FIXED_ORDER;
402  }
403  }
404 
405  if (s->options.max_prediction_order < s->options.min_prediction_order) {
406  av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
407  s->options.min_prediction_order, s->options.max_prediction_order);
408  return AVERROR(EINVAL);
409  }
410 
411  if (avctx->frame_size > 0) {
412  if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
413  avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
414  av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
415  avctx->frame_size);
416  return AVERROR(EINVAL);
417  }
418  } else {
419  s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
420  }
421  s->max_blocksize = s->avctx->frame_size;
422 
423  /* set maximum encoded frame size in verbatim mode */
424  s->max_framesize = flac_get_max_frame_size(s->avctx->frame_size,
425  s->channels,
426  s->avctx->bits_per_raw_sample);
427 
428  /* initialize MD5 context */
429  s->md5ctx = av_md5_alloc();
430  if (!s->md5ctx)
431  return AVERROR(ENOMEM);
432  av_md5_init(s->md5ctx);
433 
434  streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
435  if (!streaminfo)
436  return AVERROR(ENOMEM);
437  write_streaminfo(s, streaminfo);
438  avctx->extradata = streaminfo;
440 
441  s->frame_count = 0;
442  s->min_framesize = s->max_framesize;
443 
444  if ((channels == 3 &&
446  (channels == 4 &&
449  (channels == 5 &&
452  (channels == 6 &&
455  if (avctx->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
456  av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "
457  "output stream will have incorrect "
458  "channel layout.\n");
459  } else {
460  av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
461  "will use Flac channel layout for "
462  "%d channels.\n", channels);
463  }
464  }
465 
466  ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
467  s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
468 
469  ff_bswapdsp_init(&s->bdsp);
470  ff_flacencdsp_init(&s->flac_dsp);
471 
473 
474  return ret;
475 }
476 
477 
478 static void init_frame(FlacEncodeContext *s, int nb_samples)
479 {
480  int i, ch;
481  FlacFrame *frame;
482 
483  frame = &s->frame;
484 
485  for (i = 0; i < 16; i++) {
486  if (nb_samples == ff_flac_blocksize_table[i]) {
487  frame->blocksize = ff_flac_blocksize_table[i];
488  frame->bs_code[0] = i;
489  frame->bs_code[1] = 0;
490  break;
491  }
492  }
493  if (i == 16) {
494  frame->blocksize = nb_samples;
495  if (frame->blocksize <= 256) {
496  frame->bs_code[0] = 6;
497  frame->bs_code[1] = frame->blocksize-1;
498  } else {
499  frame->bs_code[0] = 7;
500  frame->bs_code[1] = frame->blocksize-1;
501  }
502  }
503 
504  for (ch = 0; ch < s->channels; ch++) {
505  FlacSubframe *sub = &frame->subframes[ch];
506 
507  sub->wasted = 0;
508  sub->obits = s->avctx->bits_per_raw_sample;
509 
510  if (sub->obits > 16)
511  sub->rc.coding_mode = CODING_MODE_RICE2;
512  else
513  sub->rc.coding_mode = CODING_MODE_RICE;
514  }
515 
516  frame->verbatim_only = 0;
517 }
518 
519 
520 /**
521  * Copy channel-interleaved input samples into separate subframes.
522  */
523 static void copy_samples(FlacEncodeContext *s, const void *samples)
524 {
525  int i, j, ch;
526  FlacFrame *frame;
527  int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -
528  s->avctx->bits_per_raw_sample;
529 
530 #define COPY_SAMPLES(bits) do { \
531  const int ## bits ## _t *samples0 = samples; \
532  frame = &s->frame; \
533  for (i = 0, j = 0; i < frame->blocksize; i++) \
534  for (ch = 0; ch < s->channels; ch++, j++) \
535  frame->subframes[ch].samples[i] = samples0[j] >> shift; \
536 } while (0)
537 
538  if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
539  COPY_SAMPLES(16);
540  else
541  COPY_SAMPLES(32);
542 }
543 
544 
545 static uint64_t rice_count_exact(const int32_t *res, int n, int k)
546 {
547  int i;
548  uint64_t count = 0;
549 
550  for (i = 0; i < n; i++) {
551  unsigned v = ((unsigned)(res[i]) << 1) ^ (res[i] >> 31);
552  count += (v >> k) + 1 + k;
553  }
554  return count;
555 }
556 
557 
559  int pred_order)
560 {
561  int p, porder, psize;
562  int i, part_end;
563  uint64_t count = 0;
564 
565  /* subframe header */
566  count += 8;
567 
568  if (sub->wasted)
569  count += sub->wasted;
570 
571  /* subframe */
572  if (sub->type == FLAC_SUBFRAME_CONSTANT) {
573  count += sub->obits;
574  } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
575  count += s->frame.blocksize * sub->obits;
576  } else {
577  /* warm-up samples */
578  count += pred_order * sub->obits;
579 
580  /* LPC coefficients */
581  if (sub->type == FLAC_SUBFRAME_LPC)
582  count += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
583 
584  /* rice-encoded block */
585  count += 2;
586 
587  /* partition order */
588  porder = sub->rc.porder;
589  psize = s->frame.blocksize >> porder;
590  count += 4;
591 
592  /* residual */
593  i = pred_order;
594  part_end = psize;
595  for (p = 0; p < 1 << porder; p++) {
596  int k = sub->rc.params[p];
597  count += sub->rc.coding_mode;
598  count += rice_count_exact(&sub->residual[i], part_end - i, k);
599  i = part_end;
600  part_end = FFMIN(s->frame.blocksize, part_end + psize);
601  }
602  }
603 
604  return count;
605 }
606 
607 
608 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
609 
610 /**
611  * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
612  */
613 static int find_optimal_param(uint64_t sum, int n, int max_param)
614 {
615  int k;
616  uint64_t sum2;
617 
618  if (sum <= n >> 1)
619  return 0;
620  sum2 = sum - (n >> 1);
621  k = av_log2(av_clipl_int32(sum2 / n));
622  return FFMIN(k, max_param);
623 }
624 
625 static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
626 {
627  int bestk = 0;
628  int64_t bestbits = INT64_MAX;
629  int k;
630 
631  for (k = 0; k <= max_param; k++) {
632  int64_t bits = sums[k][i];
633  if (bits < bestbits) {
634  bestbits = bits;
635  bestk = k;
636  }
637  }
638 
639  return bestk;
640 }
641 
642 static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder,
643  uint64_t sums[32][MAX_PARTITIONS],
644  int n, int pred_order, int max_param, int exact)
645 {
646  int i;
647  int k, cnt, part;
648  uint64_t all_bits;
649 
650  part = (1 << porder);
651  all_bits = 4 * part;
652 
653  cnt = (n >> porder) - pred_order;
654  for (i = 0; i < part; i++) {
655  if (exact) {
656  k = find_optimal_param_exact(sums, i, max_param);
657  all_bits += sums[k][i];
658  } else {
659  k = find_optimal_param(sums[0][i], cnt, max_param);
660  all_bits += rice_encode_count(sums[0][i], cnt, k);
661  }
662  rc->params[i] = k;
663  cnt = n >> porder;
664  }
665 
666  rc->porder = porder;
667 
668  return all_bits;
669 }
670 
671 
672 static void calc_sum_top(int pmax, int kmax, const uint32_t *data, int n, int pred_order,
673  uint64_t sums[32][MAX_PARTITIONS])
674 {
675  int i, k;
676  int parts;
677  const uint32_t *res, *res_end;
678 
679  /* sums for highest level */
680  parts = (1 << pmax);
681 
682  for (k = 0; k <= kmax; k++) {
683  res = &data[pred_order];
684  res_end = &data[n >> pmax];
685  for (i = 0; i < parts; i++) {
686  if (kmax) {
687  uint64_t sum = (1LL + k) * (res_end - res);
688  while (res < res_end)
689  sum += *(res++) >> k;
690  sums[k][i] = sum;
691  } else {
692  uint64_t sum = 0;
693  while (res < res_end)
694  sum += *(res++);
695  sums[k][i] = sum;
696  }
697  res_end += n >> pmax;
698  }
699  }
700 }
701 
702 static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
703 {
704  int i, k;
705  int parts = (1 << level);
706  for (i = 0; i < parts; i++) {
707  for (k=0; k<=kmax; k++)
708  sums[k][i] = sums[k][2*i] + sums[k][2*i+1];
709  }
710 }
711 
712 static uint64_t calc_rice_params(RiceContext *rc,
713  uint32_t udata[FLAC_MAX_BLOCKSIZE],
714  uint64_t sums[32][MAX_PARTITIONS],
715  int pmin, int pmax,
716  const int32_t *data, int n, int pred_order, int exact)
717 {
718  int i;
719  uint64_t bits[MAX_PARTITION_ORDER+1];
720  int opt_porder;
721  RiceContext tmp_rc;
722  int kmax = (1 << rc->coding_mode) - 2;
723 
724  av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
725  av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
726  av_assert1(pmin <= pmax);
727 
728  tmp_rc.coding_mode = rc->coding_mode;
729 
730  for (i = pred_order; i < n; i++)
731  udata[i] = ((unsigned)(data[i]) << 1) ^ (data[i] >> 31);
732 
733  calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);
734 
735  opt_porder = pmin;
736  bits[pmin] = UINT32_MAX;
737  for (i = pmax; ; ) {
738  bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact);
739  if (bits[i] < bits[opt_porder] || pmax == pmin) {
740  opt_porder = i;
741  *rc = tmp_rc;
742  }
743  if (i == pmin)
744  break;
745  calc_sum_next(--i, sums, exact ? kmax : 0);
746  }
747 
748  return bits[opt_porder];
749 }
750 
751 
752 static int get_max_p_order(int max_porder, int n, int order)
753 {
754  int porder = FFMIN(max_porder, av_log2(n^(n-1)));
755  if (order > 0)
756  porder = FFMIN(porder, av_log2(n/order));
757  return porder;
758 }
759 
760 
762  FlacSubframe *sub, int pred_order)
763 {
764  int pmin = get_max_p_order(s->options.min_partition_order,
765  s->frame.blocksize, pred_order);
766  int pmax = get_max_p_order(s->options.max_partition_order,
767  s->frame.blocksize, pred_order);
768 
769  uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
770  if (sub->type == FLAC_SUBFRAME_LPC)
771  bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
772  bits += calc_rice_params(&sub->rc, sub->rc_udata, sub->rc_sums, pmin, pmax, sub->residual,
773  s->frame.blocksize, pred_order, s->options.exact_rice_parameters);
774  return bits;
775 }
776 
777 
778 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
779  int order)
780 {
781  int i;
782 
783  for (i = 0; i < order; i++)
784  res[i] = smp[i];
785 
786  if (order == 0) {
787  for (i = order; i < n; i++)
788  res[i] = smp[i];
789  } else if (order == 1) {
790  for (i = order; i < n; i++)
791  res[i] = smp[i] - smp[i-1];
792  } else if (order == 2) {
793  int a = smp[order-1] - smp[order-2];
794  for (i = order; i < n; i += 2) {
795  int b = smp[i ] - smp[i-1];
796  res[i] = b - a;
797  a = smp[i+1] - smp[i ];
798  res[i+1] = a - b;
799  }
800  } else if (order == 3) {
801  int a = smp[order-1] - smp[order-2];
802  int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
803  for (i = order; i < n; i += 2) {
804  int b = smp[i ] - smp[i-1];
805  int d = b - a;
806  res[i] = d - c;
807  a = smp[i+1] - smp[i ];
808  c = a - b;
809  res[i+1] = c - d;
810  }
811  } else {
812  int a = smp[order-1] - smp[order-2];
813  int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
814  int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
815  for (i = order; i < n; i += 2) {
816  int b = smp[i ] - smp[i-1];
817  int d = b - a;
818  int f = d - c;
819  res[i ] = f - e;
820  a = smp[i+1] - smp[i ];
821  c = a - b;
822  e = c - d;
823  res[i+1] = e - f;
824  }
825  }
826 }
827 
828 
829 /* These four functions check for every residual whether it can be
830  * contained in <INT32_MIN,INT32_MAX]. In case it doesn't, the
831  * function that called this function has to try something else.
832  * Each function is duplicated, once for int32_t input, once for
833  * int64_t input */
834 #define ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT() \
835 { \
836  for (int i = 0; i < order; i++) \
837  res[i] = smp[i]; \
838  if (order == 0) { \
839  for (int i = order; i < n; i++) { \
840  if (smp[i] == INT32_MIN) \
841  return 1; \
842  res[i] = smp[i]; \
843  } \
844  } else if (order == 1) { \
845  for (int i = order; i < n; i++) { \
846  int64_t res64 = (int64_t)smp[i] - smp[i-1]; \
847  if (res64 <= INT32_MIN || res64 > INT32_MAX) \
848  return 1; \
849  res[i] = res64; \
850  } \
851  } else if (order == 2) { \
852  for (int i = order; i < n; i++) { \
853  int64_t res64 = (int64_t)smp[i] - 2*(int64_t)smp[i-1] + smp[i-2]; \
854  if (res64 <= INT32_MIN || res64 > INT32_MAX) \
855  return 1; \
856  res[i] = res64; \
857  } \
858  } else if (order == 3) { \
859  for (int i = order; i < n; i++) { \
860  int64_t res64 = (int64_t)smp[i] - 3*(int64_t)smp[i-1] + 3*(int64_t)smp[i-2] - smp[i-3]; \
861  if (res64 <= INT32_MIN || res64 > INT32_MAX) \
862  return 1; \
863  res[i] = res64; \
864  } \
865  } else { \
866  for (int i = order; i < n; i++) { \
867  int64_t res64 = (int64_t)smp[i] - 4*(int64_t)smp[i-1] + 6*(int64_t)smp[i-2] - 4*(int64_t)smp[i-3] + smp[i-4]; \
868  if (res64 <= INT32_MIN || res64 > INT32_MAX) \
869  return 1; \
870  res[i] = res64; \
871  } \
872  } \
873  return 0; \
874 }
875 
877  int n, int order)
878 {
880 }
881 
882 
883 static int encode_residual_fixed_with_residual_limit_33bps(int32_t *res, const int64_t *smp,
884  int n, int order)
885 {
887 }
888 
889 #define LPC_ENCODE_WITH_RESIDUAL_LIMIT() \
890 { \
891  for (int i = 0; i < order; i++) \
892  res[i] = smp[i]; \
893  for (int i = order; i < len; i++) { \
894  int64_t p = 0, tmp; \
895  for (int j = 0; j < order; j++) \
896  p += (int64_t)coefs[j]*smp[(i-1)-j]; \
897  p >>= shift; \
898  tmp = smp[i] - p; \
899  if (tmp <= INT32_MIN || tmp > INT32_MAX) \
900  return 1; \
901  res[i] = tmp; \
902  } \
903  return 0; \
904 }
905 
906 static int lpc_encode_with_residual_limit(int32_t *res, const int32_t *smp, int len,
907  int order, int32_t *coefs, int shift)
908 {
910 }
911 
912 static int lpc_encode_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int len,
913  int order, int32_t *coefs, int shift)
914 {
916 }
917 
919  int32_t *res, const int32_t *smp,
920  const int64_t *smp_33bps, int len,
921  int order, int32_t *coefs, int shift)
922 {
923  uint64_t max_residual_value = 0;
924  int64_t max_sample_value = ((int64_t)(1) << (bps-1));
925  /* This calculates the max size of any residual with the current
926  * predictor, so we know whether we need to check the residual */
927  for (int i = 0; i < order; i++)
928  max_residual_value += FFABS(max_sample_value * coefs[i]);
929  max_residual_value >>= shift;
930  max_residual_value += max_sample_value;
931  if (bps > 32) {
932  if (lpc_encode_with_residual_limit_33bps(res, smp_33bps, len, order, coefs, shift))
933  return 1;
934  } else if (max_residual_value > INT32_MAX) {
935  if (lpc_encode_with_residual_limit(res, smp, len, order, coefs, shift))
936  return 1;
937  } else if (bps + s->options.lpc_coeff_precision + av_log2(order) <= 32) {
938  s->flac_dsp.lpc16_encode(res, smp, len, order, coefs, shift);
939  } else {
940  s->flac_dsp.lpc32_encode(res, smp, len, order, coefs, shift);
941  }
942  return 0;
943 }
944 
945 #define DEFAULT_TO_VERBATIM() \
946 { \
947  sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM; \
948  if (sub->obits <= 32) \
949  memcpy(res, smp, n * sizeof(int32_t)); \
950  return subframe_count_exact(s, sub, 0); \
951 }
952 
954 {
955  int i, n;
956  int min_order, max_order, opt_order, omethod;
957  FlacFrame *frame;
958  FlacSubframe *sub;
960  int shift[MAX_LPC_ORDER];
961  int32_t *res, *smp;
962  int64_t *smp_33bps;
963 
964  frame = &s->frame;
965  sub = &frame->subframes[ch];
966  res = sub->residual;
967  smp = sub->samples;
968  smp_33bps = frame->samples_33bps;
969  n = frame->blocksize;
970 
971  /* CONSTANT */
972  if (sub->obits > 32) {
973  for (i = 1; i < n; i++)
974  if(smp_33bps[i] != smp_33bps[0])
975  break;
976  if (i == n) {
977  sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
978  return subframe_count_exact(s, sub, 0);
979  }
980  } else {
981  for (i = 1; i < n; i++)
982  if(smp[i] != smp[0])
983  break;
984  if (i == n) {
985  sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
986  res[0] = smp[0];
987  return subframe_count_exact(s, sub, 0);
988  }
989  }
990 
991  /* VERBATIM */
992  if (frame->verbatim_only || n < 5) {
994  }
995 
996  min_order = s->options.min_prediction_order;
997  max_order = s->options.max_prediction_order;
998  omethod = s->options.prediction_order_method;
999 
1000  /* FIXED */
1001  sub->type = FLAC_SUBFRAME_FIXED;
1002  if (s->options.lpc_type == FF_LPC_TYPE_NONE ||
1003  s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) {
1004  uint64_t bits[MAX_FIXED_ORDER+1];
1005  if (max_order > MAX_FIXED_ORDER)
1006  max_order = MAX_FIXED_ORDER;
1007  opt_order = 0;
1008  bits[0] = UINT32_MAX;
1009  for (i = min_order; i <= max_order; i++) {
1010  if (sub->obits == 33) {
1011  if (encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, i))
1012  continue;
1013  } else if (sub->obits + i >= 32) {
1014  if (encode_residual_fixed_with_residual_limit(res, smp, n, i))
1015  continue;
1016  } else
1017  encode_residual_fixed(res, smp, n, i);
1019  if (bits[i] < bits[opt_order])
1020  opt_order = i;
1021  }
1022  if (opt_order == 0 && bits[0] == UINT32_MAX) {
1023  /* No predictor found with residuals within <INT32_MIN,INT32_MAX],
1024  * so encode a verbatim subframe instead */
1026  }
1027  sub->order = opt_order;
1028  sub->type_code = sub->type | sub->order;
1029  if (sub->order != max_order) {
1030  if (sub->obits == 33)
1031  encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, sub->order);
1032  else if (sub->obits + i >= 32)
1033  encode_residual_fixed_with_residual_limit(res, smp, n, sub->order);
1034  else
1035  encode_residual_fixed(res, smp, n, sub->order);
1036  find_subframe_rice_params(s, sub, sub->order);
1037  }
1038  return subframe_count_exact(s, sub, sub->order);
1039  }
1040 
1041  /* LPC */
1042  sub->type = FLAC_SUBFRAME_LPC;
1043  if (sub->obits == 33)
1044  /* As ff_lpc_calc_coefs is shared with other codecs and the LSB
1045  * probably isn't predictable anyway, throw away LSB for analysis
1046  * so it fits 32 bit int and existing function can be used
1047  * unmodified */
1048  for (i = 0; i < n; i++)
1049  smp[i] = smp_33bps[i] >> 1;
1050 
1051  opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, smp, n, min_order, max_order,
1052  s->options.lpc_coeff_precision, coefs, shift, s->options.lpc_type,
1053  s->options.lpc_passes, omethod,
1055 
1056  if (omethod == ORDER_METHOD_2LEVEL ||
1057  omethod == ORDER_METHOD_4LEVEL ||
1058  omethod == ORDER_METHOD_8LEVEL) {
1059  int levels = 1 << omethod;
1060  uint64_t bits[1 << ORDER_METHOD_8LEVEL];
1061  int order = -1;
1062  int opt_index = levels-1;
1063  opt_order = max_order-1;
1064  bits[opt_index] = UINT32_MAX;
1065  for (i = levels-1; i >= 0; i--) {
1066  int last_order = order;
1067  order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
1068  order = av_clip(order, min_order - 1, max_order - 1);
1069  if (order == last_order)
1070  continue;
1071  if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, order+1, coefs[order], shift[order]))
1072  continue;
1073  bits[i] = find_subframe_rice_params(s, sub, order+1);
1074  if (bits[i] < bits[opt_index]) {
1075  opt_index = i;
1076  opt_order = order;
1077  }
1078  }
1079  opt_order++;
1080  } else if (omethod == ORDER_METHOD_SEARCH) {
1081  // brute-force optimal order search
1082  uint64_t bits[MAX_LPC_ORDER];
1083  opt_order = 0;
1084  bits[0] = UINT32_MAX;
1085  for (i = min_order-1; i < max_order; i++) {
1086  if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i]))
1087  continue;
1089  if (bits[i] < bits[opt_order])
1090  opt_order = i;
1091  }
1092  opt_order++;
1093  } else if (omethod == ORDER_METHOD_LOG) {
1094  uint64_t bits[MAX_LPC_ORDER];
1095  int step;
1096 
1097  opt_order = min_order - 1 + (max_order-min_order)/3;
1098  memset(bits, -1, sizeof(bits));
1099 
1100  for (step = 16; step; step >>= 1) {
1101  int last = opt_order;
1102  for (i = last-step; i <= last+step; i += step) {
1103  if (i < min_order-1 || i >= max_order || bits[i] < UINT32_MAX)
1104  continue;
1105  if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, i+1, coefs[i], shift[i]))
1106  continue;
1108  if (bits[i] < bits[opt_order])
1109  opt_order = i;
1110  }
1111  }
1112  opt_order++;
1113  }
1114 
1115  if (s->options.multi_dim_quant) {
1116  int allsteps = 1;
1117  int i, step, improved;
1118  int64_t best_score = INT64_MAX;
1119  int32_t qmax;
1120 
1121  qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1;
1122 
1123  for (i=0; i<opt_order; i++)
1124  allsteps *= 3;
1125 
1126  do {
1127  improved = 0;
1128  for (step = 0; step < allsteps; step++) {
1129  int tmp = step;
1130  int32_t lpc_try[MAX_LPC_ORDER];
1131  int64_t score = 0;
1132  int diffsum = 0;
1133 
1134  for (i=0; i<opt_order; i++) {
1135  int diff = ((tmp + 1) % 3) - 1;
1136  lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax);
1137  tmp /= 3;
1138  diffsum += !!diff;
1139  }
1140  if (diffsum >8)
1141  continue;
1142 
1143  if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, opt_order, lpc_try, shift[opt_order-1]))
1144  continue;
1145  score = find_subframe_rice_params(s, sub, opt_order);
1146  if (score < best_score) {
1147  best_score = score;
1148  memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs));
1149  improved=1;
1150  }
1151  }
1152  } while(improved);
1153  }
1154 
1155  sub->order = opt_order;
1156  sub->type_code = sub->type | (sub->order-1);
1157  sub->shift = shift[sub->order-1];
1158  for (i = 0; i < sub->order; i++)
1159  sub->coefs[i] = coefs[sub->order-1][i];
1160 
1161  if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, sub->order, sub->coefs, sub->shift)) {
1162  /* No predictor found with residuals within <INT32_MIN,INT32_MAX],
1163  * so encode a verbatim subframe instead */
1165  }
1166 
1167  find_subframe_rice_params(s, sub, sub->order);
1168 
1169  return subframe_count_exact(s, sub, sub->order);
1170 }
1171 
1172 
1174 {
1175  uint8_t av_unused tmp;
1176  int count;
1177 
1178  /*
1179  <14> Sync code
1180  <1> Reserved
1181  <1> Blocking strategy
1182  <4> Block size in inter-channel samples
1183  <4> Sample rate
1184  <4> Channel assignment
1185  <3> Sample size in bits
1186  <1> Reserved
1187  */
1188  count = 32;
1189 
1190  /* coded frame number */
1191  PUT_UTF8(s->frame_count, tmp, count += 8;)
1192 
1193  /* explicit block size */
1194  if (s->frame.bs_code[0] == 6)
1195  count += 8;
1196  else if (s->frame.bs_code[0] == 7)
1197  count += 16;
1198 
1199  /* explicit sample rate */
1200  count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8;
1201 
1202  /* frame header CRC-8 */
1203  count += 8;
1204 
1205  return count;
1206 }
1207 
1208 
1210 {
1211  int ch;
1212  uint64_t count;
1213 
1214  count = count_frame_header(s);
1215 
1216  for (ch = 0; ch < s->channels; ch++)
1217  count += encode_residual_ch(s, ch);
1218 
1219  count += (8 - (count & 7)) & 7; // byte alignment
1220  count += 16; // CRC-16
1221 
1222  count >>= 3;
1223  if (count > INT_MAX)
1224  return AVERROR_BUG;
1225  return count;
1226 }
1227 
1228 
1230 {
1231  int ch, i, wasted_bits;
1232 
1233  for (ch = 0; ch < s->channels; ch++) {
1234  FlacSubframe *sub = &s->frame.subframes[ch];
1235 
1236  if (sub->obits > 32) {
1237  int64_t v = 0;
1238  for (i = 0; i < s->frame.blocksize; i++) {
1239  v |= s->frame.samples_33bps[i];
1240  if (v & 1)
1241  break;
1242  }
1243 
1244  if (!v || (v & 1))
1245  return;
1246 
1247  v = ff_ctzll(v);
1248 
1249  /* If any wasted bits are found, samples are moved
1250  * from frame.samples_33bps to frame.subframes[ch] */
1251  for (i = 0; i < s->frame.blocksize; i++)
1252  sub->samples[i] = s->frame.samples_33bps[i] >> v;
1253  wasted_bits = v;
1254  } else {
1255  int32_t v = 0;
1256  for (i = 0; i < s->frame.blocksize; i++) {
1257  v |= sub->samples[i];
1258  if (v & 1)
1259  break;
1260  }
1261 
1262  if (!v || (v & 1))
1263  return;
1264 
1265  v = ff_ctz(v);
1266 
1267  for (i = 0; i < s->frame.blocksize; i++)
1268  sub->samples[i] >>= v;
1269  wasted_bits = v;
1270  }
1271 
1272  sub->wasted = wasted_bits;
1273  sub->obits -= wasted_bits;
1274 
1275  /* for 24-bit, check if removing wasted bits makes the range better
1276  * suited for using RICE instead of RICE2 for entropy coding */
1277  if (sub->obits <= 17)
1278  sub->rc.coding_mode = CODING_MODE_RICE;
1279  }
1280 }
1281 
1282 
1283 static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n,
1284  int max_rice_param, int bps)
1285 {
1286  int best;
1287  uint64_t sum[4];
1288  uint64_t score[4];
1289  int k;
1290 
1291  /* calculate sum of 2nd order residual for each channel */
1292  sum[0] = sum[1] = sum[2] = sum[3] = 0;
1293  if(bps < 30) {
1294  int32_t lt, rt;
1295  for (int i = 2; i < n; i++) {
1296  lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1297  rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
1298  sum[2] += FFABS((lt + rt) >> 1);
1299  sum[3] += FFABS(lt - rt);
1300  sum[0] += FFABS(lt);
1301  sum[1] += FFABS(rt);
1302  }
1303  } else {
1304  int64_t lt, rt;
1305  for (int i = 2; i < n; i++) {
1306  lt = (int64_t)left_ch[i] - 2*(int64_t)left_ch[i-1] + left_ch[i-2];
1307  rt = (int64_t)right_ch[i] - 2*(int64_t)right_ch[i-1] + right_ch[i-2];
1308  sum[2] += FFABS((lt + rt) >> 1);
1309  sum[3] += FFABS(lt - rt);
1310  sum[0] += FFABS(lt);
1311  sum[1] += FFABS(rt);
1312  }
1313  }
1314  /* estimate bit counts */
1315  for (int i = 0; i < 4; i++) {
1316  k = find_optimal_param(2 * sum[i], n, max_rice_param);
1317  sum[i] = rice_encode_count( 2 * sum[i], n, k);
1318  }
1319 
1320  /* calculate score for each mode */
1321  score[0] = sum[0] + sum[1];
1322  score[1] = sum[0] + sum[3];
1323  score[2] = sum[1] + sum[3];
1324  score[3] = sum[2] + sum[3];
1325 
1326  /* return mode with lowest score */
1327  best = 0;
1328  for (int i = 1; i < 4; i++)
1329  if (score[i] < score[best])
1330  best = i;
1331 
1332  return best;
1333 }
1334 
1335 
1336 /**
1337  * Perform stereo channel decorrelation.
1338  */
1340 {
1341  FlacFrame *frame;
1342  int32_t *left, *right;
1343  int64_t *side_33bps;
1344  int n;
1345 
1346  frame = &s->frame;
1347  n = frame->blocksize;
1348  left = frame->subframes[0].samples;
1349  right = frame->subframes[1].samples;
1350  side_33bps = frame->samples_33bps;
1351 
1352  if (s->channels != 2) {
1353  frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1354  return;
1355  }
1356 
1357  if (s->options.ch_mode < 0) {
1358  int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;
1359  frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param, s->avctx->bits_per_raw_sample);
1360  } else
1361  frame->ch_mode = s->options.ch_mode;
1362 
1363  /* perform decorrelation and adjust bits-per-sample */
1364  if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1365  return;
1366  if(s->avctx->bits_per_raw_sample == 32) {
1367  if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1368  int64_t tmp;
1369  for (int i = 0; i < n; i++) {
1370  tmp = left[i];
1371  left[i] = (tmp + right[i]) >> 1;
1372  side_33bps[i] = tmp - right[i];
1373  }
1374  frame->subframes[1].obits++;
1375  } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1376  for (int i = 0; i < n; i++)
1377  side_33bps[i] = (int64_t)left[i] - right[i];
1378  frame->subframes[1].obits++;
1379  } else {
1380  for (int i = 0; i < n; i++)
1381  side_33bps[i] = (int64_t)left[i] - right[i];
1382  frame->subframes[0].obits++;
1383  }
1384  } else {
1385  if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1386  int32_t tmp;
1387  for (int i = 0; i < n; i++) {
1388  tmp = left[i];
1389  left[i] = (tmp + right[i]) >> 1;
1390  right[i] = tmp - right[i];
1391  }
1392  frame->subframes[1].obits++;
1393  } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1394  for (int i = 0; i < n; i++)
1395  right[i] = left[i] - right[i];
1396  frame->subframes[1].obits++;
1397  } else {
1398  for (int i = 0; i < n; i++)
1399  left[i] -= right[i];
1400  frame->subframes[0].obits++;
1401  }
1402  }
1403 }
1404 
1405 
1406 static void write_utf8(PutBitContext *pb, uint32_t val)
1407 {
1408  uint8_t tmp;
1409  PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1410 }
1411 
1412 
1414 {
1415  FlacFrame *frame;
1416  int crc;
1417 
1418  frame = &s->frame;
1419 
1420  put_bits(&s->pb, 16, 0xFFF8);
1421  put_bits(&s->pb, 4, frame->bs_code[0]);
1422  put_bits(&s->pb, 4, s->sr_code[0]);
1423 
1424  if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1425  put_bits(&s->pb, 4, s->channels-1);
1426  else
1427  put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
1428 
1429  put_bits(&s->pb, 3, s->bps_code);
1430  put_bits(&s->pb, 1, 0);
1431  write_utf8(&s->pb, s->frame_count);
1432 
1433  if (frame->bs_code[0] == 6)
1434  put_bits(&s->pb, 8, frame->bs_code[1]);
1435  else if (frame->bs_code[0] == 7)
1436  put_bits(&s->pb, 16, frame->bs_code[1]);
1437 
1438  if (s->sr_code[0] == 12)
1439  put_bits(&s->pb, 8, s->sr_code[1]);
1440  else if (s->sr_code[0] > 12)
1441  put_bits(&s->pb, 16, s->sr_code[1]);
1442 
1443  flush_put_bits(&s->pb);
1444  crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,
1445  put_bytes_output(&s->pb));
1446  put_bits(&s->pb, 8, crc);
1447 }
1448 
1449 
1450 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k)
1451 {
1452  unsigned v, e;
1453 
1454  v = ((unsigned)(i) << 1) ^ (i >> 31);
1455 
1456  e = (v >> k) + 1;
1457  while (e > 31) {
1458  put_bits(pb, 31, 0);
1459  e -= 31;
1460  }
1461  put_bits(pb, e, 1);
1462  if (k) {
1463  unsigned mask = UINT32_MAX >> (32-k);
1464  put_bits(pb, k, v & mask);
1465  }
1466 }
1467 
1468 
1470 {
1471  int ch;
1472 
1473  for (ch = 0; ch < s->channels; ch++) {
1474  FlacSubframe *sub = &s->frame.subframes[ch];
1475  int p, porder, psize;
1476  int32_t *part_end;
1477  int32_t *res = sub->residual;
1478  int32_t *frame_end = &sub->residual[s->frame.blocksize];
1479 
1480  /* subframe header */
1481  put_bits(&s->pb, 1, 0);
1482  put_bits(&s->pb, 6, sub->type_code);
1483  put_bits(&s->pb, 1, !!sub->wasted);
1484  if (sub->wasted)
1485  put_bits(&s->pb, sub->wasted, 1);
1486 
1487  /* subframe */
1488  if (sub->type == FLAC_SUBFRAME_CONSTANT) {
1489  if(sub->obits == 33)
1490  put_sbits63(&s->pb, 33, s->frame.samples_33bps[0]);
1491  else if(sub->obits == 32)
1492  put_bits32(&s->pb, res[0]);
1493  else
1494  put_sbits(&s->pb, sub->obits, res[0]);
1495  } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
1496  if (sub->obits == 33) {
1497  int64_t *res64 = s->frame.samples_33bps;
1498  int64_t *frame_end64 = &s->frame.samples_33bps[s->frame.blocksize];
1499  while (res64 < frame_end64)
1500  put_sbits63(&s->pb, 33, (*res64++));
1501  } else if (sub->obits == 32) {
1502  while (res < frame_end)
1503  put_bits32(&s->pb, *res++);
1504  } else {
1505  while (res < frame_end)
1506  put_sbits(&s->pb, sub->obits, *res++);
1507  }
1508  } else {
1509  /* warm-up samples */
1510  if (sub->obits == 33) {
1511  for (int i = 0; i < sub->order; i++)
1512  put_sbits63(&s->pb, 33, s->frame.samples_33bps[i]);
1513  res += sub->order;
1514  } else if (sub->obits == 32) {
1515  for (int i = 0; i < sub->order; i++)
1516  put_bits32(&s->pb, *res++);
1517  } else {
1518  for (int i = 0; i < sub->order; i++)
1519  put_sbits(&s->pb, sub->obits, *res++);
1520  }
1521 
1522  /* LPC coefficients */
1523  if (sub->type == FLAC_SUBFRAME_LPC) {
1524  int cbits = s->options.lpc_coeff_precision;
1525  put_bits( &s->pb, 4, cbits-1);
1526  put_sbits(&s->pb, 5, sub->shift);
1527  for (int i = 0; i < sub->order; i++)
1528  put_sbits(&s->pb, cbits, sub->coefs[i]);
1529  }
1530 
1531  /* rice-encoded block */
1532  put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
1533 
1534  /* partition order */
1535  porder = sub->rc.porder;
1536  psize = s->frame.blocksize >> porder;
1537  put_bits(&s->pb, 4, porder);
1538 
1539  /* residual */
1540  part_end = &sub->residual[psize];
1541  for (p = 0; p < 1 << porder; p++) {
1542  int k = sub->rc.params[p];
1543  put_bits(&s->pb, sub->rc.coding_mode, k);
1544  while (res < part_end)
1545  set_sr_golomb_flac(&s->pb, *res++, k);
1546  part_end = FFMIN(frame_end, part_end + psize);
1547  }
1548  }
1549  }
1550 }
1551 
1552 
1554 {
1555  int crc;
1556  flush_put_bits(&s->pb);
1557  crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,
1558  put_bytes_output(&s->pb)));
1559  put_bits(&s->pb, 16, crc);
1560  flush_put_bits(&s->pb);
1561 }
1562 
1563 
1565 {
1566  init_put_bits(&s->pb, avpkt->data, avpkt->size);
1568  write_subframes(s);
1570  return put_bytes_output(&s->pb);
1571 }
1572 
1573 
1574 static int update_md5_sum(FlacEncodeContext *s, const void *samples)
1575 {
1576  const uint8_t *buf;
1577  int buf_size = s->frame.blocksize * s->channels *
1578  ((s->avctx->bits_per_raw_sample + 7) / 8);
1579 
1580  if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
1581  av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
1582  if (!s->md5_buffer)
1583  return AVERROR(ENOMEM);
1584  }
1585 
1586  if (s->avctx->bits_per_raw_sample <= 16) {
1587  buf = (const uint8_t *)samples;
1588 #if HAVE_BIGENDIAN
1589  s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer,
1590  (const uint16_t *) samples, buf_size / 2);
1591  buf = s->md5_buffer;
1592 #endif
1593  } else if (s->avctx->bits_per_raw_sample <= 24) {
1594  int i;
1595  const int32_t *samples0 = samples;
1596  uint8_t *tmp = s->md5_buffer;
1597 
1598  for (i = 0; i < s->frame.blocksize * s->channels; i++) {
1599  int32_t v = samples0[i] >> 8;
1600  AV_WL24(tmp + 3*i, v);
1601  }
1602  buf = s->md5_buffer;
1603  } else {
1604  /* s->avctx->bits_per_raw_sample <= 32 */
1605  int i;
1606  const int32_t *samples0 = samples;
1607  uint8_t *tmp = s->md5_buffer;
1608 
1609  for (i = 0; i < s->frame.blocksize * s->channels; i++)
1610  AV_WL32(tmp + 4*i, samples0[i]);
1611  buf = s->md5_buffer;
1612  }
1613  av_md5_update(s->md5ctx, buf, buf_size);
1614 
1615  return 0;
1616 }
1617 
1618 
1619 static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1620  const AVFrame *frame, int *got_packet_ptr)
1621 {
1623  int frame_bytes, out_bytes, ret;
1624 
1625  s = avctx->priv_data;
1626 
1627  /* when the last block is reached, update the header in extradata */
1628  if (!frame) {
1629  s->max_framesize = s->max_encoded_framesize;
1630  av_md5_final(s->md5ctx, s->md5sum);
1631  write_streaminfo(s, avctx->extradata);
1632 
1633  if (!s->flushed) {
1634  uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
1635  avctx->extradata_size);
1636  if (!side_data)
1637  return AVERROR(ENOMEM);
1638  memcpy(side_data, avctx->extradata, avctx->extradata_size);
1639 
1640  avpkt->pts = s->next_pts;
1641 
1642  *got_packet_ptr = 1;
1643  s->flushed = 1;
1644  }
1645 
1646  return 0;
1647  }
1648 
1649  /* change max_framesize for small final frame */
1650  if (frame->nb_samples < s->frame.blocksize) {
1651  s->max_framesize = flac_get_max_frame_size(frame->nb_samples,
1652  s->channels,
1653  avctx->bits_per_raw_sample);
1654  }
1655 
1656  init_frame(s, frame->nb_samples);
1657 
1658  copy_samples(s, frame->data[0]);
1659 
1661 
1663 
1664  frame_bytes = encode_frame(s);
1665 
1666  /* Fall back on verbatim mode if the compressed frame is larger than it
1667  would be if encoded uncompressed. */
1668  if (frame_bytes < 0 || frame_bytes > s->max_framesize) {
1669  s->frame.verbatim_only = 1;
1670  frame_bytes = encode_frame(s);
1671  if (frame_bytes < 0) {
1672  av_log(avctx, AV_LOG_ERROR, "Bad frame count\n");
1673  return frame_bytes;
1674  }
1675  }
1676 
1677  if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_bytes, 0)) < 0)
1678  return ret;
1679 
1680  out_bytes = write_frame(s, avpkt);
1681 
1682  s->frame_count++;
1683  s->sample_count += frame->nb_samples;
1684  if ((ret = update_md5_sum(s, frame->data[0])) < 0) {
1685  av_log(avctx, AV_LOG_ERROR, "Error updating MD5 checksum\n");
1686  return ret;
1687  }
1688  if (out_bytes > s->max_encoded_framesize)
1689  s->max_encoded_framesize = out_bytes;
1690  if (out_bytes < s->min_framesize)
1691  s->min_framesize = out_bytes;
1692 
1693  s->next_pts = frame->pts + ff_samples_to_time_base(avctx, frame->nb_samples);
1694 
1695  av_shrink_packet(avpkt, out_bytes);
1696 
1697  *got_packet_ptr = 1;
1698  return 0;
1699 }
1700 
1701 
1703 {
1704  FlacEncodeContext *s = avctx->priv_data;
1705 
1706  av_freep(&s->md5ctx);
1707  av_freep(&s->md5_buffer);
1708  ff_lpc_end(&s->lpc_ctx);
1709  return 0;
1710 }
1711 
1712 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1713 static const AVOption options[] = {
1714 { "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext, options.lpc_coeff_precision), AV_OPT_TYPE_INT, {.i64 = 15 }, 0, MAX_LPC_PRECISION, FLAGS },
1715 { "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" },
1716 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1717 { "fixed", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1718 { "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1719 { "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, "lpc_type" },
1720 { "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 },
1721 { "min_partition_order", NULL, offsetof(FlacEncodeContext, options.min_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },
1722 { "max_partition_order", NULL, offsetof(FlacEncodeContext, options.max_partition_order), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, MAX_PARTITION_ORDER, FLAGS },
1723 { "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" },
1724 { "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, INT_MIN, INT_MAX, FLAGS, "predm" },
1725 { "2level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1726 { "4level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1727 { "8level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, "predm" },
1728 { "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, "predm" },
1729 { "log", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG }, INT_MIN, INT_MAX, FLAGS, "predm" },
1730 { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, "ch_mode" },
1731 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1732 { "indep", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1733 { "left_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1734 { "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1735 { "mid_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE }, INT_MIN, INT_MAX, FLAGS, "ch_mode" },
1736 { "exact_rice_parameters", "Calculate rice parameters exactly", offsetof(FlacEncodeContext, options.exact_rice_parameters), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1737 { "multi_dim_quant", "Multi-dimensional quantization", offsetof(FlacEncodeContext, options.multi_dim_quant), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
1738 { "min_prediction_order", NULL, offsetof(FlacEncodeContext, options.min_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
1739 { "max_prediction_order", NULL, offsetof(FlacEncodeContext, options.max_prediction_order), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, MAX_LPC_ORDER, FLAGS },
1740 
1741 { NULL },
1742 };
1743 
1744 static const AVClass flac_encoder_class = {
1745  .class_name = "FLAC encoder",
1746  .item_name = av_default_item_name,
1747  .option = options,
1748  .version = LIBAVUTIL_VERSION_INT,
1749 };
1750 
1752  .p.name = "flac",
1753  CODEC_LONG_NAME("FLAC (Free Lossless Audio Codec)"),
1754  .p.type = AVMEDIA_TYPE_AUDIO,
1755  .p.id = AV_CODEC_ID_FLAC,
1756  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY |
1759  .priv_data_size = sizeof(FlacEncodeContext),
1762  .close = flac_encode_close,
1763  .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
1766  .p.priv_class = &flac_encoder_class,
1768 };
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1077
bswapdsp.h
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
LPC_ENCODE_WITH_RESIDUAL_LIMIT
#define LPC_ENCODE_WITH_RESIDUAL_LIMIT()
Definition: flacenc.c:889
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:91
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
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:291
flac_encode_init
static av_cold int flac_encode_init(AVCodecContext *avctx)
Definition: flacenc.c:269
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
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:1049
CompressionOptions::exact_rice_parameters
int exact_rice_parameters
Definition: flacenc.c:68
MAX_PARTITION_ORDER
#define MAX_PARTITION_ORDER
Definition: flacenc.c:45
FlacEncodeContext::bdsp
BswapDSPContext bdsp
Definition: flacenc.c:126
sub
static float sub(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:31
encode_residual_fixed_with_residual_limit_33bps
static int encode_residual_fixed_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int n, int order)
Definition: flacenc.c:883
CompressionOptions::max_prediction_order
int max_prediction_order
Definition: flacenc.c:63
CompressionOptions::ch_mode
int ch_mode
Definition: flacenc.c:67
MAX_LPC_SHIFT
#define MAX_LPC_SHIFT
Definition: flacenc.c:49
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:90
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:1619
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_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:376
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:330
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:66
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:127
CompressionOptions::prediction_order_method
int prediction_order_method
Definition: flacenc.c:64
FlacFrame
Definition: flacenc.c:95
select_blocksize
static int select_blocksize(int samplerate, int block_time_ms)
Set blocksize based on samplerate.
Definition: flacenc.c:192
CODING_MODE_RICE
@ CODING_MODE_RICE
Definition: flacenc.c:52
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: defs.h:62
AV_CODEC_ID_FLAC
@ AV_CODEC_ID_FLAC
Definition: codec_id.h:450
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:306
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:311
CompressionOptions::compression_level
int compression_level
Definition: flacenc.c:57
FLAC_CHMODE_LEFT_SIDE
@ FLAC_CHMODE_LEFT_SIDE
Definition: flac.h:40
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:761
ORDER_METHOD_4LEVEL
#define ORDER_METHOD_4LEVEL
Definition: lpc.h:33
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
FlacSubframe::wasted
int wasted
Definition: flacenc.c:82
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:2106
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
DEFAULT_TO_VERBATIM
#define DEFAULT_TO_VERBATIM()
Definition: flacenc.c:945
CompressionOptions::lpc_coeff_precision
int lpc_coeff_precision
Definition: flacenc.c:61
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:315
AVMD5
Definition: md5.c:40
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:372
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
lpc_encode_choose_datapath
static int lpc_encode_choose_datapath(FlacEncodeContext *s, int32_t bps, int32_t *res, const int32_t *smp, const int64_t *smp_33bps, int len, int order, int32_t *coefs, int shift)
Definition: flacenc.c:918
avassert.h
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:1469
av_cold
#define av_cold
Definition: attributes.h:90
mask
static const uint16_t mask[17]
Definition: lzw.c:38
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:542
s
#define s(width, name)
Definition: cbs_vp9.c:256
FlacSubframe::type_code
int type_code
Definition: flacenc.c:80
FlacSubframe::obits
int obits
Definition: flacenc.c:81
FlacEncodeContext::max_framesize
int max_framesize
Definition: flacenc.c:114
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
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:112
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:380
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
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
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:176
CompressionOptions::multi_dim_quant
int multi_dim_quant
Definition: flacenc.c:69
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FlacSubframe::order
int order
Definition: flacenc.c:83
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1498
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:1229
channels
channels
Definition: aptx.h:31
FlacSubframe::rc
RiceContext rc
Definition: flacenc.c:87
FLAC_SUBFRAME_LPC
#define FLAC_SUBFRAME_LPC
Definition: flacenc.c:42
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:642
CompressionOptions
Definition: dcaenc.c:56
FLAC_SUBFRAME_VERBATIM
#define FLAC_SUBFRAME_VERBATIM
Definition: flacenc.c:40
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
RiceContext::porder
int porder
Definition: flacenc.c:74
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:39
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:96
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
FlacFrame::samples_33bps
int64_t samples_33bps[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:97
FLAC_SUBFRAME_FIXED
#define FLAC_SUBFRAME_FIXED
Definition: flacenc.c:41
FlacEncodeContext::lpc_ctx
LPCContext lpc_ctx
Definition: flacenc.c:122
MIN_LPC_SHIFT
#define MIN_LPC_SHIFT
Definition: flacenc.c:48
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:90
ff_ctzll
#define ff_ctzll
Definition: intmath.h:127
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:1712
FlacEncodeContext::next_pts
int64_t next_pts
Definition: flacenc.c:130
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
put_sbits63
static void put_sbits63(PutBitContext *pb, int n, int64_t value)
Definition: put_bits.h:366
CompressionOptions::lpc_passes
int lpc_passes
Definition: flacenc.c:60
FlacEncodeContext::channels
int channels
Definition: flacenc.c:108
estimate_stereo_mode
static int estimate_stereo_mode(const int32_t *left_ch, const int32_t *right_ch, int n, int max_rice_param, int bps)
Definition: flacenc.c:1283
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:545
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:953
get_max_p_order
static int get_max_p_order(int max_porder, int n, int order)
Definition: flacenc.c:752
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:625
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
encode_residual_fixed_with_residual_limit
static int encode_residual_fixed_with_residual_limit(int32_t *res, const int32_t *smp, int n, int order)
Definition: flacenc.c:876
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:301
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:257
channel_decorrelation
static void channel_decorrelation(FlacEncodeContext *s)
Perform stereo channel decorrelation.
Definition: flacenc.c:1339
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:1648
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1065
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:1209
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:672
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:92
FlacEncodeContext::options
CompressionOptions options
Definition: flacenc.c:120
header
static const uint8_t header[24]
Definition: sdr2.c:67
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:162
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:1564
av_bswap16
#define av_bswap16
Definition: bswap.h:31
FlacSubframe::type
int type
Definition: flacenc.c:79
ORDER_METHOD_EST
#define ORDER_METHOD_EST
Definition: lpc.h:31
options
static const AVOption options[]
Definition: flacenc.c:1713
FlacSubframe
Definition: flacenc.c:78
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:932
FlacSubframe::coefs
int32_t coefs[MAX_LPC_ORDER]
Definition: flacenc.c:84
calc_sum_next
static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
Definition: flacenc.c:702
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:541
write_utf8
static void write_utf8(PutBitContext *pb, uint32_t val)
Definition: flacenc.c:1406
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:377
CompressionOptions::min_partition_order
int min_partition_order
Definition: flacenc.c:65
count_frame_header
static int count_frame_header(FlacEncodeContext *s)
Definition: flacenc.c:1173
ff_flac_encoder
const FFCodec ff_flac_encoder
Definition: flacenc.c:1751
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:1413
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:1553
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:523
len
int len
Definition: vorbis_enc_data.h:426
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:46
lpc_encode_with_residual_limit_33bps
static int lpc_encode_with_residual_limit_33bps(int32_t *res, const int64_t *smp, int len, int order, int32_t *coefs, int shift)
Definition: flacenc.c:912
avcodec.h
CompressionOptions::lpc_type
enum FFLPCType lpc_type
Definition: flacenc.c:59
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:712
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1352
encode_residual_fixed
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, int order)
Definition: flacenc.c:778
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
FLAC_MAX_CHANNELS
#define FLAC_MAX_CHANNELS
Definition: flac.h:33
MAX_LPC_PRECISION
#define MAX_LPC_PRECISION
Definition: flacenc.c:47
AVCodecContext
main external API structure.
Definition: avcodec.h:440
ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT
#define ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT()
Definition: flacenc.c:834
FlacEncodeContext::bps_code
int bps_code
Definition: flacenc.c:111
FlacSubframe::rc_sums
uint64_t rc_sums[32][MAX_PARTITIONS]
Definition: flacenc.c:89
channel_layout.h
FlacSubframe::rc_udata
uint32_t rc_udata[FLAC_MAX_BLOCKSIZE]
Definition: flacenc.c:88
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:558
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
frame_end
static void frame_end(MpegEncContext *s)
Definition: mpegvideo_enc.c:1626
FlacEncodeContext::sr_code
int sr_code[2]
Definition: flacenc.c:110
CompressionOptions::min_prediction_order
int min_prediction_order
Definition: flacenc.c:62
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
lpc_encode_with_residual_limit
static int lpc_encode_with_residual_limit(int32_t *res, const int32_t *smp, int len, int order, int32_t *coefs, int shift)
Definition: flacenc.c:906
FlacSubframe::shift
int shift
Definition: flacenc.c:85
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:478
RiceContext::params
int params[MAX_PARTITIONS]
Definition: flacenc.c:75
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
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:467
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
RiceContext::coding_mode
enum CodingMode coding_mode
Definition: flacenc.c:73
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:613
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:1574
flac_encode_close
static av_cold int flac_encode_close(AVCodecContext *avctx)
Definition: flacenc.c:1702
d
d
Definition: ffmpeg_filter.c:156
CODING_MODE_RICE2
@ CODING_MODE_RICE2
Definition: flacenc.c:53
int32_t
int32_t
Definition: audioconvert.c:56
CompressionOptions::block_time_ms
int block_time_ms
Definition: flacenc.c:58
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:381
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:1744
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
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:378
MAX_FIXED_ORDER
#define MAX_FIXED_ORDER
Definition: flacenc.c:44
ORDER_METHOD_2LEVEL
#define ORDER_METHOD_2LEVEL
Definition: lpc.h:32
FLAC_MIN_BLOCKSIZE
#define FLAC_MIN_BLOCKSIZE
Definition: flac.h:34
set_sr_golomb_flac
static void set_sr_golomb_flac(PutBitContext *pb, int i, int k)
Definition: flacenc.c:1450
FLAC_CHMODE_INDEPENDENT
@ FLAC_CHMODE_INDEPENDENT
Definition: flac.h:39
flac.h
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
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:379
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:51
rice_encode_count
#define rice_encode_count(sum, n, k)
Definition: flacenc.c:608
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:512
FF_LPC_TYPE_FIXED
@ FF_LPC_TYPE_FIXED
fixed LPC coefficients
Definition: lpc.h:47
intmath.h