ffmpeg / libavcodec / flacenc.c @ f1f373c2
History  View  Annotate  Download (38.4 KB)
1 
/**


2 
* FLAC audio encoder

3 
* Copyright (c) 2006 Justin Ruggles <justin.ruggles@gmail.com>

4 
*

5 
* This file is part of FFmpeg.

6 
*

7 
* FFmpeg is free software; you can redistribute it and/or

8 
* modify it under the terms of the GNU Lesser General Public

9 
* License as published by the Free Software Foundation; either

10 
* version 2.1 of the License, or (at your option) any later version.

11 
*

12 
* FFmpeg is distributed in the hope that it will be useful,

13 
* but WITHOUT ANY WARRANTY; without even the implied warranty of

14 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 
* Lesser General Public License for more details.

16 
*

17 
* You should have received a copy of the GNU Lesser General Public

18 
* License along with FFmpeg; if not, write to the Free Software

19 
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 021101301 USA

20 
*/

21  
22 
#include "libavutil/crc.h" 
23 
#include "libavutil/lls.h" 
24 
#include "avcodec.h" 
25 
#include "bitstream.h" 
26 
#include "dsputil.h" 
27 
#include "golomb.h" 
28 
#include "lpc.h" 
29  
30 
#define FLAC_MAX_CH 8 
31 
#define FLAC_MIN_BLOCKSIZE 16 
32 
#define FLAC_MAX_BLOCKSIZE 65535 
33  
34 
#define FLAC_SUBFRAME_CONSTANT 0 
35 
#define FLAC_SUBFRAME_VERBATIM 1 
36 
#define FLAC_SUBFRAME_FIXED 8 
37 
#define FLAC_SUBFRAME_LPC 32 
38  
39 
#define FLAC_CHMODE_NOT_STEREO 0 
40 
#define FLAC_CHMODE_LEFT_RIGHT 1 
41 
#define FLAC_CHMODE_LEFT_SIDE 8 
42 
#define FLAC_CHMODE_RIGHT_SIDE 9 
43 
#define FLAC_CHMODE_MID_SIDE 10 
44  
45 
#define FLAC_STREAMINFO_SIZE 34 
46  
47 
#define MAX_FIXED_ORDER 4 
48 
#define MAX_PARTITION_ORDER 8 
49 
#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER) 
50 
#define MAX_LPC_PRECISION 15 
51 
#define MAX_LPC_SHIFT 15 
52 
#define MAX_RICE_PARAM 14 
53  
54 
typedef struct CompressionOptions { 
55 
int compression_level;

56 
int block_time_ms;

57 
int use_lpc;

58 
int lpc_coeff_precision;

59 
int min_prediction_order;

60 
int max_prediction_order;

61 
int prediction_order_method;

62 
int min_partition_order;

63 
int max_partition_order;

64 
} CompressionOptions; 
65  
66 
typedef struct RiceContext { 
67 
int porder;

68 
int params[MAX_PARTITIONS];

69 
} RiceContext; 
70  
71 
typedef struct FlacSubframe { 
72 
int type;

73 
int type_code;

74 
int obits;

75 
int order;

76 
int32_t coefs[MAX_LPC_ORDER]; 
77 
int shift;

78 
RiceContext rc; 
79 
int32_t samples[FLAC_MAX_BLOCKSIZE]; 
80 
int32_t residual[FLAC_MAX_BLOCKSIZE+1];

81 
} FlacSubframe; 
82  
83 
typedef struct FlacFrame { 
84 
FlacSubframe subframes[FLAC_MAX_CH]; 
85 
int blocksize;

86 
int bs_code[2]; 
87 
uint8_t crc8; 
88 
int ch_mode;

89 
} FlacFrame; 
90  
91 
typedef struct FlacEncodeContext { 
92 
PutBitContext pb; 
93 
int channels;

94 
int ch_code;

95 
int samplerate;

96 
int sr_code[2]; 
97 
int max_framesize;

98 
uint32_t frame_count; 
99 
FlacFrame frame; 
100 
CompressionOptions options; 
101 
AVCodecContext *avctx; 
102 
DSPContext dsp; 
103 
} FlacEncodeContext; 
104  
105 
static const int flac_samplerates[16] = { 
106 
0, 0, 0, 0, 
107 
8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000, 
108 
0, 0, 0, 0 
109 
}; 
110  
111 
static const int flac_blocksizes[16] = { 
112 
0,

113 
192,

114 
576, 1152, 2304, 4608, 
115 
0, 0, 
116 
256, 512, 1024, 2048, 4096, 8192, 16384, 32768 
117 
}; 
118  
119 
/**

120 
* Writes streaminfo metadata block to byte array

121 
*/

122 
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header) 
123 
{ 
124 
PutBitContext pb; 
125  
126 
memset(header, 0, FLAC_STREAMINFO_SIZE);

127 
init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE); 
128  
129 
/* streaminfo metadata block */

130 
put_bits(&pb, 16, s>avctx>frame_size);

131 
put_bits(&pb, 16, s>avctx>frame_size);

132 
put_bits(&pb, 24, 0); 
133 
put_bits(&pb, 24, s>max_framesize);

134 
put_bits(&pb, 20, s>samplerate);

135 
put_bits(&pb, 3, s>channels1); 
136 
put_bits(&pb, 5, 15); /* bits per sample  1 */ 
137 
flush_put_bits(&pb); 
138 
/* total samples = 0 */

139 
/* MD5 signature = 0 */

140 
} 
141  
142 
/**

143 
* Sets blocksize based on samplerate

144 
* Chooses the closest predefined blocksize >= BLOCK_TIME_MS milliseconds

145 
*/

