3 * Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "libavutil/crc.h"
23 #include "libavutil/lls.h"
24 #include "libavutil/md5.h"
26 #include "bitstream.h"
33 #define FLAC_SUBFRAME_CONSTANT 0
34 #define FLAC_SUBFRAME_VERBATIM 1
35 #define FLAC_SUBFRAME_FIXED 8
36 #define FLAC_SUBFRAME_LPC 32
38 #define MAX_FIXED_ORDER 4
39 #define MAX_PARTITION_ORDER 8
40 #define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
41 #define MAX_LPC_PRECISION 15
42 #define MAX_LPC_SHIFT 15
43 #define MAX_RICE_PARAM 14
45 typedef struct CompressionOptions
{
46 int compression_level
;
49 int lpc_coeff_precision
;
50 int min_prediction_order
;
51 int max_prediction_order
;
52 int prediction_order_method
;
53 int min_partition_order
;
54 int max_partition_order
;
57 typedef struct RiceContext
{
59 int params
[MAX_PARTITIONS
];
62 typedef struct FlacSubframe
{
67 int32_t coefs
[MAX_LPC_ORDER
];
70 int32_t samples
[FLAC_MAX_BLOCKSIZE
];
71 int32_t residual
[FLAC_MAX_BLOCKSIZE
+1];
74 typedef struct FlacFrame
{
75 FlacSubframe subframes
[FLAC_MAX_CHANNELS
];
82 typedef struct FlacEncodeContext
{
89 int max_encoded_framesize
;
91 uint64_t sample_count
;
94 CompressionOptions options
;
95 AVCodecContext
*avctx
;
101 * Writes streaminfo metadata block to byte array
103 static void write_streaminfo(FlacEncodeContext
*s
, uint8_t *header
)
107 memset(header
, 0, FLAC_STREAMINFO_SIZE
);
108 init_put_bits(&pb
, header
, FLAC_STREAMINFO_SIZE
);
110 /* streaminfo metadata block */
111 put_bits(&pb
, 16, s
->avctx
->frame_size
);
112 put_bits(&pb
, 16, s
->avctx
->frame_size
);
113 put_bits(&pb
, 24, s
->min_framesize
);
114 put_bits(&pb
, 24, s
->max_framesize
);
115 put_bits(&pb
, 20, s
->samplerate
);
116 put_bits(&pb
, 3, s
->channels
-1);
117 put_bits(&pb
, 5, 15); /* bits per sample - 1 */
118 /* write 36-bit sample count in 2 put_bits() calls */
119 put_bits(&pb
, 24, (s
->sample_count
& 0xFFFFFF000LL
) >> 12);
120 put_bits(&pb
, 12, s
->sample_count
& 0x000000FFFLL
);
122 memcpy(&header
[18], s
->md5sum
, 16);
126 * Sets blocksize based on samplerate
127 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
129 static int select_blocksize(int samplerate
, int block_time_ms
)
135 assert(samplerate
> 0);
136 blocksize
= ff_flac_blocksize_table
[1];
137 target
= (samplerate
* block_time_ms
) / 1000;
138 for(i
=0; i
<16; i
++) {
139 if(target
>= ff_flac_blocksize_table
[i
] && ff_flac_blocksize_table
[i
] > blocksize
) {
140 blocksize
= ff_flac_blocksize_table
[i
];
146 static av_cold
int flac_encode_init(AVCodecContext
*avctx
)
148 int freq
= avctx
->sample_rate
;
149 int channels
= avctx
->channels
;
150 FlacEncodeContext
*s
= avctx
->priv_data
;
156 dsputil_init(&s
->dsp
, avctx
);
158 if(avctx
->sample_fmt
!= SAMPLE_FMT_S16
) {
162 if(channels
< 1 || channels
> FLAC_MAX_CHANNELS
) {
165 s
->channels
= channels
;
167 /* find samplerate in table */
170 for(i
=4; i
<12; i
++) {
171 if(freq
== ff_flac_sample_rate_table
[i
]) {
172 s
->samplerate
= ff_flac_sample_rate_table
[i
];
178 /* if not in table, samplerate is non-standard */
180 if(freq
% 1000 == 0 && freq
< 255000) {
182 s
->sr_code
[1] = freq
/ 1000;
183 } else if(freq
% 10 == 0 && freq
< 655350) {
185 s
->sr_code
[1] = freq
/ 10;
186 } else if(freq
< 65535) {
188 s
->sr_code
[1] = freq
;
192 s
->samplerate
= freq
;
195 /* set compression option defaults based on avctx->compression_level */
196 if(avctx
->compression_level
< 0) {
197 s
->options
.compression_level
= 5;
199 s
->options
.compression_level
= avctx
->compression_level
;
201 av_log(avctx
, AV_LOG_DEBUG
, " compression: %d\n", s
->options
.compression_level
);
203 level
= s
->options
.compression_level
;
205 av_log(avctx
, AV_LOG_ERROR
, "invalid compression level: %d\n",
206 s
->options
.compression_level
);
210 s
->options
.block_time_ms
= ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level
];
211 s
->options
.use_lpc
= ((int[]){ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level
];
212 s
->options
.min_prediction_order
= ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level
];
213 s
->options
.max_prediction_order
= ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level
];
214 s
->options
.prediction_order_method
= ((int[]){ ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
215 ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
216 ORDER_METHOD_4LEVEL
, ORDER_METHOD_LOG
, ORDER_METHOD_4LEVEL
,
217 ORDER_METHOD_LOG
, ORDER_METHOD_SEARCH
, ORDER_METHOD_LOG
,
218 ORDER_METHOD_SEARCH
})[level
];
219 s
->options
.min_partition_order
= ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level
];
220 s
->options
.max_partition_order
= ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level
];
222 /* set compression option overrides from AVCodecContext */
223 if(avctx
->use_lpc
>= 0) {
224 s
->options
.use_lpc
= av_clip(avctx
->use_lpc
, 0, 11);
226 if(s
->options
.use_lpc
== 1)
227 av_log(avctx
, AV_LOG_DEBUG
, " use lpc: Levinson-Durbin recursion with Welch window\n");
228 else if(s
->options
.use_lpc
> 1)
229 av_log(avctx
, AV_LOG_DEBUG
, " use lpc: Cholesky factorization\n");
231 if(avctx
->min_prediction_order
>= 0) {
232 if(s
->options
.use_lpc
) {
233 if(avctx
->min_prediction_order
< MIN_LPC_ORDER
||
234 avctx
->min_prediction_order
> MAX_LPC_ORDER
) {
235 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
236 avctx
->min_prediction_order
);
240 if(avctx
->min_prediction_order
> MAX_FIXED_ORDER
) {
241 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
242 avctx
->min_prediction_order
);
246 s
->options
.min_prediction_order
= avctx
->min_prediction_order
;
248 if(avctx
->max_prediction_order
>= 0) {
249 if(s
->options
.use_lpc
) {
250 if(avctx
->max_prediction_order
< MIN_LPC_ORDER
||
251 avctx
->max_prediction_order
> MAX_LPC_ORDER
) {
252 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
253 avctx
->max_prediction_order
);
257 if(avctx
->max_prediction_order
> MAX_FIXED_ORDER
) {
258 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
259 avctx
->max_prediction_order
);
263 s
->options
.max_prediction_order
= avctx
->max_prediction_order
;
265 if(s
->options
.max_prediction_order
< s
->options
.min_prediction_order
) {
266 av_log(avctx
, AV_LOG_ERROR
, "invalid prediction orders: min=%d max=%d\n",
267 s
->options
.min_prediction_order
, s
->options
.max_prediction_order
);
270 av_log(avctx
, AV_LOG_DEBUG
, " prediction order: %d, %d\n",
271 s
->options
.min_prediction_order
, s
->options
.max_prediction_order
);
273 if(avctx
->prediction_order_method
>= 0) {
274 if(avctx
->prediction_order_method
> ORDER_METHOD_LOG
) {
275 av_log(avctx
, AV_LOG_ERROR
, "invalid prediction order method: %d\n",
276 avctx
->prediction_order_method
);
279 s
->options
.prediction_order_method
= avctx
->prediction_order_method
;
281 switch(s
->options
.prediction_order_method
) {
282 case ORDER_METHOD_EST
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
284 case ORDER_METHOD_2LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
286 case ORDER_METHOD_4LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
288 case ORDER_METHOD_8LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
290 case ORDER_METHOD_SEARCH
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
291 "full search"); break;
292 case ORDER_METHOD_LOG
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
293 "log search"); break;
296 if(avctx
->min_partition_order
>= 0) {
297 if(avctx
->min_partition_order
> MAX_PARTITION_ORDER
) {
298 av_log(avctx
, AV_LOG_ERROR
, "invalid min partition order: %d\n",
299 avctx
->min_partition_order
);
302 s
->options
.min_partition_order
= avctx
->min_partition_order
;
304 if(avctx
->max_partition_order
>= 0) {
305 if(avctx
->max_partition_order
> MAX_PARTITION_ORDER
) {
306 av_log(avctx
, AV_LOG_ERROR
, "invalid max partition order: %d\n",
307 avctx
->max_partition_order
);
310 s
->options
.max_partition_order
= avctx
->max_partition_order
;
312 if(s
->options
.max_partition_order
< s
->options
.min_partition_order
) {
313 av_log(avctx
, AV_LOG_ERROR
, "invalid partition orders: min=%d max=%d\n",
314 s
->options
.min_partition_order
, s
->options
.max_partition_order
);
317 av_log(avctx
, AV_LOG_DEBUG
, " partition order: %d, %d\n",
318 s
->options
.min_partition_order
, s
->options
.max_partition_order
);
320 if(avctx
->frame_size
> 0) {
321 if(avctx
->frame_size
< FLAC_MIN_BLOCKSIZE
||
322 avctx
->frame_size
> FLAC_MAX_BLOCKSIZE
) {
323 av_log(avctx
, AV_LOG_ERROR
, "invalid block size: %d\n",
328 s
->avctx
->frame_size
= select_blocksize(s
->samplerate
, s
->options
.block_time_ms
);
330 av_log(avctx
, AV_LOG_DEBUG
, " block size: %d\n", s
->avctx
->frame_size
);
332 /* set LPC precision */
333 if(avctx
->lpc_coeff_precision
> 0) {
334 if(avctx
->lpc_coeff_precision
> MAX_LPC_PRECISION
) {
335 av_log(avctx
, AV_LOG_ERROR
, "invalid lpc coeff precision: %d\n",
336 avctx
->lpc_coeff_precision
);
339 s
->options
.lpc_coeff_precision
= avctx
->lpc_coeff_precision
;
341 /* default LPC precision */
342 s
->options
.lpc_coeff_precision
= 15;
344 av_log(avctx
, AV_LOG_DEBUG
, " lpc precision: %d\n",
345 s
->options
.lpc_coeff_precision
);
347 /* set maximum encoded frame size in verbatim mode */
348 s
->max_framesize
= ff_flac_get_max_frame_size(s
->avctx
->frame_size
,
351 /* initialize MD5 context */
352 s
->md5ctx
= av_malloc(av_md5_size
);
354 return AVERROR_NOMEM
;
355 av_md5_init(s
->md5ctx
);
357 streaminfo
= av_malloc(FLAC_STREAMINFO_SIZE
);
358 write_streaminfo(s
, streaminfo
);
359 avctx
->extradata
= streaminfo
;
360 avctx
->extradata_size
= FLAC_STREAMINFO_SIZE
;
363 s
->min_framesize
= s
->max_framesize
;
365 avctx
->coded_frame
= avcodec_alloc_frame();
366 avctx
->coded_frame
->key_frame
= 1;
371 static void init_frame(FlacEncodeContext
*s
)
378 for(i
=0; i
<16; i
++) {
379 if(s
->avctx
->frame_size
== ff_flac_blocksize_table
[i
]) {
380 frame
->blocksize
= ff_flac_blocksize_table
[i
];
381 frame
->bs_code
[0] = i
;
382 frame
->bs_code
[1] = 0;
387 frame
->blocksize
= s
->avctx
->frame_size
;
388 if(frame
->blocksize
<= 256) {
389 frame
->bs_code
[0] = 6;
390 frame
->bs_code
[1] = frame
->blocksize
-1;
392 frame
->bs_code
[0] = 7;
393 frame
->bs_code
[1] = frame
->blocksize
-1;
397 for(ch
=0; ch
<s
->channels
; ch
++) {
398 frame
->subframes
[ch
].obits
= 16;
403 * Copy channel-interleaved input samples into separate subframes
405 static void copy_samples(FlacEncodeContext
*s
, int16_t *samples
)
411 for(i
=0,j
=0; i
<frame
->blocksize
; i
++) {
412 for(ch
=0; ch
<s
->channels
; ch
++,j
++) {
413 frame
->subframes
[ch
].samples
[i
] = samples
[j
];
419 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
422 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
424 static int find_optimal_param(uint32_t sum
, int n
)
432 k
= av_log2(n
<256 ? FASTDIV(sum2
,n
) : sum2
/n
);
433 return FFMIN(k
, MAX_RICE_PARAM
);
436 static uint32_t calc_optimal_rice_params(RiceContext
*rc
, int porder
,
437 uint32_t *sums
, int n
, int pred_order
)
443 part
= (1 << porder
);
446 cnt
= (n
>> porder
) - pred_order
;
447 for(i
=0; i
<part
; i
++) {
448 k
= find_optimal_param(sums
[i
], cnt
);
450 all_bits
+= rice_encode_count(sums
[i
], cnt
, k
);
459 static void calc_sums(int pmin
, int pmax
, uint32_t *data
, int n
, int pred_order
,
460 uint32_t sums
[][MAX_PARTITIONS
])
464 uint32_t *res
, *res_end
;
466 /* sums for highest level */
468 res
= &data
[pred_order
];
469 res_end
= &data
[n
>> pmax
];
470 for(i
=0; i
<parts
; i
++) {
472 while(res
< res_end
){
478 /* sums for lower levels */
479 for(i
=pmax
-1; i
>=pmin
; i
--) {
481 for(j
=0; j
<parts
; j
++) {
482 sums
[i
][j
] = sums
[i
+1][2*j
] + sums
[i
+1][2*j
+1];
487 static uint32_t calc_rice_params(RiceContext
*rc
, int pmin
, int pmax
,
488 int32_t *data
, int n
, int pred_order
)
491 uint32_t bits
[MAX_PARTITION_ORDER
+1];
495 uint32_t sums
[MAX_PARTITION_ORDER
+1][MAX_PARTITIONS
];
497 assert(pmin
>= 0 && pmin
<= MAX_PARTITION_ORDER
);
498 assert(pmax
>= 0 && pmax
<= MAX_PARTITION_ORDER
);
499 assert(pmin
<= pmax
);
501 udata
= av_malloc(n
* sizeof(uint32_t));
503 udata
[i
] = (2*data
[i
]) ^ (data
[i
]>>31);
506 calc_sums(pmin
, pmax
, udata
, n
, pred_order
, sums
);
509 bits
[pmin
] = UINT32_MAX
;
510 for(i
=pmin
; i
<=pmax
; i
++) {
511 bits
[i
] = calc_optimal_rice_params(&tmp_rc
, i
, sums
[i
], n
, pred_order
);
512 if(bits
[i
] <= bits
[opt_porder
]) {
519 return bits
[opt_porder
];
522 static int get_max_p_order(int max_porder
, int n
, int order
)
524 int porder
= FFMIN(max_porder
, av_log2(n
^(n
-1)));
526 porder
= FFMIN(porder
, av_log2(n
/order
));
530 static uint32_t calc_rice_params_fixed(RiceContext
*rc
, int pmin
, int pmax
,
531 int32_t *data
, int n
, int pred_order
,
535 pmin
= get_max_p_order(pmin
, n
, pred_order
);
536 pmax
= get_max_p_order(pmax
, n
, pred_order
);
537 bits
= pred_order
*bps
+ 6;
538 bits
+= calc_rice_params(rc
, pmin
, pmax
, data
, n
, pred_order
);
542 static uint32_t calc_rice_params_lpc(RiceContext
*rc
, int pmin
, int pmax
,
543 int32_t *data
, int n
, int pred_order
,
544 int bps
, int precision
)
547 pmin
= get_max_p_order(pmin
, n
, pred_order
);
548 pmax
= get_max_p_order(pmax
, n
, pred_order
);
549 bits
= pred_order
*bps
+ 4 + 5 + pred_order
*precision
+ 6;
550 bits
+= calc_rice_params(rc
, pmin
, pmax
, data
, n
, pred_order
);
555 * Apply Welch window function to audio block
557 static void apply_welch_window(const int32_t *data
, int len
, double *w_data
)
563 assert(!(len
&1)); //the optimization in r11881 does not support odd len
564 //if someone wants odd len extend the change in r11881
567 c
= 2.0 / (len
- 1.0);
571 for(i
=0; i
<n2
; i
++) {
574 w_data
[-i
-1] = data
[-i
-1] * w
;
575 w_data
[+i
] = data
[+i
] * w
;
580 * Calculates autocorrelation data from audio samples
581 * A Welch window function is applied before calculation.
583 void ff_flac_compute_autocorr(const int32_t *data
, int len
, int lag
,
587 double tmp
[len
+ lag
+ 1];
588 double *data1
= tmp
+ lag
;
590 apply_welch_window(data
, len
, data1
);
596 for(j
=0; j
<lag
; j
+=2){
597 double sum0
= 1.0, sum1
= 1.0;
598 for(i
=0; i
<len
; i
++){
599 sum0
+= data1
[i
] * data1
[i
-j
];
600 sum1
+= data1
[i
] * data1
[i
-j
-1];
608 for(i
=0; i
<len
; i
+=2){
609 sum
+= data1
[i
] * data1
[i
-j
]
610 + data1
[i
+1] * data1
[i
-j
+1];
617 static void encode_residual_verbatim(int32_t *res
, int32_t *smp
, int n
)
620 memcpy(res
, smp
, n
* sizeof(int32_t));
623 static void encode_residual_fixed(int32_t *res
, const int32_t *smp
, int n
,
628 for(i
=0; i
<order
; i
++) {
633 for(i
=order
; i
<n
; i
++)
636 for(i
=order
; i
<n
; i
++)
637 res
[i
]= smp
[i
] - smp
[i
-1];
639 int a
= smp
[order
-1] - smp
[order
-2];
640 for(i
=order
; i
<n
; i
+=2) {
641 int b
= smp
[i
] - smp
[i
-1];
643 a
= smp
[i
+1] - smp
[i
];
647 int a
= smp
[order
-1] - smp
[order
-2];
648 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
649 for(i
=order
; i
<n
; i
+=2) {
650 int b
= smp
[i
] - smp
[i
-1];
653 a
= smp
[i
+1] - smp
[i
];
658 int a
= smp
[order
-1] - smp
[order
-2];
659 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
660 int e
= smp
[order
-1] - 3*smp
[order
-2] + 3*smp
[order
-3] - smp
[order
-4];
661 for(i
=order
; i
<n
; i
+=2) {
662 int b
= smp
[i
] - smp
[i
-1];
666 a
= smp
[i
+1] - smp
[i
];
675 int c = coefs[(x)-1];\
681 static av_always_inline
void encode_residual_lpc_unrolled(
682 int32_t *res
, const int32_t *smp
, int n
,
683 int order
, const int32_t *coefs
, int shift
, int big
)
686 for(i
=order
; i
<n
; i
+=2) {
687 int s
= smp
[i
-order
];
736 res
[i
] = smp
[i
] - (p0
>> shift
);
737 res
[i
+1] = smp
[i
+1] - (p1
>> shift
);
741 static void encode_residual_lpc(int32_t *res
, const int32_t *smp
, int n
,
742 int order
, const int32_t *coefs
, int shift
)
745 for(i
=0; i
<order
; i
++) {
749 for(i
=order
; i
<n
; i
+=2) {
753 for(j
=0; j
<order
; j
++) {
759 res
[i
] = smp
[i
] - (p0
>> shift
);
760 res
[i
+1] = smp
[i
+1] - (p1
>> shift
);
764 case 1: encode_residual_lpc_unrolled(res
, smp
, n
, 1, coefs
, shift
, 0); break;
765 case 2: encode_residual_lpc_unrolled(res
, smp
, n
, 2, coefs
, shift
, 0); break;
766 case 3: encode_residual_lpc_unrolled(res
, smp
, n
, 3, coefs
, shift
, 0); break;
767 case 4: encode_residual_lpc_unrolled(res
, smp
, n
, 4, coefs
, shift
, 0); break;
768 case 5: encode_residual_lpc_unrolled(res
, smp
, n
, 5, coefs
, shift
, 0); break;
769 case 6: encode_residual_lpc_unrolled(res
, smp
, n
, 6, coefs
, shift
, 0); break;
770 case 7: encode_residual_lpc_unrolled(res
, smp
, n
, 7, coefs
, shift
, 0); break;
771 case 8: encode_residual_lpc_unrolled(res
, smp
, n
, 8, coefs
, shift
, 0); break;
772 default: encode_residual_lpc_unrolled(res
, smp
, n
, order
, coefs
, shift
, 1); break;
777 static int encode_residual(FlacEncodeContext
*ctx
, int ch
)
780 int min_order
, max_order
, opt_order
, precision
, omethod
;
781 int min_porder
, max_porder
;
784 int32_t coefs
[MAX_LPC_ORDER
][MAX_LPC_ORDER
];
785 int shift
[MAX_LPC_ORDER
];
789 sub
= &frame
->subframes
[ch
];
792 n
= frame
->blocksize
;
796 if(smp
[i
] != smp
[0]) break;
799 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_CONSTANT
;
806 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_VERBATIM
;
807 encode_residual_verbatim(res
, smp
, n
);
808 return sub
->obits
* n
;
811 min_order
= ctx
->options
.min_prediction_order
;
812 max_order
= ctx
->options
.max_prediction_order
;
813 min_porder
= ctx
->options
.min_partition_order
;
814 max_porder
= ctx
->options
.max_partition_order
;
815 precision
= ctx
->options
.lpc_coeff_precision
;
816 omethod
= ctx
->options
.prediction_order_method
;
819 if(!ctx
->options
.use_lpc
|| max_order
== 0 || (n
<= max_order
)) {
820 uint32_t bits
[MAX_FIXED_ORDER
+1];
821 if(max_order
> MAX_FIXED_ORDER
) max_order
= MAX_FIXED_ORDER
;
823 bits
[0] = UINT32_MAX
;
824 for(i
=min_order
; i
<=max_order
; i
++) {
825 encode_residual_fixed(res
, smp
, n
, i
);
826 bits
[i
] = calc_rice_params_fixed(&sub
->rc
, min_porder
, max_porder
, res
,
828 if(bits
[i
] < bits
[opt_order
]) {
832 sub
->order
= opt_order
;
833 sub
->type
= FLAC_SUBFRAME_FIXED
;
834 sub
->type_code
= sub
->type
| sub
->order
;
835 if(sub
->order
!= max_order
) {
836 encode_residual_fixed(res
, smp
, n
, sub
->order
);
837 return calc_rice_params_fixed(&sub
->rc
, min_porder
, max_porder
, res
, n
,
838 sub
->order
, sub
->obits
);
840 return bits
[sub
->order
];
844 opt_order
= ff_lpc_calc_coefs(&ctx
->dsp
, smp
, n
, min_order
, max_order
,
845 precision
, coefs
, shift
, ctx
->options
.use_lpc
,
846 omethod
, MAX_LPC_SHIFT
, 0);
848 if(omethod
== ORDER_METHOD_2LEVEL
||
849 omethod
== ORDER_METHOD_4LEVEL
||
850 omethod
== ORDER_METHOD_8LEVEL
) {
851 int levels
= 1 << omethod
;
852 uint32_t bits
[levels
];
854 int opt_index
= levels
-1;
855 opt_order
= max_order
-1;
856 bits
[opt_index
] = UINT32_MAX
;
857 for(i
=levels
-1; i
>=0; i
--) {
858 order
= min_order
+ (((max_order
-min_order
+1) * (i
+1)) / levels
)-1;
859 if(order
< 0) order
= 0;
860 encode_residual_lpc(res
, smp
, n
, order
+1, coefs
[order
], shift
[order
]);
861 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
862 res
, n
, order
+1, sub
->obits
, precision
);
863 if(bits
[i
] < bits
[opt_index
]) {
869 } else if(omethod
== ORDER_METHOD_SEARCH
) {
870 // brute-force optimal order search
871 uint32_t bits
[MAX_LPC_ORDER
];
873 bits
[0] = UINT32_MAX
;
874 for(i
=min_order
-1; i
<max_order
; i
++) {
875 encode_residual_lpc(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
876 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
877 res
, n
, i
+1, sub
->obits
, precision
);
878 if(bits
[i
] < bits
[opt_order
]) {
883 } else if(omethod
== ORDER_METHOD_LOG
) {
884 uint32_t bits
[MAX_LPC_ORDER
];
887 opt_order
= min_order
- 1 + (max_order
-min_order
)/3;
888 memset(bits
, -1, sizeof(bits
));
890 for(step
=16 ;step
; step
>>=1){
892 for(i
=last
-step
; i
<=last
+step
; i
+= step
){
893 if(i
<min_order
-1 || i
>=max_order
|| bits
[i
] < UINT32_MAX
)
895 encode_residual_lpc(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
896 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
897 res
, n
, i
+1, sub
->obits
, precision
);
898 if(bits
[i
] < bits
[opt_order
])
905 sub
->order
= opt_order
;
906 sub
->type
= FLAC_SUBFRAME_LPC
;
907 sub
->type_code
= sub
->type
| (sub
->order
-1);
908 sub
->shift
= shift
[sub
->order
-1];
909 for(i
=0; i
<sub
->order
; i
++) {
910 sub
->coefs
[i
] = coefs
[sub
->order
-1][i
];
912 encode_residual_lpc(res
, smp
, n
, sub
->order
, sub
->coefs
, sub
->shift
);
913 return calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
, res
, n
, sub
->order
,
914 sub
->obits
, precision
);
917 static int encode_residual_v(FlacEncodeContext
*ctx
, int ch
)
925 sub
= &frame
->subframes
[ch
];
928 n
= frame
->blocksize
;
932 if(smp
[i
] != smp
[0]) break;
935 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_CONSTANT
;
941 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_VERBATIM
;
942 encode_residual_verbatim(res
, smp
, n
);
943 return sub
->obits
* n
;
946 static int estimate_stereo_mode(int32_t *left_ch
, int32_t *right_ch
, int n
)
954 /* calculate sum of 2nd order residual for each channel */
955 sum
[0] = sum
[1] = sum
[2] = sum
[3] = 0;
957 lt
= left_ch
[i
] - 2*left_ch
[i
-1] + left_ch
[i
-2];
958 rt
= right_ch
[i
] - 2*right_ch
[i
-1] + right_ch
[i
-2];
959 sum
[2] += FFABS((lt
+ rt
) >> 1);
960 sum
[3] += FFABS(lt
- rt
);
964 /* estimate bit counts */
966 k
= find_optimal_param(2*sum
[i
], n
);
967 sum
[i
] = rice_encode_count(2*sum
[i
], n
, k
);
970 /* calculate score for each mode */
971 score
[0] = sum
[0] + sum
[1];
972 score
[1] = sum
[0] + sum
[3];
973 score
[2] = sum
[1] + sum
[3];
974 score
[3] = sum
[2] + sum
[3];
976 /* return mode with lowest score */
979 if(score
[i
] < score
[best
]) {
984 return FLAC_CHMODE_INDEPENDENT
;
985 } else if(best
== 1) {
986 return FLAC_CHMODE_LEFT_SIDE
;
987 } else if(best
== 2) {
988 return FLAC_CHMODE_RIGHT_SIDE
;
990 return FLAC_CHMODE_MID_SIDE
;
995 * Perform stereo channel decorrelation
997 static void channel_decorrelation(FlacEncodeContext
*ctx
)
1000 int32_t *left
, *right
;
1003 frame
= &ctx
->frame
;
1004 n
= frame
->blocksize
;
1005 left
= frame
->subframes
[0].samples
;
1006 right
= frame
->subframes
[1].samples
;
1008 if(ctx
->channels
!= 2) {
1009 frame
->ch_mode
= FLAC_CHMODE_INDEPENDENT
;
1013 frame
->ch_mode
= estimate_stereo_mode(left
, right
, n
);
1015 /* perform decorrelation and adjust bits-per-sample */
1016 if(frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
) {
1019 if(frame
->ch_mode
== FLAC_CHMODE_MID_SIDE
) {
1021 for(i
=0; i
<n
; i
++) {
1023 left
[i
] = (tmp
+ right
[i
]) >> 1;
1024 right
[i
] = tmp
- right
[i
];
1026 frame
->subframes
[1].obits
++;
1027 } else if(frame
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
) {
1028 for(i
=0; i
<n
; i
++) {
1029 right
[i
] = left
[i
] - right
[i
];
1031 frame
->subframes
[1].obits
++;
1033 for(i
=0; i
<n
; i
++) {
1034 left
[i
] -= right
[i
];
1036 frame
->subframes
[0].obits
++;
1040 static void write_utf8(PutBitContext
*pb
, uint32_t val
)
1043 PUT_UTF8(val
, tmp
, put_bits(pb
, 8, tmp
);)
1046 static void output_frame_header(FlacEncodeContext
*s
)
1053 put_bits(&s
->pb
, 16, 0xFFF8);
1054 put_bits(&s
->pb
, 4, frame
->bs_code
[0]);
1055 put_bits(&s
->pb
, 4, s
->sr_code
[0]);
1056 if(frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
) {
1057 put_bits(&s
->pb
, 4, s
->channels
-1);
1059 put_bits(&s
->pb
, 4, frame
->ch_mode
);
1061 put_bits(&s
->pb
, 3, 4); /* bits-per-sample code */
1062 put_bits(&s
->pb
, 1, 0);
1063 write_utf8(&s
->pb
, s
->frame_count
);
1064 if(frame
->bs_code
[0] == 6) {
1065 put_bits(&s
->pb
, 8, frame
->bs_code
[1]);
1066 } else if(frame
->bs_code
[0] == 7) {
1067 put_bits(&s
->pb
, 16, frame
->bs_code
[1]);
1069 if(s
->sr_code
[0] == 12) {
1070 put_bits(&s
->pb
, 8, s
->sr_code
[1]);
1071 } else if(s
->sr_code
[0] > 12) {
1072 put_bits(&s
->pb
, 16, s
->sr_code
[1]);
1074 flush_put_bits(&s
->pb
);
1075 crc
= av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0,
1076 s
->pb
.buf
, put_bits_count(&s
->pb
)>>3);
1077 put_bits(&s
->pb
, 8, crc
);
1080 static void output_subframe_constant(FlacEncodeContext
*s
, int ch
)
1085 sub
= &s
->frame
.subframes
[ch
];
1086 res
= sub
->residual
[0];
1087 put_sbits(&s
->pb
, sub
->obits
, res
);
1090 static void output_subframe_verbatim(FlacEncodeContext
*s
, int ch
)
1098 sub
= &frame
->subframes
[ch
];
1100 for(i
=0; i
<frame
->blocksize
; i
++) {
1101 res
= sub
->residual
[i
];
1102 put_sbits(&s
->pb
, sub
->obits
, res
);
1106 static void output_residual(FlacEncodeContext
*ctx
, int ch
)
1108 int i
, j
, p
, n
, parts
;
1109 int k
, porder
, psize
, res_cnt
;
1114 frame
= &ctx
->frame
;
1115 sub
= &frame
->subframes
[ch
];
1116 res
= sub
->residual
;
1117 n
= frame
->blocksize
;
1119 /* rice-encoded block */
1120 put_bits(&ctx
->pb
, 2, 0);
1122 /* partition order */
1123 porder
= sub
->rc
.porder
;
1124 psize
= n
>> porder
;
1125 parts
= (1 << porder
);
1126 put_bits(&ctx
->pb
, 4, porder
);
1127 res_cnt
= psize
- sub
->order
;
1131 for(p
=0; p
<parts
; p
++) {
1132 k
= sub
->rc
.params
[p
];
1133 put_bits(&ctx
->pb
, 4, k
);
1134 if(p
== 1) res_cnt
= psize
;
1135 for(i
=0; i
<res_cnt
&& j
<n
; i
++, j
++) {
1136 set_sr_golomb_flac(&ctx
->pb
, res
[j
], k
, INT32_MAX
, 0);
1141 static void output_subframe_fixed(FlacEncodeContext
*ctx
, int ch
)
1147 frame
= &ctx
->frame
;
1148 sub
= &frame
->subframes
[ch
];
1150 /* warm-up samples */
1151 for(i
=0; i
<sub
->order
; i
++) {
1152 put_sbits(&ctx
->pb
, sub
->obits
, sub
->residual
[i
]);
1156 output_residual(ctx
, ch
);
1159 static void output_subframe_lpc(FlacEncodeContext
*ctx
, int ch
)
1165 frame
= &ctx
->frame
;
1166 sub
= &frame
->subframes
[ch
];
1168 /* warm-up samples */
1169 for(i
=0; i
<sub
->order
; i
++) {
1170 put_sbits(&ctx
->pb
, sub
->obits
, sub
->residual
[i
]);
1173 /* LPC coefficients */
1174 cbits
= ctx
->options
.lpc_coeff_precision
;
1175 put_bits(&ctx
->pb
, 4, cbits
-1);
1176 put_sbits(&ctx
->pb
, 5, sub
->shift
);
1177 for(i
=0; i
<sub
->order
; i
++) {
1178 put_sbits(&ctx
->pb
, cbits
, sub
->coefs
[i
]);
1182 output_residual(ctx
, ch
);
1185 static void output_subframes(FlacEncodeContext
*s
)
1193 for(ch
=0; ch
<s
->channels
; ch
++) {
1194 sub
= &frame
->subframes
[ch
];
1196 /* subframe header */
1197 put_bits(&s
->pb
, 1, 0);
1198 put_bits(&s
->pb
, 6, sub
->type_code
);
1199 put_bits(&s
->pb
, 1, 0); /* no wasted bits */
1202 if(sub
->type
== FLAC_SUBFRAME_CONSTANT
) {
1203 output_subframe_constant(s
, ch
);
1204 } else if(sub
->type
== FLAC_SUBFRAME_VERBATIM
) {
1205 output_subframe_verbatim(s
, ch
);
1206 } else if(sub
->type
== FLAC_SUBFRAME_FIXED
) {
1207 output_subframe_fixed(s
, ch
);
1208 } else if(sub
->type
== FLAC_SUBFRAME_LPC
) {
1209 output_subframe_lpc(s
, ch
);
1214 static void output_frame_footer(FlacEncodeContext
*s
)
1217 flush_put_bits(&s
->pb
);
1218 crc
= bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0,
1219 s
->pb
.buf
, put_bits_count(&s
->pb
)>>3));
1220 put_bits(&s
->pb
, 16, crc
);
1221 flush_put_bits(&s
->pb
);
1224 static void update_md5_sum(FlacEncodeContext
*s
, int16_t *samples
)
1226 #ifdef WORDS_BIGENDIAN
1228 for(i
= 0; i
< s
->frame
.blocksize
*s
->channels
; i
++) {
1229 int16_t smp
= le2me_16(samples
[i
]);
1230 av_md5_update(s
->md5ctx
, (uint8_t *)&smp
, 2);
1233 av_md5_update(s
->md5ctx
, (uint8_t *)samples
, s
->frame
.blocksize
*s
->channels
*2);
1237 static int flac_encode_frame(AVCodecContext
*avctx
, uint8_t *frame
,
1238 int buf_size
, void *data
)
1241 FlacEncodeContext
*s
;
1242 int16_t *samples
= data
;
1246 s
= avctx
->priv_data
;
1248 if(buf_size
< s
->max_framesize
*2) {
1249 av_log(avctx
, AV_LOG_ERROR
, "output buffer too small\n");
1253 /* when the last block is reached, update the header in extradata */
1255 s
->max_framesize
= s
->max_encoded_framesize
;
1256 av_md5_final(s
->md5ctx
, s
->md5sum
);
1257 write_streaminfo(s
, avctx
->extradata
);
1263 copy_samples(s
, samples
);
1265 channel_decorrelation(s
);
1267 for(ch
=0; ch
<s
->channels
; ch
++) {
1268 encode_residual(s
, ch
);
1272 init_put_bits(&s
->pb
, frame
, buf_size
);
1273 output_frame_header(s
);
1274 output_subframes(s
);
1275 output_frame_footer(s
);
1276 out_bytes
= put_bits_count(&s
->pb
) >> 3;
1278 if(out_bytes
> s
->max_framesize
) {
1280 /* still too large. must be an error. */
1281 av_log(avctx
, AV_LOG_ERROR
, "error encoding frame\n");
1285 /* frame too large. use verbatim mode */
1286 for(ch
=0; ch
<s
->channels
; ch
++) {
1287 encode_residual_v(s
, ch
);
1294 s
->sample_count
+= avctx
->frame_size
;
1295 update_md5_sum(s
, samples
);
1296 if (out_bytes
> s
->max_encoded_framesize
)
1297 s
->max_encoded_framesize
= out_bytes
;
1298 if (out_bytes
< s
->min_framesize
)
1299 s
->min_framesize
= out_bytes
;
1304 static av_cold
int flac_encode_close(AVCodecContext
*avctx
)
1306 if (avctx
->priv_data
) {
1307 FlacEncodeContext
*s
= avctx
->priv_data
;
1308 av_freep(&s
->md5ctx
);
1310 av_freep(&avctx
->extradata
);
1311 avctx
->extradata_size
= 0;
1312 av_freep(&avctx
->coded_frame
);
1316 AVCodec flac_encoder
= {
1320 sizeof(FlacEncodeContext
),
1325 .capabilities
= CODEC_CAP_SMALL_LAST_FRAME
| CODEC_CAP_DELAY
,
1326 .sample_fmts
= (enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
1327 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),