ffmpeg / libavcodec / flacenc.c @ 77a78e9b
History  View  Annotate  Download (40.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/md5.h" 
24 
#include "avcodec.h" 
25 
#include "get_bits.h" 
26 
#include "golomb.h" 
27 
#include "lpc.h" 
28 
#include "flac.h" 
29 
#include "flacdata.h" 
30  
31 
#define FLAC_SUBFRAME_CONSTANT 0 
32 
#define FLAC_SUBFRAME_VERBATIM 1 
33 
#define FLAC_SUBFRAME_FIXED 8 
34 
#define FLAC_SUBFRAME_LPC 32 
35  
36 
#define MAX_FIXED_ORDER 4 
37 
#define MAX_PARTITION_ORDER 8 
38 
#define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER) 
39 
#define MAX_LPC_PRECISION 15 
40 
#define MAX_LPC_SHIFT 15 
41 
#define MAX_RICE_PARAM 14 
42  
43 
typedef struct CompressionOptions { 
44 
int compression_level;

45 
int block_time_ms;

46 
enum AVLPCType lpc_type;

47 
int lpc_passes;

48 
int lpc_coeff_precision;

49 
int min_prediction_order;

50 
int max_prediction_order;

51 
int prediction_order_method;

52 
int min_partition_order;

53 
int max_partition_order;

54 
} CompressionOptions; 
55  
56 
typedef struct RiceContext { 
57 
int porder;

58 
int params[MAX_PARTITIONS];

59 
} RiceContext; 
60  
61 
typedef struct FlacSubframe { 
62 
int type;

63 
int type_code;

64 
int obits;

65 
int order;

66 
int32_t coefs[MAX_LPC_ORDER]; 
67 
int shift;

68 
RiceContext rc; 
69 
int32_t samples[FLAC_MAX_BLOCKSIZE]; 
70 
int32_t residual[FLAC_MAX_BLOCKSIZE+1];

71 
} FlacSubframe; 
72  
73 
typedef struct FlacFrame { 
74 
FlacSubframe subframes[FLAC_MAX_CHANNELS]; 
75 
int blocksize;

76 
int bs_code[2]; 
77 
uint8_t crc8; 
78 
int ch_mode;

79 
int verbatim_only;

80 
} FlacFrame; 
81  
82 
typedef struct FlacEncodeContext { 
83 
PutBitContext pb; 
84 
int channels;

85 
int samplerate;

86 
int sr_code[2]; 
87 
int max_blocksize;

88 
int min_framesize;

89 
int max_framesize;

90 
int max_encoded_framesize;

91 
uint32_t frame_count; 
92 
uint64_t sample_count; 
93 
uint8_t md5sum[16];

94 
FlacFrame frame; 
95 
CompressionOptions options; 
96 
AVCodecContext *avctx; 
97 
LPCContext lpc_ctx; 
98 
struct AVMD5 *md5ctx;

99 
} FlacEncodeContext; 
100  
101  
102 
/**

103 
* Write streaminfo metadata block to byte array.

104 
*/

105 
static void write_streaminfo(FlacEncodeContext *s, uint8_t *header) 
106 
{ 
107 
PutBitContext pb; 
108  
109 
memset(header, 0, FLAC_STREAMINFO_SIZE);

110 
init_put_bits(&pb, header, FLAC_STREAMINFO_SIZE); 
111  
112 
/* streaminfo metadata block */

113 
put_bits(&pb, 16, s>max_blocksize);

114 
put_bits(&pb, 16, s>max_blocksize);

115 
put_bits(&pb, 24, s>min_framesize);

116 
put_bits(&pb, 24, s>max_framesize);

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

118 
put_bits(&pb, 3, s>channels1); 
119 
put_bits(&pb, 5, 15); /* bits per sample  1 */ 
120 
/* write 36bit sample count in 2 put_bits() calls */

121 
put_bits(&pb, 24, (s>sample_count & 0xFFFFFF000LL) >> 12); 
122 
put_bits(&pb, 12, s>sample_count & 0x000000FFFLL); 
123 
flush_put_bits(&pb); 
124 
memcpy(&header[18], s>md5sum, 16); 
125 
} 
126  
127  
128 
/**

129 
* Set blocksize based on samplerate.

130 
* Choose the closest predefined blocksize >= BLOCK_TIME_MS milliseconds.

131 
*/

132 
static int select_blocksize(int samplerate, int block_time_ms) 
133 
{ 
134 
int i;

135 
int target;

136 
int blocksize;

137  
138 
assert(samplerate > 0);

139 
blocksize = ff_flac_blocksize_table[1];

140 
target = (samplerate * block_time_ms) / 1000;

141 
for (i = 0; i < 16; i++) { 
142 
if (target >= ff_flac_blocksize_table[i] &&

143 
ff_flac_blocksize_table[i] > blocksize) { 
144 
blocksize = ff_flac_blocksize_table[i]; 
145 
} 
146 
} 
147 
return blocksize;

148 
} 
149  
150  
151 
static av_cold void dprint_compression_options(FlacEncodeContext *s) 
152 
{ 
153 
AVCodecContext *avctx = s>avctx; 
154 
CompressionOptions *opt = &s>options; 
155  
156 
av_log(avctx, AV_LOG_DEBUG, " compression: %d\n", opt>compression_level);

157  
158 
switch (opt>lpc_type) {

159 
case AV_LPC_TYPE_NONE:

160 
av_log(avctx, AV_LOG_DEBUG, " lpc type: None\n");

161 
break;

162 
case AV_LPC_TYPE_FIXED:

163 
av_log(avctx, AV_LOG_DEBUG, " lpc type: Fixed predefined coefficients\n");

164 
break;

165 
case AV_LPC_TYPE_LEVINSON:

166 
av_log(avctx, AV_LOG_DEBUG, " lpc type: LevinsonDurbin recursion with Welch window\n");

167 
break;

168 
case AV_LPC_TYPE_CHOLESKY:

169 
av_log(avctx, AV_LOG_DEBUG, " lpc type: Cholesky factorization, %d pass%s\n",

170 
opt>lpc_passes, opt>lpc_passes == 1 ? "" : "es"); 
171 
break;

172 
} 
173  
174 
av_log(avctx, AV_LOG_DEBUG, " prediction order: %d, %d\n",

175 
opt>min_prediction_order, opt>max_prediction_order); 
176  
177 
switch (opt>prediction_order_method) {

178 
case ORDER_METHOD_EST:

179 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "estimate"); 
180 
break;

181 
case ORDER_METHOD_2LEVEL:

182 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "2level"); 
183 
break;

184 
case ORDER_METHOD_4LEVEL:

185 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "4level"); 
186 
break;