146 
static int select_blocksize(int samplerate, int block_time_ms) 
147 
{ 
148 
int i;

149 
int target;

150 
int blocksize;

151  
152 
assert(samplerate > 0);

153 
blocksize = flac_blocksizes[1];

154 
target = (samplerate * block_time_ms) / 1000;

155 
for(i=0; i<16; i++) { 
156 
if(target >= flac_blocksizes[i] && flac_blocksizes[i] > blocksize) {

157 
blocksize = flac_blocksizes[i]; 
158 
} 
159 
} 
160 
return blocksize;

161 
} 
162  
163 
static av_cold int flac_encode_init(AVCodecContext *avctx) 
164 
{ 
165 
int freq = avctx>sample_rate;

166 
int channels = avctx>channels;

167 
FlacEncodeContext *s = avctx>priv_data; 
168 
int i, level;

169 
uint8_t *streaminfo; 
170  
171 
s>avctx = avctx; 
172  
173 
dsputil_init(&s>dsp, avctx); 
174  
175 
if(avctx>sample_fmt != SAMPLE_FMT_S16) {

176 
return 1; 
177 
} 
178  
179 
if(channels < 1  channels > FLAC_MAX_CH) { 
180 
return 1; 
181 
} 
182 
s>channels = channels; 
183 
s>ch_code = s>channels1;

184  
185 
/* find samplerate in table */

186 
if(freq < 1) 
187 
return 1; 
188 
for(i=4; i<12; i++) { 
189 
if(freq == flac_samplerates[i]) {

190 
s>samplerate = flac_samplerates[i]; 
191 
s>sr_code[0] = i;

192 
s>sr_code[1] = 0; 
193 
break;

194 
} 
195 
} 
196 
/* if not in table, samplerate is nonstandard */

197 
if(i == 12) { 
198 
if(freq % 1000 == 0 && freq < 255000) { 
199 
s>sr_code[0] = 12; 
200 
s>sr_code[1] = freq / 1000; 
201 
} else if(freq % 10 == 0 && freq < 655350) { 
202 
s>sr_code[0] = 14; 
203 
s>sr_code[1] = freq / 10; 
204 
} else if(freq < 65535) { 
205 
s>sr_code[0] = 13; 
206 
s>sr_code[1] = freq;

207 
} else {

208 
return 1; 
209 
} 
210 
s>samplerate = freq; 
211 
} 
212  
213 
/* set compression option defaults based on avctx>compression_level */

214 
if(avctx>compression_level < 0) { 
215 
s>options.compression_level = 5;

216 
} else {

217 
s>options.compression_level = avctx>compression_level; 
218 
} 
219 
av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", s>options.compression_level);

220  
221 
level= s>options.compression_level; 
222 
if(level > 12) { 
223 
av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",

224 
s>options.compression_level); 
225 
return 1; 
226 
} 
227  
228 
s>options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level]; 
229 
s>options.use_lpc = ((int[]){ 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level]; 
230 
s>options.min_prediction_order= ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level]; 
231 
s>options.max_prediction_order= ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level]; 
232 
s>options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,

233 
ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, 
234 
ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL, 
235 
ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG, 
236 
ORDER_METHOD_SEARCH})[level]; 
237 
s>options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level]; 
238 
s>options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level]; 
239  
240 
/* set compression option overrides from AVCodecContext */

241 
if(avctx>use_lpc >= 0) { 
242 
s>options.use_lpc = av_clip(avctx>use_lpc, 0, 11); 
243 
} 
244 
if(s>options.use_lpc == 1) 
245 
av_log(avctx, AV_LOG_DEBUG, " use lpc: LevinsonDurbin recursion with Welch window\n");

246 
else if(s>options.use_lpc > 1) 
247 
av_log(avctx, AV_LOG_DEBUG, " use lpc: Cholesky factorization\n");

248  
249 
if(avctx>min_prediction_order >= 0) { 
250 
if(s>options.use_lpc) {

251 
if(avctx>min_prediction_order < MIN_LPC_ORDER 

252 
avctx>min_prediction_order > MAX_LPC_ORDER) { 
253 
av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",

254 
avctx>min_prediction_order); 
255 
return 1; 
256 
} 
257 
} else {

258 
if(avctx>min_prediction_order > MAX_FIXED_ORDER) {

259 
av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",

260 
avctx>min_prediction_order); 
261 
return 1; 
262 
} 
263 
} 
264 
s>options.min_prediction_order = avctx>min_prediction_order; 
265 
} 
266 
if(avctx>max_prediction_order >= 0) { 
267 
if(s>options.use_lpc) {

268 
if(avctx>max_prediction_order < MIN_LPC_ORDER 

269 
avctx>max_prediction_order > MAX_LPC_ORDER) { 
270 
av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",

271 
avctx>max_prediction_order); 
272 
return 1; 
273 
} 
274 
} else {

275 
if(avctx>max_prediction_order > MAX_FIXED_ORDER) {

276 
av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",

277 
avctx>max_prediction_order); 
278 
return 1; 
279 
} 
280 
} 
281 
s>options.max_prediction_order = avctx>max_prediction_order; 
282 
} 
283 
if(s>options.max_prediction_order < s>options.min_prediction_order) {

284 
av_log(avctx, AV_LOG_ERROR, "invalid prediction orders: min=%d max=%d\n",

285 
s>options.min_prediction_order, s>options.max_prediction_order); 
286 
return 1; 
287 
} 
288 
av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",

289 
s>options.min_prediction_order, s>options.max_prediction_order); 
290  
291 
if(avctx>prediction_order_method >= 0) { 
292 
if(avctx>prediction_order_method > ORDER_METHOD_LOG) {

293 
av_log(avctx, AV_LOG_ERROR, "invalid prediction order method: %d\n",

294 
avctx>prediction_order_method); 
295 
return 1; 
296 
} 
297 
s>options.prediction_order_method = avctx>prediction_order_method; 
298 
} 
299 
switch(s>options.prediction_order_method) {

300 
case ORDER_METHOD_EST: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
301 
"estimate"); break; 
302 
case ORDER_METHOD_2LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
303 
"2level"); break; 
304 
case ORDER_METHOD_4LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
305 
"4level"); break; 
306 
case ORDER_METHOD_8LEVEL: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
307 
"8level"); break; 
308 
case ORDER_METHOD_SEARCH: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
309 
"full search"); break; 
310 
case ORDER_METHOD_LOG: av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", 
311 
"log search"); break; 
312 
} 
313  
314 
if(avctx>min_partition_order >= 0) { 
315 
if(avctx>min_partition_order > MAX_PARTITION_ORDER) {

316 
av_log(avctx, AV_LOG_ERROR, "invalid min partition order: %d\n",

317 
avctx>min_partition_order); 
318 
return 1; 
319 
} 
320 
s>options.min_partition_order = avctx>min_partition_order; 
321 
} 
322 
if(avctx>max_partition_order >= 0) { 
323 
if(avctx>max_partition_order > MAX_PARTITION_ORDER) {

324 
av_log(avctx, AV_LOG_ERROR, "invalid max partition order: %d\n",

325 
avctx>max_partition_order); 
326 
return 1; 
327 
} 
328 
s>options.max_partition_order = avctx>max_partition_order; 
329 
} 
330 
if(s>options.max_partition_order < s>options.min_partition_order) {

331 
av_log(avctx, AV_LOG_ERROR, "invalid partition orders: min=%d max=%d\n",

332 
s>options.min_partition_order, s>options.max_partition_order); 
333 
return 1; 
334 
} 
335 
av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",

