FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/flacenc.c
Date: 2024-04-24 02:45:42
Exec Total Coverage
Lines: 722 850 84.9%
Functions: 36 38 94.7%
Branches: 401 617 65.0%
Line Branch Exec Source
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"
23 #include "libavutil/channel_layout.h"
24 #include "libavutil/crc.h"
25 #include "libavutil/intmath.h"
26 #include "libavutil/md5.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/opt.h"
29
30 #include "avcodec.h"
31 #include "bswapdsp.h"
32 #include "codec_internal.h"
33 #include "encode.h"
34 #include "put_bits.h"
35 #include "lpc.h"
36 #include "flac.h"
37 #include "flacdata.h"
38 #include "flacencdsp.h"
39
40 #define FLAC_SUBFRAME_CONSTANT 0
41 #define FLAC_SUBFRAME_VERBATIM 1
42 #define FLAC_SUBFRAME_FIXED 8
43 #define FLAC_SUBFRAME_LPC 32
44
45 #define MAX_FIXED_ORDER 4
46 #define MAX_PARTITION_ORDER 8
47 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
48 #define MAX_LPC_PRECISION 15
49 #define MIN_LPC_SHIFT 0
50 #define MAX_LPC_SHIFT 15
51
52 enum CodingMode {
53 CODING_MODE_RICE = 4,
54 CODING_MODE_RICE2 = 5,
55 };
56
57 typedef struct CompressionOptions {
58 int compression_level;
59 int block_time_ms;
60 enum FFLPCType lpc_type;
61 int lpc_passes;
62 int lpc_coeff_precision;
63 int min_prediction_order;
64 int max_prediction_order;
65 int prediction_order_method;
66 int min_partition_order;
67 int max_partition_order;
68 int ch_mode;
69 int exact_rice_parameters;
70 int multi_dim_quant;
71 } CompressionOptions;
72
73 typedef struct RiceContext {
74 enum CodingMode coding_mode;
75 int porder;
76 int params[MAX_PARTITIONS];
77 } RiceContext;
78
79 typedef struct FlacSubframe {
80 int type;
81 int type_code;
82 int obits;
83 int wasted;
84 int order;
85 int32_t coefs[MAX_LPC_ORDER];
86 int shift;
87
88 RiceContext rc;
89 uint32_t rc_udata[FLAC_MAX_BLOCKSIZE];
90 uint64_t rc_sums[32][MAX_PARTITIONS];
91
92 int32_t samples[FLAC_MAX_BLOCKSIZE];
93 int32_t residual[FLAC_MAX_BLOCKSIZE+11];
94 } FlacSubframe;
95
96 typedef struct FlacFrame {
97 FlacSubframe subframes[FLAC_MAX_CHANNELS];
98 int64_t samples_33bps[FLAC_MAX_BLOCKSIZE];
99 int blocksize;
100 int bs_code[2];
101 uint8_t crc8;
102 int ch_mode;
103 int verbatim_only;
104 } FlacFrame;
105
106 typedef struct FlacEncodeContext {
107 AVClass *class;
108 PutBitContext pb;
109 int channels;
110 int samplerate;
111 int sr_code[2];
112 int bps_code;
113 int max_blocksize;
114 int min_framesize;
115 int max_framesize;
116 int max_encoded_framesize;
117 uint32_t frame_count;
118 uint64_t sample_count;
119 uint8_t md5sum[16];
120 FlacFrame frame;
121 CompressionOptions options;
122 AVCodecContext *avctx;
123 LPCContext lpc_ctx;
124 struct AVMD5 *md5ctx;
125 uint8_t *md5_buffer;
126 unsigned int md5_buffer_size;
127 BswapDSPContext bdsp;
128 FLACEncDSPContext flac_dsp;
129
130 int flushed;
131 int64_t next_pts;
132 } FlacEncodeContext;
133
134
135 /**
136 * Write streaminfo metadata block to byte array.
137 */
138 175 static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
139 {
140 PutBitContext pb;
141
142 175 memset(header, 0, FLAC_STREAMINFO_SIZE);
143 175 init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
144
145 /* streaminfo metadata block */
146 175 put_bits(&pb, 16, s->max_blocksize);
147 175 put_bits(&pb, 16, s->max_blocksize);
148 175 put_bits(&pb, 24, s->min_framesize);
149 175 put_bits(&pb, 24, s->max_framesize);
150 175 put_bits(&pb, 20, s->samplerate);
151 175 put_bits(&pb, 3, s->channels-1);
152 175 put_bits(&pb, 5, s->avctx->bits_per_raw_sample - 1);
153 /* write 36-bit sample count in 2 put_bits() calls */
154 175 put_bits(&pb, 24, (s->sample_count & 0xFFFFFF000LL) >> 12);
155 175 put_bits(&pb, 12, s->sample_count & 0x000000FFFLL);
156 175 flush_put_bits(&pb);
157 175 memcpy(&header[18], s->md5sum, 16);
158 175 }
159
160
161 /**
162 * Calculate an estimate for the maximum frame size based on verbatim mode.
163 * @param blocksize block size, in samples
164 * @param ch number of channels
165 * @param bps bits-per-sample
166 */
167 119 static int flac_get_max_frame_size(int blocksize, int ch, int bps)
168 {
169 /* Technically, there is no limit to FLAC frame size, but an encoder
170 should not write a frame that is larger than if verbatim encoding mode
171 were to be used. */
172
173 int count;
174
175 119 count = 16; /* frame header */
176 119 count += ch * ((7+bps+7)/8); /* subframe headers */
177
2/2
✓ Branch 0 taken 74 times.
✓ Branch 1 taken 45 times.
 119 if (ch == 2) {
178 /* for stereo, need to account for using decorrelation */
179 74 count += (( 2*bps+1) * blocksize + 7) / 8;
180 } else {
181 45 count += ( ch*bps * blocksize + 7) / 8;
182 }
183 119 count += 2; /* frame footer */
184
185 119 return count;
186 }
187
188
189 /**
190 * Set blocksize based on samplerate.
191 * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.
192 */
193 69 static int select_blocksize(int samplerate, int block_time_ms)
194 {
195 int i;
196 int target;
197 int blocksize;
198
199
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 av_assert0(samplerate > 0);
200 69 blocksize = ff_flac_blocksize_table[1];
201 69 target = (samplerate * block_time_ms) / 1000;
202
2/2
✓ Branch 0 taken 1104 times.
✓ Branch 1 taken 69 times.
 1173 for (i = 0; i < 16; i++) {
203
2/2
✓ Branch 0 taken 875 times.
✓ Branch 1 taken 229 times.
 1104 if (target >= ff_flac_blocksize_table[i] &&
204
2/2
✓ Branch 0 taken 270 times.
✓ Branch 1 taken 605 times.
 875 ff_flac_blocksize_table[i] > blocksize) {
205 270 blocksize = ff_flac_blocksize_table[i];
206 }
207 }
208 69 return blocksize;
209 }
210
211
212 69 static av_cold void dprint_compression_options(FlacEncodeContext *s)
213 {
214 69 AVCodecContext *avctx = s->avctx;
215 69 CompressionOptions *opt = &s->options;
216
217 69 av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level);
218
219
3/5
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 65 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 69 switch (opt->lpc_type) {
220 ✗ case FF_LPC_TYPE_NONE:
221 ✗ av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");
222 ✗ break;
223 3 case FF_LPC_TYPE_FIXED:
224 3 av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n");
225 3 break;
226 65 case FF_LPC_TYPE_LEVINSON:
227 65 av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n");
228 65 break;
229 1 case FF_LPC_TYPE_CHOLESKY:
230 1 av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",
231
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 opt->lpc_passes, opt->lpc_passes == 1 ? "" : "es");
232 1 break;
233 }
234
235 69 av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
236 opt->min_prediction_order, opt->max_prediction_order);
237
238
2/7
✓ Branch 0 taken 68 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
 69 switch (opt->prediction_order_method) {
239 68 case ORDER_METHOD_EST:
240 68 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate");
241 68 break;
242 ✗ case ORDER_METHOD_2LEVEL:
243 ✗ av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level");
244 ✗ break;
245 1 case ORDER_METHOD_4LEVEL:
246 1 av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level");
247 1 break;
248 ✗ case ORDER_METHOD_8LEVEL:
249 ✗ av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level");
250 ✗ break;
251 ✗ case ORDER_METHOD_SEARCH:
252 ✗ av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search");
253 ✗ break;
254 ✗ case ORDER_METHOD_LOG:
255 ✗ av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search");
256 ✗ break;
257 }
258
259
260 69 av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
261 opt->min_partition_order, opt->max_partition_order);
262
263 69 av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size);
264
265 69 av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
266 opt->lpc_coeff_precision);
267 69 }
268
269
270 69 static av_cold int flac_encode_init(AVCodecContext *avctx)
271 {
272 69 int freq = avctx->sample_rate;
273 69 int channels = avctx->ch_layout.nb_channels;
274 69 FlacEncodeContext *s = avctx->priv_data;
275 int i, level, ret;
276 uint8_t *streaminfo;
277
278 69 s->avctx = avctx;
279
280
2/3
✓ Branch 0 taken 67 times.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 69 switch (avctx->sample_fmt) {
281 67 case AV_SAMPLE_FMT_S16:
282 67 avctx->bits_per_raw_sample = 16;
283 67 s->bps_code = 4;
284 67 break;
285 2 case AV_SAMPLE_FMT_S32:
286
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (avctx->bits_per_raw_sample <= 24) {
287
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (avctx->bits_per_raw_sample < 24)
288 ✗ av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n");
289 1 avctx->bits_per_raw_sample = 24;
290 1 s->bps_code = 6;
291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 } else if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
292 ✗ av_log(avctx, AV_LOG_WARNING,
293 "encoding as 24 bits-per-sample, more is considered "
294 "experimental. Add -strict experimental if you want "
295 "to encode more than 24 bits-per-sample\n");
296 ✗ avctx->bits_per_raw_sample = 24;
297 ✗ s->bps_code = 6;
298 } else {
299 1 avctx->bits_per_raw_sample = 32;
300 1 s->bps_code = 7;
301 }
302 2 break;
303 }
304
305
2/4
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 69 times.
 69 if (channels < 1 || channels > FLAC_MAX_CHANNELS) {
306 ✗ av_log(avctx, AV_LOG_ERROR, "%d channels not supported (max %d)\n",
307 channels, FLAC_MAX_CHANNELS);
308 ✗ return AVERROR(EINVAL);
309 }
310 69 s->channels = channels;
311
312 /* find samplerate in table */
313
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (freq < 1)
314 ✗ return AVERROR(EINVAL);
315
1/2
✓ Branch 0 taken 578 times.
✗ Branch 1 not taken.
 578 for (i = 1; i < 12; i++) {
316
2/2
✓ Branch 0 taken 69 times.
✓ Branch 1 taken 509 times.
 578 if (freq == ff_flac_sample_rate_table[i]) {
317 69 s->samplerate = ff_flac_sample_rate_table[i];
318 69 s->sr_code[0] = i;
319 69 s->sr_code[1] = 0;
320 69 break;
321 }
322 }
323 /* if not in table, samplerate is non-standard */
324
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (i == 12) {
325 ✗ if (freq % 1000 == 0 && freq < 255000) {
326 ✗ s->sr_code[0] = 12;
327 ✗ s->sr_code[1] = freq / 1000;
328 ✗ } else if (freq % 10 == 0 && freq < 655350) {
329 ✗ s->sr_code[0] = 14;
330 ✗ s->sr_code[1] = freq / 10;
331 ✗ } else if (freq < 65535) {
332 ✗ s->sr_code[0] = 13;
333 ✗ s->sr_code[1] = freq;
334 ✗ } else if (freq < 1048576) {
335 ✗ s->sr_code[0] = 0;
336 ✗ s->sr_code[1] = 0;
337 } else {
338 ✗ av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq);
339 ✗ return AVERROR(EINVAL);
340 }
341 ✗ s->samplerate = freq;
342 }
343
344 /* set compression option defaults based on avctx->compression_level */
345
2/2
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 3 times.
 69 if (avctx->compression_level < 0)
