simplify lpc
[libav.git] / libavcodec / flacenc.c
CommitLineData
9e96ab03
MN
1/**
2 * FLAC audio encoder
3 * Copyright (c) 2006 Justin Ruggles <jruggle@earthlink.net>
4 *
b78e7197
DB
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
9e96ab03
MN
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
b78e7197 10 * version 2.1 of the License, or (at your option) any later version.
9e96ab03 11 *
b78e7197 12 * FFmpeg is distributed in the hope that it will be useful,
9e96ab03
MN
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
b78e7197 18 * License along with FFmpeg; if not, write to the Free Software
9e96ab03
MN
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "avcodec.h"
23#include "bitstream.h"
24#include "crc.h"
6810b93a 25#include "dsputil.h"
9e96ab03 26#include "golomb.h"
ab01b2b8 27#include "lls.h"
9e96ab03
MN
28
29#define FLAC_MAX_CH 8
30#define FLAC_MIN_BLOCKSIZE 16
31#define FLAC_MAX_BLOCKSIZE 65535
32
33#define FLAC_SUBFRAME_CONSTANT 0
34#define FLAC_SUBFRAME_VERBATIM 1
35#define FLAC_SUBFRAME_FIXED 8
36#define FLAC_SUBFRAME_LPC 32
37
38#define FLAC_CHMODE_NOT_STEREO 0
39#define FLAC_CHMODE_LEFT_RIGHT 1
40#define FLAC_CHMODE_LEFT_SIDE 8
41#define FLAC_CHMODE_RIGHT_SIDE 9
42#define FLAC_CHMODE_MID_SIDE 10
43
a403fc03
JR
44#define ORDER_METHOD_EST 0
45#define ORDER_METHOD_2LEVEL 1
46#define ORDER_METHOD_4LEVEL 2
47#define ORDER_METHOD_8LEVEL 3
48#define ORDER_METHOD_SEARCH 4
dbb45a3b 49#define ORDER_METHOD_LOG 5
a403fc03 50
9e96ab03
MN
51#define FLAC_STREAMINFO_SIZE 34
52
a403fc03
JR
53#define MIN_LPC_ORDER 1
54#define MAX_LPC_ORDER 32
55#define MAX_FIXED_ORDER 4
56#define MAX_PARTITION_ORDER 8
57#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
58#define MAX_LPC_PRECISION 15
59#define MAX_LPC_SHIFT 15
60#define MAX_RICE_PARAM 14
61
62typedef struct CompressionOptions {
63 int compression_level;
64 int block_time_ms;
65 int use_lpc;
66 int lpc_coeff_precision;
67 int min_prediction_order;
68 int max_prediction_order;
69 int prediction_order_method;
70 int min_partition_order;
71 int max_partition_order;
72} CompressionOptions;
73
e71bcc37
JR
74typedef struct RiceContext {
75 int porder;
a403fc03 76 int params[MAX_PARTITIONS];
e71bcc37
JR
77} RiceContext;
78
9e96ab03
MN
79typedef struct FlacSubframe {
80 int type;
81 int type_code;
82 int obits;
83 int order;
a403fc03
JR
84 int32_t coefs[MAX_LPC_ORDER];
85 int shift;
e71bcc37 86 RiceContext rc;
9e96ab03 87 int32_t samples[FLAC_MAX_BLOCKSIZE];
0d2caa37 88 int32_t residual[FLAC_MAX_BLOCKSIZE+1];
9e96ab03
MN
89} FlacSubframe;
90
91typedef struct FlacFrame {
92 FlacSubframe subframes[FLAC_MAX_CH];
93 int blocksize;
94 int bs_code[2];
95 uint8_t crc8;
96 int ch_mode;
97} FlacFrame;
98
99typedef struct FlacEncodeContext {
100 PutBitContext pb;
101 int channels;
102 int ch_code;
103 int samplerate;
104 int sr_code[2];
105 int blocksize;
106 int max_framesize;
107 uint32_t frame_count;
108 FlacFrame frame;
a403fc03 109 CompressionOptions options;
e71bcc37 110 AVCodecContext *avctx;
6810b93a 111 DSPContext dsp;
9e96ab03
MN
112} FlacEncodeContext;
113
114static const int flac_samplerates[16] = {
115 0, 0, 0, 0,
116 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
117 0, 0, 0, 0
118};
119
120static const int flac_blocksizes[16] = {
121 0,
122 192,
123 576, 1152, 2304, 4608,
124 0, 0,
125 256, 512, 1024, 2048, 4096, 8192, 16384, 32768
126};
127
9e96ab03
MN
128/**
129 * Writes streaminfo metadata block to byte array
130 */
131static void write_streaminfo(FlacEncodeContext *s, uint8_t *header)
132{
133 PutBitContext pb;
134
135 memset(header, 0, FLAC_STREAMINFO_SIZE);
136 init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE);
137
138 /* streaminfo metadata block */
139 put_bits(&pb, 16, s->blocksize);
140 put_bits(&pb, 16, s->blocksize);
141 put_bits(&pb, 24, 0);
142 put_bits(&pb, 24, s->max_framesize);
143 put_bits(&pb, 20, s->samplerate);
144 put_bits(&pb, 3, s->channels-1);
145 put_bits(&pb, 5, 15); /* bits per sample - 1 */
146 flush_put_bits(&pb);
147 /* total samples = 0 */
148 /* MD5 signature = 0 */
149}
150
9e96ab03
MN
151/**
152 * Sets blocksize based on samplerate
153 * Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds
154 */
a403fc03 155static int select_blocksize(int samplerate, int block_time_ms)
9e96ab03
MN
156{
157 int i;
158 int target;
159 int blocksize;
160
161 assert(samplerate > 0);
d1015e88 162 blocksize = flac_blocksizes[1];
a403fc03 163 target = (samplerate * block_time_ms) / 1000;
d1015e88
MN
164 for(i=0; i<16; i++) {
165 if(target >= flac_blocksizes[i] && flac_blocksizes[i] > blocksize) {
166 blocksize = flac_blocksizes[i];
9e96ab03
MN
167 }
168 }
9e96ab03
MN
169 return blocksize;
170}
171
172static int flac_encode_init(AVCodecContext *avctx)
173{
174 int freq = avctx->sample_rate;
175 int channels = avctx->channels;
176 FlacEncodeContext *s = avctx->priv_data;
7c69b830 177 int i, level;
9e96ab03
MN
178 uint8_t *streaminfo;
179
e71bcc37
JR
180 s->avctx = avctx;
181
6810b93a
LM
182 dsputil_init(&s->dsp, avctx);
183
9e96ab03
MN
184 if(avctx->sample_fmt != SAMPLE_FMT_S16) {
185 return -1;
186 }
187
188 if(channels < 1 || channels > FLAC_MAX_CH) {
189 return -1;
190 }
191 s->channels = channels;
192 s->ch_code = s->channels-1;
193
194 /* find samplerate in table */
195 if(freq < 1)
196 return -1;
197 for(i=4; i<12; i++) {
198 if(freq == flac_samplerates[i]) {
199 s->samplerate = flac_samplerates[i];
200 s->sr_code[0] = i;
201 s->sr_code[1] = 0;
202 break;
203 }
204 }
205 /* if not in table, samplerate is non-standard */
206 if(i == 12) {
207 if(freq % 1000 == 0 && freq < 255000) {
208 s->sr_code[0] = 12;
209 s->sr_code[1] = freq / 1000;
210 } else if(freq % 10 == 0 && freq < 655350) {
211 s->sr_code[0] = 14;
212 s->sr_code[1] = freq / 10;
213 } else if(freq < 65535) {
214 s->sr_code[0] = 13;
215 s->sr_code[1] = freq;
216 } else {
217 return -1;
218 }
219 s->samplerate = freq;
220 }
221
a403fc03
JR
222 /* set compression option defaults based on avctx->compression_level */
223 if(avctx->compression_level < 0) {
224 s->options.compression_level = 5;
225 } else {
226 s->options.compression_level = avctx->compression_level;
227 }
228 av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s->options.compression_level);
229
7c69b830 230 level= s->options.compression_level;
26053bdc 231 if(level > 12) {
a403fc03
JR
232 av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",
233 s->options.compression_level);
234 return -1;
235 }
236
26053bdc
JR
237 s->options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level];
238 s->options.use_lpc = ((int[]){ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
239 s->options.min_prediction_order= ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level];
240 s->options.max_prediction_order= ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level];
241 s->options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
242 ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,
5f3acd9e
JR
243 ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL,
244 ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG,
26053bdc 245 ORDER_METHOD_SEARCH})[level];
e1bbc032
JR
246 s->options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level];
247 s->options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level];
7c69b830 248
a403fc03
JR
249 /* set compression option overrides from AVCodecContext */
250 if(avctx->use_lpc >= 0) {
f66e4f5f 251 s->options.use_lpc = av_clip(avctx->use_lpc, 0, 11);
a403fc03 252 }
ab01b2b8
MN
253 if(s->options.use_lpc == 1)
254 av_log(avctx, AV_LOG_DEBUG, " use lpc: Levinson-Durbin recursion with Welch window\n");
255 else if(s->options.use_lpc > 1)
256 av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");
a403fc03
JR
257
258 if(avctx->min_prediction_order >= 0) {
259 if(s->options.use_lpc) {
260 if(avctx->min_prediction_order < MIN_LPC_ORDER ||
261 avctx->min_prediction_order > MAX_LPC_ORDER) {
262 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
263 avctx->min_prediction_order);
264 return -1;
265 }
266 } else {
267 if(avctx->min_prediction_order > MAX_FIXED_ORDER) {
268 av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",
269 avctx->min_prediction_order);
270 return -1;
271 }
272 }
273 s->options.min_prediction_order = avctx->min_prediction_order;
274 }
275 if(avctx->max_prediction_order >= 0) {
276 if(s->options.use_lpc) {
277 if(avctx->max_prediction_order < MIN_LPC_ORDER ||
278 avctx->max_prediction_order > MAX_LPC_ORDER) {
279 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
280 avctx->max_prediction_order);
281 return -1;
282 }
283 } else {
284 if(avctx->max_prediction_order > MAX_FIXED_ORDER) {
285 av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",
286 avctx->max_prediction_order);
287 return -1;
288 }
289 }
290 s->options.max_prediction_order = avctx->max_prediction_order;
291 }
292 if(s->options.max_prediction_order < s->options.min_prediction_order) {
293 av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",
294 s->options.min_prediction_order, s->options.max_prediction_order);
295 return -1;
296 }
297 av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",
298 s->options.min_prediction_order, s->options.max_prediction_order);
299
300 if(avctx->prediction_order_method >= 0) {
dbb45a3b 301 if(avctx->prediction_order_method > ORDER_METHOD_LOG) {
a403fc03
JR
302 av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",
303 avctx->prediction_order_method);
304 return -1;
305 }
306 s->options.prediction_order_method = avctx->prediction_order_method;
307 }
26053bdc 308 switch(s->options.prediction_order_method) {
a403fc03
JR
309 case ORDER_METHOD_EST: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
310 "estimate"); break;
311 case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
312 "2-level"); break;
313 case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
314 "4-level"); break;
315 case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
316 "8-level"); break;
317 case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
318 "full search"); break;
dbb45a3b
MN
319 case ORDER_METHOD_LOG: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n",
320 "log search"); break;
a403fc03
JR
321 }
322
323 if(avctx->min_partition_order >= 0) {
324 if(avctx->min_partition_order > MAX_PARTITION_ORDER) {
325 av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",
326 avctx->min_partition_order);
327 return -1;
328 }
329 s->options.min_partition_order = avctx->min_partition_order;
330 }
331 if(avctx->max_partition_order >= 0) {
332 if(avctx->max_partition_order > MAX_PARTITION_ORDER) {
333 av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",
334 avctx->max_partition_order);
335 return -1;
336 }
337 s->options.max_partition_order = avctx->max_partition_order;
338 }
339 if(s->options.max_partition_order < s->options.min_partition_order) {
340 av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",
341 s->options.min_partition_order, s->options.max_partition_order);
342 return -1;
343 }
344 av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",
345 s->options.min_partition_order, s->options.max_partition_order);
346
347 if(avctx->frame_size > 0) {
348 if(avctx->frame_size < FLAC_MIN_BLOCKSIZE ||
c6375bf2 349 avctx->frame_size > FLAC_MAX_BLOCKSIZE) {
a403fc03
JR
350 av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",
351 avctx->frame_size);
352 return -1;
353 }
354 s->blocksize = avctx->frame_size;
355 } else {
356 s->blocksize = select_blocksize(s->samplerate, s->options.block_time_ms);
357 avctx->frame_size = s->blocksize;
358 }
359 av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s->blocksize);
360
361 /* set LPC precision */
362 if(avctx->lpc_coeff_precision > 0) {
363 if(avctx->lpc_coeff_precision > MAX_LPC_PRECISION) {
364 av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",
365 avctx->lpc_coeff_precision);
366 return -1;
367 }
368 s->options.lpc_coeff_precision = avctx->lpc_coeff_precision;
369 } else {
370 /* select LPC precision based on block size */
371 if( s->blocksize <= 192) s->options.lpc_coeff_precision = 7;
372 else if(s->blocksize <= 384) s->options.lpc_coeff_precision = 8;
373 else if(s->blocksize <= 576) s->options.lpc_coeff_precision = 9;
374 else if(s->blocksize <= 1152) s->options.lpc_coeff_precision = 10;
375 else if(s->blocksize <= 2304) s->options.lpc_coeff_precision = 11;
376 else if(s->blocksize <= 4608) s->options.lpc_coeff_precision = 12;
377 else if(s->blocksize <= 8192) s->options.lpc_coeff_precision = 13;
378 else if(s->blocksize <= 16384) s->options.lpc_coeff_precision = 14;
379 else s->options.lpc_coeff_precision = 15;
380 }
381 av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",
382 s->options.lpc_coeff_precision);
9e96ab03 383
f33aa120
MN
384 /* set maximum encoded frame size in verbatim mode */
385 if(s->channels == 2) {
386 s->max_framesize = 14 + ((s->blocksize * 33 + 7) >> 3);
387 } else {
388 s->max_framesize = 14 + (s->blocksize * s->channels * 2);
389 }
9e96ab03
MN
390
391 streaminfo = av_malloc(FLAC_STREAMINFO_SIZE);
392 write_streaminfo(s, streaminfo);
393 avctx->extradata = streaminfo;
394 avctx->extradata_size = FLAC_STREAMINFO_SIZE;
395
396 s->frame_count = 0;
397
398 avctx->coded_frame = avcodec_alloc_frame();
399 avctx->coded_frame->key_frame = 1;
400
401 return 0;
402}
403
f33aa120 404static void init_frame(FlacEncodeContext *s)
9e96ab03
MN
405{
406 int i, ch;
407 FlacFrame *frame;
408
409 frame = &s->frame;
410
411 for(i=0; i<16; i++) {
412 if(s->blocksize == flac_blocksizes[i]) {
413 frame->blocksize = flac_blocksizes[i];
414 frame->bs_code[0] = i;
415 frame->bs_code[1] = 0;
416 break;
417 }
418 }
419 if(i == 16) {
420 frame->blocksize = s->blocksize;
421 if(frame->blocksize <= 256) {
422 frame->bs_code[0] = 6;
423 frame->bs_code[1] = frame->blocksize-1;
424 } else {
425 frame->bs_code[0] = 7;
426 frame->bs_code[1] = frame->blocksize-1;
427 }
428 }
429
430 for(ch=0; ch<s->channels; ch++) {
431 frame->subframes[ch].obits = 16;
432 }
9e96ab03
MN
433}
434
435/**
436 * Copy channel-interleaved input samples into separate subframes
437 */
438static void copy_samples(FlacEncodeContext *s, int16_t *samples)
439{
440 int i, j, ch;
441 FlacFrame *frame;
442
443 frame = &s->frame;
444 for(i=0,j=0; i<frame->blocksize; i++) {
445 for(ch=0; ch<s->channels; ch++,j++) {
446 frame->subframes[ch].samples[i] = samples[j];
447 }
448 }
449}
450
e71bcc37
JR
451
452#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
453
14bd2a9f
LM
454/**
455 * Solve for d/dk(rice_encode_count) = n-((sum-(n>>1))>>(k+1)) = 0
456 */
e71bcc37
JR
457static int find_optimal_param(uint32_t sum, int n)
458{
14bd2a9f
LM
459 int k;
460 uint32_t sum2;
461
462 if(sum <= n>>1)
463 return 0;
464 sum2 = sum-(n>>1);
465 k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);
466 return FFMIN(k, MAX_RICE_PARAM);
e71bcc37
JR
467}
468
469static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder,
470 uint32_t *sums, int n, int pred_order)
471{
472 int i;
473 int k, cnt, part;
474 uint32_t all_bits;
475
476 part = (1 << porder);
477 all_bits = 0;
478
479 cnt = (n >> porder) - pred_order;
480 for(i=0; i<part; i++) {
481 if(i == 1) cnt = (n >> porder);
482 k = find_optimal_param(sums[i], cnt);
483 rc->params[i] = k;
484 all_bits += rice_encode_count(sums[i], cnt, k);
485 }
486 all_bits += (4 * part);
487
488 rc->porder = porder;
489
490 return all_bits;
491}
492
a403fc03
JR
493static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order,
494 uint32_t sums[][MAX_PARTITIONS])
e71bcc37
JR
495{
496 int i, j;
78f67b7a
MN
497 int parts;
498 uint32_t *res, *res_end;
e71bcc37
JR
499
500 /* sums for highest level */
501 parts = (1 << pmax);
502 res = &data[pred_order];
78f67b7a 503 res_end = &data[n >> pmax];
e71bcc37 504 for(i=0; i<parts; i++) {
f6215b1b 505 uint32_t sum = 0;
78f67b7a 506 while(res < res_end){
f6215b1b 507 sum += *(res++);
e71bcc37 508 }
f6215b1b 509 sums[pmax][i] = sum;
78f67b7a 510 res_end+= n >> pmax;
e71bcc37
JR
511 }
512 /* sums for lower levels */
a403fc03 513 for(i=pmax-1; i>=pmin; i--) {
e71bcc37
JR
514 parts = (1 << i);
515 for(j=0; j<parts; j++) {
516 sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1];
517 }
518 }
519}
520
a403fc03
JR
521static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax,
522 int32_t *data, int n, int pred_order)
e71bcc37
JR
523{
524 int i;
a403fc03 525 uint32_t bits[MAX_PARTITION_ORDER+1];
e71bcc37 526 int opt_porder;
a403fc03 527 RiceContext tmp_rc;
e71bcc37 528 uint32_t *udata;
a403fc03 529 uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];
e71bcc37 530
a403fc03
JR
531 assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);
532 assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);
533 assert(pmin <= pmax);
e71bcc37
JR
534
535 udata = av_malloc(n * sizeof(uint32_t));
536 for(i=0; i<n; i++) {
537 udata[i] = (2*data[i]) ^ (data[i]>>31);
538 }
539
a403fc03 540 calc_sums(pmin, pmax, udata, n, pred_order, sums);
e71bcc37 541
a403fc03
JR
542 opt_porder = pmin;
543 bits[pmin] = UINT32_MAX;
544 for(i=pmin; i<=pmax; i++) {
545 bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order);
546 if(bits[i] <= bits[opt_porder]) {
e71bcc37 547 opt_porder = i;
41275956 548 *rc= tmp_rc;
e71bcc37
JR
549 }
550 }
e71bcc37
JR
551
552 av_freep(&udata);
a403fc03 553 return bits[opt_porder];
e71bcc37
JR
554}
555
1e5707b7
JR
556static int get_max_p_order(int max_porder, int n, int order)
557{
558 int porder = FFMIN(max_porder, av_log2(n^(n-1)));
559 if(order > 0)
560 porder = FFMIN(porder, av_log2(n/order));
561 return porder;
562}
563
a403fc03
JR
564static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax,
565 int32_t *data, int n, int pred_order,
566 int bps)
e71bcc37
JR
567{
568 uint32_t bits;
1e5707b7
JR
569 pmin = get_max_p_order(pmin, n, pred_order);
570 pmax = get_max_p_order(pmax, n, pred_order);
e71bcc37 571 bits = pred_order*bps + 6;
a403fc03
JR
572 bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
573 return bits;
574}
575
576static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax,
577 int32_t *data, int n, int pred_order,
578 int bps, int precision)
579{
580 uint32_t bits;
1e5707b7
JR
581 pmin = get_max_p_order(pmin, n, pred_order);
582 pmax = get_max_p_order(pmax, n, pred_order);
a403fc03
JR
583 bits = pred_order*bps + 4 + 5 + pred_order*precision + 6;
584 bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order);
e71bcc37
JR
585 return bits;
586}
587
a403fc03
JR
588/**
589 * Apply Welch window function to audio block
590 */
591static void apply_welch_window(const int32_t *data, int len, double *w_data)
592{
593 int i, n2;
594 double w;
595 double c;
596
597 n2 = (len >> 1);
598 c = 2.0 / (len - 1.0);
599 for(i=0; i<n2; i++) {
600 w = c - i - 1.0;
601 w = 1.0 - (w * w);
602 w_data[i] = data[i] * w;
603 w_data[len-1-i] = data[len-1-i] * w;
604 }
605}
606
607/**
608 * Calculates autocorrelation data from audio samples
609 * A Welch window function is applied before calculation.
610 */
6810b93a
LM
611void ff_flac_compute_autocorr(const int32_t *data, int len, int lag,
612 double *autoc)
a403fc03 613{
28e968c4 614 int i, j;
19b9c7cc 615 double tmp[len + lag + 1];
b2e30cb3 616 double *data1= tmp + lag;
a403fc03 617
a403fc03
JR
618 apply_welch_window(data, len, data1);
619
28e968c4
LM
620 for(j=0; j<lag; j++)
621 data1[j-lag]= 0.0;
19b9c7cc 622 data1[len] = 0.0;
b2e30cb3 623
28e968c4
LM
624 for(j=0; j<lag; j+=2){
625 double sum0 = 1.0, sum1 = 1.0;
626 for(i=0; i<len; i++){
627 sum0 += data1[i] * data1[i-j];
628 sum1 += data1[i] * data1[i-j-1];
a403fc03 629 }
28e968c4
LM
630 autoc[j ] = sum0;
631 autoc[j+1] = sum1;
632 }
633
634 if(j==lag){
635 double sum = 1.0;
19b9c7cc
LM
636 for(i=0; i<len; i+=2){
637 sum += data1[i ] * data1[i-j ]
638 + data1[i+1] * data1[i-j+1];
639 }
28e968c4 640 autoc[j] = sum;
a403fc03 641 }
a403fc03
JR
642}
643
644/**
645 * Levinson-Durbin recursion.
646 * Produces LPC coefficients from autocorrelation data.
647 */
648static void compute_lpc_coefs(const double *autoc, int max_order,
649 double lpc[][MAX_LPC_ORDER], double *ref)
650{
651 int i, j, i2;
652 double r, err, tmp;
653 double lpc_tmp[MAX_LPC_ORDER];
654
655 for(i=0; i<max_order; i++) lpc_tmp[i] = 0;
656 err = autoc[0];
657
658 for(i=0; i<max_order; i++) {
659 r = -autoc[i+1];
660 for(j=0; j<i; j++) {
661 r -= lpc_tmp[j] * autoc[i-j];
662 }
663 r /= err;
664 ref[i] = fabs(r);
665
666 err *= 1.0 - (r * r);
667
668 i2 = (i >> 1);
669 lpc_tmp[i] = r;
670 for(j=0; j<i2; j++) {
671 tmp = lpc_tmp[j];
672 lpc_tmp[j] += r * lpc_tmp[i-1-j];
673 lpc_tmp[i-1-j] += r * tmp;
674 }
675 if(i & 1) {
676 lpc_tmp[j] += lpc_tmp[j] * r;
677 }
678
679 for(j=0; j<=i; j++) {
680 lpc[i][j] = -lpc_tmp[j];
681 }
682 }
683}
684
685/**
686 * Quantize LPC coefficients
687 */
688static void quantize_lpc_coefs(double *lpc_in, int order, int precision,
689 int32_t *lpc_out, int *shift)
690{
691 int i;
1484a467 692 double cmax, error;
a403fc03
JR
693 int32_t qmax;
694 int sh;
695
696 /* define maximum levels */
697 qmax = (1 << (precision - 1)) - 1;
698
699 /* find maximum coefficient value */
700 cmax = 0.0;
701 for(i=0; i<order; i++) {
5d2f52b9 702 cmax= FFMAX(cmax, fabs(lpc_in[i]));
a403fc03
JR
703 }
704
705 /* if maximum value quantizes to zero, return all zeros */
706 if(cmax * (1 << MAX_LPC_SHIFT) < 1.0) {
707 *shift = 0;
5d2f52b9 708 memset(lpc_out, 0, sizeof(int32_t) * order);
a403fc03
JR
709 return;
710 }
711
712 /* calculate level shift which scales max coeff to available bits */
713 sh = MAX_LPC_SHIFT;
714 while((cmax * (1 << sh) > qmax) && (sh > 0)) {
715 sh--;
716 }
717
718 /* since negative shift values are unsupported in decoder, scale down
719 coefficients instead */
720 if(sh == 0 && cmax > qmax) {
721 double scale = ((double)qmax) / cmax;
722 for(i=0; i<order; i++) {
723 lpc_in[i] *= scale;
724 }
725 }
726
727 /* output quantized coefficients and level shift */
1484a467 728 error=0;
a403fc03 729 for(i=0; i<order; i++) {
1484a467 730 error += lpc_in[i] * (1 << sh);
f66e4f5f 731 lpc_out[i] = av_clip(lrintf(error), -qmax, qmax);
1484a467 732 error -= lpc_out[i];
a403fc03
JR
733 }
734 *shift = sh;
735}
736
737static int estimate_best_order(double *ref, int max_order)
738{
739 int i, est;
740
741 est = 1;
742 for(i=max_order-1; i>=0; i--) {
743 if(ref[i] > 0.10) {
744 est = i+1;
745 break;
746 }
747 }
748 return est;
749}
750
751/**
752 * Calculate LPC coefficients for multiple orders
753 */
6810b93a
LM
754static int lpc_calc_coefs(FlacEncodeContext *s,
755 const int32_t *samples, int blocksize, int max_order,
a403fc03 756 int precision, int32_t coefs[][MAX_LPC_ORDER],
26053bdc 757 int *shift, int use_lpc, int omethod)
a403fc03
JR
758{
759 double autoc[MAX_LPC_ORDER+1];
760 double ref[MAX_LPC_ORDER];
761 double lpc[MAX_LPC_ORDER][MAX_LPC_ORDER];
ab01b2b8 762 int i, j, pass;
a403fc03
JR
763 int opt_order;
764
765 assert(max_order >= MIN_LPC_ORDER && max_order <= MAX_LPC_ORDER);
766
ab01b2b8 767 if(use_lpc == 1){
6810b93a 768 s->dsp.flac_compute_autocorr(samples, blocksize, max_order, autoc);
ab01b2b8
MN
769
770 compute_lpc_coefs(autoc, max_order, lpc, ref);
ab01b2b8
MN
771 }else{
772 LLSModel m[2];
408ec4e2 773 double var[MAX_LPC_ORDER+1], eval, weight;
ab01b2b8
MN
774
775 for(pass=0; pass<use_lpc-1; pass++){
8ea543b5 776 av_init_lls(&m[pass&1], max_order);
a403fc03 777
408ec4e2 778 weight=0;
ab01b2b8
MN
779 for(i=max_order; i<blocksize; i++){
780 for(j=0; j<=max_order; j++)
781 var[j]= samples[i-j];
a403fc03 782
ab01b2b8 783 if(pass){
408ec4e2 784 eval= av_evaluate_lls(&m[(pass-1)&1], var+1, max_order-1);
ab01b2b8
MN
785 eval= (512>>pass) + fabs(eval - var[0]);
786 for(j=0; j<=max_order; j++)
8ea543b5 787 var[j]/= sqrt(eval);
408ec4e2
MN
788 weight += 1/eval;
789 }else
790 weight++;
ab01b2b8
MN
791
792 av_update_lls(&m[pass&1], var, 1.0);
793 }
408ec4e2 794 av_solve_lls(&m[pass&1], 0.001, 0);
ab01b2b8
MN
795 }
796
408ec4e2
MN
797 for(i=0; i<max_order; i++){
798 for(j=0; j<max_order; j++)
799 lpc[i][j]= m[(pass-1)&1].coeff[i][j];
800 ref[i]= sqrt(m[(pass-1)&1].variance[i] / weight) * (blocksize - max_order) / 4000;
801 }
802 for(i=max_order-1; i>0; i--)
803 ref[i] = ref[i-1] - ref[i];
ab01b2b8 804 }
26053bdc 805 opt_order = max_order;
a403fc03 806
26053bdc
JR
807 if(omethod == ORDER_METHOD_EST) {
808 opt_order = estimate_best_order(ref, max_order);
809 i = opt_order-1;
810 quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i]);
811 } else {
812 for(i=0; i<max_order; i++) {
813 quantize_lpc_coefs(lpc[i], i+1, precision, coefs[i], &shift[i]);
814 }
815 }
a403fc03
JR
816
817 return opt_order;
818}
819
820
e71bcc37
JR
821static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n)
822{
823 assert(n > 0);
824 memcpy(res, smp, n * sizeof(int32_t));
825}
826
a403fc03
JR
827static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n,
828 int order)
e71bcc37
JR
829{
830 int i;
831
832 for(i=0; i<order; i++) {
833 res[i] = smp[i];
834 }
835
836 if(order==0){
837 for(i=order; i<n; i++)
838 res[i]= smp[i];
839 }else if(order==1){
840 for(i=order; i<n; i++)
841 res[i]= smp[i] - smp[i-1];
842 }else if(order==2){
a309dce7 843 int a = smp[order-1] - smp[order-2];
bfdd5bc1 844 for(i=order; i<n; i+=2) {
a309dce7
LM
845 int b = smp[i] - smp[i-1];
846 res[i]= b - a;
bfdd5bc1
LM
847 a = smp[i+1] - smp[i];
848 res[i+1]= a - b;
a309dce7 849 }
e71bcc37 850 }else if(order==3){
a309dce7
LM
851 int a = smp[order-1] - smp[order-2];
852 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
bfdd5bc1 853 for(i=order; i<n; i+=2) {
a309dce7
LM
854 int b = smp[i] - smp[i-1];
855 int d = b - a;
856 res[i]= d - c;
bfdd5bc1
LM
857 a = smp[i+1] - smp[i];
858 c = a - b;
859 res[i+1]= c - d;
a309dce7 860 }
e71bcc37 861 }else{
a309dce7
LM
862 int a = smp[order-1] - smp[order-2];
863 int c = smp[order-1] - 2*smp[order-2] + smp[order-3];
864 int e = smp[order-1] - 3*smp[order-2] + 3*smp[order-3] - smp[order-4];
bfdd5bc1 865 for(i=order; i<n; i+=2) {
a309dce7
LM
866 int b = smp[i] - smp[i-1];
867 int d = b - a;
868 int f = d - c;
869 res[i]= f - e;
bfdd5bc1
LM
870 a = smp[i+1] - smp[i];
871 c = a - b;
872 e = c - d;
873 res[i+1]= e - f;
a309dce7 874 }
e71bcc37
JR
875 }
876}
877
dc44d4ad 878#define LPC1(x) {\
b8de3429 879 int c = coefs[(x)-1];\
dc44d4ad 880 p0 += c*s;\
b8de3429
LM
881 s = smp[i-(x)+1];\
882 p1 += c*s;\
dc44d4ad
LM
883}
884
885static av_always_inline void encode_residual_lpc_unrolled(
886 int32_t *res, const int32_t *smp, int n,
887 int order, const int32_t *coefs, int shift, int big)
888{
889 int i;
890 for(i=order; i<n; i+=2) {
b8de3429
LM
891 int s = smp[i-order];
892 int p0 = 0, p1 = 0;
dc44d4ad
LM
893 if(big) {
894 switch(order) {
895 case 32: LPC1(32)
896 case 31: LPC1(31)
897 case 30: LPC1(30)
898 case 29: LPC1(29)
899 case 28: LPC1(28)
900 case 27: LPC1(27)
901 case 26: LPC1(26)
902 case 25: LPC1(25)
903 case 24: LPC1(24)
904 case 23: LPC1(23)
905 case 22: LPC1(22)
906 case 21: LPC1(21)
907 case 20: LPC1(20)
908 case 19: LPC1(19)
909 case 18: LPC1(18)
910 case 17: LPC1(17)
911 case 16: LPC1(16)
912 case 15: LPC1(15)
913 case 14: LPC1(14)
914 case 13: LPC1(13)
915 case 12: LPC1(12)
916 case 11: LPC1(11)
917 case 10: LPC1(10)
918 case 9: LPC1( 9)
919 LPC1( 8)
920 LPC1( 7)
921 LPC1( 6)
922 LPC1( 5)
923 LPC1( 4)
924 LPC1( 3)
925 LPC1( 2)
b8de3429 926 LPC1( 1)
dc44d4ad
LM
927 }
928 } else {
929 switch(order) {
930 case 8: LPC1( 8)
931 case 7: LPC1( 7)
932 case 6: LPC1( 6)
933 case 5: LPC1( 5)
934 case 4: LPC1( 4)
935 case 3: LPC1( 3)
936 case 2: LPC1( 2)
b8de3429 937 case 1: LPC1( 1)
dc44d4ad
LM
938 }
939 }
dc44d4ad
LM
940 res[i ] = smp[i ] - (p0 >> shift);
941 res[i+1] = smp[i+1] - (p1 >> shift);
942 }
943}
944
a403fc03
JR
945static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n,
946 int order, const int32_t *coefs, int shift)
947{
dc44d4ad 948 int i;
a403fc03
JR
949 for(i=0; i<order; i++) {
950 res[i] = smp[i];
951 }
dc44d4ad 952#ifdef CONFIG_SMALL
f74471e0 953 for(i=order; i<n; i+=2) {
dc44d4ad 954 int j;
b8de3429
LM
955 int s = smp[i];
956 int p0 = 0, p1 = 0;
957 for(j=0; j<order; j++) {
958 int c = coefs[j];
f74471e0 959 p1 += c*s;
b8de3429
LM
960 s = smp[i-j-1];
961 p0 += c*s;
a403fc03 962 }
b8de3429 963 res[i ] = smp[i ] - (p0 >> shift);
f74471e0 964 res[i+1] = smp[i+1] - (p1 >> shift);
a403fc03 965 }
dc44d4ad
LM
966#else
967 switch(order) {
968 case 1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break;
969 case 2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break;
970 case 3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break;
971 case 4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break;
972 case 5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break;
973 case 6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break;
974 case 7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break;
975 case 8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break;
976 default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break;
977 }
978#endif
a403fc03
JR
979}
980
e71bcc37
JR
981static int encode_residual(FlacEncodeContext *ctx, int ch)
982{
a403fc03 983 int i, n;
26053bdc 984 int min_order, max_order, opt_order, precision, omethod;
1e5707b7 985 int min_porder, max_porder;
e71bcc37
JR
986 FlacFrame *frame;
987 FlacSubframe *sub;
a403fc03
JR
988 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];
989 int shift[MAX_LPC_ORDER];
e71bcc37
JR
990 int32_t *res, *smp;
991
992 frame = &ctx->frame;
993 sub = &frame->subframes[ch];
994 res = sub->residual;
995 smp = sub->samples;
996 n = frame->blocksize;
997
998 /* CONSTANT */
999 for(i=1; i<n; i++) {
1000 if(smp[i] != smp[0]) break;
1001 }
1002 if(i == n) {
1003 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
1004 res[0] = smp[0];
1005 return sub->obits;
1006 }
1007
1008 /* VERBATIM */
1009 if(n < 5) {
1010 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
1011 encode_residual_verbatim(res, smp, n);
1012 return sub->obits * n;
1013 }
1014
a403fc03
JR
1015 min_order = ctx->options.min_prediction_order;
1016 max_order = ctx->options.max_prediction_order;
1017 min_porder = ctx->options.min_partition_order;
1018 max_porder = ctx->options.max_partition_order;
1019 precision = ctx->options.lpc_coeff_precision;
26053bdc 1020 omethod = ctx->options.prediction_order_method;
e71bcc37
JR
1021
1022 /* FIXED */
a403fc03
JR
1023 if(!ctx->options.use_lpc || max_order == 0 || (n <= max_order)) {
1024 uint32_t bits[MAX_FIXED_ORDER+1];
1025 if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;
1026 opt_order = 0;
1027 bits[0] = UINT32_MAX;
1028 for(i=min_order; i<=max_order; i++) {
1029 encode_residual_fixed(res, smp, n, i);
1e5707b7 1030 bits[i] = calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res,
a403fc03
JR
1031 n, i, sub->obits);
1032 if(bits[i] < bits[opt_order]) {
1033 opt_order = i;
1034 }
e71bcc37 1035 }
a403fc03
JR
1036 sub->order = opt_order;
1037 sub->type = FLAC_SUBFRAME_FIXED;
1038 sub->type_code = sub->type | sub->order;
1039 if(sub->order != max_order) {
1040 encode_residual_fixed(res, smp, n, sub->order);
1e5707b7 1041 return calc_rice_params_fixed(&sub->rc, min_porder, max_porder, res, n,
a403fc03
JR
1042 sub->order, sub->obits);
1043 }
1044 return bits[sub->order];
e71bcc37 1045 }
a403fc03
JR
1046
1047 /* LPC */
6810b93a 1048 opt_order = lpc_calc_coefs(ctx, smp, n, max_order, precision, coefs, shift, ctx->options.use_lpc, omethod);
26053bdc
JR
1049
1050 if(omethod == ORDER_METHOD_2LEVEL ||
1051 omethod == ORDER_METHOD_4LEVEL ||
1052 omethod == ORDER_METHOD_8LEVEL) {
1053 int levels = 1 << omethod;
1054 uint32_t bits[levels];
1055 int order;
1056 int opt_index = levels-1;
1057 opt_order = max_order-1;
1058 bits[opt_index] = UINT32_MAX;
1059 for(i=levels-1; i>=0; i--) {
1060 order = min_order + (((max_order-min_order+1) * (i+1)) / levels)-1;
1061 if(order < 0) order = 0;
1062 encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);
1063 bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
1064 res, n, order+1, sub->obits, precision);
1065 if(bits[i] < bits[opt_index]) {
1066 opt_index = i;
1067 opt_order = order;
1068 }
1069 }
1070 opt_order++;
1071 } else if(omethod == ORDER_METHOD_SEARCH) {
1072 // brute-force optimal order search
1073 uint32_t bits[MAX_LPC_ORDER];
1074 opt_order = 0;
1075 bits[0] = UINT32_MAX;
1076 for(i=min_order-1; i<max_order; i++) {
1077 encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
1078 bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
1079 res, n, i+1, sub->obits, precision);
1080 if(bits[i] < bits[opt_order]) {
1081 opt_order = i;
1082 }
1083 }
1084 opt_order++;
dbb45a3b
MN
1085 } else if(omethod == ORDER_METHOD_LOG) {
1086 uint32_t bits[MAX_LPC_ORDER];
1087 int step;
1088
1089 opt_order= min_order - 1 + (max_order-min_order)/3;
1090 memset(bits, -1, sizeof(bits));
1091
1092 for(step=16 ;step; step>>=1){
1093 int last= opt_order;
1094 for(i=last-step; i<=last+step; i+= step){
1095 if(i<min_order-1 || i>=max_order || bits[i] < UINT32_MAX)
1096 continue;
1097 encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);
1098 bits[i] = calc_rice_params_lpc(&sub->rc, min_porder, max_porder,
1099 res, n, i+1, sub->obits, precision);
1100 if(bits[i] < bits[opt_order])
1101 opt_order= i;
1102 }
1103 }
1104 opt_order++;
26053bdc
JR
1105 }
1106
1107 sub->order = opt_order;
a403fc03
JR
1108 sub->type = FLAC_SUBFRAME_LPC;
1109 sub->type_code = sub->type | (sub->order-1);
1110 sub->shift = shift[sub->order-1];
1111 for(i=0; i<sub->order; i++) {
1112 sub->coefs[i] = coefs[sub->order-1][i];
e71bcc37 1113 }
a403fc03 1114 encode_residual_lpc(res, smp, n, sub->order, sub->coefs, sub->shift);
1e5707b7 1115 return calc_rice_params_lpc(&sub->rc, min_porder, max_porder, res, n, sub->order,
a403fc03 1116 sub->obits, precision);
e71bcc37
JR
1117}
1118
1119static int encode_residual_v(FlacEncodeContext *ctx, int ch)
1120{
1121 int i, n;
1122 FlacFrame *frame;
1123 FlacSubframe *sub;
1124 int32_t *res, *smp;
1125
1126 frame = &ctx->frame;
1127 sub = &frame->subframes[ch];
1128 res = sub->residual;
1129 smp = sub->samples;
1130 n = frame->blocksize;
1131
1132 /* CONSTANT */
1133 for(i=1; i<n; i++) {
1134 if(smp[i] != smp[0]) break;
1135 }
1136 if(i == n) {
1137 sub->type = sub->type_code = FLAC_SUBFRAME_CONSTANT;
1138 res[0] = smp[0];
1139 return sub->obits;
1140 }
1141
1142 /* VERBATIM */
1143 sub->type = sub->type_code = FLAC_SUBFRAME_VERBATIM;
1144 encode_residual_verbatim(res, smp, n);
1145 return sub->obits * n;
1146}
1147
f33aa120
MN
1148static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)
1149{
1150 int i, best;
1151 int32_t lt, rt;
e71bcc37 1152 uint64_t sum[4];
f33aa120 1153 uint64_t score[4];
e71bcc37 1154 int k;
f33aa120 1155
a403fc03 1156 /* calculate sum of 2nd order residual for each channel */
e71bcc37 1157 sum[0] = sum[1] = sum[2] = sum[3] = 0;
f33aa120
MN
1158 for(i=2; i<n; i++) {
1159 lt = left_ch[i] - 2*left_ch[i-1] + left_ch[i-2];
1160 rt = right_ch[i] - 2*right_ch[i-1] + right_ch[i-2];
c26abfa5
DB
1161 sum[2] += FFABS((lt + rt) >> 1);
1162 sum[3] += FFABS(lt - rt);
1163 sum[0] += FFABS(lt);
1164 sum[1] += FFABS(rt);
e71bcc37 1165 }
a403fc03 1166 /* estimate bit counts */
e71bcc37
JR
1167 for(i=0; i<4; i++) {
1168 k = find_optimal_param(2*sum[i], n);
1169 sum[i] = rice_encode_count(2*sum[i], n, k);
f33aa120
MN
1170 }
1171
1172 /* calculate score for each mode */
e71bcc37
JR
1173 score[0] = sum[0] + sum[1];
1174 score[1] = sum[0] + sum[3];
1175 score[2] = sum[1] + sum[3];
1176 score[3] = sum[2] + sum[3];
f33aa120
MN
1177
1178 /* return mode with lowest score */
1179 best = 0;
1180 for(i=1; i<4; i++) {
1181 if(score[i] < score[best]) {
1182 best = i;
1183 }
1184 }
1185 if(best == 0) {
1186 return FLAC_CHMODE_LEFT_RIGHT;
1187 } else if(best == 1) {
1188 return FLAC_CHMODE_LEFT_SIDE;
1189 } else if(best == 2) {
1190 return FLAC_CHMODE_RIGHT_SIDE;
1191 } else {
1192 return FLAC_CHMODE_MID_SIDE;
1193 }
1194}
1195
1196/**
1197 * Perform stereo channel decorrelation
1198 */
1199static void channel_decorrelation(FlacEncodeContext *ctx)
1200{
1201 FlacFrame *frame;
1202 int32_t *left, *right;
1203 int i, n;
1204
1205 frame = &ctx->frame;
1206 n = frame->blocksize;
1207 left = frame->subframes[0].samples;
1208 right = frame->subframes[1].samples;
1209
1210 if(ctx->channels != 2) {
1211 frame->ch_mode = FLAC_CHMODE_NOT_STEREO;
1212 return;
1213 }
1214
1215 frame->ch_mode = estimate_stereo_mode(left, right, n);
1216
1217 /* perform decorrelation and adjust bits-per-sample */
1218 if(frame->ch_mode == FLAC_CHMODE_LEFT_RIGHT) {
1219 return;
1220 }
1221 if(frame->ch_mode == FLAC_CHMODE_MID_SIDE) {
1222 int32_t tmp;
1223 for(i=0; i<n; i++) {
1224 tmp = left[i];
1225 left[i] = (tmp + right[i]) >> 1;
1226 right[i] = tmp - right[i];
1227 }
1228 frame->subframes[1].obits++;
1229 } else if(frame->ch_mode == FLAC_CHMODE_LEFT_SIDE) {
1230 for(i=0; i<n; i++) {
1231 right[i] = left[i] - right[i];
1232 }
1233 frame->subframes[1].obits++;
1234 } else {
1235 for(i=0; i<n; i++) {
1236 left[i] -= right[i];
1237 }
1238 frame->subframes[0].obits++;
1239 }
1240}
1241
e71bcc37 1242static void put_sbits(PutBitContext *pb, int bits, int32_t val)
9e96ab03 1243{
9e96ab03 1244 assert(bits >= 0 && bits <= 31);
d1015e88
MN
1245
1246 put_bits(pb, bits, val & ((1<<bits)-1));
9e96ab03
MN
1247}
1248
e71bcc37 1249static void write_utf8(PutBitContext *pb, uint32_t val)
9e96ab03 1250{
360932f7
ZM
1251 uint8_t tmp;
1252 PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)
9e96ab03
MN
1253}
1254
e71bcc37 1255static void output_frame_header(FlacEncodeContext *s)
9e96ab03
MN
1256{
1257 FlacFrame *frame;
1258 int crc;
1259
1260 frame = &s->frame;
1261
1262 put_bits(&s->pb, 16, 0xFFF8);
1263 put_bits(&s->pb, 4, frame->bs_code[0]);
1264 put_bits(&s->pb, 4, s->sr_code[0]);
1265 if(frame->ch_mode == FLAC_CHMODE_NOT_STEREO) {
1266 put_bits(&s->pb, 4, s->ch_code);
1267 } else {
1268 put_bits(&s->pb, 4, frame->ch_mode);
1269 }
1270 put_bits(&s->pb, 3, 4); /* bits-per-sample code */
1271 put_bits(&s->pb, 1, 0);
1272 write_utf8(&s->pb, s->frame_count);
f33aa120
MN
1273 if(frame->bs_code[0] == 6) {
1274 put_bits(&s->pb, 8, frame->bs_code[1]);
1275 } else if(frame->bs_code[0] == 7) {
1276 put_bits(&s->pb, 16, frame->bs_code[1]);
9e96ab03 1277 }
f33aa120
MN
1278 if(s->sr_code[0] == 12) {
1279 put_bits(&s->pb, 8, s->sr_code[1]);
1280 } else if(s->sr_code[0] > 12) {
1281 put_bits(&s->pb, 16, s->sr_code[1]);
9e96ab03
MN
1282 }
1283 flush_put_bits(&s->pb);
1284 crc = av_crc(av_crc07, 0, s->pb.buf, put_bits_count(&s->pb)>>3);
1285 put_bits(&s->pb, 8, crc);
1286}
1287
e71bcc37
JR
1288static void output_subframe_constant(FlacEncodeContext *s, int ch)
1289{
1290 FlacSubframe *sub;
1291 int32_t res;
1292
1293 sub = &s->frame.subframes[ch];
1294 res = sub->residual[0];
1295 put_sbits(&s->pb, sub->obits, res);
1296}
1297
9e96ab03
MN
1298static void output_subframe_verbatim(FlacEncodeContext *s, int ch)
1299{
1300 int i;
1301 FlacFrame *frame;
1302 FlacSubframe *sub;
1303 int32_t res;
1304
1305 frame = &s->frame;
1306 sub = &frame->subframes[ch];
1307
1308 for(i=0; i<frame->blocksize; i++) {
1309 res = sub->residual[i];
1310 put_sbits(&s->pb, sub->obits, res);
1311 }
1312}
1313
e71bcc37 1314static void output_residual(FlacEncodeContext *ctx, int ch)
9e96ab03 1315{
e71bcc37 1316 int i, j, p, n, parts;
9e96ab03
MN
1317 int k, porder, psize, res_cnt;
1318 FlacFrame *frame;
1319 FlacSubframe *sub;
e71bcc37 1320 int32_t *res;
9e96ab03
MN
1321
1322 frame = &ctx->frame;
1323 sub = &frame->subframes[ch];
e71bcc37
JR
1324 res = sub->residual;
1325 n = frame->blocksize;
9e96ab03
MN
1326
1327 /* rice-encoded block */
1328 put_bits(&ctx->pb, 2, 0);
1329
1330 /* partition order */
e71bcc37
JR
1331 porder = sub->rc.porder;
1332 psize = n >> porder;
1333 parts = (1 << porder);
9e96ab03
MN
1334 put_bits(&ctx->pb, 4, porder);
1335 res_cnt = psize - sub->order;
1336
1337 /* residual */
1338 j = sub->order;
e71bcc37
JR
1339 for(p=0; p<parts; p++) {
1340 k = sub->rc.params[p];
9e96ab03
MN
1341 put_bits(&ctx->pb, 4, k);
1342 if(p == 1) res_cnt = psize;
e71bcc37
JR
1343 for(i=0; i<res_cnt && j<n; i++, j++) {
1344 set_sr_golomb_flac(&ctx->pb, res[j], k, INT32_MAX, 0);
9e96ab03
MN
1345 }
1346 }
1347}
1348
e71bcc37 1349static void output_subframe_fixed(FlacEncodeContext *ctx, int ch)
9e96ab03
MN
1350{
1351 int i;
1352 FlacFrame *frame;
1353 FlacSubframe *sub;
1354
1355 frame = &ctx->frame;
1356 sub = &frame->subframes[ch];
1357
1358 /* warm-up samples */
1359 for(i=0; i<sub->order; i++) {
1360 put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1361 }
1362
1363 /* residual */
1364 output_residual(ctx, ch);
1365}
1366
a403fc03
JR
1367static void output_subframe_lpc(FlacEncodeContext *ctx, int ch)
1368{
1369 int i, cbits;
1370 FlacFrame *frame;
1371 FlacSubframe *sub;
1372
1373 frame = &ctx->frame;
1374 sub = &frame->subframes[ch];
1375
1376 /* warm-up samples */
1377 for(i=0; i<sub->order; i++) {
1378 put_sbits(&ctx->pb, sub->obits, sub->residual[i]);
1379 }
1380
1381 /* LPC coefficients */
1382 cbits = ctx->options.lpc_coeff_precision;
1383 put_bits(&ctx->pb, 4, cbits-1);
1384 put_sbits(&ctx->pb, 5, sub->shift);
1385 for(i=0; i<sub->order; i++) {
1386 put_sbits(&ctx->pb, cbits, sub->coefs[i]);
1387 }
1388
1389 /* residual */
1390 output_residual(ctx, ch);
1391}
1392
9e96ab03
MN
1393static void output_subframes(FlacEncodeContext *s)
1394{
1395 FlacFrame *frame;
1396 FlacSubframe *sub;
1397 int ch;
1398
1399 frame = &s->frame;
1400
1401 for(ch=0; ch<s->channels; ch++) {
1402 sub = &frame->subframes[ch];
1403
1404 /* subframe header */
1405 put_bits(&s->pb, 1, 0);
1406 put_bits(&s->pb, 6, sub->type_code);
1407 put_bits(&s->pb, 1, 0); /* no wasted bits */
1408
1409 /* subframe */
e71bcc37
JR
1410 if(sub->type == FLAC_SUBFRAME_CONSTANT) {
1411 output_subframe_constant(s, ch);
1412 } else if(sub->type == FLAC_SUBFRAME_VERBATIM) {
9e96ab03 1413 output_subframe_verbatim(s, ch);
e71bcc37 1414 } else if(sub->type == FLAC_SUBFRAME_FIXED) {
9e96ab03 1415 output_subframe_fixed(s, ch);
a403fc03
JR
1416 } else if(sub->type == FLAC_SUBFRAME_LPC) {
1417 output_subframe_lpc(s, ch);
9e96ab03
MN
1418 }
1419 }
1420}
1421
1422static void output_frame_footer(FlacEncodeContext *s)
1423{
1424 int crc;
1425 flush_put_bits(&s->pb);
1426 crc = bswap_16(av_crc(av_crc8005, 0, s->pb.buf, put_bits_count(&s->pb)>>3));
1427 put_bits(&s->pb, 16, crc);
1428 flush_put_bits(&s->pb);
1429}
1430
1431static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame,
1432 int buf_size, void *data)
1433{
1434 int ch;
1435 FlacEncodeContext *s;
1436 int16_t *samples = data;
1437 int out_bytes;
1438
1439 s = avctx->priv_data;
1440
1441 s->blocksize = avctx->frame_size;
f33aa120 1442 init_frame(s);
9e96ab03
MN
1443
1444 copy_samples(s, samples);
1445
f33aa120
MN
1446 channel_decorrelation(s);
1447
9e96ab03
MN
1448 for(ch=0; ch<s->channels; ch++) {
1449 encode_residual(s, ch);
1450 }
1451 init_put_bits(&s->pb, frame, buf_size);
1452 output_frame_header(s);
1453 output_subframes(s);
1454 output_frame_footer(s);
1455 out_bytes = put_bits_count(&s->pb) >> 3;
1456
1457 if(out_bytes > s->max_framesize || out_bytes >= buf_size) {
1458 /* frame too large. use verbatim mode */
1459 for(ch=0; ch<s->channels; ch++) {
e71bcc37 1460 encode_residual_v(s, ch);
9e96ab03
MN
1461 }
1462 init_put_bits(&s->pb, frame, buf_size);
1463 output_frame_header(s);
1464 output_subframes(s);
1465 output_frame_footer(s);
1466 out_bytes = put_bits_count(&s->pb) >> 3;
1467
1468 if(out_bytes > s->max_framesize || out_bytes >= buf_size) {
1469 /* still too large. must be an error. */
1470 av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");
1471 return -1;
1472 }
1473 }
1474
1475 s->frame_count++;
1476 return out_bytes;
1477}
1478
1479static int flac_encode_close(AVCodecContext *avctx)
1480{
f33aa120
MN
1481 av_freep(&avctx->extradata);
1482 avctx->extradata_size = 0;
9e96ab03
MN
1483 av_freep(&avctx->coded_frame);
1484 return 0;
1485}
1486
1487AVCodec flac_encoder = {
1488 "flac",
1489 CODEC_TYPE_AUDIO,
1490 CODEC_ID_FLAC,
1491 sizeof(FlacEncodeContext),
1492 flac_encode_init,
1493 flac_encode_frame,
1494 flac_encode_close,
1495 NULL,
1496 .capabilities = CODEC_CAP_SMALL_LAST_FRAME,
1497};