336 
s>options.min_partition_order, s>options.max_partition_order); 
337  
338 
if(avctx>frame_size > 0) { 
339 
if(avctx>frame_size < FLAC_MIN_BLOCKSIZE 

340 
avctx>frame_size > FLAC_MAX_BLOCKSIZE) { 
341 
av_log(avctx, AV_LOG_ERROR, "invalid block size: %d\n",

342 
avctx>frame_size); 
343 
return 1; 
344 
} 
345 
} else {

346 
s>avctx>frame_size = select_blocksize(s>samplerate, s>options.block_time_ms); 
347 
} 
348 
av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", s>avctx>frame_size);

349  
350 
/* set LPC precision */

351 
if(avctx>lpc_coeff_precision > 0) { 
352 
if(avctx>lpc_coeff_precision > MAX_LPC_PRECISION) {

353 
av_log(avctx, AV_LOG_ERROR, "invalid lpc coeff precision: %d\n",

354 
avctx>lpc_coeff_precision); 
355 
return 1; 
356 
} 
357 
s>options.lpc_coeff_precision = avctx>lpc_coeff_precision; 
358 
} else {

359 
/* default LPC precision */

360 
s>options.lpc_coeff_precision = 15;

361 
} 
362 
av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",

363 
s>options.lpc_coeff_precision); 
364  
365 
/* set maximum encoded frame size in verbatim mode */

366 
if(s>channels == 2) { 
367 
s>max_framesize = 14 + ((s>avctx>frame_size * 33 + 7) >> 3); 
368 
} else {

369 
s>max_framesize = 14 + (s>avctx>frame_size * s>channels * 2); 
370 
} 
371  
372 
streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); 
373 
write_streaminfo(s, streaminfo); 
374 
avctx>extradata = streaminfo; 
375 
avctx>extradata_size = FLAC_STREAMINFO_SIZE; 
376  
377 
s>frame_count = 0;

378  
379 
avctx>coded_frame = avcodec_alloc_frame(); 
380 
avctx>coded_frame>key_frame = 1;

381  
382 
return 0; 
383 
} 
384  
385 
static void init_frame(FlacEncodeContext *s) 
386 
{ 
387 
int i, ch;

388 
FlacFrame *frame; 
389  
390 
frame = &s>frame; 
391  
392 
for(i=0; i<16; i++) { 
393 
if(s>avctx>frame_size == flac_blocksizes[i]) {

394 
frame>blocksize = flac_blocksizes[i]; 
395 
frame>bs_code[0] = i;

396 
frame>bs_code[1] = 0; 
397 
break;

398 
} 
399 
} 
400 
if(i == 16) { 
401 
frame>blocksize = s>avctx>frame_size; 
402 
if(frame>blocksize <= 256) { 
403 
frame>bs_code[0] = 6; 
404 
frame>bs_code[1] = frame>blocksize1; 
405 
} else {

406 
frame>bs_code[0] = 7; 
407 
frame>bs_code[1] = frame>blocksize1; 
408 
} 
409 
} 
410  
411 
for(ch=0; ch<s>channels; ch++) { 
412 
frame>subframes[ch].obits = 16;

413 
} 
414 
} 
415  
416 
/**

417 
* Copy channelinterleaved input samples into separate subframes

418 
*/

419 
static void copy_samples(FlacEncodeContext *s, int16_t *samples) 
420 
{ 
421 
int i, j, ch;

422 
FlacFrame *frame; 
423  
424 
frame = &s>frame; 
425 
for(i=0,j=0; i<frame>blocksize; i++) { 
426 
for(ch=0; ch<s>channels; ch++,j++) { 
427 
frame>subframes[ch].samples[i] = samples[j]; 
428 
} 
429 
} 
430 
} 
431  
432  
433 
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum(n>>1))>>(k))) 
434  
435 
/**

436 
* Solve for d/dk(rice_encode_count) = n((sum(n>>1))>>(k+1)) = 0

437 
*/

438 
static int find_optimal_param(uint32_t sum, int n) 
439 
{ 
440 
int k;

441 
uint32_t sum2; 
442  
443 
if(sum <= n>>1) 
444 
return 0; 
445 
sum2 = sum(n>>1);

446 
k = av_log2(n<256 ? FASTDIV(sum2,n) : sum2/n);

447 
return FFMIN(k, MAX_RICE_PARAM);

448 
} 
449  
450 
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder, 
451 
uint32_t *sums, int n, int pred_order) 
452 
{ 
453 
int i;

454 
int k, cnt, part;

455 
uint32_t all_bits; 
456  
457 
part = (1 << porder);

458 
all_bits = 4 * part;

459  
460 
cnt = (n >> porder)  pred_order; 
461 
for(i=0; i<part; i++) { 
462 
k = find_optimal_param(sums[i], cnt); 
463 
rc>params[i] = k; 
464 
all_bits += rice_encode_count(sums[i], cnt, k); 
465 
cnt = n >> porder; 
466 
} 
467  
468 
rc>porder = porder; 
469  
470 
return all_bits;

471 
} 
472  
473 
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order, 
474 
uint32_t sums[][MAX_PARTITIONS]) 
475 
{ 
476 
int i, j;

477 
int parts;

478 
uint32_t *res, *res_end; 
479  
480 
/* sums for highest level */

481 
parts = (1 << pmax);

482 
res = &data[pred_order]; 
483 
res_end = &data[n >> pmax]; 
484 
for(i=0; i<parts; i++) { 
485 
uint32_t sum = 0;

486 
while(res < res_end){

487 
sum += *(res++); 
488 
} 
489 
sums[pmax][i] = sum; 
490 
res_end+= n >> pmax; 
491 
} 
492 
/* sums for lower levels */

493 
for(i=pmax1; i>=pmin; i) { 
494 
parts = (1 << i);

495 
for(j=0; j<parts; j++) { 
496 
sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1]; 
497 
} 
498 
} 
499 
} 
500  
501 
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax, 
502 
int32_t *data, int n, int pred_order) 
503 
{ 
504 
int i;

505 
uint32_t bits[MAX_PARTITION_ORDER+1];

506 
int opt_porder;

507 
RiceContext tmp_rc; 
508 
uint32_t *udata; 
509 
uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];