346 66 s->options.compression_level = 5;
347 else
348 3 s->options.compression_level = avctx->compression_level;
349
350 69 level = s->options.compression_level;
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (level > 12) {
352 ✗ av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
353 s->options.compression_level);
354 ✗ return AVERROR(EINVAL);
355 }
356
357 69 s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
358
359
2/2
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 3 times.
 69 if (s->options.lpc_type == FF_LPC_TYPE_DEFAULT)
360 66 s->options.lpc_type = ((int[]){ FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED, FF_LPC_TYPE_FIXED,
361 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
362 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
363 FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON, FF_LPC_TYPE_LEVINSON,
364 66 FF_LPC_TYPE_LEVINSON})[level];
365
366
1/2
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
 69 if (s->options.min_prediction_order < 0)
367 69 s->options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
368
1/2
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
 69 if (s->options.max_prediction_order < 0)
369 69 s->options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
370
371
1/2
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
 69 if (s->options.prediction_order_method < 0)
372 69 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
373 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
374 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL,
375 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
376 69 ORDER_METHOD_SEARCH})[level];
377
378
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (s->options.min_partition_order > s->options.max_partition_order) {
379 ✗ av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
380 s->options.min_partition_order, s->options.max_partition_order);
381 ✗ return AVERROR(EINVAL);
382 }
383
1/2
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
 69 if (s->options.min_partition_order < 0)
384 69 s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
385
1/2
✓ Branch 0 taken 69 times.
✗ Branch 1 not taken.
 69 if (s->options.max_partition_order < 0)
386 69 s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
387
388
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (s->options.lpc_type == FF_LPC_TYPE_NONE) {
389 ✗ s->options.min_prediction_order = 0;
390 ✗ s->options.max_prediction_order = 0;
391
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 66 times.
 69 } else if (s->options.lpc_type == FF_LPC_TYPE_FIXED) {
392
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (s->options.min_prediction_order > MAX_FIXED_ORDER) {
393 ✗ av_log(avctx, AV_LOG_WARNING,
394 "invalid min prediction order %d, clamped to %d\n",
395 s->options.min_prediction_order, MAX_FIXED_ORDER);
396 ✗ s->options.min_prediction_order = MAX_FIXED_ORDER;
397 }
398
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 2 times.
 3 if (s->options.max_prediction_order > MAX_FIXED_ORDER) {
399 1 av_log(avctx, AV_LOG_WARNING,
400 "invalid max prediction order %d, clamped to %d\n",
401 s->options.max_prediction_order, MAX_FIXED_ORDER);
402 1 s->options.max_prediction_order = MAX_FIXED_ORDER;
403 }
404 }
405
406
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (s->options.max_prediction_order < s->options.min_prediction_order) {
407 ✗ av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
408 s->options.min_prediction_order, s->options.max_prediction_order);
409 ✗ return AVERROR(EINVAL);
410 }
411
412
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (avctx->frame_size > 0) {
413 ✗ if (avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
414 ✗ avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
415 ✗ av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
416 avctx->frame_size);
417 ✗ return AVERROR(EINVAL);
418 }
419 } else {
420 69 s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms);
421 }
422 69 s->max_blocksize = s->avctx->frame_size;
423
424 /* set maximum encoded frame size in verbatim mode */
425 138 s->max_framesize = flac_get_max_frame_size(s->avctx->frame_size,
426 s->channels,
427 69 s->avctx->bits_per_raw_sample);
428
429 /* initialize MD5 context */
430 69 s->md5ctx = av_md5_alloc();
431
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (!s->md5ctx)
432 ✗ return AVERROR(ENOMEM);
433 69 av_md5_init(s->md5ctx);
434
435 69 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
436
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 69 times.
 69 if (!streaminfo)
437 ✗ return AVERROR(ENOMEM);
438 69 write_streaminfo(s, streaminfo);
439 69 avctx->extradata = streaminfo;
440 69 avctx->extradata_size = FLAC_STREAMINFO_SIZE;
441
442 69 s->frame_count = 0;
443 69 s->min_framesize = s->max_framesize;
444
445
3/4
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 65 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
 73 if ((channels == 3 &&
446
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 69 times.
 73 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_SURROUND)) ||
447 ✗ (channels == 4 &&
448 ✗ av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_2_2) &&
449
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 69 times.
 69 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_QUAD)) ||
450 ✗ (channels == 5 &&
451 ✗ av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0) &&
452
2/2
✓ Branch 1 taken 7 times.
✓ Branch 2 taken 62 times.
 69 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT0_BACK)) ||
453
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 1 times.
 7 (channels == 6 &&
454
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
 13 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1) &&