187 
case ORDER_METHOD_8LEVEL:

188 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "8level"); 
189 
break;

190 
case ORDER_METHOD_SEARCH:

191 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "full search"); 
192 
break;

193 
case ORDER_METHOD_LOG:

194 
av_log(avctx, AV_LOG_DEBUG, " order method: %s\n", "log search"); 
195 
break;

196 
} 
197  
198  
199 
av_log(avctx, AV_LOG_DEBUG, " partition order: %d, %d\n",

200 
opt>min_partition_order, opt>max_partition_order); 
201  
202 
av_log(avctx, AV_LOG_DEBUG, " block size: %d\n", avctx>frame_size);

203  
204 
av_log(avctx, AV_LOG_DEBUG, " lpc precision: %d\n",

205 
opt>lpc_coeff_precision); 
206 
} 
207  
208  
209 
static av_cold int flac_encode_init(AVCodecContext *avctx) 
210 
{ 
211 
int freq = avctx>sample_rate;

212 
int channels = avctx>channels;

213 
FlacEncodeContext *s = avctx>priv_data; 
214 
int i, level, ret;

215 
uint8_t *streaminfo; 
216  
217 
s>avctx = avctx; 
218  
219 
if (avctx>sample_fmt != AV_SAMPLE_FMT_S16)

220 
return 1; 
221  
222 
if (channels < 1  channels > FLAC_MAX_CHANNELS) 
223 
return 1; 
224 
s>channels = channels; 
225  
226 
/* find samplerate in table */

227 
if (freq < 1) 
228 
return 1; 
229 
for (i = 4; i < 12; i++) { 
230 
if (freq == ff_flac_sample_rate_table[i]) {

231 
s>samplerate = ff_flac_sample_rate_table[i]; 
232 
s>sr_code[0] = i;

233 
s>sr_code[1] = 0; 
234 
break;

235 
} 
236 
} 
237 
/* if not in table, samplerate is nonstandard */

238 
if (i == 12) { 
239 
if (freq % 1000 == 0 && freq < 255000) { 
240 
s>sr_code[0] = 12; 
241 
s>sr_code[1] = freq / 1000; 
242 
} else if (freq % 10 == 0 && freq < 655350) { 
243 
s>sr_code[0] = 14; 
244 
s>sr_code[1] = freq / 10; 
245 
} else if (freq < 65535) { 
246 
s>sr_code[0] = 13; 
247 
s>sr_code[1] = freq;

248 
} else {

249 
return 1; 
250 
} 
251 
s>samplerate = freq; 
252 
} 
253  
254 
/* set compression option defaults based on avctx>compression_level */

255 
if (avctx>compression_level < 0) 
256 
s>options.compression_level = 5;

257 
else

258 
s>options.compression_level = avctx>compression_level; 
259  
260 
level = s>options.compression_level; 
261 
if (level > 12) { 
262 
av_log(avctx, AV_LOG_ERROR, "invalid compression level: %d\n",

263 
s>options.compression_level); 
264 
return 1; 
265 
} 
266  
267 
s>options.block_time_ms = ((int[]){ 27, 27, 27,105,105,105,105,105,105,105,105,105,105})[level]; 
268  
269 
s>options.lpc_type = ((int[]){ AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED, AV_LPC_TYPE_FIXED,

270 
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, 
271 
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, 
272 
AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, AV_LPC_TYPE_LEVINSON, 
273 
AV_LPC_TYPE_LEVINSON})[level]; 
274  
275 
s>options.min_prediction_order = ((int[]){ 2, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1})[level]; 
276 
s>options.max_prediction_order = ((int[]){ 3, 4, 4, 6, 8, 8, 8, 8, 12, 12, 12, 32, 32})[level]; 
277  
278 
s>options.prediction_order_method = ((int[]){ ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST,

279 
ORDER_METHOD_EST, ORDER_METHOD_EST, ORDER_METHOD_EST, 
280 
ORDER_METHOD_4LEVEL, ORDER_METHOD_LOG, ORDER_METHOD_4LEVEL, 
281 
ORDER_METHOD_LOG, ORDER_METHOD_SEARCH, ORDER_METHOD_LOG, 
282 
ORDER_METHOD_SEARCH})[level]; 
283  
284 
s>options.min_partition_order = ((int[]){ 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})[level]; 
285 
s>options.max_partition_order = ((int[]){ 2, 2, 3, 3, 3, 8, 8, 8, 8, 8, 8, 8, 8})[level]; 
286  
287 
/* set compression option overrides from AVCodecContext */

288 
#if FF_API_USE_LPC

289 
/* for compatibility with deprecated AVCodecContext.use_lpc */

290 
if (avctx>use_lpc == 0) { 
291 
s>options.lpc_type = AV_LPC_TYPE_FIXED; 
292 
} else if (avctx>use_lpc == 1) { 
293 
s>options.lpc_type = AV_LPC_TYPE_LEVINSON; 
294 
} else if (avctx>use_lpc > 1) { 
295 
s>options.lpc_type = AV_LPC_TYPE_CHOLESKY; 
296 
s>options.lpc_passes = avctx>use_lpc  1;

297 
} 
298 
#endif

299 
if (avctx>lpc_type > AV_LPC_TYPE_DEFAULT) {

300 
if (avctx>lpc_type > AV_LPC_TYPE_CHOLESKY) {

301 
av_log(avctx, AV_LOG_ERROR, "unknown lpc type: %d\n", avctx>lpc_type);

302 
return 1; 
303 
} 
304 
s>options.lpc_type = avctx>lpc_type; 
305 
if (s>options.lpc_type == AV_LPC_TYPE_CHOLESKY) {

306 
if (avctx>lpc_passes < 0) { 
307 
// default number of passes for Cholesky

308 
s>options.lpc_passes = 2;

309 
} else if (avctx>lpc_passes == 0) { 
310 
av_log(avctx, AV_LOG_ERROR, "invalid number of lpc passes: %d\n",

311 
avctx>lpc_passes); 
312 
return 1; 
313 
} else {

314 
s>options.lpc_passes = avctx>lpc_passes; 
315 
} 
316 
} 
317 
} 
318  
319 
if (s>options.lpc_type == AV_LPC_TYPE_NONE) {

320 
s>options.min_prediction_order = 0;

321 
} else if (avctx>min_prediction_order >= 0) { 
322 
if (s>options.lpc_type == AV_LPC_TYPE_FIXED) {

323 
if (avctx>min_prediction_order > MAX_FIXED_ORDER) {

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

325 
avctx>min_prediction_order); 
326 
return 1; 
327 
} 
328 
} else if (avctx>min_prediction_order < MIN_LPC_ORDER  
329 
avctx>min_prediction_order > MAX_LPC_ORDER) { 
330 
av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n",

331 
avctx>min_prediction_order); 
332 
return 1; 
333 
} 
334 
s>options.min_prediction_order = avctx>min_prediction_order; 
335 
} 
336 
if (s>options.lpc_type == AV_LPC_TYPE_NONE) {

337 
s>options.max_prediction_order = 0;

338 
} else if (avctx>max_prediction_order >= 0) { 
339 
if (s>options.lpc_type == AV_LPC_TYPE_FIXED) {

340 
if (avctx>max_prediction_order > MAX_FIXED_ORDER) {

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

342 
avctx>max_prediction_order); 
343 
return 1; 
344 
} 
345 
} else if (avctx>max_prediction_order < MIN_LPC_ORDER  
346 
avctx>max_prediction_order > MAX_LPC_ORDER) { 
347 
av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n",

348 
avctx>max_prediction_order); 
349 
return 1; 
350 
} 
351 
s>options.max_prediction_order = avctx>max_prediction_order; 
352 
} 
353 
if (s>options.max_prediction_order < s>options.min_prediction_order) {

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

355 
s>options.min_prediction_order, s>options.max_prediction_order); 
356 
return 1; 
357 
} 
358  
359 
if (avctx>prediction_order_method >= 0) { 
360 
if (avctx>prediction_order_method > ORDER_METHOD_LOG) {

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

362 
avctx>prediction_order_method); 
363 
return 1; 
364 
} 
365 
s>options.prediction_order_method = avctx>prediction_order_method; 
366 
} 
367  
368 
if (avctx>min_partition_order >= 0) { 
369 
if (avctx>min_partition_order > MAX_PARTITION_ORDER) {

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

371 
avctx>min_partition_order); 
372 
return 1; 
373 
} 
374 
s>options.min_partition_order = avctx>min_partition_order; 
375 
} 
376 
if (avctx>max_partition_order >= 0) { 
377 
if (avctx>max_partition_order > MAX_PARTITION_ORDER) {

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

379 
avctx>max_partition_order); 
380 
return 1; 
381 
} 
382 
s>options.max_partition_order = avctx>max_partition_order; 
383 
} 
384 
if (s>options.max_partition_order < s>options.min_partition_order) {

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

386 
s>options.min_partition_order, s>options.max_partition_order); 
387 
return 1; 
388 
} 
389  
390 
if (avctx>frame_size > 0) { 
391 
if (avctx>frame_size < FLAC_MIN_BLOCKSIZE 

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

394 
avctx>frame_size); 
395 
return 1; 
396 
} 
397 
} else {

398 
s>avctx>frame_size = select_blocksize(s>samplerate, s>options.block_time_ms); 
399 
} 
400 
s>max_blocksize = s>avctx>frame_size; 
401  
402 
/* set LPC precision */