510  
511 
assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);

512 
assert(pmax >= 0 && pmax <= MAX_PARTITION_ORDER);

513 
assert(pmin <= pmax); 
514  
515 
udata = av_malloc(n * sizeof(uint32_t));

516 
for(i=0; i<n; i++) { 
517 
udata[i] = (2*data[i]) ^ (data[i]>>31); 
518 
} 
519  
520 
calc_sums(pmin, pmax, udata, n, pred_order, sums); 
521  
522 
opt_porder = pmin; 
523 
bits[pmin] = UINT32_MAX; 
524 
for(i=pmin; i<=pmax; i++) {

525 
bits[i] = calc_optimal_rice_params(&tmp_rc, i, sums[i], n, pred_order); 
526 
if(bits[i] <= bits[opt_porder]) {

527 
opt_porder = i; 
528 
*rc= tmp_rc; 
529 
} 
530 
} 
531  
532 
av_freep(&udata); 
533 
return bits[opt_porder];

534 
} 
535  
536 
static int get_max_p_order(int max_porder, int n, int order) 
537 
{ 
538 
int porder = FFMIN(max_porder, av_log2(n^(n1))); 
539 
if(order > 0) 
540 
porder = FFMIN(porder, av_log2(n/order)); 
541 
return porder;

542 
} 
543  
544 
static uint32_t calc_rice_params_fixed(RiceContext *rc, int pmin, int pmax, 
545 
int32_t *data, int n, int pred_order, 
546 
int bps)

547 
{ 
548 
uint32_t bits; 
549 
pmin = get_max_p_order(pmin, n, pred_order); 
550 
pmax = get_max_p_order(pmax, n, pred_order); 
551 
bits = pred_order*bps + 6;

552 
bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order); 
553 
return bits;

554 
} 
555  
556 
static uint32_t calc_rice_params_lpc(RiceContext *rc, int pmin, int pmax, 
557 
int32_t *data, int n, int pred_order, 
558 
int bps, int precision) 
559 
{ 
560 
uint32_t bits; 
561 
pmin = get_max_p_order(pmin, n, pred_order); 
562 
pmax = get_max_p_order(pmax, n, pred_order); 
563 
bits = pred_order*bps + 4 + 5 + pred_order*precision + 6; 
564 
bits += calc_rice_params(rc, pmin, pmax, data, n, pred_order); 
565 
return bits;

566 
} 
567  
568 
/**

569 
* Apply Welch window function to audio block

570 
*/

571 
static void apply_welch_window(const int32_t *data, int len, double *w_data) 
572 
{ 
573 
int i, n2;

574 
double w;

575 
double c;

576  
577 
assert(!(len&1)); //the optimization in r11881 does not support odd len 
578 
//if someone wants odd len extend the change in r11881

579  
580 
n2 = (len >> 1);

581 
c = 2.0 / (len  1.0); 
582  
583 
w_data+=n2; 
584 
data+=n2; 
585 
for(i=0; i<n2; i++) { 
586 
w = c  n2 + i; 
587 
w = 1.0  (w * w); 
588 
w_data[i1] = data[i1] * w; 
589 
w_data[+i ] = data[+i ] * w; 
590 
} 
591 
} 
592  
593 
/**

594 
* Calculates autocorrelation data from audio samples

595 
* A Welch window function is applied before calculation.

596 
*/

597 
void ff_flac_compute_autocorr(const int32_t *data, int len, int lag, 
598 
double *autoc)

599 
{ 
600 
int i, j;

601 
double tmp[len + lag + 1]; 
602 
double *data1= tmp + lag;

603  
604 
apply_welch_window(data, len, data1); 
605  
606 
for(j=0; j<lag; j++) 
607 
data1[jlag]= 0.0; 
608 
data1[len] = 0.0; 
609  
610 
for(j=0; j<lag; j+=2){ 
611 
double sum0 = 1.0, sum1 = 1.0; 
612 
for(i=0; i<len; i++){ 
613 
sum0 += data1[i] * data1[ij]; 
614 
sum1 += data1[i] * data1[ij1];

615 
} 
616 
autoc[j ] = sum0; 
617 
autoc[j+1] = sum1;

618 
} 
619  
620 
if(j==lag){

621 
double sum = 1.0; 
622 
for(i=0; i<len; i+=2){ 
623 
sum += data1[i ] * data1[ij ] 
624 
+ data1[i+1] * data1[ij+1]; 
625 
} 
626 
autoc[j] = sum; 
627 
} 
628 
} 
629  
630  
631 
static void encode_residual_verbatim(int32_t *res, int32_t *smp, int n) 
632 
{ 
633 
assert(n > 0);

634 
memcpy(res, smp, n * sizeof(int32_t));

635 
} 
636  
637 
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, 
638 
int order)

639 
{ 
640 
int i;

641  
642 
for(i=0; i<order; i++) { 
643 
res[i] = smp[i]; 
644 
} 
645  
646 
if(order==0){ 
647 
for(i=order; i<n; i++)

648 
res[i]= smp[i]; 
649 
}else if(order==1){ 
650 
for(i=order; i<n; i++)

651 
res[i]= smp[i]  smp[i1];

652 
}else if(order==2){ 
653 
int a = smp[order1]  smp[order2]; 
654 
for(i=order; i<n; i+=2) { 
655 
int b = smp[i]  smp[i1]; 
656 
res[i]= b  a; 
657 
a = smp[i+1]  smp[i];

658 
res[i+1]= a  b;

659 
} 
660 
}else if(order==3){ 
661 
int a = smp[order1]  smp[order2]; 
662 
int c = smp[order1]  2*smp[order2] + smp[order3]; 
663 
for(i=order; i<n; i+=2) { 
664 
int b = smp[i]  smp[i1]; 
665 
int d = b  a;

666 
res[i]= d  c; 
667 
a = smp[i+1]  smp[i];

668 
c = a  b; 
669 
res[i+1]= c  d;

670 
} 
671 
}else{

672 
int a = smp[order1]  smp[order2]; 
673 
int c = smp[order1]  2*smp[order2] + smp[order3]; 
674 
int e = smp[order1]  3*smp[order2] + 3*smp[order3]  smp[order4]; 
675 
for(i=order; i<n; i+=2) { 
676 
int b = smp[i]  smp[i1]; 
677 
int d = b  a;

678 
int f = d  c;

679 
res[i]= f  e; 
680 
a = smp[i+1]  smp[i];

681 
c = a  b; 
682 
e = c  d; 
683 
res[i+1]= e  f;

684 
} 
685 
} 
686 
} 
687  
688 
#define LPC1(x) {\

