3 * Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/avassert.h"
23 #include "libavutil/crc.h"
24 #include "libavutil/intmath.h"
25 #include "libavutil/md5.h"
26 #include "libavutil/opt.h"
37 #define FLAC_SUBFRAME_CONSTANT 0
38 #define FLAC_SUBFRAME_VERBATIM 1
39 #define FLAC_SUBFRAME_FIXED 8
40 #define FLAC_SUBFRAME_LPC 32
42 #define MAX_FIXED_ORDER 4
43 #define MAX_PARTITION_ORDER 8
44 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
45 #define MAX_LPC_PRECISION 15
46 #define MAX_LPC_SHIFT 15
50 CODING_MODE_RICE2
= 5,
53 typedef struct CompressionOptions
{
54 int compression_level
;
56 enum FFLPCType lpc_type
;
58 int lpc_coeff_precision
;
59 int min_prediction_order
;
60 int max_prediction_order
;
61 int prediction_order_method
;
62 int min_partition_order
;
63 int max_partition_order
;
67 typedef struct RiceContext
{
68 enum CodingMode coding_mode
;
70 int params
[MAX_PARTITIONS
];
73 typedef struct FlacSubframe
{
79 int32_t coefs
[MAX_LPC_ORDER
];
82 int32_t samples
[FLAC_MAX_BLOCKSIZE
];
83 int32_t residual
[FLAC_MAX_BLOCKSIZE
+11];
86 typedef struct FlacFrame
{
87 FlacSubframe subframes
[FLAC_MAX_CHANNELS
];
95 typedef struct FlacEncodeContext
{
105 int max_encoded_framesize
;
106 uint32_t frame_count
;
107 uint64_t sample_count
;
110 CompressionOptions options
;
111 AVCodecContext
*avctx
;
113 struct AVMD5
*md5ctx
;
115 unsigned int md5_buffer_size
;
116 BswapDSPContext bdsp
;
117 FLACDSPContext flac_dsp
;
125 * Write streaminfo metadata block to byte array.
127 static void write_streaminfo(FlacEncodeContext
*s
, uint8_t *header
)
131 memset(header
, 0, FLAC_STREAMINFO_SIZE
);
132 init_put_bits(&pb
, header
, FLAC_STREAMINFO_SIZE
);
134 /* streaminfo metadata block */
135 put_bits(&pb
, 16, s
->max_blocksize
);
136 put_bits(&pb
, 16, s
->max_blocksize
);
137 put_bits(&pb
, 24, s
->min_framesize
);
138 put_bits(&pb
, 24, s
->max_framesize
);
139 put_bits(&pb
, 20, s
->samplerate
);
140 put_bits(&pb
, 3, s
->channels
-1);
141 put_bits(&pb
, 5, s
->avctx
->bits_per_raw_sample
- 1);
142 /* write 36-bit sample count in 2 put_bits() calls */
143 put_bits(&pb
, 24, (s
->sample_count
& 0xFFFFFF000LL
) >> 12);
144 put_bits(&pb
, 12, s
->sample_count
& 0x000000FFFLL
);
146 memcpy(&header
[18], s
->md5sum
, 16);
151 * Set blocksize based on samplerate.
152 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
154 static int select_blocksize(int samplerate
, int block_time_ms
)
160 av_assert0(samplerate
> 0);
161 blocksize
= ff_flac_blocksize_table
[1];
162 target
= (samplerate
* block_time_ms
) / 1000;
163 for (i
= 0; i
< 16; i
++) {
164 if (target
>= ff_flac_blocksize_table
[i
] &&
165 ff_flac_blocksize_table
[i
] > blocksize
) {
166 blocksize
= ff_flac_blocksize_table
[i
];
173 static av_cold
void dprint_compression_options(FlacEncodeContext
*s
)
175 AVCodecContext
*avctx
= s
->avctx
;
176 CompressionOptions
*opt
= &s
->options
;
178 av_log(avctx
, AV_LOG_DEBUG
, " compression: %d\n", opt
->compression_level
);
180 switch (opt
->lpc_type
) {
181 case FF_LPC_TYPE_NONE
:
182 av_log(avctx
, AV_LOG_DEBUG
, " lpc type: None\n");
184 case FF_LPC_TYPE_FIXED
:
185 av_log(avctx
, AV_LOG_DEBUG
, " lpc type: Fixed pre-defined coefficients\n");
187 case FF_LPC_TYPE_LEVINSON
:
188 av_log(avctx
, AV_LOG_DEBUG
, " lpc type: Levinson-Durbin recursion with Welch window\n");
190 case FF_LPC_TYPE_CHOLESKY
:
191 av_log(avctx
, AV_LOG_DEBUG
, " lpc type: Cholesky factorization, %d pass%s\n",
192 opt
->lpc_passes
, opt
->lpc_passes
== 1 ? "" : "es");
196 av_log(avctx
, AV_LOG_DEBUG
, " prediction order: %d, %d\n",
197 opt
->min_prediction_order
, opt
->max_prediction_order
);
199 switch (opt
->prediction_order_method
) {
200 case ORDER_METHOD_EST
:
201 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "estimate");
203 case ORDER_METHOD_2LEVEL
:
204 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "2-level");
206 case ORDER_METHOD_4LEVEL
:
207 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "4-level");
209 case ORDER_METHOD_8LEVEL
:
210 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "8-level");
212 case ORDER_METHOD_SEARCH
:
213 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "full search");
215 case ORDER_METHOD_LOG
:
216 av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n", "log search");
221 av_log(avctx
, AV_LOG_DEBUG
, " partition order: %d, %d\n",
222 opt
->min_partition_order
, opt
->max_partition_order
);
224 av_log(avctx
, AV_LOG_DEBUG
, " block size: %d\n", avctx
->frame_size
);
226 av_log(avctx
, AV_LOG_DEBUG
, " lpc precision: %d\n",
227 opt
->lpc_coeff_precision
);
231 static av_cold
int flac_encode_init(AVCodecContext
*avctx
)
233 int freq
= avctx
->sample_rate
;
234 int channels
= avctx
->channels
;
235 FlacEncodeContext
*s
= avctx
->priv_data
;
241 switch (avctx
->sample_fmt
) {
242 case AV_SAMPLE_FMT_S16
:
243 avctx
->bits_per_raw_sample
= 16;
246 case AV_SAMPLE_FMT_S32
:
247 if (avctx
->bits_per_raw_sample
!= 24)
248 av_log(avctx
, AV_LOG_WARNING
, "encoding as 24 bits-per-sample\n");
249 avctx
->bits_per_raw_sample
= 24;
254 if (channels
< 1 || channels
> FLAC_MAX_CHANNELS
) {
255 av_log(avctx
, AV_LOG_ERROR
, "%d channels not supported (max %d)\n",
256 channels
, FLAC_MAX_CHANNELS
);
257 return AVERROR(EINVAL
);
259 s
->channels
= channels
;
261 /* find samplerate in table */
264 for (i
= 4; i
< 12; i
++) {
265 if (freq
== ff_flac_sample_rate_table
[i
]) {
266 s
->samplerate
= ff_flac_sample_rate_table
[i
];
272 /* if not in table, samplerate is non-standard */
274 if (freq
% 1000 == 0 && freq
< 255000) {
276 s
->sr_code
[1] = freq
/ 1000;
277 } else if (freq
% 10 == 0 && freq
< 655350) {
279 s
->sr_code
[1] = freq
/ 10;
280 } else if (freq
< 65535) {
282 s
->sr_code
[1] = freq
;
284 av_log(avctx
, AV_LOG_ERROR
, "%d Hz not supported\n", freq
);
285 return AVERROR(EINVAL
);
287 s
->samplerate
= freq
;
290 /* set compression option defaults based on avctx->compression_level */
291 if (avctx
->compression_level
< 0)
292 s
->options
.compression_level
= 5;
294 s
->options
.compression_level
= avctx
->compression_level
;
296 level
= s
->options
.compression_level
;
298 av_log(avctx
, AV_LOG_ERROR
, "invalid compression level: %d\n",
299 s
->options
.compression_level
);
300 return AVERROR(EINVAL
);
303 s
->options
.block_time_ms
= ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level
];
305 if (s
->options
.lpc_type
== FF_LPC_TYPE_DEFAULT
)
306 s
->options
.lpc_type
= ((int[]){ FF_LPC_TYPE_FIXED
, FF_LPC_TYPE_FIXED
, FF_LPC_TYPE_FIXED
,
307 FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
,
308 FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
,
309 FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
, FF_LPC_TYPE_LEVINSON
,
310 FF_LPC_TYPE_LEVINSON
})[level
];
312 s
->options
.min_prediction_order
= ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level
];
313 s
->options
.max_prediction_order
= ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level
];
315 if (s
->options
.prediction_order_method
< 0)
316 s
->options
.prediction_order_method
= ((int[]){ ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
317 ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
318 ORDER_METHOD_4LEVEL
, ORDER_METHOD_LOG
, ORDER_METHOD_4LEVEL
,
319 ORDER_METHOD_LOG
, ORDER_METHOD_SEARCH
, ORDER_METHOD_LOG
,
320 ORDER_METHOD_SEARCH
})[level
];
322 if (s
->options
.min_partition_order
> s
->options
.max_partition_order
) {
323 av_log(avctx
, AV_LOG_ERROR
, "invalid partition orders: min=%d max=%d\n",
324 s
->options
.min_partition_order
, s
->options
.max_partition_order
);
325 return AVERROR(EINVAL
);
327 if (s
->options
.min_partition_order
< 0)
328 s
->options
.min_partition_order
= ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level
];
329 if (s
->options
.max_partition_order
< 0)
330 s
->options
.max_partition_order
= ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level
];
332 if (s
->options
.lpc_type
== FF_LPC_TYPE_NONE
) {
333 s
->options
.min_prediction_order
= 0;
334 } else if (avctx
->min_prediction_order
>= 0) {
335 if (s
->options
.lpc_type
== FF_LPC_TYPE_FIXED
) {
336 if (avctx
->min_prediction_order
> MAX_FIXED_ORDER
) {
337 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
338 avctx
->min_prediction_order
);
339 return AVERROR(EINVAL
);
341 } else if (avctx
->min_prediction_order
< MIN_LPC_ORDER
||
342 avctx
->min_prediction_order
> MAX_LPC_ORDER
) {
343 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
344 avctx
->min_prediction_order
);
345 return AVERROR(EINVAL
);
347 s
->options
.min_prediction_order
= avctx
->min_prediction_order
;
349 if (s
->options
.lpc_type
== FF_LPC_TYPE_NONE
) {
350 s
->options
.max_prediction_order
= 0;
351 } else if (avctx
->max_prediction_order
>= 0) {
352 if (s
->options
.lpc_type
== FF_LPC_TYPE_FIXED
) {
353 if (avctx
->max_prediction_order
> MAX_FIXED_ORDER
) {
354 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
355 avctx
->max_prediction_order
);
356 return AVERROR(EINVAL
);
358 } else if (avctx
->max_prediction_order
< MIN_LPC_ORDER
||
359 avctx
->max_prediction_order
> MAX_LPC_ORDER
) {
360 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
361 avctx
->max_prediction_order
);
362 return AVERROR(EINVAL
);
364 s
->options
.max_prediction_order
= avctx
->max_prediction_order
;
366 if (s
->options
.max_prediction_order
< s
->options
.min_prediction_order
) {
367 av_log(avctx
, AV_LOG_ERROR
, "invalid prediction orders: min=%d max=%d\n",
368 s
->options
.min_prediction_order
, s
->options
.max_prediction_order
);
369 return AVERROR(EINVAL
);
372 if (avctx
->frame_size
> 0) {
373 if (avctx
->frame_size
< FLAC_MIN_BLOCKSIZE
||
374 avctx
->frame_size
> FLAC_MAX_BLOCKSIZE
) {
375 av_log(avctx
, AV_LOG_ERROR
, "invalid block size: %d\n",
377 return AVERROR(EINVAL
);
380 s
->avctx
->frame_size
= select_blocksize(s
->samplerate
, s
->options
.block_time_ms
);
382 s
->max_blocksize
= s
->avctx
->frame_size
;
384 /* set maximum encoded frame size in verbatim mode */
385 s
->max_framesize
= ff_flac_get_max_frame_size(s
->avctx
->frame_size
,
387 s
->avctx
->bits_per_raw_sample
);
389 /* initialize MD5 context */
390 s
->md5ctx
= av_md5_alloc();
392 return AVERROR(ENOMEM
);
393 av_md5_init(s
->md5ctx
);
395 streaminfo
= av_malloc(FLAC_STREAMINFO_SIZE
);
397 return AVERROR(ENOMEM
);
398 write_streaminfo(s
, streaminfo
);
399 avctx
->extradata
= streaminfo
;
400 avctx
->extradata_size
= FLAC_STREAMINFO_SIZE
;
403 s
->min_framesize
= s
->max_framesize
;
406 avctx
->channel_layout
!= (AV_CH_LAYOUT_STEREO
|AV_CH_FRONT_CENTER
) ||
408 avctx
->channel_layout
!= AV_CH_LAYOUT_2_2
&&
409 avctx
->channel_layout
!= AV_CH_LAYOUT_QUAD
||
411 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT0
&&
412 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT0_BACK
||
414 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT1
&&
415 avctx
->channel_layout
!= AV_CH_LAYOUT_5POINT1_BACK
) {
416 if (avctx
->channel_layout
) {
417 av_log(avctx
, AV_LOG_ERROR
, "Channel layout not supported by Flac, "
418 "output stream will have incorrect "
419 "channel layout.\n");
421 av_log(avctx
, AV_LOG_WARNING
, "No channel layout specified. The encoder "
422 "will use Flac channel layout for "
423 "%d channels.\n", channels
);
427 ret
= ff_lpc_init(&s
->lpc_ctx
, avctx
->frame_size
,
428 s
->options
.max_prediction_order
, FF_LPC_TYPE_LEVINSON
);
430 ff_bswapdsp_init(&s
->bdsp
);
431 ff_flacdsp_init(&s
->flac_dsp
, avctx
->sample_fmt
, channels
,
432 avctx
->bits_per_raw_sample
);
434 dprint_compression_options(s
);
440 static void init_frame(FlacEncodeContext
*s
, int nb_samples
)
447 for (i
= 0; i
< 16; i
++) {
448 if (nb_samples
== ff_flac_blocksize_table
[i
]) {
449 frame
->blocksize
= ff_flac_blocksize_table
[i
];
450 frame
->bs_code
[0] = i
;
451 frame
->bs_code
[1] = 0;
456 frame
->blocksize
= nb_samples
;
457 if (frame
->blocksize
<= 256) {
458 frame
->bs_code
[0] = 6;
459 frame
->bs_code
[1] = frame
->blocksize
-1;
461 frame
->bs_code
[0] = 7;
462 frame
->bs_code
[1] = frame
->blocksize
-1;
466 for (ch
= 0; ch
< s
->channels
; ch
++) {
467 FlacSubframe
*sub
= &frame
->subframes
[ch
];
470 sub
->obits
= s
->avctx
->bits_per_raw_sample
;
473 sub
->rc
.coding_mode
= CODING_MODE_RICE2
;
475 sub
->rc
.coding_mode
= CODING_MODE_RICE
;
478 frame
->verbatim_only
= 0;
483 * Copy channel-interleaved input samples into separate subframes.
485 static void copy_samples(FlacEncodeContext
*s
, const void *samples
)
489 int shift
= av_get_bytes_per_sample(s
->avctx
->sample_fmt
) * 8 -
490 s
->avctx
->bits_per_raw_sample
;
492 #define COPY_SAMPLES(bits) do { \
493 const int ## bits ## _t *samples0 = samples; \
495 for (i = 0, j = 0; i < frame->blocksize; i++) \
496 for (ch = 0; ch < s->channels; ch++, j++) \
497 frame->subframes[ch].samples[i] = samples0[j] >> shift; \
500 if (s
->avctx
->sample_fmt
== AV_SAMPLE_FMT_S16
)
507 static uint64_t rice_count_exact(int32_t *res
, int n
, int k
)
512 for (i
= 0; i
< n
; i
++) {
513 int32_t v
= -2 * res
[i
] - 1;
515 count
+= (v
>> k
) + 1 + k
;
521 static uint64_t subframe_count_exact(FlacEncodeContext
*s
, FlacSubframe
*sub
,
524 int p
, porder
, psize
;
528 /* subframe header */
532 if (sub
->type
== FLAC_SUBFRAME_CONSTANT
) {
534 } else if (sub
->type
== FLAC_SUBFRAME_VERBATIM
) {
535 count
+= s
->frame
.blocksize
* sub
->obits
;
537 /* warm-up samples */
538 count
+= pred_order
* sub
->obits
;
540 /* LPC coefficients */
541 if (sub
->type
== FLAC_SUBFRAME_LPC
)
542 count
+= 4 + 5 + pred_order
* s
->options
.lpc_coeff_precision
;
544 /* rice-encoded block */
547 /* partition order */
548 porder
= sub
->rc
.porder
;
549 psize
= s
->frame
.blocksize
>> porder
;
555 for (p
= 0; p
< 1 << porder
; p
++) {
556 int k
= sub
->rc
.params
[p
];
557 count
+= sub
->rc
.coding_mode
;
558 count
+= rice_count_exact(&sub
->residual
[i
], part_end
- i
, k
);
560 part_end
= FFMIN(s
->frame
.blocksize
, part_end
+ psize
);
568 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
571 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0.
573 static int find_optimal_param(uint64_t sum
, int n
, int max_param
)
580 sum2
= sum
- (n
>> 1);
581 k
= av_log2(av_clipl_int32(sum2
/ n
));
582 return FFMIN(k
, max_param
);
586 static uint64_t calc_optimal_rice_params(RiceContext
*rc
, int porder
,
587 uint64_t *sums
, int n
, int pred_order
)
590 int k
, cnt
, part
, max_param
;
593 max_param
= (1 << rc
->coding_mode
) - 2;
595 part
= (1 << porder
);
598 cnt
= (n
>> porder
) - pred_order
;
599 for (i
= 0; i
< part
; i
++) {
600 k
= find_optimal_param(sums
[i
], cnt
, max_param
);
602 all_bits
+= rice_encode_count(sums
[i
], cnt
, k
);
612 static void calc_sums(int pmin
, int pmax
, uint32_t *data
, int n
, int pred_order
,
613 uint64_t sums
[][MAX_PARTITIONS
])
617 uint32_t *res
, *res_end
;
619 /* sums for highest level */
621 res
= &data
[pred_order
];
622 res_end
= &data
[n
>> pmax
];
623 for (i
= 0; i
< parts
; i
++) {
625 while (res
< res_end
)
628 res_end
+= n
>> pmax
;
630 /* sums for lower levels */
631 for (i
= pmax
- 1; i
>= pmin
; i
--) {
633 for (j
= 0; j
< parts
; j
++)
634 sums
[i
][j
] = sums
[i
+1][2*j
] + sums
[i
+1][2*j
+1];
639 static uint64_t calc_rice_params(RiceContext
*rc
, int pmin
, int pmax
,
640 int32_t *data
, int n
, int pred_order
)
643 uint64_t bits
[MAX_PARTITION_ORDER
+1];
647 uint64_t sums
[MAX_PARTITION_ORDER
+1][MAX_PARTITIONS
];
649 av_assert1(pmin
>= 0 && pmin
<= MAX_PARTITION_ORDER
);
650 av_assert1(pmax
>= 0 && pmax
<= MAX_PARTITION_ORDER
);
651 av_assert1(pmin
<= pmax
);
653 tmp_rc
.coding_mode
= rc
->coding_mode
;
655 udata
= av_malloc_array(n
, sizeof(uint32_t));
656 for (i
= 0; i
< n
; i
++)
657 udata
[i
] = (2*data
[i
]) ^ (data
[i
]>>31);
659 calc_sums(pmin
, pmax
, udata
, n
, pred_order
, sums
);
662 bits
[pmin
] = UINT32_MAX
;
663 for (i
= pmin
; i
<= pmax
; i
++) {
664 bits
[i
] = calc_optimal_rice_params(&tmp_rc
, i
, sums
[i
], n
, pred_order
);
665 if (bits
[i
] <= bits
[opt_porder
]) {
672 return bits
[opt_porder
];
676 static int get_max_p_order(int max_porder
, int n
, int order
)
678 int porder
= FFMIN(max_porder
, av_log2(n
^(n
-1)));
680 porder
= FFMIN(porder
, av_log2(n
/order
));
685 static uint64_t find_subframe_rice_params(FlacEncodeContext
*s
,
686 FlacSubframe
*sub
, int pred_order
)
688 int pmin
= get_max_p_order(s
->options
.min_partition_order
,
689 s
->frame
.blocksize
, pred_order
);
690 int pmax
= get_max_p_order(s
->options
.max_partition_order
,
691 s
->frame
.blocksize
, pred_order
);
693 uint64_t bits
= 8 + pred_order
* sub
->obits
+ 2 + sub
->rc
.coding_mode
;
694 if (sub
->type
== FLAC_SUBFRAME_LPC
)
695 bits
+= 4 + 5 + pred_order
* s
->options
.lpc_coeff_precision
;
696 bits
+= calc_rice_params(&sub
->rc
, pmin
, pmax
, sub
->residual
,
697 s
->frame
.blocksize
, pred_order
);
702 static void encode_residual_fixed(int32_t *res
, const int32_t *smp
, int n
,
707 for (i
= 0; i
< order
; i
++)
711 for (i
= order
; i
< n
; i
++)
713 } else if (order
== 1) {
714 for (i
= order
; i
< n
; i
++)
715 res
[i
] = smp
[i
] - smp
[i
-1];
716 } else if (order
== 2) {
717 int a
= smp
[order
-1] - smp
[order
-2];
718 for (i
= order
; i
< n
; i
+= 2) {
719 int b
= smp
[i
] - smp
[i
-1];
721 a
= smp
[i
+1] - smp
[i
];
724 } else if (order
== 3) {
725 int a
= smp
[order
-1] - smp
[order
-2];
726 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
727 for (i
= order
; i
< n
; i
+= 2) {
728 int b
= smp
[i
] - smp
[i
-1];
731 a
= smp
[i
+1] - smp
[i
];
736 int a
= smp
[order
-1] - smp
[order
-2];
737 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
738 int e
= smp
[order
-1] - 3*smp
[order
-2] + 3*smp
[order
-3] - smp
[order
-4];
739 for (i
= order
; i
< n
; i
+= 2) {
740 int b
= smp
[i
] - smp
[i
-1];
744 a
= smp
[i
+1] - smp
[i
];
753 static int encode_residual_ch(FlacEncodeContext
*s
, int ch
)
756 int min_order
, max_order
, opt_order
, omethod
;
759 int32_t coefs
[MAX_LPC_ORDER
][MAX_LPC_ORDER
];
760 int shift
[MAX_LPC_ORDER
];
764 sub
= &frame
->subframes
[ch
];
767 n
= frame
->blocksize
;
770 for (i
= 1; i
< n
; i
++)
774 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_CONSTANT
;
776 return subframe_count_exact(s
, sub
, 0);
780 if (frame
->verbatim_only
|| n
< 5) {
781 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_VERBATIM
;
782 memcpy(res
, smp
, n
* sizeof(int32_t));
783 return subframe_count_exact(s
, sub
, 0);
786 min_order
= s
->options
.min_prediction_order
;
787 max_order
= s
->options
.max_prediction_order
;
788 omethod
= s
->options
.prediction_order_method
;
791 sub
->type
= FLAC_SUBFRAME_FIXED
;
792 if (s
->options
.lpc_type
== FF_LPC_TYPE_NONE
||
793 s
->options
.lpc_type
== FF_LPC_TYPE_FIXED
|| n
<= max_order
) {
794 uint64_t bits
[MAX_FIXED_ORDER
+1];
795 if (max_order
> MAX_FIXED_ORDER
)
796 max_order
= MAX_FIXED_ORDER
;
798 bits
[0] = UINT32_MAX
;
799 for (i
= min_order
; i
<= max_order
; i
++) {
800 encode_residual_fixed(res
, smp
, n
, i
);
801 bits
[i
] = find_subframe_rice_params(s
, sub
, i
);
802 if (bits
[i
] < bits
[opt_order
])
805 sub
->order
= opt_order
;
806 sub
->type_code
= sub
->type
| sub
->order
;
807 if (sub
->order
!= max_order
) {
808 encode_residual_fixed(res
, smp
, n
, sub
->order
);
809 find_subframe_rice_params(s
, sub
, sub
->order
);
811 return subframe_count_exact(s
, sub
, sub
->order
);
815 sub
->type
= FLAC_SUBFRAME_LPC
;
816 opt_order
= ff_lpc_calc_coefs(&s
->lpc_ctx
, smp
, n
, min_order
, max_order
,
817 s
->options
.lpc_coeff_precision
, coefs
, shift
, s
->options
.lpc_type
,
818 s
->options
.lpc_passes
, omethod
,
821 if (omethod
== ORDER_METHOD_2LEVEL
||
822 omethod
== ORDER_METHOD_4LEVEL
||
823 omethod
== ORDER_METHOD_8LEVEL
) {
824 int levels
= 1 << omethod
;
825 uint64_t bits
[1 << ORDER_METHOD_8LEVEL
];
827 int opt_index
= levels
-1;
828 opt_order
= max_order
-1;
829 bits
[opt_index
] = UINT32_MAX
;
830 for (i
= levels
-1; i
>= 0; i
--) {
831 int last_order
= order
;
832 order
= min_order
+ (((max_order
-min_order
+1) * (i
+1)) / levels
)-1;
833 order
= av_clip(order
, min_order
- 1, max_order
- 1);
834 if (order
== last_order
)
836 s
->flac_dsp
.lpc_encode(res
, smp
, n
, order
+1, coefs
[order
],
838 bits
[i
] = find_subframe_rice_params(s
, sub
, order
+1);
839 if (bits
[i
] < bits
[opt_index
]) {
845 } else if (omethod
== ORDER_METHOD_SEARCH
) {
846 // brute-force optimal order search
847 uint64_t bits
[MAX_LPC_ORDER
];
849 bits
[0] = UINT32_MAX
;
850 for (i
= min_order
-1; i
< max_order
; i
++) {
851 s
->flac_dsp
.lpc_encode(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
852 bits
[i
] = find_subframe_rice_params(s
, sub
, i
+1);
853 if (bits
[i
] < bits
[opt_order
])
857 } else if (omethod
== ORDER_METHOD_LOG
) {
858 uint64_t bits
[MAX_LPC_ORDER
];
861 opt_order
= min_order
- 1 + (max_order
-min_order
)/3;
862 memset(bits
, -1, sizeof(bits
));
864 for (step
= 16; step
; step
>>= 1) {
865 int last
= opt_order
;
866 for (i
= last
-step
; i
<= last
+step
; i
+= step
) {
867 if (i
< min_order
-1 || i
>= max_order
|| bits
[i
] < UINT32_MAX
)
869 s
->flac_dsp
.lpc_encode(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
870 bits
[i
] = find_subframe_rice_params(s
, sub
, i
+1);
871 if (bits
[i
] < bits
[opt_order
])
878 sub
->order
= opt_order
;
879 sub
->type_code
= sub
->type
| (sub
->order
-1);
880 sub
->shift
= shift
[sub
->order
-1];
881 for (i
= 0; i
< sub
->order
; i
++)
882 sub
->coefs
[i
] = coefs
[sub
->order
-1][i
];
884 s
->flac_dsp
.lpc_encode(res
, smp
, n
, sub
->order
, sub
->coefs
, sub
->shift
);
886 find_subframe_rice_params(s
, sub
, sub
->order
);
888 return subframe_count_exact(s
, sub
, sub
->order
);
892 static int count_frame_header(FlacEncodeContext
*s
)
894 uint8_t av_unused tmp
;
900 <1> Blocking strategy
901 <4> Block size in inter-channel samples
903 <4> Channel assignment
904 <3> Sample size in bits
909 /* coded frame number */
910 PUT_UTF8(s
->frame_count
, tmp
, count
+= 8;)
912 /* explicit block size */
913 if (s
->frame
.bs_code
[0] == 6)
915 else if (s
->frame
.bs_code
[0] == 7)
918 /* explicit sample rate */
919 count
+= ((s
->sr_code
[0] == 12) + (s
->sr_code
[0] > 12)) * 8;
921 /* frame header CRC-8 */
928 static int encode_frame(FlacEncodeContext
*s
)
933 count
= count_frame_header(s
);
935 for (ch
= 0; ch
< s
->channels
; ch
++)
936 count
+= encode_residual_ch(s
, ch
);
938 count
+= (8 - (count
& 7)) & 7; // byte alignment
939 count
+= 16; // CRC-16
948 static void remove_wasted_bits(FlacEncodeContext
*s
)
952 for (ch
= 0; ch
< s
->channels
; ch
++) {
953 FlacSubframe
*sub
= &s
->frame
.subframes
[ch
];
956 for (i
= 0; i
< s
->frame
.blocksize
; i
++) {
957 v
|= sub
->samples
[i
];
965 for (i
= 0; i
< s
->frame
.blocksize
; i
++)
966 sub
->samples
[i
] >>= v
;
971 /* for 24-bit, check if removing wasted bits makes the range better
972 suited for using RICE instead of RICE2 for entropy coding */
973 if (sub
->obits
<= 17)
974 sub
->rc
.coding_mode
= CODING_MODE_RICE
;
980 static int estimate_stereo_mode(int32_t *left_ch
, int32_t *right_ch
, int n
,
989 /* calculate sum of 2nd order residual for each channel */
990 sum
[0] = sum
[1] = sum
[2] = sum
[3] = 0;
991 for (i
= 2; i
< n
; i
++) {
992 lt
= left_ch
[i
] - 2*left_ch
[i
-1] + left_ch
[i
-2];
993 rt
= right_ch
[i
] - 2*right_ch
[i
-1] + right_ch
[i
-2];
994 sum
[2] += FFABS((lt
+ rt
) >> 1);
995 sum
[3] += FFABS(lt
- rt
);
999 /* estimate bit counts */
1000 for (i
= 0; i
< 4; i
++) {
1001 k
= find_optimal_param(2 * sum
[i
], n
, max_rice_param
);
1002 sum
[i
] = rice_encode_count( 2 * sum
[i
], n
, k
);
1005 /* calculate score for each mode */
1006 score
[0] = sum
[0] + sum
[1];
1007 score
[1] = sum
[0] + sum
[3];
1008 score
[2] = sum
[1] + sum
[3];
1009 score
[3] = sum
[2] + sum
[3];
1011 /* return mode with lowest score */
1013 for (i
= 1; i
< 4; i
++)
1014 if (score
[i
] < score
[best
])
1022 * Perform stereo channel decorrelation.
1024 static void channel_decorrelation(FlacEncodeContext
*s
)
1027 int32_t *left
, *right
;
1031 n
= frame
->blocksize
;
1032 left
= frame
->subframes
[0].samples
;
1033 right
= frame
->subframes
[1].samples
;
1035 if (s
->channels
!= 2) {
1036 frame
->ch_mode
= FLAC_CHMODE_INDEPENDENT
;
1040 if (s
->options
.ch_mode
< 0) {
1041 int max_rice_param
= (1 << frame
->subframes
[0].rc
.coding_mode
) - 2;
1042 frame
->ch_mode
= estimate_stereo_mode(left
, right
, n
, max_rice_param
);
1044 frame
->ch_mode
= s
->options
.ch_mode
;
1046 /* perform decorrelation and adjust bits-per-sample */
1047 if (frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
)
1049 if (frame
->ch_mode
== FLAC_CHMODE_MID_SIDE
) {
1051 for (i
= 0; i
< n
; i
++) {
1053 left
[i
] = (tmp
+ right
[i
]) >> 1;
1054 right
[i
] = tmp
- right
[i
];
1056 frame
->subframes
[1].obits
++;
1057 } else if (frame
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
) {
1058 for (i
= 0; i
< n
; i
++)
1059 right
[i
] = left
[i
] - right
[i
];
1060 frame
->subframes
[1].obits
++;
1062 for (i
= 0; i
< n
; i
++)
1063 left
[i
] -= right
[i
];
1064 frame
->subframes
[0].obits
++;
1069 static void write_utf8(PutBitContext
*pb
, uint32_t val
)
1072 PUT_UTF8(val
, tmp
, put_bits(pb
, 8, tmp
);)
1076 static void write_frame_header(FlacEncodeContext
*s
)
1083 put_bits(&s
->pb
, 16, 0xFFF8);
1084 put_bits(&s
->pb
, 4, frame
->bs_code
[0]);
1085 put_bits(&s
->pb
, 4, s
->sr_code
[0]);
1087 if (frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
)
1088 put_bits(&s
->pb
, 4, s
->channels
-1);
1090 put_bits(&s
->pb
, 4, frame
->ch_mode
+ FLAC_MAX_CHANNELS
- 1);
1092 put_bits(&s
->pb
, 3, s
->bps_code
);
1093 put_bits(&s
->pb
, 1, 0);
1094 write_utf8(&s
->pb
, s
->frame_count
);
1096 if (frame
->bs_code
[0] == 6)
1097 put_bits(&s
->pb
, 8, frame
->bs_code
[1]);
1098 else if (frame
->bs_code
[0] == 7)
1099 put_bits(&s
->pb
, 16, frame
->bs_code
[1]);
1101 if (s
->sr_code
[0] == 12)
1102 put_bits(&s
->pb
, 8, s
->sr_code
[1]);
1103 else if (s
->sr_code
[0] > 12)
1104 put_bits(&s
->pb
, 16, s
->sr_code
[1]);
1106 flush_put_bits(&s
->pb
);
1107 crc
= av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0, s
->pb
.buf
,
1108 put_bits_count(&s
->pb
) >> 3);
1109 put_bits(&s
->pb
, 8, crc
);
1113 static void write_subframes(FlacEncodeContext
*s
)
1117 for (ch
= 0; ch
< s
->channels
; ch
++) {
1118 FlacSubframe
*sub
= &s
->frame
.subframes
[ch
];
1119 int i
, p
, porder
, psize
;
1121 int32_t *res
= sub
->residual
;
1122 int32_t *frame_end
= &sub
->residual
[s
->frame
.blocksize
];
1124 /* subframe header */
1125 put_bits(&s
->pb
, 1, 0);
1126 put_bits(&s
->pb
, 6, sub
->type_code
);
1127 put_bits(&s
->pb
, 1, !!sub
->wasted
);
1129 put_bits(&s
->pb
, sub
->wasted
, 1);
1132 if (sub
->type
== FLAC_SUBFRAME_CONSTANT
) {
1133 put_sbits(&s
->pb
, sub
->obits
, res
[0]);
1134 } else if (sub
->type
== FLAC_SUBFRAME_VERBATIM
) {
1135 while (res
< frame_end
)
1136 put_sbits(&s
->pb
, sub
->obits
, *res
++);
1138 /* warm-up samples */
1139 for (i
= 0; i
< sub
->order
; i
++)
1140 put_sbits(&s
->pb
, sub
->obits
, *res
++);
1142 /* LPC coefficients */
1143 if (sub
->type
== FLAC_SUBFRAME_LPC
) {
1144 int cbits
= s
->options
.lpc_coeff_precision
;
1145 put_bits( &s
->pb
, 4, cbits
-1);
1146 put_sbits(&s
->pb
, 5, sub
->shift
);
1147 for (i
= 0; i
< sub
->order
; i
++)
1148 put_sbits(&s
->pb
, cbits
, sub
->coefs
[i
]);
1151 /* rice-encoded block */
1152 put_bits(&s
->pb
, 2, sub
->rc
.coding_mode
- 4);
1154 /* partition order */
1155 porder
= sub
->rc
.porder
;
1156 psize
= s
->frame
.blocksize
>> porder
;
1157 put_bits(&s
->pb
, 4, porder
);
1160 part_end
= &sub
->residual
[psize
];
1161 for (p
= 0; p
< 1 << porder
; p
++) {
1162 int k
= sub
->rc
.params
[p
];
1163 put_bits(&s
->pb
, sub
->rc
.coding_mode
, k
);
1164 while (res
< part_end
)
1165 set_sr_golomb_flac(&s
->pb
, *res
++, k
, INT32_MAX
, 0);
1166 part_end
= FFMIN(frame_end
, part_end
+ psize
);
1173 static void write_frame_footer(FlacEncodeContext
*s
)
1176 flush_put_bits(&s
->pb
);
1177 crc
= av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0, s
->pb
.buf
,
1178 put_bits_count(&s
->pb
)>>3));
1179 put_bits(&s
->pb
, 16, crc
);
1180 flush_put_bits(&s
->pb
);
1184 static int write_frame(FlacEncodeContext
*s
, AVPacket
*avpkt
)
1186 init_put_bits(&s
->pb
, avpkt
->data
, avpkt
->size
);
1187 write_frame_header(s
);
1189 write_frame_footer(s
);
1190 return put_bits_count(&s
->pb
) >> 3;
1194 static int update_md5_sum(FlacEncodeContext
*s
, const void *samples
)
1197 int buf_size
= s
->frame
.blocksize
* s
->channels
*
1198 ((s
->avctx
->bits_per_raw_sample
+ 7) / 8);
1200 if (s
->avctx
->bits_per_raw_sample
> 16 || HAVE_BIGENDIAN
) {
1201 av_fast_malloc(&s
->md5_buffer
, &s
->md5_buffer_size
, buf_size
);
1203 return AVERROR(ENOMEM
);
1206 if (s
->avctx
->bits_per_raw_sample
<= 16) {
1207 buf
= (const uint8_t *)samples
;
1209 s
->bdsp
.bswap16_buf((uint16_t *) s
->md5_buffer
,
1210 (const uint16_t *) samples
, buf_size
/ 2);
1211 buf
= s
->md5_buffer
;
1215 const int32_t *samples0
= samples
;
1216 uint8_t *tmp
= s
->md5_buffer
;
1218 for (i
= 0; i
< s
->frame
.blocksize
* s
->channels
; i
++) {
1219 int32_t v
= samples0
[i
] >> 8;
1220 *tmp
++ = (v
) & 0xFF;
1221 *tmp
++ = (v
>> 8) & 0xFF;
1222 *tmp
++ = (v
>> 16) & 0xFF;
1224 buf
= s
->md5_buffer
;
1226 av_md5_update(s
->md5ctx
, buf
, buf_size
);
1232 static int flac_encode_frame(AVCodecContext
*avctx
, AVPacket
*avpkt
,
1233 const AVFrame
*frame
, int *got_packet_ptr
)
1235 FlacEncodeContext
*s
;
1236 int frame_bytes
, out_bytes
, ret
;
1238 s
= avctx
->priv_data
;
1240 /* when the last block is reached, update the header in extradata */
1242 s
->max_framesize
= s
->max_encoded_framesize
;
1243 av_md5_final(s
->md5ctx
, s
->md5sum
);
1244 write_streaminfo(s
, avctx
->extradata
);
1246 if (avctx
->side_data_only_packets
&& !s
->flushed
) {
1247 uint8_t *side_data
= av_packet_new_side_data(avpkt
, AV_PKT_DATA_NEW_EXTRADATA
,
1248 avctx
->extradata_size
);
1250 return AVERROR(ENOMEM
);
1251 memcpy(side_data
, avctx
->extradata
, avctx
->extradata_size
);
1253 avpkt
->pts
= s
->next_pts
;
1255 *got_packet_ptr
= 1;
1262 /* change max_framesize for small final frame */
1263 if (frame
->nb_samples
< s
->frame
.blocksize
) {
1264 s
->max_framesize
= ff_flac_get_max_frame_size(frame
->nb_samples
,
1266 avctx
->bits_per_raw_sample
);
1269 init_frame(s
, frame
->nb_samples
);
1271 copy_samples(s
, frame
->data
[0]);
1273 channel_decorrelation(s
);
1275 remove_wasted_bits(s
);
1277 frame_bytes
= encode_frame(s
);
1279 /* Fall back on verbatim mode if the compressed frame is larger than it
1280 would be if encoded uncompressed. */
1281 if (frame_bytes
< 0 || frame_bytes
> s
->max_framesize
) {
1282 s
->frame
.verbatim_only
= 1;
1283 frame_bytes
= encode_frame(s
);
1284 if (frame_bytes
< 0) {
1285 av_log(avctx
, AV_LOG_ERROR
, "Bad frame count\n");
1290 if ((ret
= ff_alloc_packet2(avctx
, avpkt
, frame_bytes
)) < 0)
1293 out_bytes
= write_frame(s
, avpkt
);
1296 s
->sample_count
+= frame
->nb_samples
;
1297 if ((ret
= update_md5_sum(s
, frame
->data
[0])) < 0) {
1298 av_log(avctx
, AV_LOG_ERROR
, "Error updating MD5 checksum\n");
1301 if (out_bytes
> s
->max_encoded_framesize
)
1302 s
->max_encoded_framesize
= out_bytes
;
1303 if (out_bytes
< s
->min_framesize
)
1304 s
->min_framesize
= out_bytes
;
1306 avpkt
->pts
= frame
->pts
;
1307 avpkt
->duration
= ff_samples_to_time_base(avctx
, frame
->nb_samples
);
1308 avpkt
->size
= out_bytes
;
1310 s
->next_pts
= avpkt
->pts
+ avpkt
->duration
;
1312 *got_packet_ptr
= 1;
1317 static av_cold
int flac_encode_close(AVCodecContext
*avctx
)
1319 if (avctx
->priv_data
) {
1320 FlacEncodeContext
*s
= avctx
->priv_data
;
1321 av_freep(&s
->md5ctx
);
1322 av_freep(&s
->md5_buffer
);
1323 ff_lpc_end(&s
->lpc_ctx
);
1325 av_freep(&avctx
->extradata
);
1326 avctx
->extradata_size
= 0;
1330 #define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
1331 static const AVOption options
[] = {
1332 { "lpc_coeff_precision", "LPC coefficient precision", offsetof(FlacEncodeContext
, options
.lpc_coeff_precision
), AV_OPT_TYPE_INT
, {.i64
= 15 }, 0, MAX_LPC_PRECISION
, FLAGS
},
1333 { "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" },
1334 { "none", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= FF_LPC_TYPE_NONE
}, INT_MIN
, INT_MAX
, FLAGS
, "lpc_type" },
1335 { "fixed", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= FF_LPC_TYPE_FIXED
}, INT_MIN
, INT_MAX
, FLAGS
, "lpc_type" },
1336 { "levinson", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= FF_LPC_TYPE_LEVINSON
}, INT_MIN
, INT_MAX
, FLAGS
, "lpc_type" },
1337 { "cholesky", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= FF_LPC_TYPE_CHOLESKY
}, INT_MIN
, INT_MAX
, FLAGS
, "lpc_type" },
1338 { "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
},
1339 { "min_partition_order", NULL
, offsetof(FlacEncodeContext
, options
.min_partition_order
), AV_OPT_TYPE_INT
, {.i64
= -1 }, -1, MAX_PARTITION_ORDER
, FLAGS
},
1340 { "max_partition_order", NULL
, offsetof(FlacEncodeContext
, options
.max_partition_order
), AV_OPT_TYPE_INT
, {.i64
= -1 }, -1, MAX_PARTITION_ORDER
, FLAGS
},
1341 { "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" },
1342 { "estimation", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_EST
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1343 { "2level", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_2LEVEL
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1344 { "4level", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_4LEVEL
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1345 { "8level", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_8LEVEL
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1346 { "search", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_SEARCH
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1347 { "log", NULL
, 0, AV_OPT_TYPE_CONST
, {.i64
= ORDER_METHOD_LOG
}, INT_MIN
, INT_MAX
, FLAGS
, "predm" },
1348 { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext
, options
.ch_mode
), AV_OPT_TYPE_INT
, { .i64
= -1 }, -1, FLAC_CHMODE_MID_SIDE
, FLAGS
, "ch_mode" },
1349 { "auto", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= -1 }, INT_MIN
, INT_MAX
, FLAGS
, "ch_mode" },
1350 { "indep", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= FLAC_CHMODE_INDEPENDENT
}, INT_MIN
, INT_MAX
, FLAGS
, "ch_mode" },
1351 { "left_side", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= FLAC_CHMODE_LEFT_SIDE
}, INT_MIN
, INT_MAX
, FLAGS
, "ch_mode" },
1352 { "right_side", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= FLAC_CHMODE_RIGHT_SIDE
}, INT_MIN
, INT_MAX
, FLAGS
, "ch_mode" },
1353 { "mid_side", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= FLAC_CHMODE_MID_SIDE
}, INT_MIN
, INT_MAX
, FLAGS
, "ch_mode" },
1357 static const AVClass flac_encoder_class
= {
1359 av_default_item_name
,
1361 LIBAVUTIL_VERSION_INT
,
1364 AVCodec ff_flac_encoder
= {
1366 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
1367 .type
= AVMEDIA_TYPE_AUDIO
,
1368 .id
= AV_CODEC_ID_FLAC
,
1369 .priv_data_size
= sizeof(FlacEncodeContext
),
1370 .init
= flac_encode_init
,
1371 .encode2
= flac_encode_frame
,
1372 .close
= flac_encode_close
,
1373 .capabilities
= CODEC_CAP_SMALL_LAST_FRAME
| CODEC_CAP_DELAY
| CODEC_CAP_LOSSLESS
,
1374 .sample_fmts
= (const enum AVSampleFormat
[]){ AV_SAMPLE_FMT_S16
,
1376 AV_SAMPLE_FMT_NONE
},
1377 .priv_class
= &flac_encoder_class
,