403 
if (avctx>lpc_coeff_precision > 0) { 
404 
if (avctx>lpc_coeff_precision > MAX_LPC_PRECISION) {

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

406 
avctx>lpc_coeff_precision); 
407 
return 1; 
408 
} 
409 
s>options.lpc_coeff_precision = avctx>lpc_coeff_precision; 
410 
} else {

411 
/* default LPC precision */

412 
s>options.lpc_coeff_precision = 15;

413 
} 
414  
415 
/* set maximum encoded frame size in verbatim mode */

416 
s>max_framesize = ff_flac_get_max_frame_size(s>avctx>frame_size, 
417 
s>channels, 16);

418  
419 
/* initialize MD5 context */

420 
s>md5ctx = av_malloc(av_md5_size); 
421 
if (!s>md5ctx)

422 
return AVERROR(ENOMEM);

423 
av_md5_init(s>md5ctx); 
424  
425 
streaminfo = av_malloc(FLAC_STREAMINFO_SIZE); 
426 
if (!streaminfo)

427 
return AVERROR(ENOMEM);

428 
write_streaminfo(s, streaminfo); 
429 
avctx>extradata = streaminfo; 
430 
avctx>extradata_size = FLAC_STREAMINFO_SIZE; 
431  
432 
s>frame_count = 0;

433 
s>min_framesize = s>max_framesize; 
434  
435 
avctx>coded_frame = avcodec_alloc_frame(); 
436 
if (!avctx>coded_frame)

437 
return AVERROR(ENOMEM);

438  
439 
ret = ff_lpc_init(&s>lpc_ctx, avctx>frame_size, 
440 
s>options.max_prediction_order, AV_LPC_TYPE_LEVINSON); 
441  
442 
dprint_compression_options(s); 
443  
444 
return ret;

445 
} 
446  
447  
448 
static void init_frame(FlacEncodeContext *s) 
449 
{ 
450 
int i, ch;

451 
FlacFrame *frame; 
452  
453 
frame = &s>frame; 
454  
455 
for (i = 0; i < 16; i++) { 
456 
if (s>avctx>frame_size == ff_flac_blocksize_table[i]) {

457 
frame>blocksize = ff_flac_blocksize_table[i]; 
458 
frame>bs_code[0] = i;

459 
frame>bs_code[1] = 0; 
460 
break;

461 
} 
462 
} 
463 
if (i == 16) { 
464 
frame>blocksize = s>avctx>frame_size; 
465 
if (frame>blocksize <= 256) { 
466 
frame>bs_code[0] = 6; 
467 
frame>bs_code[1] = frame>blocksize1; 
468 
} else {

469 
frame>bs_code[0] = 7; 
470 
frame>bs_code[1] = frame>blocksize1; 
471 
} 
472 
} 
473  
474 
for (ch = 0; ch < s>channels; ch++) 
475 
frame>subframes[ch].obits = 16;

476  
477 
frame>verbatim_only = 0;

478 
} 
479  
480  
481 
/**

482 
* Copy channelinterleaved input samples into separate subframes.

483 
*/