689 
int c = coefs[(x)1];\ 
690 
p0 += c*s;\ 
691 
s = smp[i(x)+1];\

692 
p1 += c*s;\ 
693 
} 
694  
695 
static av_always_inline void encode_residual_lpc_unrolled( 
696 
int32_t *res, const int32_t *smp, int n, 
697 
int order, const int32_t *coefs, int shift, int big) 
698 
{ 
699 
int i;

700 
for(i=order; i<n; i+=2) { 
701 
int s = smp[iorder];

702 
int p0 = 0, p1 = 0; 
703 
if(big) {

704 
switch(order) {

705 
case 32: LPC1(32) 
706 
case 31: LPC1(31) 
707 
case 30: LPC1(30) 
708 
case 29: LPC1(29) 
709 
case 28: LPC1(28) 
710 
case 27: LPC1(27) 
711 
case 26: LPC1(26) 
712 
case 25: LPC1(25) 
713 
case 24: LPC1(24) 
714 
case 23: LPC1(23) 
715 
case 22: LPC1(22) 
716 
case 21: LPC1(21) 
717 
case 20: LPC1(20) 
718 
case 19: LPC1(19) 
719 
case 18: LPC1(18) 
720 
case 17: LPC1(17) 
721 
case 16: LPC1(16) 
722 
case 15: LPC1(15) 
723 
case 14: LPC1(14) 
724 
case 13: LPC1(13) 
725 
case 12: LPC1(12) 
726 
case 11: LPC1(11) 
727 
case 10: LPC1(10) 
728 
case 9: LPC1( 9) 
729 
LPC1( 8)

730 
LPC1( 7)

731 
LPC1( 6)

732 
LPC1( 5)

733 
LPC1( 4)

734 
LPC1( 3)

735 
LPC1( 2)

736 
LPC1( 1)

737 
} 
738 
} else {

739 
switch(order) {

740 
case 8: LPC1( 8) 
741 
case 7: LPC1( 7) 
742 
case 6: LPC1( 6) 
743 
case 5: LPC1( 5) 
744 
case 4: LPC1( 4) 
745 
case 3: LPC1( 3) 
746 
case 2: LPC1( 2) 
747 
case 1: LPC1( 1) 
748 
} 
749 
} 
750 
res[i ] = smp[i ]  (p0 >> shift); 
751 
res[i+1] = smp[i+1]  (p1 >> shift); 
752 
} 
753 
} 
754  
755 
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n, 
756 
int order, const int32_t *coefs, int shift) 
757 
{ 
758 
int i;

759 
for(i=0; i<order; i++) { 
760 
res[i] = smp[i]; 
761 
} 
762 
#ifdef CONFIG_SMALL

763 
for(i=order; i<n; i+=2) { 
764 
int j;

765 
int s = smp[i];

766 
int p0 = 0, p1 = 0; 
767 
for(j=0; j<order; j++) { 
768 
int c = coefs[j];

769 
p1 += c*s; 
770 
s = smp[ij1];

771 
p0 += c*s; 
772 
} 
773 
res[i ] = smp[i ]  (p0 >> shift); 
774 
res[i+1] = smp[i+1]  (p1 >> shift); 
775 
} 
776 
#else

777 
switch(order) {

778 
case 1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break; 
779 
case 2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break; 
780 
case 3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break; 
781 
case 4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break; 
782 
case 5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break; 
783 
case 6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break; 
784 
case 7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break; 
785 
case 8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break; 
786 
default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break; 
787 
} 
788 
#endif

789 
} 
790  
791 
static int encode_residual(FlacEncodeContext *ctx, int ch) 
792 
{ 
793 
int i, n;

794 
int min_order, max_order, opt_order, precision, omethod;

795 
int min_porder, max_porder;

796 
FlacFrame *frame; 
797 
FlacSubframe *sub; 
798 
int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; 
799 
int shift[MAX_LPC_ORDER];

800 
int32_t *res, *smp; 
801  
802 
frame = &ctx>frame; 
803 
sub = &frame>subframes[ch]; 
804 
res = sub>residual; 
805 
smp = sub>samples; 
806 
n = frame>blocksize; 
807  
808 
/* CONSTANT */

809 
for(i=1; i<n; i++) { 
810 
if(smp[i] != smp[0]) break; 
811 
} 
812 
if(i == n) {

813 
sub>type = sub>type_code = FLAC_SUBFRAME_CONSTANT; 
814 
res[0] = smp[0]; 
815 
return sub>obits;

816 
} 
817  
818 
/* VERBATIM */

819 
if(n < 5) { 
820 
sub>type = sub>type_code = FLAC_SUBFRAME_VERBATIM; 
821 
encode_residual_verbatim(res, smp, n); 
822 
return sub>obits * n;

823 
} 
824  
825 
min_order = ctx>options.min_prediction_order; 
826 
max_order = ctx>options.max_prediction_order; 
827 
min_porder = ctx>options.min_partition_order; 
828 
max_porder = ctx>options.max_partition_order; 
829 
precision = ctx>options.lpc_coeff_precision; 
830 
omethod = ctx>options.prediction_order_method; 
831  
832 
/* FIXED */

833 
if(!ctx>options.use_lpc  max_order == 0  (n <= max_order)) { 
834 
uint32_t bits[MAX_FIXED_ORDER+1];

835 
if(max_order > MAX_FIXED_ORDER) max_order = MAX_FIXED_ORDER;

836 
opt_order = 0;

837 
bits[0] = UINT32_MAX;

838 
for(i=min_order; i<=max_order; i++) {

839 
encode_residual_fixed(res, smp, n, i); 
840 
bits[i] = calc_rice_params_fixed(&sub>rc, min_porder, max_porder, res, 
841 
n, i, sub>obits); 
842 
if(bits[i] < bits[opt_order]) {

843 
opt_order = i; 
844 
} 
845 
} 
846 
sub>order = opt_order; 
847 
sub>type = FLAC_SUBFRAME_FIXED; 
848 
sub>type_code = sub>type  sub>order; 
849 
if(sub>order != max_order) {

850 
encode_residual_fixed(res, smp, n, sub>order); 
851 
return calc_rice_params_fixed(&sub>rc, min_porder, max_porder, res, n,

852 
sub>order, sub>obits); 
853 
} 
854 
return bits[sub>order];

855 
} 
856  
857 
/* LPC */

858 
opt_order = ff_lpc_calc_coefs(&ctx>dsp, smp, n, min_order, max_order, 
859 
precision, coefs, shift, ctx>options.use_lpc, 
860 
omethod, MAX_LPC_SHIFT, 0);

861  
862 
if(omethod == ORDER_METHOD_2LEVEL 

863 
omethod == ORDER_METHOD_4LEVEL  
864 
omethod == ORDER_METHOD_8LEVEL) { 
865 
int levels = 1 << omethod; 
866 
uint32_t bits[levels]; 
867 
int order;

868 
int opt_index = levels1; 
869 
opt_order = max_order1;

870 
bits[opt_index] = UINT32_MAX; 
871 
for(i=levels1; i>=0; i) { 
872 
order = min_order + (((max_ordermin_order+1) * (i+1)) / levels)1; 
873 
if(order < 0) order = 0; 
874 
encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);

875 
bits[i] = calc_rice_params_lpc(&sub>rc, min_porder, max_porder, 
876 
res, n, order+1, sub>obits, precision);

877 
if(bits[i] < bits[opt_index]) {

878 
opt_index = i; 
879 
opt_order = order; 
880 
} 
881 
} 
882 
opt_order++; 
883 
} else if(omethod == ORDER_METHOD_SEARCH) { 
884 
// bruteforce optimal order search

885 
uint32_t bits[MAX_LPC_ORDER]; 
886 
opt_order = 0;

887 
bits[0] = UINT32_MAX;

888 
for(i=min_order1; i<max_order; i++) { 
889 
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);

890 
bits[i] = calc_rice_params_lpc(&sub>rc, min_porder, max_porder, 
891 
res, n, i+1, sub>obits, precision);

892 
if(bits[i] < bits[opt_order]) {

893 
opt_order = i; 
894 
} 
895 
} 
896 
opt_order++; 
897 
} else if(omethod == ORDER_METHOD_LOG) { 
898 
uint32_t bits[MAX_LPC_ORDER]; 
899 
int step;

900  
901 
opt_order= min_order  1 + (max_ordermin_order)/3; 
902 
memset(bits, 1, sizeof(bits)); 
903  
904 
for(step=16 ;step; step>>=1){ 
905 
int last= opt_order;

906 
for(i=laststep; i<=last+step; i+= step){

907 
if(i<min_order1  i>=max_order  bits[i] < UINT32_MAX) 
908 
continue;

909 
encode_residual_lpc(res, smp, n, i+1, coefs[i], shift[i]);

910 
bits[i] = calc_rice_params_lpc(&sub>rc, min_porder, max_porder, 
911 
res, n, i+1, sub>obits, precision);

912 
if(bits[i] < bits[opt_order])

913 
opt_order= i; 
914 
} 
915 
} 
916 
opt_order++; 
917 
} 
918  
919 
sub>order = opt_order; 
920 
sub>type = FLAC_SUBFRAME_LPC; 
921 
sub>type_code = sub>type  (sub>order1);