455 6 av_channel_layout_compare(&avctx->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_5POINT1_BACK))) {
456 ✗ if (avctx->ch_layout.order != AV_CHANNEL_ORDER_UNSPEC) {
457 ✗ av_log(avctx, AV_LOG_ERROR, "Channel layout not supported by Flac, "
458 "output stream will have incorrect "
459 "channel layout.\n");
460 } else {
461 ✗ av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
462 "will use Flac channel layout for "
463 "%d channels.\n", channels);
464 }
465 }
466
467 69 ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,
468 s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON);
469
470 69 ff_bswapdsp_init(&s->bdsp);
471 69 ff_flacencdsp_init(&s->flac_dsp);
472
473 69 dprint_compression_options(s);
474
475 69 return ret;
476 }
477
478
479 4844 static void init_frame(FlacEncodeContext *s, int nb_samples)
480 {
481 int i, ch;
482 FlacFrame *frame;
483
484 4844 frame = &s->frame;
485
486
2/2
✓ Branch 0 taken 34501 times.
✓ Branch 1 taken 50 times.
 34551 for (i = 0; i < 16; i++) {
487
2/2
✓ Branch 0 taken 4794 times.
✓ Branch 1 taken 29707 times.
 34501 if (nb_samples == ff_flac_blocksize_table[i]) {
488 4794 frame->blocksize = ff_flac_blocksize_table[i];
489 4794 frame->bs_code[0] = i;
490 4794 frame->bs_code[1] = 0;
491 4794 break;
492 }
493 }
494
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 4794 times.
 4844 if (i == 16) {
495 50 frame->blocksize = nb_samples;
496
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 50 times.
 50 if (frame->blocksize <= 256) {
497 ✗ frame->bs_code[0] = 6;
498 ✗ frame->bs_code[1] = frame->blocksize-1;
499 } else {
500 50 frame->bs_code[0] = 7;
501 50 frame->bs_code[1] = frame->blocksize-1;
502 }
503 }
504
505
2/2
✓ Branch 0 taken 13614 times.
✓ Branch 1 taken 4844 times.
 18458 for (ch = 0; ch < s->channels; ch++) {
506 13614 FlacSubframe *sub = &frame->subframes[ch];
507
508 13614 sub->wasted = 0;
509 13614 sub->obits = s->avctx->bits_per_raw_sample;
510
511
2/2
✓ Branch 0 taken 256 times.
✓ Branch 1 taken 13358 times.
 13614 if (sub->obits > 16)
512 256 sub->rc.coding_mode = CODING_MODE_RICE2;
513 else
514 13358 sub->rc.coding_mode = CODING_MODE_RICE;
515 }
516
517 4844 frame->verbatim_only = 0;
518 4844 }
519
520
521 /**
522 * Copy channel-interleaved input samples into separate subframes.
523 */
524 4844 static void copy_samples(FlacEncodeContext *s, const void *samples)
525 {
526 int i, j, ch;
527 FlacFrame *frame;
528
529 #define COPY_SAMPLES(bits, shift0) do { \
530 const int ## bits ## _t *samples0 = samples; \
531 const int shift = shift0; \
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
2/2
✓ Branch 0 taken 4716 times.
✓ Branch 1 taken 128 times.
 4844 if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16)
539
4/4
✓ Branch 0 taken 78380250 times.
✓ Branch 1 taken 26255791 times.
✓ Branch 2 taken 26255791 times.
✓ Branch 3 taken 4716 times.
 104640757 COPY_SAMPLES(16, 0);
540 else
541
4/4
✓ Branch 0 taken 3928266 times.
✓ Branch 1 taken 1964133 times.
✓ Branch 2 taken 1964133 times.
✓ Branch 3 taken 128 times.
 5892527 COPY_SAMPLES(32, 32 - s->avctx->bits_per_raw_sample);
542 4844 }
543
544
545 99307 static uint64_t rice_count_exact(const int32_t *res, int n, int k)
546 {
547 int i;
548 99307 uint64_t count = 0;
549
550
2/2
✓ Branch 0 taken 46427218 times.
✓ Branch 1 taken 99307 times.
 46526525 for (i = 0; i < n; i++) {
551 46427218 unsigned v = ((unsigned)(res[i]) << 1) ^ (res[i] >> 31);
552 46427218 count += (v >> k) + 1 + k;
553 }
554 99307 return count;
555 }
556
557
558 13614 static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub,
559 int pred_order)
560 {
561 int p, porder, psize;
562 int i, part_end;
563 13614 uint64_t count = 0;
564
565 /* subframe header */
566 13614 count += 8;
567
568
2/2
✓ Branch 0 taken 5212 times.
✓ Branch 1 taken 8402 times.
 13614 if (sub->wasted)
569 5212 count += sub->wasted;
570
571 /* subframe */
572
2/2
✓ Branch 0 taken 5776 times.
✓ Branch 1 taken 7838 times.
 13614 if (sub->type == FLAC_SUBFRAME_CONSTANT) {
573 5776 count += sub->obits;
574
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7837 times.
 7838 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
575 1 count += s->frame.blocksize * sub->obits;
576 } else {
577 /* warm-up samples */
578 7837 count += pred_order * sub->obits;
579
580 /* LPC coefficients */
581
2/2
✓ Branch 0 taken 6963 times.
✓ Branch 1 taken 874 times.
 7837 if (sub->type == FLAC_SUBFRAME_LPC)
582 6963 count += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
583
584 /* rice-encoded block */
585 7837 count += 2;
586
587 /* partition order */
588 7837 porder = sub->rc.porder;
589 7837 psize = s->frame.blocksize >> porder;
590 7837 count += 4;
591
592 /* residual */
593 7837 i = pred_order;
594 7837 part_end = psize;
595
2/2
✓ Branch 0 taken 99307 times.
✓ Branch 1 taken 7837 times.
 107144 for (p = 0; p < 1 << porder; p++) {
596 99307 int k = sub->rc.params[p];
597 99307 count += sub->rc.coding_mode;
598 99307 count += rice_count_exact(&sub->residual[i], part_end - i, k);
599 99307 i = part_end;
600 99307 part_end = FFMIN(s->frame.blocksize, part_end + psize);
601 }
602 }
603
604 13614 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 31226548 static int find_optimal_param(uint64_t sum, int n, int max_param)
614 {
615 int k;
616 uint64_t sum2;
617
618
2/2
✓ Branch 0 taken 1394535 times.
✓ Branch 1 taken 29832013 times.
 31226548 if (sum <= n >> 1)
619 1394535 return 0;
620 29832013 sum2 = sum - (n >> 1);
621 29832013 k = av_log2(av_clipl_int32(sum2 / n));
622 29832013 return FFMIN(k, max_param);
623 }
624
625 27285 static int find_optimal_param_exact(uint64_t sums[32][MAX_PARTITIONS], int i, int max_param)
626 {
627 27285 int bestk = 0;
628 27285 int64_t bestbits = INT64_MAX;
629 int k;
630
631
2/2
✓ Branch 0 taken 409275 times.
✓ Branch 1 taken 27285 times.
 436560 for (k = 0; k <= max_param; k++) {
632 409275 int64_t bits = sums[k][i];
633
2/2
✓ Branch 0 taken 253571 times.
✓ Branch 1 taken 155704 times.
 409275 if (bits < bestbits) {
634 253571 bestbits = bits;
635 253571 bestk = k;
636 }
637 }
638
639 27285 return bestk;
640 }
641
642 668271 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 668271 part = (1 << porder);
651 668271 all_bits = 4 * part;
652
653 668271 cnt = (n >> porder) - pred_order;
654
2/2
✓ Branch 0 taken 31243089 times.
✓ Branch 1 taken 668271 times.
 31911360 for (i = 0; i < part; i++) {
655
2/2
✓ Branch 0 taken 27285 times.
✓ Branch 1 taken 31215804 times.
 31243089 if (exact) {
656 27285 k = find_optimal_param_exact(sums, i, max_param);
657 27285 all_bits += sums[k][i];
658 } else {
659 31215804 k = find_optimal_param(sums[0][i], cnt, max_param);
660 31215804 all_bits += rice_encode_count(sums[0][i], cnt, k);
661 }
662 31243089 rc->params[i] = k;
663 31243089 cnt = n >> porder;
664 }
665
666 668271 rc->porder = porder;
667
668 668271 return all_bits;
669 }
670
671
672 91191 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 91191 parts = (1 << pmax);
681
682
2/2
✓ Branch 0 taken 116657 times.
✓ Branch 1 taken 91191 times.
 207848 for (k = 0; k <= kmax; k++) {
683 116657 res = &data[pred_order];
684 116657 res_end = &data[n >> pmax];
685
2/2
✓ Branch 0 taken 15870868 times.
✓ Branch 1 taken 116657 times.
 15987525 for (i = 0; i < parts; i++) {
686
2/2
✓ Branch 0 taken 218280 times.
✓ Branch 1 taken 15652588 times.
 15870868 if (kmax) {
687 218280 uint64_t sum = (1LL + k) * (res_end - res);
688
2/2
✓ Branch 0 taken 31324725 times.
✓ Branch 1 taken 218280 times.
 31543005 while (res < res_end)
689 31324725 sum += *(res++) >> k;
690 218280 sums[k][i] = sum;
691 } else {
692 15652588 uint64_t sum = 0;
693
2/2
✓ Branch 0 taken 407817168 times.
✓ Branch 1 taken 15652588 times.
 423469756 while (res < res_end)
694 407817168 sum += *(res++);
695 15652588 sums[k][i] = sum;
696 }
697 15870868 res_end += n >> pmax;
698 }
699 }
700 91191 }
701
702 577080 static void calc_sum_next(int level, uint64_t sums[32][MAX_PARTITIONS], int kmax)
703 {
704 int i, k;
705 577080 int parts = (1 << level);
706
2/2
✓ Branch 0 taken 15575949 times.
✓ Branch 1 taken 577080 times.
 16153029 for (i = 0; i < parts; i++) {
707
2/2
✓ Branch 0 taken 15754211 times.
✓ Branch 1 taken 15575949 times.
 31330160 for (k=0; k<=kmax; k++)
708 15754211 sums[k][i] = sums[k][2*i] + sums[k][2*i+1];
709 }
710 577080 }
711
712 91191 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 91191 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 91191 tmp_rc.coding_mode = rc->coding_mode;
729
730
2/2
✓ Branch 0 taken 409905483 times.
✓ Branch 1 taken 91191 times.
 409996674 for (i = pred_order; i < n; i++)