484 
static void copy_samples(FlacEncodeContext *s, const int16_t *samples) 
485 
{ 
486 
int i, j, ch;

487 
FlacFrame *frame; 
488  
489 
frame = &s>frame; 
490 
for (i = 0, j = 0; i < frame>blocksize; i++) 
491 
for (ch = 0; ch < s>channels; ch++, j++) 
492 
frame>subframes[ch].samples[i] = samples[j]; 
493 
} 
494  
495  
496 
static int rice_count_exact(int32_t *res, int n, int k) 
497 
{ 
498 
int i;

499 
int count = 0; 
500  
501 
for (i = 0; i < n; i++) { 
502 
int32_t v = 2 * res[i]  1; 
503 
v ^= v >> 31;

504 
count += (v >> k) + 1 + k;

505 
} 
506 
return count;

507 
} 
508  
509  
510 
static int subframe_count_exact(FlacEncodeContext *s, FlacSubframe *sub, 
511 
int pred_order)

512 
{ 
513 
int p, porder, psize;

514 
int i, part_end;

515 
int count = 0; 
516  
517 
/* subframe header */

518 
count += 8;

519  
520 
/* subframe */

521 
if (sub>type == FLAC_SUBFRAME_CONSTANT) {

522 
count += sub>obits; 
523 
} else if (sub>type == FLAC_SUBFRAME_VERBATIM) { 
524 
count += s>frame.blocksize * sub>obits; 
525 
} else {

526 
/* warmup samples */

527 
count += pred_order * sub>obits; 
528  
529 
/* LPC coefficients */

530 
if (sub>type == FLAC_SUBFRAME_LPC)

531 
count += 4 + 5 + pred_order * s>options.lpc_coeff_precision; 
532  
533 
/* riceencoded block */

534 
count += 2;

535  
536 
/* partition order */

537 
porder = sub>rc.porder; 
538 
psize = s>frame.blocksize >> porder; 
539 
count += 4;

540  
541 
/* residual */

542 
i = pred_order; 
543 
part_end = psize; 
544 
for (p = 0; p < 1 << porder; p++) { 
545 
int k = sub>rc.params[p];

546 
count += 4;

547 
count += rice_count_exact(&sub>residual[i], part_end  i, k); 
548 
i = part_end; 
549 
part_end = FFMIN(s>frame.blocksize, part_end + psize); 
550 
} 
551 
} 
552  
553 
return count;

554 
} 
555  
556  
557 
#define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum(n>>1))>>(k))) 
558  
559 
/**

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

561 
*/

562 
static int find_optimal_param(uint32_t sum, int n) 
563 
{ 
564 
int k;

565 
uint32_t sum2; 
566  
567 
if (sum <= n >> 1) 
568 
return 0; 
569 
sum2 = sum  (n >> 1);

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

571 
return FFMIN(k, MAX_RICE_PARAM);

572 
} 
573  
574  
575 
static uint32_t calc_optimal_rice_params(RiceContext *rc, int porder, 
576 
uint32_t *sums, int n, int pred_order) 
577 
{ 
578 
int i;

579 
int k, cnt, part;

580 
uint32_t all_bits; 
581  
582 
part = (1 << porder);

583 
all_bits = 4 * part;

584  
585 
cnt = (n >> porder)  pred_order; 
586 
for (i = 0; i < part; i++) { 
587 
k = find_optimal_param(sums[i], cnt); 
588 
rc>params[i] = k; 
589 
all_bits += rice_encode_count(sums[i], cnt, k); 
590 
cnt = n >> porder; 
591 
} 
592  
593 
rc>porder = porder; 
594  
595 
return all_bits;

596 
} 
597  
598  
599 
static void calc_sums(int pmin, int pmax, uint32_t *data, int n, int pred_order, 
600 
uint32_t sums[][MAX_PARTITIONS]) 
601 
{ 
602 
int i, j;

603 
int parts;

604 
uint32_t *res, *res_end; 
605  
606 
/* sums for highest level */

607 
parts = (1 << pmax);

608 
res = &data[pred_order]; 
609 
res_end = &data[n >> pmax]; 
610 
for (i = 0; i < parts; i++) { 
611 
uint32_t sum = 0;

612 
while (res < res_end)

613 
sum += *(res++); 
614 
sums[pmax][i] = sum; 
615 
res_end += n >> pmax; 
616 
} 
617 
/* sums for lower levels */

618 
for (i = pmax  1; i >= pmin; i) { 
619 
parts = (1 << i);

620 
for (j = 0; j < parts; j++) 
621 
sums[i][j] = sums[i+1][2*j] + sums[i+1][2*j+1]; 
622 
} 
623 
} 
624  
625  
626 
static uint32_t calc_rice_params(RiceContext *rc, int pmin, int pmax, 
627 
int32_t *data, int n, int pred_order) 
628 
{ 
629 
int i;

630 
uint32_t bits[MAX_PARTITION_ORDER+1];

631 
int opt_porder;

632 
RiceContext tmp_rc; 
633 
uint32_t *udata; 
634 
uint32_t sums[MAX_PARTITION_ORDER+1][MAX_PARTITIONS];

635  
636 
assert(pmin >= 0 && pmin <= MAX_PARTITION_ORDER);

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

638 
assert(pmin <= pmax); 
639  
640 
udata = av_malloc(n * sizeof(uint32_t));

641 
for (i = 0; i < n; i++) 
642 
udata[i] = (2*data[i]) ^ (data[i]>>31); 
643  
644 
calc_sums(pmin, pmax, udata, n, pred_order, sums); 
645  
646 
opt_porder = pmin; 
647 
bits[pmin] = UINT32_MAX; 
648 
for (i = pmin; i <= pmax; i++) {

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

651 
opt_porder = i; 
652 
*rc = tmp_rc; 
653 
} 
654 
} 
655  
656 
av_freep(&udata); 
657 
return bits[opt_porder];

658 
} 
659  
660  
661 
static int get_max_p_order(int max_porder, int n, int order) 
662 
{ 
663 
int porder = FFMIN(max_porder, av_log2(n^(n1))); 
664 
if (order > 0) 
665 
porder = FFMIN(porder, av_log2(n/order)); 
666 
return porder;

667 
} 
668  
669  
670 
static uint32_t find_subframe_rice_params(FlacEncodeContext *s,

671 
FlacSubframe *sub, int pred_order)

672 
{ 
673 
int pmin = get_max_p_order(s>options.min_partition_order,

674 
s>frame.blocksize, pred_order); 
675 
int pmax = get_max_p_order(s>options.max_partition_order,

676 
s>frame.blocksize, pred_order); 
677  
678 
uint32_t bits = 8 + pred_order * sub>obits + 2 + 4; 
679 
if (sub>type == FLAC_SUBFRAME_LPC)

680 
bits += 4 + 5 + pred_order * s>options.lpc_coeff_precision; 
681 
bits += calc_rice_params(&sub>rc, pmin, pmax, sub>residual, 
682 
s>frame.blocksize, pred_order); 
683 
return bits;

684 
} 
685  
686  
687 
static void encode_residual_fixed(int32_t *res, const int32_t *smp, int n, 
688 
int order)