922 
sub>shift = shift[sub>order1];

923 
for(i=0; i<sub>order; i++) { 
924 
sub>coefs[i] = coefs[sub>order1][i];

925 
} 
926 
encode_residual_lpc(res, smp, n, sub>order, sub>coefs, sub>shift); 
927 
return calc_rice_params_lpc(&sub>rc, min_porder, max_porder, res, n, sub>order,

928 
sub>obits, precision); 
929 
} 
930  
931 
static int encode_residual_v(FlacEncodeContext *ctx, int ch) 
932 
{ 
933 
int i, n;

934 
FlacFrame *frame; 
935 
FlacSubframe *sub; 
936 
int32_t *res, *smp; 
937  
938 
frame = &ctx>frame; 
939 
sub = &frame>subframes[ch]; 
940 
res = sub>residual; 
941 
smp = sub>samples; 
942 
n = frame>blocksize; 
943  
944 
/* CONSTANT */

945 
for(i=1; i<n; i++) { 
946 
if(smp[i] != smp[0]) break; 
947 
} 
948 
if(i == n) {

949 
sub>type = sub>type_code = FLAC_SUBFRAME_CONSTANT; 
950 
res[0] = smp[0]; 
951 
return sub>obits;

952 
} 
953  
954 
/* VERBATIM */

955 
sub>type = sub>type_code = FLAC_SUBFRAME_VERBATIM; 
956 
encode_residual_verbatim(res, smp, n); 
957 
return sub>obits * n;

958 
} 
959  
960 
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n) 
961 
{ 
962 
int i, best;

963 
int32_t lt, rt; 
964 
uint64_t sum[4];

965 
uint64_t score[4];

966 
int k;

967  
968 
/* calculate sum of 2nd order residual for each channel */

969 
sum[0] = sum[1] = sum[2] = sum[3] = 0; 
970 
for(i=2; i<n; i++) { 
971 
lt = left_ch[i]  2*left_ch[i1] + left_ch[i2]; 
972 
rt = right_ch[i]  2*right_ch[i1] + right_ch[i2]; 
973 
sum[2] += FFABS((lt + rt) >> 1); 
974 
sum[3] += FFABS(lt  rt);

975 
sum[0] += FFABS(lt);

976 
sum[1] += FFABS(rt);

977 
} 
978 
/* estimate bit counts */

979 
for(i=0; i<4; i++) { 
980 
k = find_optimal_param(2*sum[i], n);

981 
sum[i] = rice_encode_count(2*sum[i], n, k);

982 
} 
983  
984 
/* calculate score for each mode */

985 
score[0] = sum[0] + sum[1]; 
986 
score[1] = sum[0] + sum[3]; 
987 
score[2] = sum[1] + sum[3]; 
988 
score[3] = sum[2] + sum[3]; 
989  
990 
/* return mode with lowest score */

991 
best = 0;

992 
for(i=1; i<4; i++) { 
993 
if(score[i] < score[best]) {

994 
best = i; 
995 
} 
996 
} 
997 
if(best == 0) { 
998 
return FLAC_CHMODE_LEFT_RIGHT;

999 
} else if(best == 1) { 
1000 
return FLAC_CHMODE_LEFT_SIDE;

1001 
} else if(best == 2) { 
1002 
return FLAC_CHMODE_RIGHT_SIDE;

1003 
} else {

1004 
return FLAC_CHMODE_MID_SIDE;

1005 
} 
1006 
} 
1007  
1008 
/**

1009 
* Perform stereo channel decorrelation

1010 
*/