731 409905483 udata[i] = ((unsigned)(data[i]) << 1) ^ (data[i] >> 31);
732
733
2/2
✓ Branch 0 taken 1819 times.
✓ Branch 1 taken 89372 times.
 91191 calc_sum_top(pmax, exact ? kmax : 0, udata, n, pred_order, sums);
734
735 91191 opt_porder = pmin;
736 91191 bits[pmin] = UINT32_MAX;
737 91191 for (i = pmax; ; ) {
738 668271 bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums, n, pred_order, kmax, exact);
739
4/4
✓ Branch 0 taken 278141 times.
✓ Branch 1 taken 390130 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 278137 times.
 668271 if (bits[i] < bits[opt_porder] || pmax == pmin) {
740 390134 opt_porder = i;
741 390134 *rc = tmp_rc;
742 }
743
2/2
✓ Branch 0 taken 91191 times.
✓ Branch 1 taken 577080 times.
 668271 if (i == pmin)
744 91191 break;
745
2/2
✓ Branch 0 taken 5457 times.
✓ Branch 1 taken 571623 times.
 577080 calc_sum_next(--i, sums, exact ? kmax : 0);
746 }
747
748 91191 return bits[opt_porder];
749 }
750
751
752 182382 static int get_max_p_order(int max_porder, int n, int order)
753 {
754 182382 int porder = FFMIN(max_porder, av_log2(n^(n-1)));
755
2/2
✓ Branch 0 taken 180802 times.
✓ Branch 1 taken 1580 times.
 182382 if (order > 0)
756 180802 porder = FFMIN(porder, av_log2(n/order));
757 182382 return porder;
758 }
759
760
761 91191 static uint64_t find_subframe_rice_params(FlacEncodeContext *s,
762 FlacSubframe *sub, int pred_order)
763 {
764 91191 int pmin = get_max_p_order(s->options.min_partition_order,
765 s->frame.blocksize, pred_order);
766 91191 int pmax = get_max_p_order(s->options.max_partition_order,
767 s->frame.blocksize, pred_order);
768
769 91191 uint64_t bits = 8 + pred_order * sub->obits + 2 + sub->rc.coding_mode;
770
2/2
✓ Branch 0 taken 86639 times.
✓ Branch 1 taken 4552 times.
 91191 if (sub->type == FLAC_SUBFRAME_LPC)
771 86639 bits += 4 + 5 + pred_order * s->options.lpc_coeff_precision;
772 91191 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 91191 return bits;
775 }
776
777
778 4552 static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
779 int order)
780 {
781 int i;
782
783
2/2
✓ Branch 0 taken 9292 times.
✓ Branch 1 taken 4552 times.
 13844 for (i = 0; i < order; i++)
784 9292 res[i] = smp[i];
785
786
2/2
✓ Branch 0 taken 790 times.
✓ Branch 1 taken 3762 times.
 4552 if (order == 0) {
787
2/2
✓ Branch 0 taken 908640 times.
✓ Branch 1 taken 790 times.
 909430 for (i = order; i < n; i++)
788 908640 res[i] = smp[i];
789
2/2
✓ Branch 0 taken 932 times.
✓ Branch 1 taken 2830 times.
 3762 } else if (order == 1) {
790
2/2
✓ Branch 0 taken 1899976 times.
✓ Branch 1 taken 932 times.
 1900908 for (i = order; i < n; i++)
791 1899976 res[i] = smp[i] - smp[i-1];
792
2/2
✓ Branch 0 taken 1004 times.
✓ Branch 1 taken 1826 times.
 2830 } else if (order == 2) {
793 1004 int a = smp[order-1] - smp[order-2];
794
2/2
✓ Branch 0 taken 1090768 times.
✓ Branch 1 taken 1004 times.
 1091772 for (i = order; i < n; i += 2) {
795 1090768 int b = smp[i ] - smp[i-1];
796 1090768 res[i] = b - a;
797 1090768 a = smp[i+1] - smp[i ];
798 1090768 res[i+1] = a - b;
799 }
800
2/2
✓ Branch 0 taken 952 times.
✓ Branch 1 taken 874 times.
 1826 } else if (order == 3) {
801 952 int a = smp[order-1] - smp[order-2];
802 952 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
803
2/2
✓ Branch 0 taken 874622 times.
✓ Branch 1 taken 952 times.
 875574 for (i = order; i < n; i += 2) {
804 874622 int b = smp[i ] - smp[i-1];
805 874622 int d = b - a;
806 874622 res[i] = d - c;
807 874622 a = smp[i+1] - smp[i ];
808 874622 c = a - b;
809 874622 res[i+1] = c - d;
810 }
811 } else {
812 874 int a = smp[order-1] - smp[order-2];
813 874 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
814 874 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
815
2/2
✓ Branch 0 taken 815074 times.
✓ Branch 1 taken 874 times.
 815948 for (i = order; i < n; i += 2) {
816 815074 int b = smp[i ] - smp[i-1];
817 815074 int d = b - a;
818 815074 int f = d - c;
819 815074 res[i ] = f - e;
820 815074 a = smp[i+1] - smp[i ];
821 815074 c = a - b;
822 815074 e = c - d;
823 815074 res[i+1] = e - f;
824 }
825 }
826 4552 }
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
876 ✗ static int encode_residual_fixed_with_residual_limit(int32_t *res, const int32_t *smp,
877 int n, int order)
878 {
879 ✗ ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT();
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 {
886 ✗ ENCODE_RESIDUAL_FIXED_WITH_RESIDUAL_LIMIT();
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 13 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 {
909
8/10
✓ Branch 0 taken 94 times.
✓ Branch 1 taken 13 times.
✓ Branch 2 taken 401314 times.
✓ Branch 3 taken 55916 times.
✓ Branch 4 taken 55916 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 55916 times.
✓ Branch 8 taken 55916 times.
✓ Branch 9 taken 13 times.
 457337 LPC_ENCODE_WITH_RESIDUAL_LIMIT();
910 }
911
912 3 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 {
915
9/10
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 3 times.
✓ Branch 2 taken 73840 times.
✓ Branch 3 taken 9230 times.
✓ Branch 4 taken 9230 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 times.
✓ Branch 7 taken 9229 times.
✓ Branch 8 taken 9230 times.
✓ Branch 9 taken 2 times.
 83096 LPC_ENCODE_WITH_RESIDUAL_LIMIT();
916 }
917
918 86640 static int lpc_encode_choose_datapath(FlacEncodeContext *s, int32_t bps,
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 86640 uint64_t max_residual_value = 0;
924 86640 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
2/2
✓ Branch 0 taken 649749 times.
✓ Branch 1 taken 86640 times.
 736389 for (int i = 0; i < order; i++)
928 649749 max_residual_value += FFABS(max_sample_value * coefs[i]);
929 86640 max_residual_value >>= shift;
930 86640 max_residual_value += max_sample_value;
931
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 86637 times.
 86640 if (bps > 32) {
932
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 2 times.
 3 if (lpc_encode_with_residual_limit_33bps(res, smp_33bps, len, order, coefs, shift))
933 1 return 1;
934
2/2
✓ Branch 0 taken 13 times.
✓ Branch 1 taken 86624 times.
 86637 } else if (max_residual_value > INT32_MAX) {
935
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
 13 if (lpc_encode_with_residual_limit(res, smp, len, order, coefs, shift))
936 ✗ return 1;
937
2/2
✓ Branch 0 taken 5213 times.
✓ Branch 1 taken 81411 times.
 86624 } else if (bps + s->options.lpc_coeff_precision + av_log2(order) <= 32) {
938 5213 s->flac_dsp.lpc16_encode(res, smp, len, order, coefs, shift);
939 } else {
940 81411 s->flac_dsp.lpc32_encode(res, smp, len, order, coefs, shift);
941 }
942 86639 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
953 13614 static int encode_residual_ch(FlacEncodeContext *s, int ch)
954 {
955 int i, n;
956 int min_order, max_order, opt_order, omethod;
957 FlacFrame *frame;
958 FlacSubframe *sub;
959 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
960 int shift[MAX_LPC_ORDER];
961 int32_t *res, *smp;
962 int64_t *smp_33bps;
963
964 13614 frame = &s->frame;
965 13614 sub = &frame->subframes[ch];
966 13614 res = sub->residual;
967 13614 smp = sub->samples;
968 13614 smp_33bps = frame->samples_33bps;
969 13614 n = frame->blocksize;
970
971 /* CONSTANT */
972
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 13611 times.
 13614 if (sub->obits > 32) {
973
1/2
✓ Branch 0 taken 3764 times.
✗ Branch 1 not taken.
 3764 for (i = 1; i < n; i++)
974
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 3761 times.
 3764 if(smp_33bps[i] != smp_33bps[0])
975 3 break;
976
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 if (i == n) {
977 ✗ sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
978 ✗ return subframe_count_exact(s, sub, 0);
979 }
980 } else {
981
2/2
✓ Branch 0 taken 35910903 times.
✓ Branch 1 taken 5776 times.
 35916679 for (i = 1; i < n; i++)
982
2/2
✓ Branch 0 taken 7835 times.
✓ Branch 1 taken 35903068 times.
 35910903 if(smp[i] != smp[0])
983 7835 break;
984
2/2
✓ Branch 0 taken 5776 times.
✓ Branch 1 taken 7835 times.
 13611 if (i == n) {
985 5776 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
986 5776 res[0] = smp[0];
987 5776 return subframe_count_exact(s, sub, 0);
988 }
989 }
990
991 /* VERBATIM */
992
2/4
✓ Branch 0 taken 7838 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7838 times.
 7838 if (frame->verbatim_only || n < 5) {
993 ✗ DEFAULT_TO_VERBATIM();
994 }
995
996 7838 min_order = s->options.min_prediction_order;
997 7838 max_order = s->options.max_prediction_order;
998 7838 omethod = s->options.prediction_order_method;
999
1000 /* FIXED */
1001 7838 sub->type = FLAC_SUBFRAME_FIXED;
1002
1/2
✓ Branch 0 taken 7838 times.
✗ Branch 1 not taken.
 7838 if (s->options.lpc_type == FF_LPC_TYPE_NONE ||
1003
3/4
✓ Branch 0 taken 6964 times.
✓ Branch 1 taken 874 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6964 times.
 7838 s->options.lpc_type == FF_LPC_TYPE_FIXED || n <= max_order) {
1004 uint64_t bits[MAX_FIXED_ORDER+1];
1005
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 874 times.
 874 if (max_order > MAX_FIXED_ORDER)
1006 ✗ max_order = MAX_FIXED_ORDER;
1007 874 opt_order = 0;
1008 874 bits[0] = UINT32_MAX;
1009
2/2
✓ Branch 0 taken 4188 times.
✓ Branch 1 taken 874 times.
 5062 for (i = min_order; i <= max_order; i++) {
1010
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4188 times.
 4188 if (sub->obits == 33) {
1011 ✗ if (encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, i))
1012 ✗ continue;
1013
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4188 times.
 4188 } else if (sub->obits + i >= 32) {
1014 ✗ if (encode_residual_fixed_with_residual_limit(res, smp, n, i))
1015 ✗ continue;
1016 } else
1017 4188 encode_residual_fixed(res, smp, n, i);
1018 4188 bits[i] = find_subframe_rice_params(s, sub, i);
1019
2/2
✓ Branch 0 taken 2592 times.
✓ Branch 1 taken 1596 times.
 4188 if (bits[i] < bits[opt_order])
1020 2592 opt_order = i;
1021 }
1022
3/4
✓ Branch 0 taken 98 times.
✓ Branch 1 taken 776 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 98 times.
 874 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 */
1025 ✗ DEFAULT_TO_VERBATIM();
1026 }
1027 874 sub->order = opt_order;
1028 874 sub->type_code = sub->type | sub->order;
1029
2/2
✓ Branch 0 taken 364 times.
✓ Branch 1 taken 510 times.
 874 if (sub->order != max_order) {
1030
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 364 times.
 364 if (sub->obits == 33)
1031 ✗ encode_residual_fixed_with_residual_limit_33bps(res, smp_33bps, n, sub->order);
1032
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 364 times.
 364 else if (sub->obits + i >= 32)
1033 ✗ encode_residual_fixed_with_residual_limit(res, smp, n, sub->order);
1034 else
1035 364 encode_residual_fixed(res, smp, n, sub->order);
1036 364 find_subframe_rice_params(s, sub, sub->order);
1037 }
1038 874 return subframe_count_exact(s, sub, sub->order);
1039 }
1040
1041 /* LPC */
1042 6964 sub->type = FLAC_SUBFRAME_LPC;
1043
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 6961 times.
 6964 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
2/2
✓ Branch 0 taken 13824 times.
✓ Branch 1 taken 3 times.
 13827 for (i = 0; i < n; i++)
1049 13824 smp[i] = smp_33bps[i] >> 1;
1050
1051 6964 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,
1054 MIN_LPC_SHIFT, MAX_LPC_SHIFT, 0);
1055
1056
3/4
✓ Branch 0 taken 6964 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6728 times.
✓ Branch 3 taken 236 times.
 6964 if (omethod == ORDER_METHOD_2LEVEL ||
1057
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6728 times.
 6728 omethod == ORDER_METHOD_4LEVEL ||
1058 236 omethod == ORDER_METHOD_8LEVEL) {
1059 236 int levels = 1 << omethod;
1060 uint64_t bits[1 << ORDER_METHOD_8LEVEL];
1061 236 int order = -1;
1062 236 int opt_index = levels-1;
1063 236 opt_order = max_order-1;
1064 236 bits[opt_index] = UINT32_MAX;
1065
2/2
✓ Branch 0 taken 944 times.
✓ Branch 1 taken 236 times.
 1180 for (i = levels-1; i >= 0; i--) {
1066 944 int last_order = order;
1067 944 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
1068 944 order = av_clip(order, min_order - 1, max_order - 1);
1069
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 944 times.
 944 if (order == last_order)
1070 ✗ continue;
1071
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 944 times.
 944 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, order+1, coefs[order], shift[order]))
1072 ✗ continue;
1073 944 bits[i] = find_subframe_rice_params(s, sub, order+1);
1074
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 886 times.
 944 if (bits[i] < bits[opt_index]) {
1075 58 opt_index = i;
1076 58 opt_order = order;
1077 }
1078 }
1079 236 opt_order++;
1080
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6728 times.
 6728 } 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;