689 
{ 
690 
int i;

691  
692 
for (i = 0; i < order; i++) 
693 
res[i] = smp[i]; 
694  
695 
if (order == 0) { 
696 
for (i = order; i < n; i++)

697 
res[i] = smp[i]; 
698 
} else if (order == 1) { 
699 
for (i = order; i < n; i++)

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

701 
} else if (order == 2) { 
702 
int a = smp[order1]  smp[order2]; 
703 
for (i = order; i < n; i += 2) { 
704 
int b = smp[i ]  smp[i1]; 
705 
res[i] = b  a; 
706 
a = smp[i+1]  smp[i ];

707 
res[i+1] = a  b;

708 
} 
709 
} else if (order == 3) { 
710 
int a = smp[order1]  smp[order2]; 
711 
int c = smp[order1]  2*smp[order2] + smp[order3]; 
712 
for (i = order; i < n; i += 2) { 
713 
int b = smp[i ]  smp[i1]; 
714 
int d = b  a;

715 
res[i] = d  c; 
716 
a = smp[i+1]  smp[i ];

717 
c = a  b; 
718 
res[i+1] = c  d;

719 
} 
720 
} else {

721 
int a = smp[order1]  smp[order2]; 
722 
int c = smp[order1]  2*smp[order2] + smp[order3]; 
723 
int e = smp[order1]  3*smp[order2] + 3*smp[order3]  smp[order4]; 
724 
for (i = order; i < n; i += 2) { 
725 
int b = smp[i ]  smp[i1]; 
726 
int d = b  a;

727 
int f = d  c;

728 
res[i ] = f  e; 
729 
a = smp[i+1]  smp[i ];

730 
c = a  b; 
731 
e = c  d; 
732 
res[i+1] = e  f;

733 
} 
734 
} 
735 
} 
736  
737  
738 
#define LPC1(x) {\

739 
int c = coefs[(x)1];\ 
740 
p0 += c * s;\ 
741 
s = smp[i(x)+1];\

742 
p1 += c * s;\ 
743 
} 
744  
745 
static av_always_inline void encode_residual_lpc_unrolled(int32_t *res, 
746 
const int32_t *smp, int n, int order, 
747 
const int32_t *coefs, int shift, int big) 
748 
{ 
749 
int i;

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

752 
int p0 = 0, p1 = 0; 
753 
if (big) {

754 
switch (order) {

755 
case 32: LPC1(32) 
756 
case 31: LPC1(31) 
757 
case 30: LPC1(30) 
758 
case 29: LPC1(29) 
759 
case 28: LPC1(28) 
760 
case 27: LPC1(27) 
761 
case 26: LPC1(26) 
762 
case 25: LPC1(25) 
763 
case 24: LPC1(24) 
764 
case 23: LPC1(23) 
765 
case 22: LPC1(22) 
766 
case 21: LPC1(21) 
767 
case 20: LPC1(20) 
768 
case 19: LPC1(19) 
769 
case 18: LPC1(18) 
770 
case 17: LPC1(17) 
771 
case 16: LPC1(16) 
772 
case 15: LPC1(15) 
773 
case 14: LPC1(14) 
774 
case 13: LPC1(13) 
775 
case 12: LPC1(12) 
776 
case 11: LPC1(11) 
777 
case 10: LPC1(10) 
778 
case 9: LPC1( 9) 
779 
LPC1( 8)

780 
LPC1( 7)

781 
LPC1( 6)

782 
LPC1( 5)

783 
LPC1( 4)

784 
LPC1( 3)

785 
LPC1( 2)

786 
LPC1( 1)

787 
} 
788 
} else {

789 
switch (order) {

790 
case 8: LPC1( 8) 
791 
case 7: LPC1( 7) 
792 
case 6: LPC1( 6) 
793 
case 5: LPC1( 5) 
794 
case 4: LPC1( 4) 
795 
case 3: LPC1( 3) 
796 
case 2: LPC1( 2) 
797 
case 1: LPC1( 1) 
798 
} 
799 
} 
800 
res[i ] = smp[i ]  (p0 >> shift); 
801 
res[i+1] = smp[i+1]  (p1 >> shift); 
802 
} 
803 
} 
804  
805  
806 
static void encode_residual_lpc(int32_t *res, const int32_t *smp, int n, 
807 
int order, const int32_t *coefs, int shift) 
808 
{ 
809 
int i;

810 
for (i = 0; i < order; i++) 
811 
res[i] = smp[i]; 
812 
#if CONFIG_SMALL

813 
for (i = order; i < n; i += 2) { 
814 
int j;

815 
int s = smp[i];

816 
int p0 = 0, p1 = 0; 
817 
for (j = 0; j < order; j++) { 
818 
int c = coefs[j];

819 
p1 += c * s; 
820 
s = smp[ij1];

821 
p0 += c * s; 
822 
} 
823 
res[i ] = smp[i ]  (p0 >> shift); 
824 
res[i+1] = smp[i+1]  (p1 >> shift); 
825 
} 
826 
#else

827 
switch (order) {

828 
case 1: encode_residual_lpc_unrolled(res, smp, n, 1, coefs, shift, 0); break; 
829 
case 2: encode_residual_lpc_unrolled(res, smp, n, 2, coefs, shift, 0); break; 
830 
case 3: encode_residual_lpc_unrolled(res, smp, n, 3, coefs, shift, 0); break; 
831 
case 4: encode_residual_lpc_unrolled(res, smp, n, 4, coefs, shift, 0); break; 
832 
case 5: encode_residual_lpc_unrolled(res, smp, n, 5, coefs, shift, 0); break; 
833 
case 6: encode_residual_lpc_unrolled(res, smp, n, 6, coefs, shift, 0); break; 
834 
case 7: encode_residual_lpc_unrolled(res, smp, n, 7, coefs, shift, 0); break; 
835 
case 8: encode_residual_lpc_unrolled(res, smp, n, 8, coefs, shift, 0); break; 
836 
default: encode_residual_lpc_unrolled(res, smp, n, order, coefs, shift, 1); break; 
837 
} 
838 
#endif

839 
} 
840  
841  
842 
static int encode_residual_ch(FlacEncodeContext *s, int ch) 
843 
{ 
844 
int i, n;

845 
int min_order, max_order, opt_order, omethod;

846 
FlacFrame *frame; 
847 
FlacSubframe *sub; 
848 
int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; 
849 
int shift[MAX_LPC_ORDER];

850 
int32_t *res, *smp; 
851  
852 
frame = &s>frame; 
853 
sub = &frame>subframes[ch]; 
854 
res = sub>residual; 
855 
smp = sub>samples; 
856 
n = frame>blocksize; 
857  
858 
/* CONSTANT */

859 
for (i = 1; i < n; i++) 
860 
if(smp[i] != smp[0]) 
861 
break;

862 
if (i == n) {

863 
sub>type = sub>type_code = FLAC_SUBFRAME_CONSTANT; 
864 
res[0] = smp[0]; 
865 
return subframe_count_exact(s, sub, 0); 
866 
} 
867  
868 
/* VERBATIM */

869 
if (frame>verbatim_only  n < 5) { 
870 
sub>type = sub>type_code = FLAC_SUBFRAME_VERBATIM; 
871 
memcpy(res, smp, n * sizeof(int32_t));

872 
return subframe_count_exact(s, sub, 0); 
873 
} 
874  
875 
min_order = s>options.min_prediction_order; 
876 
max_order = s>options.max_prediction_order; 
877 
omethod = s>options.prediction_order_method; 
878  
879 
/* FIXED */

880 
sub>type = FLAC_SUBFRAME_FIXED; 
881 
if (s>options.lpc_type == AV_LPC_TYPE_NONE 

882 
s>options.lpc_type == AV_LPC_TYPE_FIXED  n <= max_order) { 
883 
uint32_t bits[MAX_FIXED_ORDER+1];

884 
if (max_order > MAX_FIXED_ORDER)

885 
max_order = MAX_FIXED_ORDER; 
886 
opt_order = 0;

887 
bits[0] = UINT32_MAX;

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

889 
encode_residual_fixed(res, smp, n, i); 
890 
bits[i] = find_subframe_rice_params(s, sub, i); 
891 
if (bits[i] < bits[opt_order])

892 
opt_order = i; 
893 
} 
894 
sub>order = opt_order; 
895 
sub>type_code = sub>type  sub>order; 
896 
if (sub>order != max_order) {

897 
encode_residual_fixed(res, smp, n, sub>order); 
898 
find_subframe_rice_params(s, sub, sub>order); 
899 
} 
900 
return subframe_count_exact(s, sub, sub>order);

901 
} 
902  
903 
/* LPC */