1011 
static void channel_decorrelation(FlacEncodeContext *ctx) 
1012 
{ 
1013 
FlacFrame *frame; 
1014 
int32_t *left, *right; 
1015 
int i, n;

1016  
1017 
frame = &ctx>frame; 
1018 
n = frame>blocksize; 
1019 
left = frame>subframes[0].samples;

1020 
right = frame>subframes[1].samples;

1021  
1022 
if(ctx>channels != 2) { 
1023 
frame>ch_mode = FLAC_CHMODE_NOT_STEREO; 
1024 
return;

1025 
} 
1026  
1027 
frame>ch_mode = estimate_stereo_mode(left, right, n); 
1028  
1029 
/* perform decorrelation and adjust bitspersample */

1030 
if(frame>ch_mode == FLAC_CHMODE_LEFT_RIGHT) {

1031 
return;

1032 
} 
1033 
if(frame>ch_mode == FLAC_CHMODE_MID_SIDE) {

1034 
int32_t tmp; 
1035 
for(i=0; i<n; i++) { 
1036 
tmp = left[i]; 
1037 
left[i] = (tmp + right[i]) >> 1;

1038 
right[i] = tmp  right[i]; 
1039 
} 
1040 
frame>subframes[1].obits++;

1041 
} else if(frame>ch_mode == FLAC_CHMODE_LEFT_SIDE) { 
1042 
for(i=0; i<n; i++) { 
1043 
right[i] = left[i]  right[i]; 
1044 
} 
1045 
frame>subframes[1].obits++;

1046 
} else {

1047 
for(i=0; i<n; i++) { 
1048 
left[i] = right[i]; 
1049 
} 
1050 
frame>subframes[0].obits++;

1051 
} 
1052 
} 
1053  
1054 
static void write_utf8(PutBitContext *pb, uint32_t val) 
1055 
{ 
1056 
uint8_t tmp; 
1057 
PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)

1058 
} 
1059  
1060 
static void output_frame_header(FlacEncodeContext *s) 
1061 
{ 
1062 
FlacFrame *frame; 
1063 
int crc;

1064  
1065 
frame = &s>frame; 
1066  
1067 
put_bits(&s>pb, 16, 0xFFF8); 
1068 
put_bits(&s>pb, 4, frame>bs_code[0]); 
1069 
put_bits(&s>pb, 4, s>sr_code[0]); 
1070 
if(frame>ch_mode == FLAC_CHMODE_NOT_STEREO) {

1071 
put_bits(&s>pb, 4, s>ch_code);

1072 
} else {

1073 
put_bits(&s>pb, 4, frame>ch_mode);

1074 
} 
1075 
put_bits(&s>pb, 3, 4); /* bitspersample code */ 
1076 
put_bits(&s>pb, 1, 0); 
1077 
write_utf8(&s>pb, s>frame_count); 
1078 
if(frame>bs_code[0] == 6) { 
1079 
put_bits(&s>pb, 8, frame>bs_code[1]); 
1080 
} else if(frame>bs_code[0] == 7) { 
1081 
put_bits(&s>pb, 16, frame>bs_code[1]); 
1082 
} 
1083 
if(s>sr_code[0] == 12) { 
1084 
put_bits(&s>pb, 8, s>sr_code[1]); 
1085 
} else if(s>sr_code[0] > 12) { 
1086 
put_bits(&s>pb, 16, s>sr_code[1]); 
1087 
} 
1088 
flush_put_bits(&s>pb); 
1089 
crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0,

1090 
s>pb.buf, put_bits_count(&s>pb)>>3);

1091 
put_bits(&s>pb, 8, crc);