1088 ✗ bits[i] = find_subframe_rice_params(s, sub, i+1);
1089 ✗ if (bits[i] < bits[opt_order])
1090 ✗ opt_order = i;
1091 }
1092 ✗ opt_order++;
1093
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6728 times.
 6728 } 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;
1107 ✗ bits[i] = find_subframe_rice_params(s, sub, i+1);
1108 ✗ if (bits[i] < bits[opt_order])
1109 ✗ opt_order = i;
1110 }
1111 }
1112 ✗ opt_order++;
1113 }
1114
1115
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6958 times.
 6964 if (s->options.multi_dim_quant) {
1116 6 int allsteps = 1;
1117 int i, step, improved;
1118 6 int64_t best_score = INT64_MAX;
1119 int32_t qmax;
1120
1121 6 qmax = (1 << (s->options.lpc_coeff_precision - 1)) - 1;
1122
1123
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 6 times.
 53 for (i=0; i<opt_order; i++)
1124 47 allsteps *= 3;
1125
1126 do {
1127 14 improved = 0;
1128
2/2
✓ Branch 0 taken 78732 times.
✓ Branch 1 taken 14 times.
 78746 for (step = 0; step < allsteps; step++) {
1129 78732 int tmp = step;
1130 int32_t lpc_try[MAX_LPC_ORDER];
1131 78732 int64_t score = 0;
1132 78732 int diffsum = 0;
1133
1134
2/2
✓ Branch 0 taken 623295 times.
✓ Branch 1 taken 78732 times.
 702027 for (i=0; i<opt_order; i++) {
1135 623295 int diff = ((tmp + 1) % 3) - 1;
1136 623295 lpc_try[i] = av_clip(coefs[opt_order - 1][i] + diff, -qmax, qmax);
1137 623295 tmp /= 3;
1138 623295 diffsum += !!diff;
1139 }
1140
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 78732 times.
 78732 if (diffsum >8)
1141 ✗ continue;
1142
1143
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 78732 times.
 78732 if(lpc_encode_choose_datapath(s, sub->obits, res, smp, smp_33bps, n, opt_order, lpc_try, shift[opt_order-1]))
1144 ✗ continue;
1145 78732 score = find_subframe_rice_params(s, sub, opt_order);
1146
2/2
✓ Branch 0 taken 467 times.
✓ Branch 1 taken 78265 times.
 78732 if (score < best_score) {
1147 467 best_score = score;
1148 467 memcpy(coefs[opt_order-1], lpc_try, sizeof(*coefs));
1149 467 improved=1;
1150 }
1151 }
1152
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
 14 } while(improved);
1153 }
1154
1155 6964 sub->order = opt_order;
1156 6964 sub->type_code = sub->type | (sub->order-1);
1157 6964 sub->shift = shift[sub->order-1];
1158
2/2
✓ Branch 0 taken 18666 times.
✓ Branch 1 taken 6964 times.
 25630 for (i = 0; i < sub->order; i++)
1159 18666 sub->coefs[i] = coefs[sub->order-1][i];
1160
1161
2/2
✓ Branch 1 taken 1 times.
✓ Branch 2 taken 6963 times.
 6964 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 */