904 
sub>type = FLAC_SUBFRAME_LPC; 
905 
opt_order = ff_lpc_calc_coefs(&s>lpc_ctx, smp, n, min_order, max_order, 
906 
s>options.lpc_coeff_precision, coefs, shift, s>options.lpc_type, 
907 
s>options.lpc_passes, omethod, 
908 
MAX_LPC_SHIFT, 0);

909  
910 
if (omethod == ORDER_METHOD_2LEVEL 

911 
omethod == ORDER_METHOD_4LEVEL  
912 
omethod == ORDER_METHOD_8LEVEL) { 
913 
int levels = 1 << omethod; 
914 
uint32_t bits[1 << ORDER_METHOD_8LEVEL];

915 
int order;

916 
int opt_index = levels1; 
917 
opt_order = max_order1;

918 
bits[opt_index] = UINT32_MAX; 
919 
for (i = levels1; i >= 0; i) { 
920 
order = min_order + (((max_ordermin_order+1) * (i+1)) / levels)1; 
921 
if (order < 0) 
922 
order = 0;

923 
encode_residual_lpc(res, smp, n, order+1, coefs[order], shift[order]);

924 
bits[i] = find_subframe_rice_params(s, sub, order+1);

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

926 
opt_index = i; 
927 
opt_order = order; 
928 
} 
929 
} 
930 
opt_order++; 
931 
} else if (omethod == ORDER_METHOD_SEARCH) { 
932 
// bruteforce optimal order search

933 
uint32_t bits[MAX_LPC_ORDER]; 
934 
opt_order = 0;

935 
bits[0] = UINT32_MAX;

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

938 
bits[i] = find_subframe_rice_params(s, sub, i+1);

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

940 
opt_order = i; 
941 
} 
942 
opt_order++; 
943 
} else if (omethod == ORDER_METHOD_LOG) { 
944 
uint32_t bits[MAX_LPC_ORDER]; 
945 
int step;

946  
947 
opt_order = min_order  1 + (max_ordermin_order)/3; 
948 
memset(bits, 1, sizeof(bits)); 
949  
950 
for (step = 16; step; step >>= 1) { 
951 
int last = opt_order;

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

953 
if (i < min_order1  i >= max_order  bits[i] < UINT32_MAX) 
954 
continue;

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

956 
bits[i] = find_subframe_rice_params(s, sub, i+1);

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

958 
opt_order = i; 
959 
} 
960 
} 
961 
opt_order++; 
962 
} 
963  
964 
sub>order = opt_order; 
965 
sub>type_code = sub>type  (sub>order1);

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

967 
for (i = 0; i < sub>order; i++) 
968 
sub>coefs[i] = coefs[sub>order1][i];

969  
970 
encode_residual_lpc(res, smp, n, sub>order, sub>coefs, sub>shift); 
971  
972 
find_subframe_rice_params(s, sub, sub>order); 
973  
974 
return subframe_count_exact(s, sub, sub>order);

