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
{
87 int max_encoded_framesize
;
89 uint64_t sample_count
;
92 CompressionOptions options
;
93 AVCodecContext
*avctx
;
99 * Writes streaminfo metadata block to byte array
101 static void write_streaminfo(FlacEncodeContext
*s
, uint8_t *header
)
105 memset(header
, 0, FLAC_STREAMINFO_SIZE
);
106 init_put_bits(&pb
, header
, FLAC_STREAMINFO_SIZE
);
108 /* streaminfo metadata block */
109 put_bits(&pb
, 16, s
->avctx
->frame_size
);
110 put_bits(&pb
, 16, s
->avctx
->frame_size
);
111 put_bits(&pb
, 24, s
->min_framesize
);
112 put_bits(&pb
, 24, s
->max_framesize
);
113 put_bits(&pb
, 20, s
->samplerate
);
114 put_bits(&pb
, 3, s
->channels
-1);
115 put_bits(&pb
, 5, 15); /* bits per sample - 1 */
116 /* write 36-bit sample count in 2 put_bits() calls */
117 put_bits(&pb
, 24, (s
->sample_count
& 0xFFFFFF000LL
) >> 12);
118 put_bits(&pb
, 12, s
->sample_count
& 0x000000FFFLL
);
120 memcpy(&header
[18], s
->md5sum
, 16);
124 * Sets blocksize based on samplerate
125 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
127 static int select_blocksize(int samplerate
, int block_time_ms
)
133 assert(samplerate
> 0);
134 blocksize
= ff_flac_blocksize_table
[1];
135 target
= (samplerate
* block_time_ms
) / 1000;
136 for(i
=0; i
<16; i
++) {
137 if(target
>= ff_flac_blocksize_table
[i
] && ff_flac_blocksize_table
[i
] > blocksize
) {
138 blocksize
= ff_flac_blocksize_table
[i
];
144 static av_cold
int flac_encode_init(AVCodecContext
*avctx
)
146 int freq
= avctx
->sample_rate
;
147 int channels
= avctx
->channels
;
148 FlacEncodeContext
*s
= avctx
->priv_data
;
154 dsputil_init(&s
->dsp
, avctx
);
156 if(avctx
->sample_fmt
!= SAMPLE_FMT_S16
) {
160 if(channels
< 1 || channels
> FLAC_MAX_CHANNELS
) {
163 s
->channels
= channels
;
165 /* find samplerate in table */
168 for(i
=4; i
<12; i
++) {
169 if(freq
== ff_flac_sample_rate_table
[i
]) {
170 s
->samplerate
= ff_flac_sample_rate_table
[i
];
176 /* if not in table, samplerate is non-standard */
178 if(freq
% 1000 == 0 && freq
< 255000) {
180 s
->sr_code
[1] = freq
/ 1000;
181 } else if(freq
% 10 == 0 && freq
< 655350) {
183 s
->sr_code
[1] = freq
/ 10;
184 } else if(freq
< 65535) {
186 s
->sr_code
[1] = freq
;
190 s
->samplerate
= freq
;
193 /* set compression option defaults based on avctx->compression_level */
194 if(avctx
->compression_level
< 0) {
195 s
->options
.compression_level
= 5;
197 s
->options
.compression_level
= avctx
->compression_level
;
199 av_log(avctx
, AV_LOG_DEBUG
, " compression: %d\n", s
->options
.compression_level
);
201 level
= s
->options
.compression_level
;
203 av_log(avctx
, AV_LOG_ERROR
, "invalid compression level: %d\n",
204 s
->options
.compression_level
);
208 s
->options
.block_time_ms
= ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level
];
209 s
->options
.use_lpc
= ((int[]){ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level
];
210 s
->options
.min_prediction_order
= ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level
];
211 s
->options
.max_prediction_order
= ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level
];
212 s
->options
.prediction_order_method
= ((int[]){ ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
213 ORDER_METHOD_EST
, ORDER_METHOD_EST
, ORDER_METHOD_EST
,
214 ORDER_METHOD_4LEVEL
, ORDER_METHOD_LOG
, ORDER_METHOD_4LEVEL
,
215 ORDER_METHOD_LOG
, ORDER_METHOD_SEARCH
, ORDER_METHOD_LOG
,
216 ORDER_METHOD_SEARCH
})[level
];
217 s
->options
.min_partition_order
= ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level
];
218 s
->options
.max_partition_order
= ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level
];
220 /* set compression option overrides from AVCodecContext */
221 if(avctx
->use_lpc
>= 0) {
222 s
->options
.use_lpc
= av_clip(avctx
->use_lpc
, 0, 11);
224 if(s
->options
.use_lpc
== 1)
225 av_log(avctx
, AV_LOG_DEBUG
, " use lpc: Levinson-Durbin recursion with Welch window\n");
226 else if(s
->options
.use_lpc
> 1)
227 av_log(avctx
, AV_LOG_DEBUG
, " use lpc: Cholesky factorization\n");
229 if(avctx
->min_prediction_order
>= 0) {
230 if(s
->options
.use_lpc
) {
231 if(avctx
->min_prediction_order
< MIN_LPC_ORDER
||
232 avctx
->min_prediction_order
> MAX_LPC_ORDER
) {
233 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
234 avctx
->min_prediction_order
);
238 if(avctx
->min_prediction_order
> MAX_FIXED_ORDER
) {
239 av_log(avctx
, AV_LOG_ERROR
, "invalid min prediction order: %d\n",
240 avctx
->min_prediction_order
);
244 s
->options
.min_prediction_order
= avctx
->min_prediction_order
;
246 if(avctx
->max_prediction_order
>= 0) {
247 if(s
->options
.use_lpc
) {
248 if(avctx
->max_prediction_order
< MIN_LPC_ORDER
||
249 avctx
->max_prediction_order
> MAX_LPC_ORDER
) {
250 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
251 avctx
->max_prediction_order
);
255 if(avctx
->max_prediction_order
> MAX_FIXED_ORDER
) {
256 av_log(avctx
, AV_LOG_ERROR
, "invalid max prediction order: %d\n",
257 avctx
->max_prediction_order
);
261 s
->options
.max_prediction_order
= avctx
->max_prediction_order
;
263 if(s
->options
.max_prediction_order
< s
->options
.min_prediction_order
) {
264 av_log(avctx
, AV_LOG_ERROR
, "invalid prediction orders: min=%d max=%d\n",
265 s
->options
.min_prediction_order
, s
->options
.max_prediction_order
);
268 av_log(avctx
, AV_LOG_DEBUG
, " prediction order: %d, %d\n",
269 s
->options
.min_prediction_order
, s
->options
.max_prediction_order
);
271 if(avctx
->prediction_order_method
>= 0) {
272 if(avctx
->prediction_order_method
> ORDER_METHOD_LOG
) {
273 av_log(avctx
, AV_LOG_ERROR
, "invalid prediction order method: %d\n",
274 avctx
->prediction_order_method
);
277 s
->options
.prediction_order_method
= avctx
->prediction_order_method
;
279 switch(s
->options
.prediction_order_method
) {
280 case ORDER_METHOD_EST
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
282 case ORDER_METHOD_2LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
284 case ORDER_METHOD_4LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
286 case ORDER_METHOD_8LEVEL
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
288 case ORDER_METHOD_SEARCH
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
289 "full search"); break;
290 case ORDER_METHOD_LOG
: av_log(avctx
, AV_LOG_DEBUG
, " order method: %s\n",
291 "log search"); break;
294 if(avctx
->min_partition_order
>= 0) {
295 if(avctx
->min_partition_order
> MAX_PARTITION_ORDER
) {
296 av_log(avctx
, AV_LOG_ERROR
, "invalid min partition order: %d\n",
297 avctx
->min_partition_order
);
300 s
->options
.min_partition_order
= avctx
->min_partition_order
;
302 if(avctx
->max_partition_order
>= 0) {
303 if(avctx
->max_partition_order
> MAX_PARTITION_ORDER
) {
304 av_log(avctx
, AV_LOG_ERROR
, "invalid max partition order: %d\n",
305 avctx
->max_partition_order
);
308 s
->options
.max_partition_order
= avctx
->max_partition_order
;
310 if(s
->options
.max_partition_order
< s
->options
.min_partition_order
) {
311 av_log(avctx
, AV_LOG_ERROR
, "invalid partition orders: min=%d max=%d\n",
312 s
->options
.min_partition_order
, s
->options
.max_partition_order
);
315 av_log(avctx
, AV_LOG_DEBUG
, " partition order: %d, %d\n",
316 s
->options
.min_partition_order
, s
->options
.max_partition_order
);
318 if(avctx
->frame_size
> 0) {
319 if(avctx
->frame_size
< FLAC_MIN_BLOCKSIZE
||
320 avctx
->frame_size
> FLAC_MAX_BLOCKSIZE
) {
321 av_log(avctx
, AV_LOG_ERROR
, "invalid block size: %d\n",
326 s
->avctx
->frame_size
= select_blocksize(s
->samplerate
, s
->options
.block_time_ms
);
328 av_log(avctx
, AV_LOG_DEBUG
, " block size: %d\n", s
->avctx
->frame_size
);
330 /* set LPC precision */
331 if(avctx
->lpc_coeff_precision
> 0) {
332 if(avctx
->lpc_coeff_precision
> MAX_LPC_PRECISION
) {
333 av_log(avctx
, AV_LOG_ERROR
, "invalid lpc coeff precision: %d\n",
334 avctx
->lpc_coeff_precision
);
337 s
->options
.lpc_coeff_precision
= avctx
->lpc_coeff_precision
;
339 /* default LPC precision */
340 s
->options
.lpc_coeff_precision
= 15;
342 av_log(avctx
, AV_LOG_DEBUG
, " lpc precision: %d\n",
343 s
->options
.lpc_coeff_precision
);
345 /* set maximum encoded frame size in verbatim mode */
346 if(s
->channels
== 2) {
347 s
->max_framesize
= 14 + ((s
->avctx
->frame_size
* 33 + 7) >> 3);
349 s
->max_framesize
= 14 + (s
->avctx
->frame_size
* s
->channels
* 2);
352 /* initialize MD5 context */
353 s
->md5ctx
= av_malloc(av_md5_size
);
355 return AVERROR_NOMEM
;
356 av_md5_init(s
->md5ctx
);
358 streaminfo
= av_malloc(FLAC_STREAMINFO_SIZE
);
359 write_streaminfo(s
, streaminfo
);
360 avctx
->extradata
= streaminfo
;
361 avctx
->extradata_size
= FLAC_STREAMINFO_SIZE
;
364 s
->min_framesize
= s
->max_framesize
;
366 avctx
->coded_frame
= avcodec_alloc_frame();
367 avctx
->coded_frame
->key_frame
= 1;
372 static void init_frame(FlacEncodeContext
*s
)
379 for(i
=0; i
<16; i
++) {
380 if(s
->avctx
->frame_size
== ff_flac_blocksize_table
[i
]) {
381 frame
->blocksize
= ff_flac_blocksize_table
[i
];
382 frame
->bs_code
[0] = i
;
383 frame
->bs_code
[1] = 0;
388 frame
->blocksize
= s
->avctx
->frame_size
;
389 if(frame
->blocksize
<= 256) {
390 frame
->bs_code
[0] = 6;
391 frame
->bs_code
[1] = frame
->blocksize
-1;
393 frame
->bs_code
[0] = 7;
394 frame
->bs_code
[1] = frame
->blocksize
-1;
398 for(ch
=0; ch
<s
->channels
; ch
++) {
399 frame
->subframes
[ch
].obits
= 16;
404 * Copy channel-interleaved input samples into separate subframes
406 static void copy_samples(FlacEncodeContext
*s
, int16_t *samples
)
412 for(i
=0,j
=0; i
<frame
->blocksize
; i
++) {
413 for(ch
=0; ch
<s
->channels
; ch
++,j
++) {
414 frame
->subframes
[ch
].samples
[i
] = samples
[j
];
420 #define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
423 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
425 static int find_optimal_param(uint32_t sum
, int n
)
433 k
= av_log2(n
<256 ? FASTDIV(sum2
,n
) : sum2
/n
);
434 return FFMIN(k
, MAX_RICE_PARAM
);
437 static uint32_t calc_optimal_rice_params(RiceContext
*rc
, int porder
,
438 uint32_t *sums
, int n
, int pred_order
)
444 part
= (1 << porder
);
447 cnt
= (n
>> porder
) - pred_order
;
448 for(i
=0; i
<part
; i
++) {
449 k
= find_optimal_param(sums
[i
], cnt
);
451 all_bits
+= rice_encode_count(sums
[i
], cnt
, k
);
460 static void calc_sums(int pmin
, int pmax
, uint32_t *data
, int n
, int pred_order
,
461 uint32_t sums
[][MAX_PARTITIONS
])
465 uint32_t *res
, *res_end
;
467 /* sums for highest level */
469 res
= &data
[pred_order
];
470 res_end
= &data
[n
>> pmax
];
471 for(i
=0; i
<parts
; i
++) {
473 while(res
< res_end
){
479 /* sums for lower levels */
480 for(i
=pmax
-1; i
>=pmin
; i
--) {
482 for(j
=0; j
<parts
; j
++) {
483 sums
[i
][j
] = sums
[i
+1][2*j
] + sums
[i
+1][2*j
+1];
488 static uint32_t calc_rice_params(RiceContext
*rc
, int pmin
, int pmax
,
489 int32_t *data
, int n
, int pred_order
)
492 uint32_t bits
[MAX_PARTITION_ORDER
+1];
496 uint32_t sums
[MAX_PARTITION_ORDER
+1][MAX_PARTITIONS
];
498 assert(pmin
>= 0 && pmin
<= MAX_PARTITION_ORDER
);
499 assert(pmax
>= 0 && pmax
<= MAX_PARTITION_ORDER
);
500 assert(pmin
<= pmax
);
502 udata
= av_malloc(n
* sizeof(uint32_t));
504 udata
[i
] = (2*data
[i
]) ^ (data
[i
]>>31);
507 calc_sums(pmin
, pmax
, udata
, n
, pred_order
, sums
);
510 bits
[pmin
] = UINT32_MAX
;
511 for(i
=pmin
; i
<=pmax
; i
++) {
512 bits
[i
] = calc_optimal_rice_params(&tmp_rc
, i
, sums
[i
], n
, pred_order
);
513 if(bits
[i
] <= bits
[opt_porder
]) {
520 return bits
[opt_porder
];
523 static int get_max_p_order(int max_porder
, int n
, int order
)
525 int porder
= FFMIN(max_porder
, av_log2(n
^(n
-1)));
527 porder
= FFMIN(porder
, av_log2(n
/order
));
531 static uint32_t calc_rice_params_fixed(RiceContext
*rc
, int pmin
, int pmax
,
532 int32_t *data
, int n
, int pred_order
,
536 pmin
= get_max_p_order(pmin
, n
, pred_order
);
537 pmax
= get_max_p_order(pmax
, n
, pred_order
);
538 bits
= pred_order
*bps
+ 6;
539 bits
+= calc_rice_params(rc
, pmin
, pmax
, data
, n
, pred_order
);
543 static uint32_t calc_rice_params_lpc(RiceContext
*rc
, int pmin
, int pmax
,
544 int32_t *data
, int n
, int pred_order
,
545 int bps
, int precision
)
548 pmin
= get_max_p_order(pmin
, n
, pred_order
);
549 pmax
= get_max_p_order(pmax
, n
, pred_order
);
550 bits
= pred_order
*bps
+ 4 + 5 + pred_order
*precision
+ 6;
551 bits
+= calc_rice_params(rc
, pmin
, pmax
, data
, n
, pred_order
);
556 * Apply Welch window function to audio block
558 static void apply_welch_window(const int32_t *data
, int len
, double *w_data
)
564 assert(!(len
&1)); //the optimization in r11881 does not support odd len
565 //if someone wants odd len extend the change in r11881
568 c
= 2.0 / (len
- 1.0);
572 for(i
=0; i
<n2
; i
++) {
575 w_data
[-i
-1] = data
[-i
-1] * w
;
576 w_data
[+i
] = data
[+i
] * w
;
581 * Calculates autocorrelation data from audio samples
582 * A Welch window function is applied before calculation.
584 void ff_flac_compute_autocorr(const int32_t *data
, int len
, int lag
,
588 double tmp
[len
+ lag
+ 1];
589 double *data1
= tmp
+ lag
;
591 apply_welch_window(data
, len
, data1
);
597 for(j
=0; j
<lag
; j
+=2){
598 double sum0
= 1.0, sum1
= 1.0;
599 for(i
=0; i
<len
; i
++){
600 sum0
+= data1
[i
] * data1
[i
-j
];
601 sum1
+= data1
[i
] * data1
[i
-j
-1];
609 for(i
=0; i
<len
; i
+=2){
610 sum
+= data1
[i
] * data1
[i
-j
]
611 + data1
[i
+1] * data1
[i
-j
+1];
618 static void encode_residual_verbatim(int32_t *res
, int32_t *smp
, int n
)
621 memcpy(res
, smp
, n
* sizeof(int32_t));
624 static void encode_residual_fixed(int32_t *res
, const int32_t *smp
, int n
,
629 for(i
=0; i
<order
; i
++) {
634 for(i
=order
; i
<n
; i
++)
637 for(i
=order
; i
<n
; i
++)
638 res
[i
]= smp
[i
] - smp
[i
-1];
640 int a
= smp
[order
-1] - smp
[order
-2];
641 for(i
=order
; i
<n
; i
+=2) {
642 int b
= smp
[i
] - smp
[i
-1];
644 a
= smp
[i
+1] - smp
[i
];
648 int a
= smp
[order
-1] - smp
[order
-2];
649 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
650 for(i
=order
; i
<n
; i
+=2) {
651 int b
= smp
[i
] - smp
[i
-1];
654 a
= smp
[i
+1] - smp
[i
];
659 int a
= smp
[order
-1] - smp
[order
-2];
660 int c
= smp
[order
-1] - 2*smp
[order
-2] + smp
[order
-3];
661 int e
= smp
[order
-1] - 3*smp
[order
-2] + 3*smp
[order
-3] - smp
[order
-4];
662 for(i
=order
; i
<n
; i
+=2) {
663 int b
= smp
[i
] - smp
[i
-1];
667 a
= smp
[i
+1] - smp
[i
];
676 int c = coefs[(x)-1];\
682 static av_always_inline
void encode_residual_lpc_unrolled(
683 int32_t *res
, const int32_t *smp
, int n
,
684 int order
, const int32_t *coefs
, int shift
, int big
)
687 for(i
=order
; i
<n
; i
+=2) {
688 int s
= smp
[i
-order
];
737 res
[i
] = smp
[i
] - (p0
>> shift
);
738 res
[i
+1] = smp
[i
+1] - (p1
>> shift
);
742 static void encode_residual_lpc(int32_t *res
, const int32_t *smp
, int n
,
743 int order
, const int32_t *coefs
, int shift
)
746 for(i
=0; i
<order
; i
++) {
750 for(i
=order
; i
<n
; i
+=2) {
754 for(j
=0; j
<order
; j
++) {
760 res
[i
] = smp
[i
] - (p0
>> shift
);
761 res
[i
+1] = smp
[i
+1] - (p1
>> shift
);
765 case 1: encode_residual_lpc_unrolled(res
, smp
, n
, 1, coefs
, shift
, 0); break;
766 case 2: encode_residual_lpc_unrolled(res
, smp
, n
, 2, coefs
, shift
, 0); break;
767 case 3: encode_residual_lpc_unrolled(res
, smp
, n
, 3, coefs
, shift
, 0); break;
768 case 4: encode_residual_lpc_unrolled(res
, smp
, n
, 4, coefs
, shift
, 0); break;
769 case 5: encode_residual_lpc_unrolled(res
, smp
, n
, 5, coefs
, shift
, 0); break;
770 case 6: encode_residual_lpc_unrolled(res
, smp
, n
, 6, coefs
, shift
, 0); break;
771 case 7: encode_residual_lpc_unrolled(res
, smp
, n
, 7, coefs
, shift
, 0); break;
772 case 8: encode_residual_lpc_unrolled(res
, smp
, n
, 8, coefs
, shift
, 0); break;
773 default: encode_residual_lpc_unrolled(res
, smp
, n
, order
, coefs
, shift
, 1); break;
778 static int encode_residual(FlacEncodeContext
*ctx
, int ch
)
781 int min_order
, max_order
, opt_order
, precision
, omethod
;
782 int min_porder
, max_porder
;
785 int32_t coefs
[MAX_LPC_ORDER
][MAX_LPC_ORDER
];
786 int shift
[MAX_LPC_ORDER
];
790 sub
= &frame
->subframes
[ch
];
793 n
= frame
->blocksize
;
797 if(smp
[i
] != smp
[0]) break;
800 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_CONSTANT
;
807 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_VERBATIM
;
808 encode_residual_verbatim(res
, smp
, n
);
809 return sub
->obits
* n
;
812 min_order
= ctx
->options
.min_prediction_order
;
813 max_order
= ctx
->options
.max_prediction_order
;
814 min_porder
= ctx
->options
.min_partition_order
;
815 max_porder
= ctx
->options
.max_partition_order
;
816 precision
= ctx
->options
.lpc_coeff_precision
;
817 omethod
= ctx
->options
.prediction_order_method
;
820 if(!ctx
->options
.use_lpc
|| max_order
== 0 || (n
<= max_order
)) {
821 uint32_t bits
[MAX_FIXED_ORDER
+1];
822 if(max_order
> MAX_FIXED_ORDER
) max_order
= MAX_FIXED_ORDER
;
824 bits
[0] = UINT32_MAX
;
825 for(i
=min_order
; i
<=max_order
; i
++) {
826 encode_residual_fixed(res
, smp
, n
, i
);
827 bits
[i
] = calc_rice_params_fixed(&sub
->rc
, min_porder
, max_porder
, res
,
829 if(bits
[i
] < bits
[opt_order
]) {
833 sub
->order
= opt_order
;
834 sub
->type
= FLAC_SUBFRAME_FIXED
;
835 sub
->type_code
= sub
->type
| sub
->order
;
836 if(sub
->order
!= max_order
) {
837 encode_residual_fixed(res
, smp
, n
, sub
->order
);
838 return calc_rice_params_fixed(&sub
->rc
, min_porder
, max_porder
, res
, n
,
839 sub
->order
, sub
->obits
);
841 return bits
[sub
->order
];
845 opt_order
= ff_lpc_calc_coefs(&ctx
->dsp
, smp
, n
, min_order
, max_order
,
846 precision
, coefs
, shift
, ctx
->options
.use_lpc
,
847 omethod
, MAX_LPC_SHIFT
, 0);
849 if(omethod
== ORDER_METHOD_2LEVEL
||
850 omethod
== ORDER_METHOD_4LEVEL
||
851 omethod
== ORDER_METHOD_8LEVEL
) {
852 int levels
= 1 << omethod
;
853 uint32_t bits
[levels
];
855 int opt_index
= levels
-1;
856 opt_order
= max_order
-1;
857 bits
[opt_index
] = UINT32_MAX
;
858 for(i
=levels
-1; i
>=0; i
--) {
859 order
= min_order
+ (((max_order
-min_order
+1) * (i
+1)) / levels
)-1;
860 if(order
< 0) order
= 0;
861 encode_residual_lpc(res
, smp
, n
, order
+1, coefs
[order
], shift
[order
]);
862 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
863 res
, n
, order
+1, sub
->obits
, precision
);
864 if(bits
[i
] < bits
[opt_index
]) {
870 } else if(omethod
== ORDER_METHOD_SEARCH
) {
871 // brute-force optimal order search
872 uint32_t bits
[MAX_LPC_ORDER
];
874 bits
[0] = UINT32_MAX
;
875 for(i
=min_order
-1; i
<max_order
; i
++) {
876 encode_residual_lpc(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
877 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
878 res
, n
, i
+1, sub
->obits
, precision
);
879 if(bits
[i
] < bits
[opt_order
]) {
884 } else if(omethod
== ORDER_METHOD_LOG
) {
885 uint32_t bits
[MAX_LPC_ORDER
];
888 opt_order
= min_order
- 1 + (max_order
-min_order
)/3;
889 memset(bits
, -1, sizeof(bits
));
891 for(step
=16 ;step
; step
>>=1){
893 for(i
=last
-step
; i
<=last
+step
; i
+= step
){
894 if(i
<min_order
-1 || i
>=max_order
|| bits
[i
] < UINT32_MAX
)
896 encode_residual_lpc(res
, smp
, n
, i
+1, coefs
[i
], shift
[i
]);
897 bits
[i
] = calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
,
898 res
, n
, i
+1, sub
->obits
, precision
);
899 if(bits
[i
] < bits
[opt_order
])
906 sub
->order
= opt_order
;
907 sub
->type
= FLAC_SUBFRAME_LPC
;
908 sub
->type_code
= sub
->type
| (sub
->order
-1);
909 sub
->shift
= shift
[sub
->order
-1];
910 for(i
=0; i
<sub
->order
; i
++) {
911 sub
->coefs
[i
] = coefs
[sub
->order
-1][i
];
913 encode_residual_lpc(res
, smp
, n
, sub
->order
, sub
->coefs
, sub
->shift
);
914 return calc_rice_params_lpc(&sub
->rc
, min_porder
, max_porder
, res
, n
, sub
->order
,
915 sub
->obits
, precision
);
918 static int encode_residual_v(FlacEncodeContext
*ctx
, int ch
)
926 sub
= &frame
->subframes
[ch
];
929 n
= frame
->blocksize
;
933 if(smp
[i
] != smp
[0]) break;
936 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_CONSTANT
;
942 sub
->type
= sub
->type_code
= FLAC_SUBFRAME_VERBATIM
;
943 encode_residual_verbatim(res
, smp
, n
);
944 return sub
->obits
* n
;
947 static int estimate_stereo_mode(int32_t *left_ch
, int32_t *right_ch
, int n
)
955 /* calculate sum of 2nd order residual for each channel */
956 sum
[0] = sum
[1] = sum
[2] = sum
[3] = 0;
958 lt
= left_ch
[i
] - 2*left_ch
[i
-1] + left_ch
[i
-2];
959 rt
= right_ch
[i
] - 2*right_ch
[i
-1] + right_ch
[i
-2];
960 sum
[2] += FFABS((lt
+ rt
) >> 1);
961 sum
[3] += FFABS(lt
- rt
);
965 /* estimate bit counts */
967 k
= find_optimal_param(2*sum
[i
], n
);
968 sum
[i
] = rice_encode_count(2*sum
[i
], n
, k
);
971 /* calculate score for each mode */
972 score
[0] = sum
[0] + sum
[1];
973 score
[1] = sum
[0] + sum
[3];
974 score
[2] = sum
[1] + sum
[3];
975 score
[3] = sum
[2] + sum
[3];
977 /* return mode with lowest score */
980 if(score
[i
] < score
[best
]) {
985 return FLAC_CHMODE_INDEPENDENT
;
986 } else if(best
== 1) {
987 return FLAC_CHMODE_LEFT_SIDE
;
988 } else if(best
== 2) {
989 return FLAC_CHMODE_RIGHT_SIDE
;
991 return FLAC_CHMODE_MID_SIDE
;
996 * Perform stereo channel decorrelation
998 static void channel_decorrelation(FlacEncodeContext
*ctx
)
1001 int32_t *left
, *right
;
1004 frame
= &ctx
->frame
;
1005 n
= frame
->blocksize
;
1006 left
= frame
->subframes
[0].samples
;
1007 right
= frame
->subframes
[1].samples
;
1009 if(ctx
->channels
!= 2) {
1010 frame
->ch_mode
= FLAC_CHMODE_INDEPENDENT
;
1014 frame
->ch_mode
= estimate_stereo_mode(left
, right
, n
);
1016 /* perform decorrelation and adjust bits-per-sample */
1017 if(frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
) {
1020 if(frame
->ch_mode
== FLAC_CHMODE_MID_SIDE
) {
1022 for(i
=0; i
<n
; i
++) {
1024 left
[i
] = (tmp
+ right
[i
]) >> 1;
1025 right
[i
] = tmp
- right
[i
];
1027 frame
->subframes
[1].obits
++;
1028 } else if(frame
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
) {
1029 for(i
=0; i
<n
; i
++) {
1030 right
[i
] = left
[i
] - right
[i
];
1032 frame
->subframes
[1].obits
++;
1034 for(i
=0; i
<n
; i
++) {
1035 left
[i
] -= right
[i
];
1037 frame
->subframes
[0].obits
++;
1041 static void write_utf8(PutBitContext
*pb
, uint32_t val
)
1044 PUT_UTF8(val
, tmp
, put_bits(pb
, 8, tmp
);)
1047 static void output_frame_header(FlacEncodeContext
*s
)
1054 put_bits(&s
->pb
, 16, 0xFFF8);
1055 put_bits(&s
->pb
, 4, frame
->bs_code
[0]);
1056 put_bits(&s
->pb
, 4, s
->sr_code
[0]);
1057 if(frame
->ch_mode
== FLAC_CHMODE_INDEPENDENT
) {
1058 put_bits(&s
->pb
, 4, s
->channels
-1);
1060 put_bits(&s
->pb
, 4, frame
->ch_mode
);
1062 put_bits(&s
->pb
, 3, 4); /* bits-per-sample code */
1063 put_bits(&s
->pb
, 1, 0);
1064 write_utf8(&s
->pb
, s
->frame_count
);
1065 if(frame
->bs_code
[0] == 6) {
1066 put_bits(&s
->pb
, 8, frame
->bs_code
[1]);
1067 } else if(frame
->bs_code
[0] == 7) {
1068 put_bits(&s
->pb
, 16, frame
->bs_code
[1]);
1070 if(s
->sr_code
[0] == 12) {
1071 put_bits(&s
->pb
, 8, s
->sr_code
[1]);
1072 } else if(s
->sr_code
[0] > 12) {
1073 put_bits(&s
->pb
, 16, s
->sr_code
[1]);
1075 flush_put_bits(&s
->pb
);
1076 crc
= av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0,
1077 s
->pb
.buf
, put_bits_count(&s
->pb
)>>3);
1078 put_bits(&s
->pb
, 8, crc
);
1081 static void output_subframe_constant(FlacEncodeContext
*s
, int ch
)
1086 sub
= &s
->frame
.subframes
[ch
];
1087 res
= sub
->residual
[0];
1088 put_sbits(&s
->pb
, sub
->obits
, res
);
1091 static void output_subframe_verbatim(FlacEncodeContext
*s
, int ch
)
1099 sub
= &frame
->subframes
[ch
];
1101 for(i
=0; i
<frame
->blocksize
; i
++) {
1102 res
= sub
->residual
[i
];
1103 put_sbits(&s
->pb
, sub
->obits
, res
);
1107 static void output_residual(FlacEncodeContext
*ctx
, int ch
)
1109 int i
, j
, p
, n
, parts
;
1110 int k
, porder
, psize
, res_cnt
;
1115 frame
= &ctx
->frame
;
1116 sub
= &frame
->subframes
[ch
];
1117 res
= sub
->residual
;
1118 n
= frame
->blocksize
;
1120 /* rice-encoded block */
1121 put_bits(&ctx
->pb
, 2, 0);
1123 /* partition order */
1124 porder
= sub
->rc
.porder
;
1125 psize
= n
>> porder
;
1126 parts
= (1 << porder
);
1127 put_bits(&ctx
->pb
, 4, porder
);
1128 res_cnt
= psize
- sub
->order
;
1132 for(p
=0; p
<parts
; p
++) {
1133 k
= sub
->rc
.params
[p
];
1134 put_bits(&ctx
->pb
, 4, k
);
1135 if(p
== 1) res_cnt
= psize
;
1136 for(i
=0; i
<res_cnt
&& j
<n
; i
++, j
++) {
1137 set_sr_golomb_flac(&ctx
->pb
, res
[j
], k
, INT32_MAX
, 0);
1142 static void output_subframe_fixed(FlacEncodeContext
*ctx
, int ch
)
1148 frame
= &ctx
->frame
;
1149 sub
= &frame
->subframes
[ch
];
1151 /* warm-up samples */
1152 for(i
=0; i
<sub
->order
; i
++) {
1153 put_sbits(&ctx
->pb
, sub
->obits
, sub
->residual
[i
]);
1157 output_residual(ctx
, ch
);
1160 static void output_subframe_lpc(FlacEncodeContext
*ctx
, int ch
)
1166 frame
= &ctx
->frame
;
1167 sub
= &frame
->subframes
[ch
];
1169 /* warm-up samples */
1170 for(i
=0; i
<sub
->order
; i
++) {
1171 put_sbits(&ctx
->pb
, sub
->obits
, sub
->residual
[i
]);
1174 /* LPC coefficients */
1175 cbits
= ctx
->options
.lpc_coeff_precision
;
1176 put_bits(&ctx
->pb
, 4, cbits
-1);
1177 put_sbits(&ctx
->pb
, 5, sub
->shift
);
1178 for(i
=0; i
<sub
->order
; i
++) {
1179 put_sbits(&ctx
->pb
, cbits
, sub
->coefs
[i
]);
1183 output_residual(ctx
, ch
);
1186 static void output_subframes(FlacEncodeContext
*s
)
1194 for(ch
=0; ch
<s
->channels
; ch
++) {
1195 sub
= &frame
->subframes
[ch
];
1197 /* subframe header */
1198 put_bits(&s
->pb
, 1, 0);
1199 put_bits(&s
->pb
, 6, sub
->type_code
);
1200 put_bits(&s
->pb
, 1, 0); /* no wasted bits */
1203 if(sub
->type
== FLAC_SUBFRAME_CONSTANT
) {
1204 output_subframe_constant(s
, ch
);
1205 } else if(sub
->type
== FLAC_SUBFRAME_VERBATIM
) {
1206 output_subframe_verbatim(s
, ch
);
1207 } else if(sub
->type
== FLAC_SUBFRAME_FIXED
) {
1208 output_subframe_fixed(s
, ch
);
1209 } else if(sub
->type
== FLAC_SUBFRAME_LPC
) {
1210 output_subframe_lpc(s
, ch
);
1215 static void output_frame_footer(FlacEncodeContext
*s
)
1218 flush_put_bits(&s
->pb
);
1219 crc
= bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI
), 0,
1220 s
->pb
.buf
, put_bits_count(&s
->pb
)>>3));
1221 put_bits(&s
->pb
, 16, crc
);
1222 flush_put_bits(&s
->pb
);
1225 static void update_md5_sum(FlacEncodeContext
*s
, int16_t *samples
)
1227 #ifdef WORDS_BIGENDIAN
1229 for(i
= 0; i
< s
->frame
.blocksize
*s
->channels
; i
++) {
1230 int16_t smp
= le2me_16(samples
[i
]);
1231 av_md5_update(s
->md5ctx
, (uint8_t *)&smp
, 2);
1234 av_md5_update(s
->md5ctx
, (uint8_t *)samples
, s
->frame
.blocksize
*s
->channels
*2);
1238 static int flac_encode_frame(AVCodecContext
*avctx
, uint8_t *frame
,
1239 int buf_size
, void *data
)
1242 FlacEncodeContext
*s
;
1243 int16_t *samples
= data
;
1247 s
= avctx
->priv_data
;
1249 if(buf_size
< s
->max_framesize
*2) {
1250 av_log(avctx
, AV_LOG_ERROR
, "output buffer too small\n");
1254 /* when the last block is reached, update the header in extradata */
1256 s
->max_framesize
= s
->max_encoded_framesize
;
1257 av_md5_final(s
->md5ctx
, s
->md5sum
);
1258 write_streaminfo(s
, avctx
->extradata
);
1264 copy_samples(s
, samples
);
1266 channel_decorrelation(s
);
1268 for(ch
=0; ch
<s
->channels
; ch
++) {
1269 encode_residual(s
, ch
);
1273 init_put_bits(&s
->pb
, frame
, buf_size
);
1274 output_frame_header(s
);
1275 output_subframes(s
);
1276 output_frame_footer(s
);
1277 out_bytes
= put_bits_count(&s
->pb
) >> 3;
1279 if(out_bytes
> s
->max_framesize
) {
1281 /* still too large. must be an error. */
1282 av_log(avctx
, AV_LOG_ERROR
, "error encoding frame\n");
1286 /* frame too large. use verbatim mode */
1287 for(ch
=0; ch
<s
->channels
; ch
++) {
1288 encode_residual_v(s
, ch
);
1295 s
->sample_count
+= avctx
->frame_size
;
1296 update_md5_sum(s
, samples
);
1297 if (out_bytes
> s
->max_encoded_framesize
)
1298 s
->max_encoded_framesize
= out_bytes
;
1299 if (out_bytes
< s
->min_framesize
)
1300 s
->min_framesize
= out_bytes
;
1305 static av_cold
int flac_encode_close(AVCodecContext
*avctx
)
1307 if (avctx
->priv_data
) {
1308 FlacEncodeContext
*s
= avctx
->priv_data
;
1309 av_freep(&s
->md5ctx
);
1311 av_freep(&avctx
->extradata
);
1312 avctx
->extradata_size
= 0;
1313 av_freep(&avctx
->coded_frame
);
1317 AVCodec flac_encoder
= {
1321 sizeof(FlacEncodeContext
),
1326 .capabilities
= CODEC_CAP_SMALL_LAST_FRAME
| CODEC_CAP_DELAY
,
1327 .sample_fmts
= (enum SampleFormat
[]){SAMPLE_FMT_S16
,SAMPLE_FMT_NONE
},
1328 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),