1164
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 DEFAULT_TO_VERBATIM();
1165 }
1166
1167 6963 find_subframe_rice_params(s, sub, sub->order);
1168
1169 6963 return subframe_count_exact(s, sub, sub->order);
1170 }
1171
1172
1173 4844 static int count_frame_header(FlacEncodeContext *s)
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 4844 count = 32;
1189
1190 /* coded frame number */
1191
4/4
✓ Branch 0 taken 3488 times.
✓ Branch 1 taken 1356 times.
✓ Branch 2 taken 1356 times.
✓ Branch 3 taken 1356 times.
 6200 PUT_UTF8(s->frame_count, tmp, count += 8;)
1192
1193 /* explicit block size */
1194
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 if (s->frame.bs_code[0] == 6)
1195 ✗ count += 8;
1196
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 4794 times.
 4844 else if (s->frame.bs_code[0] == 7)
1197 50 count += 16;
1198
1199 /* explicit sample rate */
1200
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12) * 2) * 8;
1201
1202 /* frame header CRC-8 */
1203 4844 count += 8;
1204
1205 4844 return count;
1206 }
1207
1208
1209 4844 static int encode_frame(FlacEncodeContext *s)
1210 {
1211 int ch;
1212 uint64_t count;
1213
1214 4844 count = count_frame_header(s);
1215
1216
2/2
✓ Branch 0 taken 13614 times.
✓ Branch 1 taken 4844 times.
 18458 for (ch = 0; ch < s->channels; ch++)
1217 13614 count += encode_residual_ch(s, ch);
1218
1219 4844 count += (8 - (count & 7)) & 7; // byte alignment
1220 4844 count += 16; // CRC-16
1221
1222 4844 count >>= 3;
1223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 if (count > INT_MAX)
1224 ✗ return AVERROR_BUG;
1225 4844 return count;
1226 }
1227
1228
1229 4844 static void remove_wasted_bits(FlacEncodeContext *s)
1230 {
1231 int ch, i, wasted_bits;
1232
1233
2/2
✓ Branch 0 taken 8450 times.
✓ Branch 1 taken 1606 times.
 10056 for (ch = 0; ch < s->channels; ch++) {
1234 8450 FlacSubframe *sub = &s->frame.subframes[ch];
1235
1236
2/2
✓ Branch 0 taken 8 times.
✓ Branch 1 taken 8442 times.
 8450 if (sub->obits > 32) {
1237 8 int64_t v = 0;
1238
2/2
✓ Branch 0 taken 29481 times.
✓ Branch 1 taken 6 times.
 29487 for (i = 0; i < s->frame.blocksize; i++) {
1239 29481 v |= s->frame.samples_33bps[i];
1240
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 29479 times.
 29481 if (v & 1)
1241 2 break;
1242 }
1243
1244
3/4
✓ Branch 0 taken 8 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 6 times.
 8 if (!v || (v & 1))
1245 2 return;
1246
1247 6 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
2/2
✓ Branch 0 taken 25701 times.
✓ Branch 1 taken 6 times.
 25707 for (i = 0; i < s->frame.blocksize; i++)
1252 25701 sub->samples[i] = s->frame.samples_33bps[i] >> v;
1253 6 wasted_bits = v;
1254 } else {
1255 8442 int32_t v = 0;
1256
2/2
✓ Branch 0 taken 44650449 times.
✓ Branch 1 taken 6832 times.
 44657281 for (i = 0; i < s->frame.blocksize; i++) {
1257 44650449 v |= sub->samples[i];
1258
2/2
✓ Branch 0 taken 1610 times.
✓ Branch 1 taken 44648839 times.
 44650449 if (v & 1)
1259 1610 break;
1260 }
1261
1262
4/4
✓ Branch 0 taken 6816 times.
✓ Branch 1 taken 1626 times.
✓ Branch 2 taken 1610 times.
✓ Branch 3 taken 5206 times.
 8442 if (!v || (v & 1))
1263 3236 return;
1264
1265 5206 v = ff_ctz(v);
1266
1267
2/2
✓ Branch 0 taken 34054501 times.
✓ Branch 1 taken 5206 times.
 34059707 for (i = 0; i < s->frame.blocksize; i++)
1268 34054501 sub->samples[i] >>= v;
1269 5206 wasted_bits = v;
1270 }
1271
1272 5212 sub->wasted = wasted_bits;
1273 5212 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
2/2
✓ Branch 0 taken 5200 times.
✓ Branch 1 taken 12 times.
 5212 if (sub->obits <= 17)
1278 5200 sub->rc.coding_mode = CODING_MODE_RICE;
1279 }
1280 }
1281
1282
1283 2686 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 2686 sum[0] = sum[1] = sum[2] = sum[3] = 0;
1293
2/2
✓ Branch 0 taken 2676 times.
✓ Branch 1 taken 10 times.
 2686 if(bps < 30) {
1294 int32_t lt, rt;
1295
2/2
✓ Branch 0 taken 15163947 times.
✓ Branch 1 taken 2676 times.
 15166623 for (int i = 2; i < n; i++) {
1296 15163947 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1297 15163947 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
1298
2/2
✓ Branch 0 taken 12296773 times.
✓ Branch 1 taken 2867174 times.
 15163947 sum[2] += FFABS((lt + rt) >> 1);
1299
2/2
✓ Branch 0 taken 12872498 times.
✓ Branch 1 taken 2291449 times.
 15163947 sum[3] += FFABS(lt - rt);
1300
2/2
✓ Branch 0 taken 12303341 times.
✓ Branch 1 taken 2860606 times.
 15163947 sum[0] += FFABS(lt);
1301
2/2
✓ Branch 0 taken 12303239 times.
✓ Branch 1 taken 2860708 times.
 15163947 sum[1] += FFABS(rt);
1302 }
1303 } else {
1304 int64_t lt, rt;
1305
2/2
✓ Branch 0 taken 44113 times.
✓ Branch 1 taken 10 times.
 44123 for (int i = 2; i < n; i++) {
1306 44113 lt = (int64_t)left_ch[i] - 2*(int64_t)left_ch[i-1] + left_ch[i-2];
1307 44113 rt = (int64_t)right_ch[i] - 2*(int64_t)right_ch[i-1] + right_ch[i-2];
1308 44113 sum[2] += FFABS((lt + rt) >> 1);
1309 44113 sum[3] += FFABS(lt - rt);
1310 44113 sum[0] += FFABS(lt);
1311 44113 sum[1] += FFABS(rt);
1312 }
1313 }
1314 /* estimate bit counts */
1315
2/2
✓ Branch 0 taken 10744 times.
✓ Branch 1 taken 2686 times.
 13430 for (int i = 0; i < 4; i++) {
1316 10744 k = find_optimal_param(2 * sum[i], n, max_rice_param);
1317 10744 sum[i] = rice_encode_count( 2 * sum[i], n, k);
1318 }
1319
1320 /* calculate score for each mode */
1321 2686 score[0] = sum[0] + sum[1];
1322 2686 score[1] = sum[0] + sum[3];
1323 2686 score[2] = sum[1] + sum[3];
1324 2686 score[3] = sum[2] + sum[3];
1325
1326 /* return mode with lowest score */
1327 2686 best = 0;
1328
2/2
✓ Branch 0 taken 8058 times.
✓ Branch 1 taken 2686 times.
 10744 for (int i = 1; i < 4; i++)
1329
2/2
✓ Branch 0 taken 1966 times.
✓ Branch 1 taken 6092 times.
 8058 if (score[i] < score[best])