975 
} 
976  
977  
978 
static int count_frame_header(FlacEncodeContext *s) 
979 
{ 
980 
uint8_t tmp; 
981 
int count;

982  
983 
/*

984 
<14> Sync code

985 
<1> Reserved

986 
<1> Blocking strategy

987 
<4> Block size in interchannel samples

988 
<4> Sample rate

989 
<4> Channel assignment

990 
<3> Sample size in bits

991 
<1> Reserved

992 
*/

993 
count = 32;

994  
995 
/* coded frame number */

996 
PUT_UTF8(s>frame_count, tmp, count += 8;)

997  
998 
/* explicit block size */

999 
if (s>frame.bs_code[0] == 6) 
1000 
count += 8;

1001 
else if (s>frame.bs_code[0] == 7) 
1002 
count += 16;

1003  
1004 
/* explicit sample rate */

1005 
count += ((s>sr_code[0] == 12) + (s>sr_code[0] > 12)) * 8; 
1006  
1007 
/* frame header CRC8 */

1008 
count += 8;

1009  
1010 
return count;

1011 
} 
1012  
1013  
1014 
static int encode_frame(FlacEncodeContext *s) 
1015 
{ 
1016 
int ch, count;

1017  
1018 
count = count_frame_header(s); 
1019  
1020 
for (ch = 0; ch < s>channels; ch++) 
1021 
count += encode_residual_ch(s, ch); 
1022  
1023 
count += (8  (count & 7)) & 7; // byte alignment 
1024 
count += 16; // CRC16 
1025  
1026 
return count >> 3; 
1027 
} 
1028  
1029  
1030 
static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n) 
1031 
{ 
1032 
int i, best;

1033 
int32_t lt, rt; 
1034 
uint64_t sum[4];

1035 
uint64_t score[4];

1036 
int k;

1037  
1038 
/* calculate sum of 2nd order residual for each channel */

1039 
sum[0] = sum[1] = sum[2] = sum[3] = 0; 
1040 
for (i = 2; i < n; i++) { 
1041 
lt = left_ch[i]  2*left_ch[i1] + left_ch[i2]; 
1042 
rt = right_ch[i]  2*right_ch[i1] + right_ch[i2]; 
1043 
sum[2] += FFABS((lt + rt) >> 1); 
1044 
sum[3] += FFABS(lt  rt);

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

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

1047 
} 
1048 
/* estimate bit counts */

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

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

1052 
} 
1053  
1054 
/* calculate score for each mode */

1055 
score[0] = sum[0] + sum[1]; 
1056 
score[1] = sum[0] + sum[3]; 
1057 
score[2] = sum[1] + sum[3]; 
1058 
score[3] = sum[2] + sum[3]; 
1059  
1060 
/* return mode with lowest score */

1061 
best = 0;

1062 
for (i = 1; i < 4; i++) 
1063 
if (score[i] < score[best])

1064 
best = i; 
1065 
if (best == 0) { 
1066 
return FLAC_CHMODE_INDEPENDENT;

1067 
} else if (best == 1) { 
1068 
return FLAC_CHMODE_LEFT_SIDE;

1069 
} else if (best == 2) { 
1070 
return FLAC_CHMODE_RIGHT_SIDE;

1071 
} else {

1072 
return FLAC_CHMODE_MID_SIDE;

1073 
} 
1074 
} 
1075  
1076  
1077 
/**

1078 
* Perform stereo channel decorrelation.

1079 
*/

1080 
static void channel_decorrelation(FlacEncodeContext *s) 
1081 
{ 
1082 
FlacFrame *frame; 
1083 
int32_t *left, *right; 
1084 
int i, n;

1085  
1086 
frame = &s>frame; 
1087 
n = frame>blocksize; 
1088 
left = frame>subframes[0].samples;

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

1090  
1091 
if (s>channels != 2) { 
1092 
frame>ch_mode = FLAC_CHMODE_INDEPENDENT; 
1093 
return;

1094 
} 
1095  
1096 
frame>ch_mode = estimate_stereo_mode(left, right, n); 
1097  
1098 
/* perform decorrelation and adjust bitspersample */

1099 
if (frame>ch_mode == FLAC_CHMODE_INDEPENDENT)

1100 
return;

1101 
if (frame>ch_mode == FLAC_CHMODE_MID_SIDE) {

1102 
int32_t tmp; 
1103 
for (i = 0; i < n; i++) { 
1104 
tmp = left[i]; 
1105 
left[i] = (tmp + right[i]) >> 1;

1106 
right[i] = tmp  right[i]; 
1107 
} 
1108 
frame>subframes[1].obits++;

1109 
} else if (frame>ch_mode == FLAC_CHMODE_LEFT_SIDE) { 
1110 
for (i = 0; i < n; i++) 
1111 
right[i] = left[i]  right[i]; 
1112 
frame>subframes[1].obits++;

1113 
} else {

1114 
for (i = 0; i < n; i++) 
1115 
left[i] = right[i]; 
1116 
frame>subframes[0].obits++;

1117 
} 
1118 
} 
1119  
1120  
1121 
static void write_utf8(PutBitContext *pb, uint32_t val) 
1122 
{ 
1123 
uint8_t tmp; 
1124 
PUT_UTF8(val, tmp, put_bits(pb, 8, tmp);)

1125 
} 
1126  
1127  
1128 
static void write_frame_header(FlacEncodeContext *s) 
1129 
{ 
1130 
FlacFrame *frame; 
1131 
int crc;

1132  
1133 
frame = &s>frame; 
1134  
1135 
put_bits(&s>pb, 16, 0xFFF8); 
1136 
put_bits(&s>pb, 4, frame>bs_code[0]); 
1137 
put_bits(&s>pb, 4, s>sr_code[0]); 
1138  
1139 
if (frame>ch_mode == FLAC_CHMODE_INDEPENDENT)

1140 
put_bits(&s>pb, 4, s>channels1); 
1141 
else

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

1143  
1144 
put_bits(&s>pb, 3, 4); /* bitspersample code */ 
1145 
put_bits(&s>pb, 1, 0); 
1146 
write_utf8(&s>pb, s>frame_count); 
1147  
1148 
if (frame>bs_code[0] == 6) 
1149 
put_bits(&s>pb, 8, frame>bs_code[1]); 
1150 
else if (frame>bs_code[0] == 7) 
1151 
put_bits(&s>pb, 16, frame>bs_code[1]); 
1152  
1153 
if (s>sr_code[0] == 12) 
1154 
put_bits(&s>pb, 8, s>sr_code[1]); 
1155 
else if (s>sr_code[0] > 12) 
1156 
put_bits(&s>pb, 16, s>sr_code[1]); 
1157  
1158 
flush_put_bits(&s>pb); 
1159 
crc = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, s>pb.buf,

1160 
put_bits_count(&s>pb) >> 3);

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