1092 
} 
1093  
1094 
static void output_subframe_constant(FlacEncodeContext *s, int ch) 
1095 
{ 
1096 
FlacSubframe *sub; 
1097 
int32_t res; 
1098  
1099 
sub = &s>frame.subframes[ch]; 
1100 
res = sub>residual[0];

1101 
put_sbits(&s>pb, sub>obits, res); 
1102 
} 
1103  
1104 
static void output_subframe_verbatim(FlacEncodeContext *s, int ch) 
1105 
{ 
1106 
int i;

1107 
FlacFrame *frame; 
1108 
FlacSubframe *sub; 
1109 
int32_t res; 
1110  
1111 
frame = &s>frame; 
1112 
sub = &frame>subframes[ch]; 
1113  
1114 
for(i=0; i<frame>blocksize; i++) { 
1115 
res = sub>residual[i]; 
1116 
put_sbits(&s>pb, sub>obits, res); 
1117 
} 
1118 
} 
1119  
1120 
static void output_residual(FlacEncodeContext *ctx, int ch) 
1121 
{ 
1122 
int i, j, p, n, parts;

1123 
int k, porder, psize, res_cnt;

1124 
FlacFrame *frame; 
1125 
FlacSubframe *sub; 
1126 
int32_t *res; 
1127  
1128 
frame = &ctx>frame; 
1129 
sub = &frame>subframes[ch]; 
1130 
res = sub>residual; 
1131 
n = frame>blocksize; 
1132  
1133 
/* riceencoded block */

1134 
put_bits(&ctx>pb, 2, 0); 
1135  
1136 
/* partition order */

1137 
porder = sub>rc.porder; 
1138 
psize = n >> porder; 
1139 
parts = (1 << porder);

1140 
put_bits(&ctx>pb, 4, porder);

1141 
res_cnt = psize  sub>order; 
1142  
1143 
/* residual */

1144 
j = sub>order; 
1145 
for(p=0; p<parts; p++) { 
1146 
k = sub>rc.params[p]; 
1147 
put_bits(&ctx>pb, 4, k);

1148 
if(p == 1) res_cnt = psize; 
1149 
for(i=0; i<res_cnt && j<n; i++, j++) { 
1150 
set_sr_golomb_flac(&ctx>pb, res[j], k, INT32_MAX, 0);

1151 
} 
1152 
} 
1153 
} 
1154  
1155 
static void output_subframe_fixed(FlacEncodeContext *ctx, int ch) 
1156 
{ 
1157 
int i;

1158 
FlacFrame *frame; 
1159 
FlacSubframe *sub; 
1160  
1161 
frame = &ctx>frame; 
1162 
sub = &frame>subframes[ch]; 
1163  
1164 
/* warmup samples */

1165 
for(i=0; i<sub>order; i++) { 
1166 
put_sbits(&ctx>pb, sub>obits, sub>residual[i]); 
1167 
} 
1168  
1169 
/* residual */

1170 
output_residual(ctx, ch); 
1171 
} 
1172  
1173 
static void output_subframe_lpc(FlacEncodeContext *ctx, int ch) 
1174 
{ 
1175 
int i, cbits;

1176 
FlacFrame *frame; 
1177 
FlacSubframe *sub; 
1178  
1179 
frame = &ctx>frame; 
1180 
sub = &frame>subframes[ch]; 
1181  
1182 
/* warmup samples */

1183 
for(i=0; i<sub>order; i++) { 
1184 
put_sbits(&ctx>pb, sub>obits, sub>residual[i]); 
1185 
} 
1186  
1187 
/* LPC coefficients */

1188 
cbits = ctx>options.lpc_coeff_precision; 
1189 
put_bits(&ctx>pb, 4, cbits1); 
1190 
put_sbits(&ctx>pb, 5, sub>shift);

1191 
for(i=0; i<sub>order; i++) { 
1192 
put_sbits(&ctx>pb, cbits, sub>coefs[i]); 
1193 
} 
1194  
1195 
/* residual */

1196 
output_residual(ctx, ch); 
1197 
} 
1198  
1199 
static void output_subframes(FlacEncodeContext *s) 
1200 
{ 
1201 
FlacFrame *frame; 
1202 
FlacSubframe *sub; 
1203 
int ch;

1204  
1205 
frame = &s>frame; 
1206  
1207 
for(ch=0; ch<s>channels; ch++) { 
1208 
sub = &frame>subframes[ch]; 
1209  
1210 
/* subframe header */

1211 
put_bits(&s>pb, 1, 0); 
1212 
put_bits(&s>pb, 6, sub>type_code);

1213 
put_bits(&s>pb, 1, 0); /* no wasted bits */ 
1214  
1215 
/* subframe */

1216 
if(sub>type == FLAC_SUBFRAME_CONSTANT) {

1217 
output_subframe_constant(s, ch); 
1218 
} else if(sub>type == FLAC_SUBFRAME_VERBATIM) { 
1219 
output_subframe_verbatim(s, ch); 
1220 
} else if(sub>type == FLAC_SUBFRAME_FIXED) { 
1221 
output_subframe_fixed(s, ch); 
1222 
} else if(sub>type == FLAC_SUBFRAME_LPC) { 
1223 
output_subframe_lpc(s, ch); 
1224 
} 
1225 
} 
1226 
} 
1227  
1228 
static void output_frame_footer(FlacEncodeContext *s) 
1229 
{ 
1230 
int crc;

1231 
flush_put_bits(&s>pb); 
1232 
crc = bswap_16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0,

1233 
s>pb.buf, put_bits_count(&s>pb)>>3));

1234 
put_bits(&s>pb, 16, crc);

1235 
flush_put_bits(&s>pb); 
1236 
} 
1237  
1238 
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame, 
1239 
int buf_size, void *data) 
1240 
{ 
1241 
int ch;

1242 
FlacEncodeContext *s; 
1243 
int16_t *samples = data; 
1244 
int out_bytes;

1245 
int reencoded=0; 
1246  
1247 
s = avctx>priv_data; 
1248  
1249 
if(buf_size < s>max_framesize*2) { 
1250 
av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");

1251 
return 0; 
1252 
} 
1253  
1254 
init_frame(s); 
1255  
1256 
copy_samples(s, samples); 
1257  
1258 
channel_decorrelation(s); 
1259  
1260 
for(ch=0; ch<s>channels; ch++) { 
1261 
encode_residual(s, ch); 
1262 
} 
1263  
1264 
write_frame:

1265 
init_put_bits(&s>pb, frame, buf_size); 
1266 
output_frame_header(s); 
1267 
output_subframes(s); 
1268 
output_frame_footer(s); 
1269 
out_bytes = put_bits_count(&s>pb) >> 3;

1270  
1271 
if(out_bytes > s>max_framesize) {

1272 
if(reencoded) {

1273 
/* still too large. must be an error. */

1274 
av_log(avctx, AV_LOG_ERROR, "error encoding frame\n");

1275 
return 1; 
1276 
} 
1277  
1278 
/* frame too large. use verbatim mode */

1279 
for(ch=0; ch<s>channels; ch++) { 
1280 
encode_residual_v(s, ch); 
1281 
} 
1282 
reencoded = 1;

1283 
goto write_frame;

1284 
} 
1285  
1286 
s>frame_count++; 
1287 
return out_bytes;

1288 
} 
1289  
1290 
static av_cold int flac_encode_close(AVCodecContext *avctx) 
1291 
{ 
1292 
av_freep(&avctx>extradata); 
1293 
avctx>extradata_size = 0;

1294 
av_freep(&avctx>coded_frame); 
1295 
return 0; 
1296 
} 
1297  
1298 
AVCodec flac_encoder = { 
1299 
"flac",

1300 
CODEC_TYPE_AUDIO, 
1301 
CODEC_ID_FLAC, 
1302 
sizeof(FlacEncodeContext),

1303 
flac_encode_init, 
1304 
flac_encode_frame, 
1305 
flac_encode_close, 
1306 
NULL,

1307 
.capabilities = CODEC_CAP_SMALL_LAST_FRAME, 
1308 
.sample_fmts = (enum SampleFormat[]){SAMPLE_FMT_S16,SAMPLE_FMT_NONE},

1309 
.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

1310 
}; 