1330 1966 best = i;
1331
1332 2686 return best;
1333 }
1334
1335
1336 /**
1337 * Perform stereo channel decorrelation.
1338 */
1339 4844 static void channel_decorrelation(FlacEncodeContext *s)
1340 {
1341 FlacFrame *frame;
1342 int32_t *left, *right;
1343 int64_t *side_33bps;
1344 int n;
1345
1346 4844 frame = &s->frame;
1347 4844 n = frame->blocksize;
1348 4844 left = frame->subframes[0].samples;
1349 4844 right = frame->subframes[1].samples;
1350 4844 side_33bps = frame->samples_33bps;
1351
1352
2/2
✓ Branch 0 taken 1794 times.
✓ Branch 1 taken 3050 times.
 4844 if (s->channels != 2) {
1353 1794 frame->ch_mode = FLAC_CHMODE_INDEPENDENT;
1354 1794 return;
1355 }
1356
1357
2/2
✓ Branch 0 taken 2686 times.
✓ Branch 1 taken 364 times.
 3050 if (s->options.ch_mode < 0) {
1358 2686 int max_rice_param = (1 << frame->subframes[0].rc.coding_mode) - 2;
1359 2686 frame->ch_mode = estimate_stereo_mode(left, right, n, max_rice_param, s->avctx->bits_per_raw_sample);
1360 } else
1361 364 frame->ch_mode = s->options.ch_mode;
1362
1363 /* perform decorrelation and adjust bits-per-sample */
1364
2/2
✓ Branch 0 taken 1052 times.
✓ Branch 1 taken 1998 times.
 3050 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1365 1052 return;
1366
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1989 times.
 1998 if(s->avctx->bits_per_raw_sample == 32) {
1367
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 8 times.
 9 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1368 int64_t tmp;
1369
2/2
✓ Branch 0 taken 4608 times.
✓ Branch 1 taken 1 times.
 4609 for (int i = 0; i < n; i++) {
1370 4608 tmp = left[i];
1371 4608 left[i] = (tmp + right[i]) >> 1;
1372 4608 side_33bps[i] = tmp - right[i];
1373 }
1374 1 frame->subframes[1].obits++;
1375
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 8 times.
 8 } 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
2/2
✓ Branch 0 taken 34917 times.
✓ Branch 1 taken 8 times.
 34925 for (int i = 0; i < n; i++)
1381 34917 side_33bps[i] = (int64_t)left[i] - right[i];
1382 8 frame->subframes[0].obits++;
1383 }
1384 } else {
1385
2/2
✓ Branch 0 taken 254 times.
✓ Branch 1 taken 1735 times.
 1989 if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1386 int32_t tmp;
1387
2/2
✓ Branch 0 taken 1078297 times.
✓ Branch 1 taken 254 times.
 1078551 for (int i = 0; i < n; i++) {
1388 1078297 tmp = left[i];
1389 1078297 left[i] = (tmp + right[i]) >> 1;
1390 1078297 right[i] = tmp - right[i];
1391 }
1392 254 frame->subframes[1].obits++;
1393
2/2
✓ Branch 0 taken 1504 times.
✓ Branch 1 taken 231 times.
 1735 } else if (frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1394
2/2
✓ Branch 0 taken 7394822 times.
✓ Branch 1 taken 1504 times.
 7396326 for (int i = 0; i < n; i++)
1395 7394822 right[i] = left[i] - right[i];
1396 1504 frame->subframes[1].obits++;
1397 } else {
1398
2/2
✓ Branch 0 taken 787590 times.
✓ Branch 1 taken 231 times.
 787821 for (int i = 0; i < n; i++)
1399 787590 left[i] -= right[i];
1400 231 frame->subframes[0].obits++;
1401 }
1402 }
1403 }
1404
1405
1406 4844 static void write_utf8(PutBitContext *pb, uint32_t val)
1407 {
1408 uint8_t tmp;
1409
4/4
✓ Branch 0 taken 3488 times.
✓ Branch 1 taken 1356 times.
✓ Branch 5 taken 1356 times.
✓ Branch 6 taken 1356 times.
 6200 PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
1410 4844 }
1411
1412
1413 4844 static void write_frame_header(FlacEncodeContext *s)
1414 {
1415 FlacFrame *frame;
1416 int crc;
1417
1418 4844 frame = &s->frame;
1419
1420 4844 put_bits(&s->pb, 16, 0xFFF8);
1421 4844 put_bits(&s->pb, 4, frame->bs_code[0]);
1422 4844 put_bits(&s->pb, 4, s->sr_code[0]);
1423
1424
2/2
✓ Branch 0 taken 2846 times.
✓ Branch 1 taken 1998 times.
 4844 if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT)
1425 2846 put_bits(&s->pb, 4, s->channels-1);
1426 else
1427 1998 put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1);
1428
1429 4844 put_bits(&s->pb, 3, s->bps_code);
1430 4844 put_bits(&s->pb, 1, 0);
1431 4844 write_utf8(&s->pb, s->frame_count);
1432
1433
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 if (frame->bs_code[0] == 6)
1434 ✗ put_bits(&s->pb, 8, frame->bs_code[1]);
1435
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 4794 times.
 4844 else if (frame->bs_code[0] == 7)
1436 50 put_bits(&s->pb, 16, frame->bs_code[1]);
1437
1438
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 if (s->sr_code[0] == 12)
1439 ✗ put_bits(&s->pb, 8, s->sr_code[1]);
1440
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 4844 times.
 4844 else if (s->sr_code[0] > 12)
1441 ✗ put_bits(&s->pb, 16, s->sr_code[1]);
1442
1443 4844 flush_put_bits(&s->pb);
1444 4844 crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s->pb.buf,
1445 4844 put_bytes_output(&s->pb));
1446 4844 put_bits(&s->pb, 8, crc);
1447 4844 }
1448
1449
1450 46427218 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k)
1451 {
1452 unsigned v, e;
1453
1454 46427218 v = ((unsigned)(i) << 1) ^ (i >> 31);
1455
1456 46427218 e = (v >> k) + 1;
1457
2/2
✓ Branch 0 taken 41 times.
✓ Branch 1 taken 46427218 times.
 46427259 while (e > 31) {
1458 41 put_bits(pb, 31, 0);
1459 41 e -= 31;
1460 }
1461 46427218 put_bits(pb, e, 1);
1462
2/2
✓ Branch 0 taken 44724675 times.
✓ Branch 1 taken 1702543 times.
 46427218 if (k) {
1463 44724675 unsigned mask = UINT32_MAX >> (32-k);
1464 44724675 put_bits(pb, k, v & mask);
1465 }
1466 46427218 }
1467
1468
1469 4844 static void write_subframes(FlacEncodeContext *s)
1470 {
1471 int ch;
1472
1473
2/2
✓ Branch 0 taken 13614 times.
✓ Branch 1 taken 4844 times.
 18458 for (ch = 0; ch < s->channels; ch++) {
1474 13614 FlacSubframe *sub = &s->frame.subframes[ch];
1475 int p, porder, psize;
1476 int32_t *part_end;
1477 13614 int32_t *res = sub->residual;
1478 13614 int32_t *frame_end = &sub->residual[s->frame.blocksize];
1479
1480 /* subframe header */
1481 13614 put_bits(&s->pb, 1, 0);
1482 13614 put_bits(&s->pb, 6, sub->type_code);
1483 13614 put_bits(&s->pb, 1, !!sub->wasted);
1484
2/2
✓ Branch 0 taken 5212 times.
✓ Branch 1 taken 8402 times.
 13614 if (sub->wasted)
1485 5212 put_bits(&s->pb, sub->wasted, 1);
1486
1487 /* subframe */
1488
2/2
✓ Branch 0 taken 5776 times.
✓ Branch 1 taken 7838 times.
 13614 if (sub->type == FLAC_SUBFRAME_CONSTANT) {
1489
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5776 times.
 5776 if(sub->obits == 33)
1490 ✗ put_sbits63(&s->pb, 33, s->frame.samples_33bps[0]);
1491
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5774 times.
 5776 else if(sub->obits == 32)
1492 2 put_bits32(&s->pb, res[0]);
1493 else
1494 5774 put_sbits(&s->pb, sub->obits, res[0]);
1495
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7837 times.
 7838 } else if (sub->type == FLAC_SUBFRAME_VERBATIM) {
1496
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (sub->obits == 33) {
1497 1 int64_t *res64 = s->frame.samples_33bps;
1498 1 int64_t *frame_end64 = &s->frame.samples_33bps[s->frame.blocksize];
1499
2/2
✓ Branch 0 taken 4608 times.
✓ Branch 1 taken 1 times.
 4609 while (res64 < frame_end64)
1500 4608 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
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 7835 times.
 7837 if (sub->obits == 33) {
1511
2/2
✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.
 18 for (int i = 0; i < sub->order; i++)
1512 16 put_sbits63(&s->pb, 33, s->frame.samples_33bps[i]);
1513 2 res += sub->order;
1514
2/2
✓ Branch 0 taken 5 times.
✓ Branch 1 taken 7830 times.
 7835 } else if (sub->obits == 32) {
1515
2/2
✓ Branch 0 taken 33 times.
✓ Branch 1 taken 5 times.
 38 for (int i = 0; i < sub->order; i++)
1516 33 put_bits32(&s->pb, *res++);
1517 } else {
1518
2/2
✓ Branch 0 taken 21201 times.
✓ Branch 1 taken 7830 times.
 29031 for (int i = 0; i < sub->order; i++)
1519 21201 put_sbits(&s->pb, sub->obits, *res++);
1520 }
1521
1522 /* LPC coefficients */
1523
2/2
✓ Branch 0 taken 6963 times.
✓ Branch 1 taken 874 times.
 7837 if (sub->type == FLAC_SUBFRAME_LPC) {
1524 6963 int cbits = s->options.lpc_coeff_precision;
1525 6963 put_bits( &s->pb, 4, cbits-1);
1526 6963 put_sbits(&s->pb, 5, sub->shift);
1527
2/2
✓ Branch 0 taken 18658 times.
✓ Branch 1 taken 6963 times.
 25621 for (int i = 0; i < sub->order; i++)
1528 18658 put_sbits(&s->pb, cbits, sub->coefs[i]);
1529 }
1530
1531 /* rice-encoded block */
1532 7837 put_bits(&s->pb, 2, sub->rc.coding_mode - 4);
1533
1534 /* partition order */
1535 7837 porder = sub->rc.porder;
1536 7837 psize = s->frame.blocksize >> porder;
1537 7837 put_bits(&s->pb, 4, porder);
1538
1539 /* residual */
1540 7837 part_end = &sub->residual[psize];
1541
2/2
✓ Branch 0 taken 99307 times.
✓ Branch 1 taken 7837 times.
 107144 for (p = 0; p < 1 << porder; p++) {
1542 99307 int k = sub->rc.params[p];
1543 99307 put_bits(&s->pb, sub->rc.coding_mode, k);
1544
2/2
✓ Branch 0 taken 46427218 times.
✓ Branch 1 taken 99307 times.
 46526525 while (res < part_end)
1545 46427218 set_sr_golomb_flac(&s->pb, *res++, k);
1546 99307 part_end = FFMIN(frame_end, part_end + psize);
1547 }
1548 }
1549 }
1550 4844 }
1551
1552
1553 4844 static void write_frame_footer(FlacEncodeContext *s)
1554 {
1555 int crc;
1556 4844 flush_put_bits(&s->pb);
1557 4844 crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s->pb.buf,
1558 4844 put_bytes_output(&s->pb)));
1559 4844 put_bits(&s->pb, 16, crc);
1560 4844 flush_put_bits(&s->pb);
1561 4844 }
1562
1563
1564 4844 static int write_frame(FlacEncodeContext *s, AVPacket *avpkt)
1565 {
1566 4844 init_put_bits(&s->pb, avpkt->data, avpkt->size);
1567 4844 write_frame_header(s);
1568 4844 write_subframes(s);
1569 4844 write_frame_footer(s);
1570 4844 return put_bytes_output(&s->pb);
1571 }
1572
1573
1574 4844 static int update_md5_sum(FlacEncodeContext *s, const void *samples)
1575 {
1576 const uint8_t *buf;
1577 4844 int buf_size = s->frame.blocksize * s->channels *
1578 4844 ((s->avctx->bits_per_raw_sample + 7) / 8);
1579
1580
2/2
✓ Branch 0 taken 128 times.
✓ Branch 1 taken 4716 times.
 4844 if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) {
1581 128 av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size);
1582
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 128 times.
 128 if (!s->md5_buffer)
