Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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/crc.h" | |
24 | #include "libavutil/intmath.h" | |
25 | #include "libavutil/md5.h" | |
26 | #include "libavutil/opt.h" | |
27 | #include "avcodec.h" | |
28 | #include "bswapdsp.h" | |
29 | #include "put_bits.h" | |
30 | #include "golomb.h" | |
31 | #include "internal.h" | |
32 | #include "lpc.h" | |
33 | #include "flac.h" | |
34 | #include "flacdata.h" | |
35 | #include "flacdsp.h" | |
36 | ||
37 | #define FLAC_SUBFRAME_CONSTANT 0 | |
38 | #define FLAC_SUBFRAME_VERBATIM 1 | |
39 | #define FLAC_SUBFRAME_FIXED 8 | |
40 | #define FLAC_SUBFRAME_LPC 32 | |
41 | ||
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 | |
47 | ||
48 | enum CodingMode { | |
49 | CODING_MODE_RICE = 4, | |
50 | CODING_MODE_RICE2 = 5, | |
51 | }; | |
52 | ||
53 | typedef struct CompressionOptions { | |
54 | int compression_level; | |
55 | int block_time_ms; | |
56 | enum FFLPCType lpc_type; | |
57 | int lpc_passes; | |
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; | |
64 | int ch_mode; | |
65 | } CompressionOptions; | |
66 | ||
67 | typedef struct RiceContext { | |
68 | enum CodingMode coding_mode; | |
69 | int porder; | |
70 | int params[MAX_PARTITIONS]; | |
71 | } RiceContext; | |
72 | ||
73 | typedef struct FlacSubframe { | |
74 | int type; | |
75 | int type_code; | |
76 | int obits; | |
77 | int wasted; | |
78 | int order; | |
79 | int32_t coefs[MAX_LPC_ORDER]; | |
80 | int shift; | |
81 | RiceContext rc; | |
82 | int32_t samples[FLAC_MAX_BLOCKSIZE]; | |
83 | int32_t residual[FLAC_MAX_BLOCKSIZE+11]; | |
84 | } FlacSubframe; | |
85 | ||
86 | typedef struct FlacFrame { | |
87 | FlacSubframe subframes[FLAC_MAX_CHANNELS]; | |
88 | int blocksize; | |
89 | int bs_code[2]; | |
90 | uint8_t crc8; | |
91 | int ch_mode; | |
92 | int verbatim_only; | |
93 | } FlacFrame; | |
94 | ||
95 | typedef struct FlacEncodeContext { | |
96 | AVClass *class; | |
97 | PutBitContext pb; | |
98 | int channels; | |
99 | int samplerate; | |
100 | int sr_code[2]; | |
101 | int bps_code; | |
102 | int max_blocksize; | |
103 | int min_framesize; | |
104 | int max_framesize; | |
105 | int max_encoded_framesize; | |
106 | uint32_t frame_count; | |
107 | uint64_t sample_count; | |
108 | uint8_t md5sum[16]; | |
109 | FlacFrame frame; | |
110 | CompressionOptions options; | |
111 | AVCodecContext *avctx; | |
112 | LPCContext lpc_ctx; | |
113 | struct AVMD5 *md5ctx; | |
114 | uint8_t *md5_buffer; | |
115 | unsigned int md5_buffer_size; | |
116 | BswapDSPContext bdsp; | |
117 | FLACDSPContext flac_dsp; | |
118 | ||
119 | int flushed; | |
120 | int64_t next_pts; | |
121 | } FlacEncodeContext; | |
122 | ||
123 | ||
124 | /** | |
125 | * Write streaminfo metadata block to byte array. | |
126 | */ | |
127 | static void write_streaminfo(FlacEncodeContext *s, uint8_t *header) | |
128 | { | |
129 | PutBitContext pb; | |
130 | ||
131 | memset(header, 0, FLAC_STREAMINFO_SIZE); | |
132 | init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE); | |
133 | ||
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); | |
145 | flush_put_bits(&pb); | |
146 | memcpy(&header[18], s->md5sum, 16); | |
147 | } | |
148 | ||
149 | ||
150 | /** | |
151 | * Set blocksize based on samplerate. | |
152 | * Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds. | |
153 | */ | |
154 | static int select_blocksize(int samplerate, int block_time_ms) | |
155 | { | |
156 | int i; | |
157 | int target; | |
158 | int blocksize; | |
159 | ||
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]; | |
167 | } | |
168 | } | |
169 | return blocksize; | |
170 | } | |
171 | ||
172 | ||
173 | static av_cold void dprint_compression_options(FlacEncodeContext *s) | |
174 | { | |
175 | AVCodecContext *avctx = s->avctx; | |
176 | CompressionOptions *opt = &s->options; | |
177 | ||
178 | av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt->compression_level); | |
179 | ||
180 | switch (opt->lpc_type) { | |
181 | case FF_LPC_TYPE_NONE: | |
182 | av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n"); | |
183 | break; | |
184 | case FF_LPC_TYPE_FIXED: | |
185 | av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed pre-defined coefficients\n"); | |
186 | break; | |
187 | case FF_LPC_TYPE_LEVINSON: | |
188 | av_log(avctx, AV_LOG_DEBUG, " lpc type: Levinson-Durbin recursion with Welch window\n"); | |
189 | break; | |
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"); | |
193 | break; | |
194 | } | |
195 | ||
196 | av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n", | |
197 | opt->min_prediction_order, opt->max_prediction_order); | |
198 | ||
199 | switch (opt->prediction_order_method) { | |
200 | case ORDER_METHOD_EST: | |
201 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate"); | |
202 | break; | |
203 | case ORDER_METHOD_2LEVEL: | |
204 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2-level"); | |
205 | break; | |
206 | case ORDER_METHOD_4LEVEL: | |
207 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4-level"); | |
208 | break; | |
209 | case ORDER_METHOD_8LEVEL: | |
210 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8-level"); | |
211 | break; | |
212 | case ORDER_METHOD_SEARCH: | |
213 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search"); | |
214 | break; | |
215 | case ORDER_METHOD_LOG: | |
216 | av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search"); | |
217 | break; | |
218 | } | |
219 | ||
220 | ||
221 | av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n", | |
222 | opt->min_partition_order, opt->max_partition_order); | |
223 | ||
224 | av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx->frame_size); | |
225 | ||
226 | av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n", | |
227 | opt->lpc_coeff_precision); | |
228 | } | |
229 | ||
230 | ||
231 | static av_cold int flac_encode_init(AVCodecContext *avctx) | |
232 | { | |
233 | int freq = avctx->sample_rate; | |
234 | int channels = avctx->channels; | |
235 | FlacEncodeContext *s = avctx->priv_data; | |
236 | int i, level, ret; | |
237 | uint8_t *streaminfo; | |
238 | ||
239 | s->avctx = avctx; | |
240 | ||
241 | switch (avctx->sample_fmt) { | |
242 | case AV_SAMPLE_FMT_S16: | |
243 | avctx->bits_per_raw_sample = 16; | |
244 | s->bps_code = 4; | |
245 | break; | |
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; | |
250 | s->bps_code = 6; | |
251 | break; | |
252 | } | |
253 | ||
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); | |
258 | } | |
259 | s->channels = channels; | |
260 | ||
261 | /* find samplerate in table */ | |
262 | if (freq < 1) | |
263 | return -1; | |
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]; | |
267 | s->sr_code[0] = i; | |
268 | s->sr_code[1] = 0; | |
269 | break; | |
270 | } | |
271 | } | |
272 | /* if not in table, samplerate is non-standard */ | |
273 | if (i == 12) { | |
274 | if (freq % 1000 == 0 && freq < 255000) { | |
275 | s->sr_code[0] = 12; | |
276 | s->sr_code[1] = freq / 1000; | |
277 | } else if (freq % 10 == 0 && freq < 655350) { | |
278 | s->sr_code[0] = 14; | |
279 | s->sr_code[1] = freq / 10; | |
280 | } else if (freq < 65535) { | |
281 | s->sr_code[0] = 13; | |
282 | s->sr_code[1] = freq; | |
283 | } else { | |
284 | av_log(avctx, AV_LOG_ERROR, "%d Hz not supported\n", freq); | |
285 | return AVERROR(EINVAL); | |
286 | } | |
287 | s->samplerate = freq; | |
288 | } | |
289 | ||
290 | /* set compression option defaults based on avctx->compression_level */ | |
291 | if (avctx->compression_level < 0) | |
292 | s->options.compression_level = 5; | |
293 | else | |
294 | s->options.compression_level = avctx->compression_level; | |
295 | ||
296 | level = s->options.compression_level; | |
297 | if (level > 12) { | |
298 | av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n", | |
299 | s->options.compression_level); | |
300 | return AVERROR(EINVAL); | |
301 | } | |
302 | ||
303 | s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level]; | |
304 | ||
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]; | |
311 | ||
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]; | |
314 | ||
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]; | |
321 | ||
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); | |
326 | } | |
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]; | |
331 | ||
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); | |
340 | } | |
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); | |
346 | } | |
347 | s->options.min_prediction_order = avctx->min_prediction_order; | |
348 | } | |
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); | |
357 | } | |
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); | |
363 | } | |
364 | s->options.max_prediction_order = avctx->max_prediction_order; | |
365 | } | |
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); | |
370 | } | |
371 | ||
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", | |
376 | avctx->frame_size); | |
377 | return AVERROR(EINVAL); | |
378 | } | |
379 | } else { | |
380 | s->avctx->frame_size = select_blocksize(s->samplerate, s->options.block_time_ms); | |
381 | } | |
382 | s->max_blocksize = s->avctx->frame_size; | |
383 | ||
384 | /* set maximum encoded frame size in verbatim mode */ | |
385 | s->max_framesize = ff_flac_get_max_frame_size(s->avctx->frame_size, | |
386 | s->channels, | |
387 | s->avctx->bits_per_raw_sample); | |
388 | ||
389 | /* initialize MD5 context */ | |
390 | s->md5ctx = av_md5_alloc(); | |
391 | if (!s->md5ctx) | |
392 | return AVERROR(ENOMEM); | |
393 | av_md5_init(s->md5ctx); | |
394 | ||
395 | streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); | |
396 | if (!streaminfo) | |
397 | return AVERROR(ENOMEM); | |
398 | write_streaminfo(s, streaminfo); | |
399 | avctx->extradata = streaminfo; | |
400 | avctx->extradata_size = FLAC_STREAMINFO_SIZE; | |
401 | ||
402 | s->frame_count = 0; | |
403 | s->min_framesize = s->max_framesize; | |
404 | ||
405 | if (channels == 3 && | |
406 | avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) || | |
407 | channels == 4 && | |
408 | avctx->channel_layout != AV_CH_LAYOUT_2_2 && | |
409 | avctx->channel_layout != AV_CH_LAYOUT_QUAD || | |
410 | channels == 5 && | |
411 | avctx->channel_layout != AV_CH_LAYOUT_5POINT0 && | |
412 | avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK || | |
413 | channels == 6 && | |
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"); | |
420 | } else { | |
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); | |
424 | } | |
425 | } | |
426 | ||
427 | ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size, | |
428 | s->options.max_prediction_order, FF_LPC_TYPE_LEVINSON); | |
429 | ||
430 | ff_bswapdsp_init(&s->bdsp); | |
f6fa7814 | 431 | ff_flacdsp_init(&s->flac_dsp, avctx->sample_fmt, channels, |
2ba45a60 DM |
432 | avctx->bits_per_raw_sample); |
433 | ||
434 | dprint_compression_options(s); | |
435 | ||
436 | return ret; | |
437 | } | |
438 | ||
439 | ||
440 | static void init_frame(FlacEncodeContext *s, int nb_samples) | |
441 | { | |
442 | int i, ch; | |
443 | FlacFrame *frame; | |
444 | ||
445 | frame = &s->frame; | |
446 | ||
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; | |
452 | break; | |
453 | } | |
454 | } | |
455 | if (i == 16) { | |
456 | frame->blocksize = nb_samples; | |
457 | if (frame->blocksize <= 256) { | |
458 | frame->bs_code[0] = 6; | |
459 | frame->bs_code[1] = frame->blocksize-1; | |
460 | } else { | |
461 | frame->bs_code[0] = 7; | |
462 | frame->bs_code[1] = frame->blocksize-1; | |
463 | } | |
464 | } | |
465 | ||
466 | for (ch = 0; ch < s->channels; ch++) { | |
467 | FlacSubframe *sub = &frame->subframes[ch]; | |
468 | ||
469 | sub->wasted = 0; | |
470 | sub->obits = s->avctx->bits_per_raw_sample; | |
471 | ||
472 | if (sub->obits > 16) | |
473 | sub->rc.coding_mode = CODING_MODE_RICE2; | |
474 | else | |
475 | sub->rc.coding_mode = CODING_MODE_RICE; | |
476 | } | |
477 | ||
478 | frame->verbatim_only = 0; | |
479 | } | |
480 | ||
481 | ||
482 | /** | |
483 | * Copy channel-interleaved input samples into separate subframes. | |
484 | */ | |
485 | static void copy_samples(FlacEncodeContext *s, const void *samples) | |
486 | { | |
487 | int i, j, ch; | |
488 | FlacFrame *frame; | |
489 | int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 - | |
490 | s->avctx->bits_per_raw_sample; | |
491 | ||
492 | #define COPY_SAMPLES(bits) do { \ | |
493 | const int ## bits ## _t *samples0 = samples; \ | |
494 | frame = &s->frame; \ | |
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; \ | |
498 | } while (0) | |
499 | ||
500 | if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S16) | |
501 | COPY_SAMPLES(16); | |
502 | else | |
503 | COPY_SAMPLES(32); | |
504 | } | |
505 | ||
506 | ||
507 | static uint64_t rice_count_exact(int32_t *res, int n, int k) | |
508 | { | |
509 | int i; | |
510 | uint64_t count = 0; | |
511 | ||
512 | for (i = 0; i < n; i++) { | |
513 | int32_t v = -2 * res[i] - 1; | |
514 | v ^= v >> 31; | |
515 | count += (v >> k) + 1 + k; | |
516 | } | |
517 | return count; | |
518 | } | |
519 | ||
520 | ||
521 | static uint64_t subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, | |
522 | int pred_order) | |
523 | { | |
524 | int p, porder, psize; | |
525 | int i, part_end; | |
526 | uint64_t count = 0; | |
527 | ||
528 | /* subframe header */ | |
529 | count += 8; | |
530 | ||
531 | /* subframe */ | |
532 | if (sub->type == FLAC_SUBFRAME_CONSTANT) { | |
533 | count += sub->obits; | |
534 | } else if (sub->type == FLAC_SUBFRAME_VERBATIM) { | |
535 | count += s->frame.blocksize * sub->obits; | |
536 | } else { | |
537 | /* warm-up samples */ | |
538 | count += pred_order * sub->obits; | |
539 | ||
540 | /* LPC coefficients */ | |
541 | if (sub->type == FLAC_SUBFRAME_LPC) | |
542 | count += 4 + 5 + pred_order * s->options.lpc_coeff_precision; | |
543 | ||
544 | /* rice-encoded block */ | |
545 | count += 2; | |
546 | ||
547 | /* partition order */ | |
548 | porder = sub->rc.porder; | |
549 | psize = s->frame.blocksize >> porder; | |
550 | count += 4; | |
551 | ||
552 | /* residual */ | |
553 | i = pred_order; | |
554 | part_end = psize; | |
555 | for (p = 0; p < 1 << porder; p++) { | |
556 | int k = sub->rc.params[p]; | |
557 | count += sub->rc.coding_mode; | |
558 | count += rice_count_exact(&sub->residual[i], part_end - i, k); | |
559 | i = part_end; | |
560 | part_end = FFMIN(s->frame.blocksize, part_end + psize); | |
561 | } | |
562 | } | |
563 | ||
564 | return count; | |
565 | } | |
566 | ||
567 | ||
568 | #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k))) | |
569 | ||
570 | /** | |
571 | * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0. | |
572 | */ | |
573 | static int find_optimal_param(uint64_t sum, int n, int max_param) | |
574 | { | |
575 | int k; | |
576 | uint64_t sum2; | |
577 | ||
578 | if (sum <= n >> 1) | |
579 | return 0; | |
580 | sum2 = sum - (n >> 1); | |
581 | k = av_log2(av_clipl_int32(sum2 / n)); | |
582 | return FFMIN(k, max_param); | |
583 | } | |
584 | ||
585 | ||
586 | static uint64_t calc_optimal_rice_params(RiceContext *rc, int porder, | |
587 | uint64_t *sums, int n, int pred_order) | |
588 | { | |
589 | int i; | |
590 | int k, cnt, part, max_param; | |
591 | uint64_t all_bits; | |
592 | ||
593 | max_param = (1 << rc->coding_mode) - 2; | |
594 | ||
595 | part = (1 << porder); | |
596 | all_bits = 4 * part; | |
597 | ||
598 | cnt = (n >> porder) - pred_order; | |
599 | for (i = 0; i < part; i++) { | |
600 | k = find_optimal_param(sums[i], cnt, max_param); | |
601 | rc->params[i] = k; | |
602 | all_bits += rice_encode_count(sums[i], cnt, k); | |
603 | cnt = n >> porder; | |
604 | } | |
605 | ||
606 | rc->porder = porder; | |
607 | ||
608 | return all_bits; | |
609 | } | |
610 | ||
611 | ||
612 | static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order, | |
613 | uint64_t sums[][MAX_PARTITIONS]) | |
614 | { | |
615 | int i, j; | |
616 | int parts; | |
617 | uint32_t *res, *res_end; | |
618 | ||
619 | /* sums for highest level */ | |
620 | parts = (1 << pmax); | |
621 | res = &data[pred_order]; | |
622 | res_end = &data[n >> pmax]; | |
623 | for (i = 0; i < parts; i++) { | |
624 | uint64_t sum = 0; | |
625 | while (res < res_end) | |
626 | sum += *(res++); | |
627 | sums[pmax][i] = sum; | |
628 | res_end += n >> pmax; | |
629 | } | |
630 | /* sums for lower levels */ | |
631 | for (i = pmax - 1; i >= pmin; i--) { | |
632 | parts = (1 << i); | |
633 | for (j = 0; j < parts; j++) | |
634 | sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1]; | |
635 | } | |
636 | } | |
637 | ||
638 | ||
639 | static uint64_t calc_rice_params(RiceContext *rc, int pmin, int pmax, | |
640 | int32_t *data, int n, int pred_order) | |
641 | { | |
642 | int i; | |
643 | uint64_t bits[MAX_PARTITION_ORDER+1]; | |
644 | int opt_porder; | |
645 | RiceContext tmp_rc; | |
646 | uint32_t *udata; | |
647 | uint64_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS]; | |
648 | ||
649 | av_assert1(pmin >= 0 && pmin <= MAX_PARTITION_ORDER); | |
650 | av_assert1(pmax >= 0 && pmax <= MAX_PARTITION_ORDER); | |
651 | av_assert1(pmin <= pmax); | |
652 | ||
653 | tmp_rc.coding_mode = rc->coding_mode; | |
654 | ||
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); | |
658 | ||
659 | calc_sums(pmin, pmax, udata, n, pred_order, sums); | |
660 | ||
661 | opt_porder = pmin; | |
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]) { | |
666 | opt_porder = i; | |
667 | *rc = tmp_rc; | |
668 | } | |
669 | } | |
670 | ||
671 | av_freep(&udata); | |
672 | return bits[opt_porder]; | |
673 | } | |
674 | ||
675 | ||
676 | static int get_max_p_order(int max_porder, int n, int order) | |
677 | { | |
678 | int porder = FFMIN(max_porder, av_log2(n^(n-1))); | |
679 | if (order > 0) | |
680 | porder = FFMIN(porder, av_log2(n/order)); | |
681 | return porder; | |
682 | } | |
683 | ||
684 | ||
685 | static uint64_t find_subframe_rice_params(FlacEncodeContext *s, | |
686 | FlacSubframe *sub, int pred_order) | |
687 | { | |
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); | |
692 | ||
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); | |
698 | return bits; | |
699 | } | |
700 | ||
701 | ||
702 | static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, | |
703 | int order) | |
704 | { | |
705 | int i; | |
706 | ||
707 | for (i = 0; i < order; i++) | |
708 | res[i] = smp[i]; | |
709 | ||
710 | if (order == 0) { | |
711 | for (i = order; i < n; i++) | |
712 | res[i] = smp[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]; | |
720 | res[i] = b - a; | |
721 | a = smp[i+1] - smp[i ]; | |
722 | res[i+1] = a - b; | |
723 | } | |
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]; | |
729 | int d = b - a; | |
730 | res[i] = d - c; | |
731 | a = smp[i+1] - smp[i ]; | |
732 | c = a - b; | |
733 | res[i+1] = c - d; | |
734 | } | |
735 | } else { | |
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]; | |
741 | int d = b - a; | |
742 | int f = d - c; | |
743 | res[i ] = f - e; | |
744 | a = smp[i+1] - smp[i ]; | |
745 | c = a - b; | |
746 | e = c - d; | |
747 | res[i+1] = e - f; | |
748 | } | |
749 | } | |
750 | } | |
751 | ||
752 | ||
753 | static int encode_residual_ch(FlacEncodeContext *s, int ch) | |
754 | { | |
755 | int i, n; | |
756 | int min_order, max_order, opt_order, omethod; | |
757 | FlacFrame *frame; | |
758 | FlacSubframe *sub; | |
759 | int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; | |
760 | int shift[MAX_LPC_ORDER]; | |
761 | int32_t *res, *smp; | |
762 | ||
763 | frame = &s->frame; | |
764 | sub = &frame->subframes[ch]; | |
765 | res = sub->residual; | |
766 | smp = sub->samples; | |
767 | n = frame->blocksize; | |
768 | ||
769 | /* CONSTANT */ | |
770 | for (i = 1; i < n; i++) | |
771 | if(smp[i] != smp[0]) | |
772 | break; | |
773 | if (i == n) { | |
774 | sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT; | |
775 | res[0] = smp[0]; | |
776 | return subframe_count_exact(s, sub, 0); | |
777 | } | |
778 | ||
779 | /* VERBATIM */ | |
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); | |
784 | } | |
785 | ||
786 | min_order = s->options.min_prediction_order; | |
787 | max_order = s->options.max_prediction_order; | |
788 | omethod = s->options.prediction_order_method; | |
789 | ||
790 | /* FIXED */ | |
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; | |
797 | opt_order = 0; | |
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]) | |
803 | opt_order = i; | |
804 | } | |
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); | |
810 | } | |
811 | return subframe_count_exact(s, sub, sub->order); | |
812 | } | |
813 | ||
814 | /* LPC */ | |
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, | |
819 | MAX_LPC_SHIFT, 0); | |
820 | ||
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]; | |
826 | int order = -1; | |
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) | |
835 | continue; | |
836 | s->flac_dsp.lpc_encode(res, smp, n, order+1, coefs[order], | |
837 | shift[order]); | |
838 | bits[i] = find_subframe_rice_params(s, sub, order+1); | |
839 | if (bits[i] < bits[opt_index]) { | |
840 | opt_index = i; | |
841 | opt_order = order; | |
842 | } | |
843 | } | |
844 | opt_order++; | |
845 | } else if (omethod == ORDER_METHOD_SEARCH) { | |
846 | // brute-force optimal order search | |
847 | uint64_t bits[MAX_LPC_ORDER]; | |
848 | opt_order = 0; | |
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]) | |
854 | opt_order = i; | |
855 | } | |
856 | opt_order++; | |
857 | } else if (omethod == ORDER_METHOD_LOG) { | |
858 | uint64_t bits[MAX_LPC_ORDER]; | |
859 | int step; | |
860 | ||
861 | opt_order = min_order - 1 + (max_order-min_order)/3; | |
862 | memset(bits, -1, sizeof(bits)); | |
863 | ||
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) | |
868 | continue; | |
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]) | |
872 | opt_order = i; | |
873 | } | |
874 | } | |
875 | opt_order++; | |
876 | } | |
877 | ||
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]; | |
883 | ||
884 | s->flac_dsp.lpc_encode(res, smp, n, sub->order, sub->coefs, sub->shift); | |
885 | ||
886 | find_subframe_rice_params(s, sub, sub->order); | |
887 | ||
888 | return subframe_count_exact(s, sub, sub->order); | |
889 | } | |
890 | ||
891 | ||
892 | static int count_frame_header(FlacEncodeContext *s) | |
893 | { | |
894 | uint8_t av_unused tmp; | |
895 | int count; | |
896 | ||
897 | /* | |
898 | <14> Sync code | |
899 | <1> Reserved | |
900 | <1> Blocking strategy | |
901 | <4> Block size in inter-channel samples | |
902 | <4> Sample rate | |
903 | <4> Channel assignment | |
904 | <3> Sample size in bits | |
905 | <1> Reserved | |
906 | */ | |
907 | count = 32; | |
908 | ||
909 | /* coded frame number */ | |
910 | PUT_UTF8(s->frame_count, tmp, count += 8;) | |
911 | ||
912 | /* explicit block size */ | |
913 | if (s->frame.bs_code[0] == 6) | |
914 | count += 8; | |
915 | else if (s->frame.bs_code[0] == 7) | |
916 | count += 16; | |
917 | ||
918 | /* explicit sample rate */ | |
919 | count += ((s->sr_code[0] == 12) + (s->sr_code[0] > 12)) * 8; | |
920 | ||
921 | /* frame header CRC-8 */ | |
922 | count += 8; | |
923 | ||
924 | return count; | |
925 | } | |
926 | ||
927 | ||
928 | static int encode_frame(FlacEncodeContext *s) | |
929 | { | |
930 | int ch; | |
931 | uint64_t count; | |
932 | ||
933 | count = count_frame_header(s); | |
934 | ||
935 | for (ch = 0; ch < s->channels; ch++) | |
936 | count += encode_residual_ch(s, ch); | |
937 | ||
938 | count += (8 - (count & 7)) & 7; // byte alignment | |
939 | count += 16; // CRC-16 | |
940 | ||
941 | count >>= 3; | |
942 | if (count > INT_MAX) | |
943 | return AVERROR_BUG; | |
944 | return count; | |
945 | } | |
946 | ||
947 | ||
948 | static void remove_wasted_bits(FlacEncodeContext *s) | |
949 | { | |
950 | int ch, i; | |
951 | ||
952 | for (ch = 0; ch < s->channels; ch++) { | |
953 | FlacSubframe *sub = &s->frame.subframes[ch]; | |
954 | int32_t v = 0; | |
955 | ||
956 | for (i = 0; i < s->frame.blocksize; i++) { | |
957 | v |= sub->samples[i]; | |
958 | if (v & 1) | |
959 | break; | |
960 | } | |
961 | ||
962 | if (v && !(v & 1)) { | |
963 | v = av_ctz(v); | |
964 | ||
965 | for (i = 0; i < s->frame.blocksize; i++) | |
966 | sub->samples[i] >>= v; | |
967 | ||
968 | sub->wasted = v; | |
969 | sub->obits -= v; | |
970 | ||
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; | |
975 | } | |
976 | } | |
977 | } | |
978 | ||
979 | ||
980 | static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n, | |
981 | int max_rice_param) | |
982 | { | |
983 | int i, best; | |
984 | int32_t lt, rt; | |
985 | uint64_t sum[4]; | |
986 | uint64_t score[4]; | |
987 | int k; | |
988 | ||
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); | |
996 | sum[0] += FFABS(lt); | |
997 | sum[1] += FFABS(rt); | |
998 | } | |
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); | |
1003 | } | |
1004 | ||
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]; | |
1010 | ||
1011 | /* return mode with lowest score */ | |
1012 | best = 0; | |
1013 | for (i = 1; i < 4; i++) | |
1014 | if (score[i] < score[best]) | |
1015 | best = i; | |
1016 | ||
1017 | return best; | |
1018 | } | |
1019 | ||
1020 | ||
1021 | /** | |
1022 | * Perform stereo channel decorrelation. | |
1023 | */ | |
1024 | static void channel_decorrelation(FlacEncodeContext *s) | |
1025 | { | |
1026 | FlacFrame *frame; | |
1027 | int32_t *left, *right; | |
1028 | int i, n; | |
1029 | ||
1030 | frame = &s->frame; | |
1031 | n = frame->blocksize; | |
1032 | left = frame->subframes[0].samples; | |
1033 | right = frame->subframes[1].samples; | |
1034 | ||
1035 | if (s->channels != 2) { | |
1036 | frame->ch_mode = FLAC_CHMODE_INDEPENDENT; | |
1037 | return; | |
1038 | } | |
1039 | ||
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); | |
1043 | } else | |
1044 | frame->ch_mode = s->options.ch_mode; | |
1045 | ||
1046 | /* perform decorrelation and adjust bits-per-sample */ | |
1047 | if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) | |
1048 | return; | |
1049 | if (frame->ch_mode == FLAC_CHMODE_MID_SIDE) { | |
1050 | int32_t tmp; | |
1051 | for (i = 0; i < n; i++) { | |
1052 | tmp = left[i]; | |
1053 | left[i] = (tmp + right[i]) >> 1; | |
1054 | right[i] = tmp - right[i]; | |
1055 | } | |
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++; | |
1061 | } else { | |
1062 | for (i = 0; i < n; i++) | |
1063 | left[i] -= right[i]; | |
1064 | frame->subframes[0].obits++; | |
1065 | } | |
1066 | } | |
1067 | ||
1068 | ||
1069 | static void write_utf8(PutBitContext *pb, uint32_t val) | |
1070 | { | |
1071 | uint8_t tmp; | |
1072 | PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);) | |
1073 | } | |
1074 | ||
1075 | ||
1076 | static void write_frame_header(FlacEncodeContext *s) | |
1077 | { | |
1078 | FlacFrame *frame; | |
1079 | int crc; | |
1080 | ||
1081 | frame = &s->frame; | |
1082 | ||
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]); | |
1086 | ||
1087 | if (frame->ch_mode == FLAC_CHMODE_INDEPENDENT) | |
1088 | put_bits(&s->pb, 4, s->channels-1); | |
1089 | else | |
1090 | put_bits(&s->pb, 4, frame->ch_mode + FLAC_MAX_CHANNELS - 1); | |
1091 | ||
1092 | put_bits(&s->pb, 3, s->bps_code); | |
1093 | put_bits(&s->pb, 1, 0); | |
1094 | write_utf8(&s->pb, s->frame_count); | |
1095 | ||
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]); | |
1100 | ||
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]); | |
1105 | ||
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); | |
1110 | } | |
1111 | ||
1112 | ||
1113 | static void write_subframes(FlacEncodeContext *s) | |
1114 | { | |
1115 | int ch; | |
1116 | ||
1117 | for (ch = 0; ch < s->channels; ch++) { | |
1118 | FlacSubframe *sub = &s->frame.subframes[ch]; | |
1119 | int i, p, porder, psize; | |
1120 | int32_t *part_end; | |
1121 | int32_t *res = sub->residual; | |
1122 | int32_t *frame_end = &sub->residual[s->frame.blocksize]; | |
1123 | ||
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); | |
1128 | if (sub->wasted) | |
1129 | put_bits(&s->pb, sub->wasted, 1); | |
1130 | ||
1131 | /* subframe */ | |
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++); | |
1137 | } else { | |
1138 | /* warm-up samples */ | |
1139 | for (i = 0; i < sub->order; i++) | |
1140 | put_sbits(&s->pb, sub->obits, *res++); | |
1141 | ||
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]); | |
1149 | } | |
1150 | ||
1151 | /* rice-encoded block */ | |
1152 | put_bits(&s->pb, 2, sub->rc.coding_mode - 4); | |
1153 | ||
1154 | /* partition order */ | |
1155 | porder = sub->rc.porder; | |
1156 | psize = s->frame.blocksize >> porder; | |
1157 | put_bits(&s->pb, 4, porder); | |
1158 | ||
1159 | /* residual */ | |
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); | |
1167 | } | |
1168 | } | |
1169 | } | |
1170 | } | |
1171 | ||
1172 | ||
1173 | static void write_frame_footer(FlacEncodeContext *s) | |
1174 | { | |
1175 | int crc; | |
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); | |
1181 | } | |
1182 | ||
1183 | ||
1184 | static int write_frame(FlacEncodeContext *s, AVPacket *avpkt) | |
1185 | { | |
1186 | init_put_bits(&s->pb, avpkt->data, avpkt->size); | |
1187 | write_frame_header(s); | |
1188 | write_subframes(s); | |
1189 | write_frame_footer(s); | |
1190 | return put_bits_count(&s->pb) >> 3; | |
1191 | } | |
1192 | ||
1193 | ||
1194 | static int update_md5_sum(FlacEncodeContext *s, const void *samples) | |
1195 | { | |
1196 | const uint8_t *buf; | |
1197 | int buf_size = s->frame.blocksize * s->channels * | |
1198 | ((s->avctx->bits_per_raw_sample + 7) / 8); | |
1199 | ||
1200 | if (s->avctx->bits_per_raw_sample > 16 || HAVE_BIGENDIAN) { | |
1201 | av_fast_malloc(&s->md5_buffer, &s->md5_buffer_size, buf_size); | |
1202 | if (!s->md5_buffer) | |
1203 | return AVERROR(ENOMEM); | |
1204 | } | |
1205 | ||
1206 | if (s->avctx->bits_per_raw_sample <= 16) { | |
1207 | buf = (const uint8_t *)samples; | |
1208 | #if HAVE_BIGENDIAN | |
1209 | s->bdsp.bswap16_buf((uint16_t *) s->md5_buffer, | |
1210 | (const uint16_t *) samples, buf_size / 2); | |
1211 | buf = s->md5_buffer; | |
1212 | #endif | |
1213 | } else { | |
1214 | int i; | |
1215 | const int32_t *samples0 = samples; | |
1216 | uint8_t *tmp = s->md5_buffer; | |
1217 | ||
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; | |
1223 | } | |
1224 | buf = s->md5_buffer; | |
1225 | } | |
1226 | av_md5_update(s->md5ctx, buf, buf_size); | |
1227 | ||
1228 | return 0; | |
1229 | } | |
1230 | ||
1231 | ||
1232 | static int flac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, | |
1233 | const AVFrame *frame, int *got_packet_ptr) | |
1234 | { | |
1235 | FlacEncodeContext *s; | |
1236 | int frame_bytes, out_bytes, ret; | |
1237 | ||
1238 | s = avctx->priv_data; | |
1239 | ||
1240 | /* when the last block is reached, update the header in extradata */ | |
1241 | if (!frame) { | |
1242 | s->max_framesize = s->max_encoded_framesize; | |
1243 | av_md5_final(s->md5ctx, s->md5sum); | |
1244 | write_streaminfo(s, avctx->extradata); | |
1245 | ||
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); | |
1249 | if (!side_data) | |
1250 | return AVERROR(ENOMEM); | |
1251 | memcpy(side_data, avctx->extradata, avctx->extradata_size); | |
1252 | ||
1253 | avpkt->pts = s->next_pts; | |
1254 | ||
1255 | *got_packet_ptr = 1; | |
1256 | s->flushed = 1; | |
1257 | } | |
1258 | ||
1259 | return 0; | |
1260 | } | |
1261 | ||
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, | |
1265 | s->channels, | |
1266 | avctx->bits_per_raw_sample); | |
1267 | } | |
1268 | ||
1269 | init_frame(s, frame->nb_samples); | |
1270 | ||
1271 | copy_samples(s, frame->data[0]); | |
1272 | ||
1273 | channel_decorrelation(s); | |
1274 | ||
1275 | remove_wasted_bits(s); | |
1276 | ||
1277 | frame_bytes = encode_frame(s); | |
1278 | ||
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"); | |
1286 | return frame_bytes; | |
1287 | } | |
1288 | } | |
1289 | ||
1290 | if ((ret = ff_alloc_packet2(avctx, avpkt, frame_bytes)) < 0) | |
1291 | return ret; | |
1292 | ||
1293 | out_bytes = write_frame(s, avpkt); | |
1294 | ||
1295 | s->frame_count++; | |
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"); | |
1299 | return ret; | |
1300 | } | |
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; | |
1305 | ||
1306 | avpkt->pts = frame->pts; | |
1307 | avpkt->duration = ff_samples_to_time_base(avctx, frame->nb_samples); | |
1308 | avpkt->size = out_bytes; | |
1309 | ||
1310 | s->next_pts = avpkt->pts + avpkt->duration; | |
1311 | ||
1312 | *got_packet_ptr = 1; | |
1313 | return 0; | |
1314 | } | |
1315 | ||
1316 | ||
1317 | static av_cold int flac_encode_close(AVCodecContext *avctx) | |
1318 | { | |
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); | |
1324 | } | |
1325 | av_freep(&avctx->extradata); | |
1326 | avctx->extradata_size = 0; | |
1327 | return 0; | |
1328 | } | |
1329 | ||
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" }, | |
1354 | { NULL }, | |
1355 | }; | |
1356 | ||
1357 | static const AVClass flac_encoder_class = { | |
1358 | "FLAC encoder", | |
1359 | av_default_item_name, | |
1360 | options, | |
1361 | LIBAVUTIL_VERSION_INT, | |
1362 | }; | |
1363 | ||
1364 | AVCodec ff_flac_encoder = { | |
1365 | .name = "flac", | |
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, | |
1375 | AV_SAMPLE_FMT_S32, | |
1376 | AV_SAMPLE_FMT_NONE }, | |
1377 | .priv_class = &flac_encoder_class, | |
1378 | }; |