1162 
} 
1163  
1164  
1165 
static void write_subframes(FlacEncodeContext *s) 
1166 
{ 
1167 
int ch;

1168  
1169 
for (ch = 0; ch < s>channels; ch++) { 
1170 
FlacSubframe *sub = &s>frame.subframes[ch]; 
1171 
int i, p, porder, psize;

1172 
int32_t *part_end; 
1173 
int32_t *res = sub>residual; 
1174 
int32_t *frame_end = &sub>residual[s>frame.blocksize]; 
1175  
1176 
/* subframe header */

1177 
put_bits(&s>pb, 1, 0); 
1178 
put_bits(&s>pb, 6, sub>type_code);

1179 
put_bits(&s>pb, 1, 0); /* no wasted bits */ 
1180  
1181 
/* subframe */

1182 
if (sub>type == FLAC_SUBFRAME_CONSTANT) {

1183 
put_sbits(&s>pb, sub>obits, res[0]);

1184 
} else if (sub>type == FLAC_SUBFRAME_VERBATIM) { 
1185 
while (res < frame_end)

1186 
put_sbits(&s>pb, sub>obits, *res++); 
1187 
} else {

1188 
/* warmup samples */

1189 
for (i = 0; i < sub>order; i++) 
1190 
put_sbits(&s>pb, sub>obits, *res++); 
1191  
1192 
/* LPC coefficients */

1193 
if (sub>type == FLAC_SUBFRAME_LPC) {

1194 
int cbits = s>options.lpc_coeff_precision;

1195 
put_bits( &s>pb, 4, cbits1); 
1196 
put_sbits(&s>pb, 5, sub>shift);

1197 
for (i = 0; i < sub>order; i++) 
1198 
put_sbits(&s>pb, cbits, sub>coefs[i]); 
1199 
} 
1200  
1201 
/* riceencoded block */

1202 
put_bits(&s>pb, 2, 0); 
1203  
1204 
/* partition order */

1205 
porder = sub>rc.porder; 
1206 
psize = s>frame.blocksize >> porder; 
1207 
put_bits(&s>pb, 4, porder);

1208  
1209 
/* residual */

1210 
part_end = &sub>residual[psize]; 
1211 
for (p = 0; p < 1 << porder; p++) { 
1212 
int k = sub>rc.params[p];

1213 
put_bits(&s>pb, 4, k);

1214 
while (res < part_end)

1215 
set_sr_golomb_flac(&s>pb, *res++, k, INT32_MAX, 0);

1216 
part_end = FFMIN(frame_end, part_end + psize); 
1217 
} 
1218 
} 
1219 
} 
1220 
} 
1221  
1222  
1223 
static void write_frame_footer(FlacEncodeContext *s) 
1224 
{ 
1225 
int crc;

1226 
flush_put_bits(&s>pb); 
1227 
crc = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, s>pb.buf,

1228 
put_bits_count(&s>pb)>>3));

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

1230 
flush_put_bits(&s>pb); 
1231 
} 
1232  
1233  
1234 
static int write_frame(FlacEncodeContext *s, uint8_t *frame, int buf_size) 
1235 
{ 
1236 
init_put_bits(&s>pb, frame, buf_size); 
1237 
write_frame_header(s); 
1238 
write_subframes(s); 
1239 
write_frame_footer(s); 
1240 
return put_bits_count(&s>pb) >> 3; 
1241 
} 
1242  
1243  
1244 
static void update_md5_sum(FlacEncodeContext *s, const int16_t *samples) 
1245 
{ 
1246 
#if HAVE_BIGENDIAN

1247 
int i;

1248 
for (i = 0; i < s>frame.blocksize * s>channels; i++) { 
1249 
int16_t smp = av_le2ne16(samples[i]); 
1250 
av_md5_update(s>md5ctx, (uint8_t *)&smp, 2);

1251 
} 
1252 
#else

1253 
av_md5_update(s>md5ctx, (const uint8_t *)samples, s>frame.blocksize*s>channels*2); 
1254 
#endif

1255 
} 
1256  
1257  
1258 
static int flac_encode_frame(AVCodecContext *avctx, uint8_t *frame, 
1259 
int buf_size, void *data) 
1260 
{ 
1261 
FlacEncodeContext *s; 
1262 
const int16_t *samples = data;

1263 
int frame_bytes, out_bytes;

1264  
1265 
s = avctx>priv_data; 
1266  
1267 
/* when the last block is reached, update the header in extradata */

1268 
if (!data) {

1269 
s>max_framesize = s>max_encoded_framesize; 
1270 
av_md5_final(s>md5ctx, s>md5sum); 
1271 
write_streaminfo(s, avctx>extradata); 
1272 
return 0; 
1273 
} 
1274  
1275 
/* change max_framesize for small final frame */

1276 
if (avctx>frame_size < s>frame.blocksize) {

1277 
s>max_framesize = ff_flac_get_max_frame_size(avctx>frame_size, 
1278 
s>channels, 16);

1279 
} 
1280  
1281 
init_frame(s); 
1282  
1283 
copy_samples(s, samples); 
1284  
1285 
channel_decorrelation(s); 
1286  
1287 
frame_bytes = encode_frame(s); 
1288  
1289 
/* fallback to verbatim mode if the compressed frame is larger than it

1290 
would be if encoded uncompressed. */

1291 
if (frame_bytes > s>max_framesize) {

1292 
s>frame.verbatim_only = 1;

1293 
frame_bytes = encode_frame(s); 
1294 
} 
1295  
1296 
if (buf_size < frame_bytes) {

1297 
av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");

1298 
return 0; 
1299 
} 
1300 
out_bytes = write_frame(s, frame, buf_size); 
1301  
1302 
s>frame_count++; 
1303 
avctx>coded_frame>pts = s>sample_count; 
1304 
s>sample_count += avctx>frame_size; 
1305 
update_md5_sum(s, samples); 
1306 
if (out_bytes > s>max_encoded_framesize)

1307 
s>max_encoded_framesize = out_bytes; 
1308 
if (out_bytes < s>min_framesize)

1309 
s>min_framesize = out_bytes; 
1310  
1311 
return out_bytes;

1312 
} 
1313  
1314  
1315 
static av_cold int flac_encode_close(AVCodecContext *avctx) 
1316 
{ 
1317 
if (avctx>priv_data) {

1318 
FlacEncodeContext *s = avctx>priv_data; 
1319 
av_freep(&s>md5ctx); 
1320 
ff_lpc_end(&s>lpc_ctx); 
1321 
} 
1322 
av_freep(&avctx>extradata); 
1323 
avctx>extradata_size = 0;

1324 
av_freep(&avctx>coded_frame); 
1325 
return 0; 
1326 
} 
1327  
1328  
1329 
AVCodec flac_encoder = { 
1330 
"flac",

1331 
AVMEDIA_TYPE_AUDIO, 
1332 
CODEC_ID_FLAC, 
1333 
sizeof(FlacEncodeContext),

1334 
flac_encode_init, 
1335 
flac_encode_frame, 
1336 
flac_encode_close, 
1337 
NULL,

1338 
.capabilities = CODEC_CAP_SMALL_LAST_FRAME  CODEC_CAP_DELAY, 
1339 
.sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE}, 
1340 
.long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

1341 
}; 