1583 ✗ return AVERROR(ENOMEM);
1584 }
1585
1586
2/2
✓ Branch 0 taken 4716 times.
✓ Branch 1 taken 128 times.
 4844 if (s->avctx->bits_per_raw_sample <= 16) {
1587 4716 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
2/2
✓ Branch 0 taken 118 times.
✓ Branch 1 taken 10 times.
 128 } else if (s->avctx->bits_per_raw_sample <= 24) {
1594 int i;
1595 118 const int32_t *samples0 = samples;
1596 118 uint8_t *tmp = s->md5_buffer;
1597
1598
2/2
✓ Branch 0 taken 3840000 times.
✓ Branch 1 taken 118 times.
 3840118 for (i = 0; i < s->frame.blocksize * s->channels; i++) {
1599 3840000 int32_t v = samples0[i] >> 8;
1600 3840000 AV_WL24(tmp + 3*i, v);
1601 }
1602 118 buf = s->md5_buffer;
1603 } else {
1604 /* s->avctx->bits_per_raw_sample <= 32 */
1605 int i;
1606 10 const int32_t *samples0 = samples;
1607 10 uint8_t *tmp = s->md5_buffer;
1608
1609
2/2
✓ Branch 0 taken 88266 times.
✓ Branch 1 taken 10 times.
 88276 for (i = 0; i < s->frame.blocksize * s->channels; i++)
1610 88266 AV_WL32(tmp + 4*i, samples0[i]);
1611 10 buf = s->md5_buffer;
1612 }
1613 4844 av_md5_update(s->md5ctx, buf, buf_size);
1614
1615 4844 return 0;
1616 }
1617
1618
1619 4950 static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1620 const AVFrame *frame, int *got_packet_ptr)
1621 {
1622 FlacEncodeContext *s;
1623 int frame_bytes, out_bytes, ret;
1624
1625 4950 s = avctx->priv_data;
1626
1627 /* when the last block is reached, update the header in extradata */
1628
2/2
✓ Branch 0 taken 106 times.
✓ Branch 1 taken 4844 times.
 4950 if (!frame) {
1629 106 s->max_framesize = s->max_encoded_framesize;
1630 106 av_md5_final(s->md5ctx, s->md5sum);
1631 106 write_streaminfo(s, avctx->extradata);
1632
1633
2/2
✓ Branch 0 taken 53 times.
✓ Branch 1 taken 53 times.
 106 if (!s->flushed) {
1634 53 uint8_t *side_data = av_packet_new_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
1635 53 avctx->extradata_size);
1636
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 53 times.
 53 if (!side_data)
1637 ✗ return AVERROR(ENOMEM);
1638 53 memcpy(side_data, avctx->extradata, avctx->extradata_size);
1639
1640 53 avpkt->pts = s->next_pts;
1641
1642 53 *got_packet_ptr = 1;
1643 53 s->flushed = 1;
1644 }
1645
1646 106 return 0;
1647 }
1648
1649 /* change max_framesize for small final frame */
1650
2/2
✓ Branch 0 taken 50 times.
✓ Branch 1 taken 4794 times.
 4844 if (frame->nb_samples < s->frame.blocksize) {
1651 50 s->max_framesize = flac_get_max_frame_size(frame->nb_samples,
1652 s->channels,
1653 avctx->bits_per_raw_sample);
1654 }
1655
1656 4844 init_frame(s, frame->nb_samples);
1657
1658 4844 copy_samples(s, frame->data[0]);
1659
1660 4844 channel_decorrelation(s);
1661
1662 4844 remove_wasted_bits(s);
1663
1664 4844 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
2/4
✓ Branch 0 taken 4844 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4844 times.
 4844 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
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4844 times.
 4844 if ((ret = ff_get_encode_buffer(avctx, avpkt, frame_bytes, 0)) < 0)
1678 ✗ return ret;
1679
1680 4844 out_bytes = write_frame(s, avpkt);
1681
1682 4844 s->frame_count++;
1683 4844 s->sample_count += frame->nb_samples;
1684
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 4844 times.
 4844 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
2/2
✓ Branch 0 taken 360 times.
✓ Branch 1 taken 4484 times.
 4844 if (out_bytes > s->max_encoded_framesize)
1689 360 s->max_encoded_framesize = out_bytes;
1690
2/2
✓ Branch 0 taken 156 times.
✓ Branch 1 taken 4688 times.
 4844 if (out_bytes < s->min_framesize)
1691 156 s->min_framesize = out_bytes;
1692
1693 4844 s->next_pts = frame->pts + ff_samples_to_time_base(avctx, frame->nb_samples);
1694
1695 4844 av_shrink_packet(avpkt, out_bytes);
1696
1697 4844 *got_packet_ptr = 1;
1698 4844 return 0;
1699 }
1700
1701
1702 69 static av_cold int flac_encode_close(AVCodecContext *avctx)
1703 {
1704 69 FlacEncodeContext *s = avctx->priv_data;
1705
1706 69 av_freep(&s->md5ctx);
1707 69 av_freep(&s->md5_buffer);
1708 69 ff_lpc_end(&s->lpc_ctx);
1709 69 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, .unit = "lpc_type" },
1716 { "none", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_NONE }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },
1717 { "fixed", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_FIXED }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },
1718 { "levinson", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_LEVINSON }, INT_MIN, INT_MAX, FLAGS, .unit = "lpc_type" },
1719 { "cholesky", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LPC_TYPE_CHOLESKY }, INT_MIN, INT_MAX, FLAGS, .unit = "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, .unit = "predm" },
1724 { "estimation", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_EST }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1725 { "2level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_2LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1726 { "4level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_4LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1727 { "8level", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_8LEVEL }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1728 { "search", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_SEARCH }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1729 { "log", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = ORDER_METHOD_LOG }, INT_MIN, INT_MAX, FLAGS, .unit = "predm" },
1730 { "ch_mode", "Stereo decorrelation mode", offsetof(FlacEncodeContext, options.ch_mode), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, FLAC_CHMODE_MID_SIDE, FLAGS, .unit = "ch_mode" },
1731 { "auto", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },
1732 { "indep", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_INDEPENDENT }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },
1733 { "left_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_LEFT_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },
1734 { "right_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_RIGHT_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "ch_mode" },
1735 { "mid_side", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FLAC_CHMODE_MID_SIDE }, INT_MIN, INT_MAX, FLAGS, .unit = "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
1751 const FFCodec ff_flac_encoder = {
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 |
1757 AV_CODEC_CAP_SMALL_LAST_FRAME |
1758 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
1759 .priv_data_size = sizeof(FlacEncodeContext),
1760 .init = flac_encode_init,
1761 FF_CODEC_ENCODE_CB(flac_encode_frame),
1762 .close = flac_encode_close,
1763 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
1764 AV_SAMPLE_FMT_S32,
1765 AV_SAMPLE_FMT_NONE },
1766 .p.priv_class = &flac_encoder_class,
1767 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_EOF_FLUSH,
1768 };
1769