blob: 804cc7b17b752a34553d0df11a641cbb3a1dd985
1 | /* |
2 | * ALAC audio encoder |
3 | * Copyright (c) 2008 Jaikrishnan Menon <realityman@gmx.net> |
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 02110-1301 USA |
20 | */ |
21 | |
22 | #include "libavutil/opt.h" |
23 | |
24 | #include "avcodec.h" |
25 | #include "put_bits.h" |
26 | #include "internal.h" |
27 | #include "lpc.h" |
28 | #include "mathops.h" |
29 | #include "alac_data.h" |
30 | |
31 | #define DEFAULT_FRAME_SIZE 4096 |
32 | #define ALAC_EXTRADATA_SIZE 36 |
33 | #define ALAC_FRAME_HEADER_SIZE 55 |
34 | #define ALAC_FRAME_FOOTER_SIZE 3 |
35 | |
36 | #define ALAC_ESCAPE_CODE 0x1FF |
37 | #define ALAC_MAX_LPC_ORDER 30 |
38 | #define DEFAULT_MAX_PRED_ORDER 6 |
39 | #define DEFAULT_MIN_PRED_ORDER 4 |
40 | #define ALAC_MAX_LPC_PRECISION 9 |
41 | #define ALAC_MIN_LPC_SHIFT 0 |
42 | #define ALAC_MAX_LPC_SHIFT 9 |
43 | |
44 | #define ALAC_CHMODE_LEFT_RIGHT 0 |
45 | #define ALAC_CHMODE_LEFT_SIDE 1 |
46 | #define ALAC_CHMODE_RIGHT_SIDE 2 |
47 | #define ALAC_CHMODE_MID_SIDE 3 |
48 | |
49 | typedef struct RiceContext { |
50 | int history_mult; |
51 | int initial_history; |
52 | int k_modifier; |
53 | int rice_modifier; |
54 | } RiceContext; |
55 | |
56 | typedef struct AlacLPCContext { |
57 | int lpc_order; |
58 | int lpc_coeff[ALAC_MAX_LPC_ORDER+1]; |
59 | int lpc_quant; |
60 | } AlacLPCContext; |
61 | |
62 | typedef struct AlacEncodeContext { |
63 | const AVClass *class; |
64 | AVCodecContext *avctx; |
65 | int frame_size; /**< current frame size */ |
66 | int verbatim; /**< current frame verbatim mode flag */ |
67 | int compression_level; |
68 | int min_prediction_order; |
69 | int max_prediction_order; |
70 | int max_coded_frame_size; |
71 | int write_sample_size; |
72 | int extra_bits; |
73 | int32_t sample_buf[2][DEFAULT_FRAME_SIZE]; |
74 | int32_t predictor_buf[2][DEFAULT_FRAME_SIZE]; |
75 | int interlacing_shift; |
76 | int interlacing_leftweight; |
77 | PutBitContext pbctx; |
78 | RiceContext rc; |
79 | AlacLPCContext lpc[2]; |
80 | LPCContext lpc_ctx; |
81 | } AlacEncodeContext; |
82 | |
83 | |
84 | static void init_sample_buffers(AlacEncodeContext *s, int channels, |
85 | const uint8_t *samples[2]) |
86 | { |
87 | int ch, i; |
88 | int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 - |
89 | s->avctx->bits_per_raw_sample; |
90 | |
91 | #define COPY_SAMPLES(type) do { \ |
92 | for (ch = 0; ch < channels; ch++) { \ |
93 | int32_t *bptr = s->sample_buf[ch]; \ |
94 | const type *sptr = (const type *)samples[ch]; \ |
95 | for (i = 0; i < s->frame_size; i++) \ |
96 | bptr[i] = sptr[i] >> shift; \ |
97 | } \ |
98 | } while (0) |
99 | |
100 | if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P) |
101 | COPY_SAMPLES(int32_t); |
102 | else |
103 | COPY_SAMPLES(int16_t); |
104 | } |
105 | |
106 | static void encode_scalar(AlacEncodeContext *s, int x, |
107 | int k, int write_sample_size) |
108 | { |
109 | int divisor, q, r; |
110 | |
111 | k = FFMIN(k, s->rc.k_modifier); |
112 | divisor = (1<<k) - 1; |
113 | q = x / divisor; |
114 | r = x % divisor; |
115 | |
116 | if (q > 8) { |
117 | // write escape code and sample value directly |
118 | put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE); |
119 | put_bits(&s->pbctx, write_sample_size, x); |
120 | } else { |
121 | if (q) |
122 | put_bits(&s->pbctx, q, (1<<q) - 1); |
123 | put_bits(&s->pbctx, 1, 0); |
124 | |
125 | if (k != 1) { |
126 | if (r > 0) |
127 | put_bits(&s->pbctx, k, r+1); |
128 | else |
129 | put_bits(&s->pbctx, k-1, 0); |
130 | } |
131 | } |
132 | } |
133 | |
134 | static void write_element_header(AlacEncodeContext *s, |
135 | enum AlacRawDataBlockType element, |
136 | int instance) |
137 | { |
138 | int encode_fs = 0; |
139 | |
140 | if (s->frame_size < DEFAULT_FRAME_SIZE) |
141 | encode_fs = 1; |
142 | |
143 | put_bits(&s->pbctx, 3, element); // element type |
144 | put_bits(&s->pbctx, 4, instance); // element instance |
145 | put_bits(&s->pbctx, 12, 0); // unused header bits |
146 | put_bits(&s->pbctx, 1, encode_fs); // Sample count is in the header |
147 | put_bits(&s->pbctx, 2, s->extra_bits >> 3); // Extra bytes (for 24-bit) |
148 | put_bits(&s->pbctx, 1, s->verbatim); // Audio block is verbatim |
149 | if (encode_fs) |
150 | put_bits32(&s->pbctx, s->frame_size); // No. of samples in the frame |
151 | } |
152 | |
153 | static void calc_predictor_params(AlacEncodeContext *s, int ch) |
154 | { |
155 | int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER]; |
156 | int shift[MAX_LPC_ORDER]; |
157 | int opt_order; |
158 | |
159 | if (s->compression_level == 1) { |
160 | s->lpc[ch].lpc_order = 6; |
161 | s->lpc[ch].lpc_quant = 6; |
162 | s->lpc[ch].lpc_coeff[0] = 160; |
163 | s->lpc[ch].lpc_coeff[1] = -190; |
164 | s->lpc[ch].lpc_coeff[2] = 170; |
165 | s->lpc[ch].lpc_coeff[3] = -130; |
166 | s->lpc[ch].lpc_coeff[4] = 80; |
167 | s->lpc[ch].lpc_coeff[5] = -25; |
168 | } else { |
169 | opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, s->sample_buf[ch], |
170 | s->frame_size, |
171 | s->min_prediction_order, |
172 | s->max_prediction_order, |
173 | ALAC_MAX_LPC_PRECISION, coefs, shift, |
174 | FF_LPC_TYPE_LEVINSON, 0, |
175 | ORDER_METHOD_EST, ALAC_MIN_LPC_SHIFT, |
176 | ALAC_MAX_LPC_SHIFT, 1); |
177 | |
178 | s->lpc[ch].lpc_order = opt_order; |
179 | s->lpc[ch].lpc_quant = shift[opt_order-1]; |
180 | memcpy(s->lpc[ch].lpc_coeff, coefs[opt_order-1], opt_order*sizeof(int)); |
181 | } |
182 | } |
183 | |
184 | static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n) |
185 | { |
186 | int i, best; |
187 | int32_t lt, rt; |
188 | uint64_t sum[4]; |
189 | uint64_t score[4]; |
190 | |
191 | /* calculate sum of 2nd order residual for each channel */ |
192 | sum[0] = sum[1] = sum[2] = sum[3] = 0; |
193 | for (i = 2; i < n; i++) { |
194 | lt = left_ch[i] - 2 * left_ch[i - 1] + left_ch[i - 2]; |
195 | rt = right_ch[i] - 2 * right_ch[i - 1] + right_ch[i - 2]; |
196 | sum[2] += FFABS((lt + rt) >> 1); |
197 | sum[3] += FFABS(lt - rt); |
198 | sum[0] += FFABS(lt); |
199 | sum[1] += FFABS(rt); |
200 | } |
201 | |
202 | /* calculate score for each mode */ |
203 | score[0] = sum[0] + sum[1]; |
204 | score[1] = sum[0] + sum[3]; |
205 | score[2] = sum[1] + sum[3]; |
206 | score[3] = sum[2] + sum[3]; |
207 | |
208 | /* return mode with lowest score */ |
209 | best = 0; |
210 | for (i = 1; i < 4; i++) { |
211 | if (score[i] < score[best]) |
212 | best = i; |
213 | } |
214 | return best; |
215 | } |
216 | |
217 | static void alac_stereo_decorrelation(AlacEncodeContext *s) |
218 | { |
219 | int32_t *left = s->sample_buf[0], *right = s->sample_buf[1]; |
220 | int i, mode, n = s->frame_size; |
221 | int32_t tmp; |
222 | |
223 | mode = estimate_stereo_mode(left, right, n); |
224 | |
225 | switch (mode) { |
226 | case ALAC_CHMODE_LEFT_RIGHT: |
227 | s->interlacing_leftweight = 0; |
228 | s->interlacing_shift = 0; |
229 | break; |
230 | case ALAC_CHMODE_LEFT_SIDE: |
231 | for (i = 0; i < n; i++) |
232 | right[i] = left[i] - right[i]; |
233 | s->interlacing_leftweight = 1; |
234 | s->interlacing_shift = 0; |
235 | break; |
236 | case ALAC_CHMODE_RIGHT_SIDE: |
237 | for (i = 0; i < n; i++) { |
238 | tmp = right[i]; |
239 | right[i] = left[i] - right[i]; |
240 | left[i] = tmp + (right[i] >> 31); |
241 | } |
242 | s->interlacing_leftweight = 1; |
243 | s->interlacing_shift = 31; |
244 | break; |
245 | default: |
246 | for (i = 0; i < n; i++) { |
247 | tmp = left[i]; |
248 | left[i] = (tmp + right[i]) >> 1; |
249 | right[i] = tmp - right[i]; |
250 | } |
251 | s->interlacing_leftweight = 1; |
252 | s->interlacing_shift = 1; |
253 | break; |
254 | } |
255 | } |
256 | |
257 | static void alac_linear_predictor(AlacEncodeContext *s, int ch) |
258 | { |
259 | int i; |
260 | AlacLPCContext lpc = s->lpc[ch]; |
261 | int32_t *residual = s->predictor_buf[ch]; |
262 | |
263 | if (lpc.lpc_order == 31) { |
264 | residual[0] = s->sample_buf[ch][0]; |
265 | |
266 | for (i = 1; i < s->frame_size; i++) { |
267 | residual[i] = s->sample_buf[ch][i ] - |
268 | s->sample_buf[ch][i - 1]; |
269 | } |
270 | |
271 | return; |
272 | } |
273 | |
274 | // generalised linear predictor |
275 | |
276 | if (lpc.lpc_order > 0) { |
277 | int32_t *samples = s->sample_buf[ch]; |
278 | |
279 | // generate warm-up samples |
280 | residual[0] = samples[0]; |
281 | for (i = 1; i <= lpc.lpc_order; i++) |
282 | residual[i] = sign_extend(samples[i] - samples[i-1], s->write_sample_size); |
283 | |
284 | // perform lpc on remaining samples |
285 | for (i = lpc.lpc_order + 1; i < s->frame_size; i++) { |
286 | int sum = 1 << (lpc.lpc_quant - 1), res_val, j; |
287 | |
288 | for (j = 0; j < lpc.lpc_order; j++) { |
289 | sum += (samples[lpc.lpc_order-j] - samples[0]) * |
290 | lpc.lpc_coeff[j]; |
291 | } |
292 | |
293 | sum >>= lpc.lpc_quant; |
294 | sum += samples[0]; |
295 | residual[i] = sign_extend(samples[lpc.lpc_order+1] - sum, |
296 | s->write_sample_size); |
297 | res_val = residual[i]; |
298 | |
299 | if (res_val) { |
300 | int index = lpc.lpc_order - 1; |
301 | int neg = (res_val < 0); |
302 | |
303 | while (index >= 0 && (neg ? (res_val < 0) : (res_val > 0))) { |
304 | int val = samples[0] - samples[lpc.lpc_order - index]; |
305 | int sign = (val ? FFSIGN(val) : 0); |
306 | |
307 | if (neg) |
308 | sign *= -1; |
309 | |
310 | lpc.lpc_coeff[index] -= sign; |
311 | val *= sign; |
312 | res_val -= (val >> lpc.lpc_quant) * (lpc.lpc_order - index); |
313 | index--; |
314 | } |
315 | } |
316 | samples++; |
317 | } |
318 | } |
319 | } |
320 | |
321 | static void alac_entropy_coder(AlacEncodeContext *s, int ch) |
322 | { |
323 | unsigned int history = s->rc.initial_history; |
324 | int sign_modifier = 0, i, k; |
325 | int32_t *samples = s->predictor_buf[ch]; |
326 | |
327 | for (i = 0; i < s->frame_size;) { |
328 | int x; |
329 | |
330 | k = av_log2((history >> 9) + 3); |
331 | |
332 | x = -2 * (*samples) -1; |
333 | x ^= x >> 31; |
334 | |
335 | samples++; |
336 | i++; |
337 | |
338 | encode_scalar(s, x - sign_modifier, k, s->write_sample_size); |
339 | |
340 | history += x * s->rc.history_mult - |
341 | ((history * s->rc.history_mult) >> 9); |
342 | |
343 | sign_modifier = 0; |
344 | if (x > 0xFFFF) |
345 | history = 0xFFFF; |
346 | |
347 | if (history < 128 && i < s->frame_size) { |
348 | unsigned int block_size = 0; |
349 | |
350 | k = 7 - av_log2(history) + ((history + 16) >> 6); |
351 | |
352 | while (*samples == 0 && i < s->frame_size) { |
353 | samples++; |
354 | i++; |
355 | block_size++; |
356 | } |
357 | encode_scalar(s, block_size, k, 16); |
358 | sign_modifier = (block_size <= 0xFFFF); |
359 | history = 0; |
360 | } |
361 | |
362 | } |
363 | } |
364 | |
365 | static void write_element(AlacEncodeContext *s, |
366 | enum AlacRawDataBlockType element, int instance, |
367 | const uint8_t *samples0, const uint8_t *samples1) |
368 | { |
369 | const uint8_t *samples[2] = { samples0, samples1 }; |
370 | int i, j, channels; |
371 | int prediction_type = 0; |
372 | PutBitContext *pb = &s->pbctx; |
373 | |
374 | channels = element == TYPE_CPE ? 2 : 1; |
375 | |
376 | if (s->verbatim) { |
377 | write_element_header(s, element, instance); |
378 | /* samples are channel-interleaved in verbatim mode */ |
379 | if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P) { |
380 | int shift = 32 - s->avctx->bits_per_raw_sample; |
381 | const int32_t *samples_s32[2] = { (const int32_t *)samples0, |
382 | (const int32_t *)samples1 }; |
383 | for (i = 0; i < s->frame_size; i++) |
384 | for (j = 0; j < channels; j++) |
385 | put_sbits(pb, s->avctx->bits_per_raw_sample, |
386 | samples_s32[j][i] >> shift); |
387 | } else { |
388 | const int16_t *samples_s16[2] = { (const int16_t *)samples0, |
389 | (const int16_t *)samples1 }; |
390 | for (i = 0; i < s->frame_size; i++) |
391 | for (j = 0; j < channels; j++) |
392 | put_sbits(pb, s->avctx->bits_per_raw_sample, |
393 | samples_s16[j][i]); |
394 | } |
395 | } else { |
396 | s->write_sample_size = s->avctx->bits_per_raw_sample - s->extra_bits + |
397 | channels - 1; |
398 | |
399 | init_sample_buffers(s, channels, samples); |
400 | write_element_header(s, element, instance); |
401 | |
402 | // extract extra bits if needed |
403 | if (s->extra_bits) { |
404 | uint32_t mask = (1 << s->extra_bits) - 1; |
405 | for (j = 0; j < channels; j++) { |
406 | int32_t *extra = s->predictor_buf[j]; |
407 | int32_t *smp = s->sample_buf[j]; |
408 | for (i = 0; i < s->frame_size; i++) { |
409 | extra[i] = smp[i] & mask; |
410 | smp[i] >>= s->extra_bits; |
411 | } |
412 | } |
413 | } |
414 | |
415 | if (channels == 2) |
416 | alac_stereo_decorrelation(s); |
417 | else |
418 | s->interlacing_shift = s->interlacing_leftweight = 0; |
419 | put_bits(pb, 8, s->interlacing_shift); |
420 | put_bits(pb, 8, s->interlacing_leftweight); |
421 | |
422 | for (i = 0; i < channels; i++) { |
423 | calc_predictor_params(s, i); |
424 | |
425 | put_bits(pb, 4, prediction_type); |
426 | put_bits(pb, 4, s->lpc[i].lpc_quant); |
427 | |
428 | put_bits(pb, 3, s->rc.rice_modifier); |
429 | put_bits(pb, 5, s->lpc[i].lpc_order); |
430 | // predictor coeff. table |
431 | for (j = 0; j < s->lpc[i].lpc_order; j++) |
432 | put_sbits(pb, 16, s->lpc[i].lpc_coeff[j]); |
433 | } |
434 | |
435 | // write extra bits if needed |
436 | if (s->extra_bits) { |
437 | for (i = 0; i < s->frame_size; i++) { |
438 | for (j = 0; j < channels; j++) { |
439 | put_bits(pb, s->extra_bits, s->predictor_buf[j][i]); |
440 | } |
441 | } |
442 | } |
443 | |
444 | // apply lpc and entropy coding to audio samples |
445 | for (i = 0; i < channels; i++) { |
446 | alac_linear_predictor(s, i); |
447 | |
448 | // TODO: determine when this will actually help. for now it's not used. |
449 | if (prediction_type == 15) { |
450 | // 2nd pass 1st order filter |
451 | int32_t *residual = s->predictor_buf[i]; |
452 | for (j = s->frame_size - 1; j > 0; j--) |
453 | residual[j] -= residual[j - 1]; |
454 | } |
455 | alac_entropy_coder(s, i); |
456 | } |
457 | } |
458 | } |
459 | |
460 | static int write_frame(AlacEncodeContext *s, AVPacket *avpkt, |
461 | uint8_t * const *samples) |
462 | { |
463 | PutBitContext *pb = &s->pbctx; |
464 | const enum AlacRawDataBlockType *ch_elements = ff_alac_channel_elements[s->avctx->channels - 1]; |
465 | const uint8_t *ch_map = ff_alac_channel_layout_offsets[s->avctx->channels - 1]; |
466 | int ch, element, sce, cpe; |
467 | |
468 | init_put_bits(pb, avpkt->data, avpkt->size); |
469 | |
470 | ch = element = sce = cpe = 0; |
471 | while (ch < s->avctx->channels) { |
472 | if (ch_elements[element] == TYPE_CPE) { |
473 | write_element(s, TYPE_CPE, cpe, samples[ch_map[ch]], |
474 | samples[ch_map[ch + 1]]); |
475 | cpe++; |
476 | ch += 2; |
477 | } else { |
478 | write_element(s, TYPE_SCE, sce, samples[ch_map[ch]], NULL); |
479 | sce++; |
480 | ch++; |
481 | } |
482 | element++; |
483 | } |
484 | |
485 | put_bits(pb, 3, TYPE_END); |
486 | flush_put_bits(pb); |
487 | |
488 | return put_bits_count(pb) >> 3; |
489 | } |
490 | |
491 | static av_always_inline int get_max_frame_size(int frame_size, int ch, int bps) |
492 | { |
493 | int header_bits = 23 + 32 * (frame_size < DEFAULT_FRAME_SIZE); |
494 | return FFALIGN(header_bits + bps * ch * frame_size + 3, 8) / 8; |
495 | } |
496 | |
497 | static av_cold int alac_encode_close(AVCodecContext *avctx) |
498 | { |
499 | AlacEncodeContext *s = avctx->priv_data; |
500 | ff_lpc_end(&s->lpc_ctx); |
501 | av_freep(&avctx->extradata); |
502 | avctx->extradata_size = 0; |
503 | return 0; |
504 | } |
505 | |
506 | static av_cold int alac_encode_init(AVCodecContext *avctx) |
507 | { |
508 | AlacEncodeContext *s = avctx->priv_data; |
509 | int ret; |
510 | uint8_t *alac_extradata; |
511 | |
512 | avctx->frame_size = s->frame_size = DEFAULT_FRAME_SIZE; |
513 | |
514 | if (avctx->sample_fmt == AV_SAMPLE_FMT_S32P) { |
515 | if (avctx->bits_per_raw_sample != 24) |
516 | av_log(avctx, AV_LOG_WARNING, "encoding as 24 bits-per-sample\n"); |
517 | avctx->bits_per_raw_sample = 24; |
518 | } else { |
519 | avctx->bits_per_raw_sample = 16; |
520 | s->extra_bits = 0; |
521 | } |
522 | |
523 | // Set default compression level |
524 | if (avctx->compression_level == FF_COMPRESSION_DEFAULT) |
525 | s->compression_level = 2; |
526 | else |
527 | s->compression_level = av_clip(avctx->compression_level, 0, 2); |
528 | |
529 | // Initialize default Rice parameters |
530 | s->rc.history_mult = 40; |
531 | s->rc.initial_history = 10; |
532 | s->rc.k_modifier = 14; |
533 | s->rc.rice_modifier = 4; |
534 | |
535 | s->max_coded_frame_size = get_max_frame_size(avctx->frame_size, |
536 | avctx->channels, |
537 | avctx->bits_per_raw_sample); |
538 | |
539 | avctx->extradata = av_mallocz(ALAC_EXTRADATA_SIZE + AV_INPUT_BUFFER_PADDING_SIZE); |
540 | if (!avctx->extradata) { |
541 | ret = AVERROR(ENOMEM); |
542 | goto error; |
543 | } |
544 | avctx->extradata_size = ALAC_EXTRADATA_SIZE; |
545 | |
546 | alac_extradata = avctx->extradata; |
547 | AV_WB32(alac_extradata, ALAC_EXTRADATA_SIZE); |
548 | AV_WB32(alac_extradata+4, MKBETAG('a','l','a','c')); |
549 | AV_WB32(alac_extradata+12, avctx->frame_size); |
550 | AV_WB8 (alac_extradata+17, avctx->bits_per_raw_sample); |
551 | AV_WB8 (alac_extradata+21, avctx->channels); |
552 | AV_WB32(alac_extradata+24, s->max_coded_frame_size); |
553 | AV_WB32(alac_extradata+28, |
554 | avctx->sample_rate * avctx->channels * avctx->bits_per_raw_sample); // average bitrate |
555 | AV_WB32(alac_extradata+32, avctx->sample_rate); |
556 | |
557 | // Set relevant extradata fields |
558 | if (s->compression_level > 0) { |
559 | AV_WB8(alac_extradata+18, s->rc.history_mult); |
560 | AV_WB8(alac_extradata+19, s->rc.initial_history); |
561 | AV_WB8(alac_extradata+20, s->rc.k_modifier); |
562 | } |
563 | |
564 | #if FF_API_PRIVATE_OPT |
565 | FF_DISABLE_DEPRECATION_WARNINGS |
566 | if (avctx->min_prediction_order >= 0) { |
567 | if (avctx->min_prediction_order < MIN_LPC_ORDER || |
568 | avctx->min_prediction_order > ALAC_MAX_LPC_ORDER) { |
569 | av_log(avctx, AV_LOG_ERROR, "invalid min prediction order: %d\n", |
570 | avctx->min_prediction_order); |
571 | ret = AVERROR(EINVAL); |
572 | goto error; |
573 | } |
574 | |
575 | s->min_prediction_order = avctx->min_prediction_order; |
576 | } |
577 | |
578 | if (avctx->max_prediction_order >= 0) { |
579 | if (avctx->max_prediction_order < MIN_LPC_ORDER || |
580 | avctx->max_prediction_order > ALAC_MAX_LPC_ORDER) { |
581 | av_log(avctx, AV_LOG_ERROR, "invalid max prediction order: %d\n", |
582 | avctx->max_prediction_order); |
583 | ret = AVERROR(EINVAL); |
584 | goto error; |
585 | } |
586 | |
587 | s->max_prediction_order = avctx->max_prediction_order; |
588 | } |
589 | FF_ENABLE_DEPRECATION_WARNINGS |
590 | #endif |
591 | |
592 | if (s->max_prediction_order < s->min_prediction_order) { |
593 | av_log(avctx, AV_LOG_ERROR, |
594 | "invalid prediction orders: min=%d max=%d\n", |
595 | s->min_prediction_order, s->max_prediction_order); |
596 | ret = AVERROR(EINVAL); |
597 | goto error; |
598 | } |
599 | |
600 | s->avctx = avctx; |
601 | |
602 | if ((ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size, |
603 | s->max_prediction_order, |
604 | FF_LPC_TYPE_LEVINSON)) < 0) { |
605 | goto error; |
606 | } |
607 | |
608 | return 0; |
609 | error: |
610 | alac_encode_close(avctx); |
611 | return ret; |
612 | } |
613 | |
614 | static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, |
615 | const AVFrame *frame, int *got_packet_ptr) |
616 | { |
617 | AlacEncodeContext *s = avctx->priv_data; |
618 | int out_bytes, max_frame_size, ret; |
619 | |
620 | s->frame_size = frame->nb_samples; |
621 | |
622 | if (frame->nb_samples < DEFAULT_FRAME_SIZE) |
623 | max_frame_size = get_max_frame_size(s->frame_size, avctx->channels, |
624 | avctx->bits_per_raw_sample); |
625 | else |
626 | max_frame_size = s->max_coded_frame_size; |
627 | |
628 | if ((ret = ff_alloc_packet2(avctx, avpkt, 4 * max_frame_size, 0)) < 0) |
629 | return ret; |
630 | |
631 | /* use verbatim mode for compression_level 0 */ |
632 | if (s->compression_level) { |
633 | s->verbatim = 0; |
634 | s->extra_bits = avctx->bits_per_raw_sample - 16; |
635 | } else { |
636 | s->verbatim = 1; |
637 | s->extra_bits = 0; |
638 | } |
639 | |
640 | out_bytes = write_frame(s, avpkt, frame->extended_data); |
641 | |
642 | if (out_bytes > max_frame_size) { |
643 | /* frame too large. use verbatim mode */ |
644 | s->verbatim = 1; |
645 | s->extra_bits = 0; |
646 | out_bytes = write_frame(s, avpkt, frame->extended_data); |
647 | } |
648 | |
649 | avpkt->size = out_bytes; |
650 | *got_packet_ptr = 1; |
651 | return 0; |
652 | } |
653 | |
654 | #define OFFSET(x) offsetof(AlacEncodeContext, x) |
655 | #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM |
656 | static const AVOption options[] = { |
657 | { "min_prediction_order", NULL, OFFSET(min_prediction_order), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MIN_PRED_ORDER }, MIN_LPC_ORDER, ALAC_MAX_LPC_ORDER, AE }, |
658 | { "max_prediction_order", NULL, OFFSET(max_prediction_order), AV_OPT_TYPE_INT, { .i64 = DEFAULT_MAX_PRED_ORDER }, MIN_LPC_ORDER, ALAC_MAX_LPC_ORDER, AE }, |
659 | |
660 | { NULL }, |
661 | }; |
662 | |
663 | static const AVClass alacenc_class = { |
664 | .class_name = "alacenc", |
665 | .item_name = av_default_item_name, |
666 | .option = options, |
667 | .version = LIBAVUTIL_VERSION_INT, |
668 | }; |
669 | |
670 | AVCodec ff_alac_encoder = { |
671 | .name = "alac", |
672 | .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"), |
673 | .type = AVMEDIA_TYPE_AUDIO, |
674 | .id = AV_CODEC_ID_ALAC, |
675 | .priv_data_size = sizeof(AlacEncodeContext), |
676 | .priv_class = &alacenc_class, |
677 | .init = alac_encode_init, |
678 | .encode2 = alac_encode_frame, |
679 | .close = alac_encode_close, |
680 | .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME, |
681 | .channel_layouts = ff_alac_channel_layouts, |
682 | .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P, |
683 | AV_SAMPLE_FMT_S16P, |
684 | AV_SAMPLE_FMT_NONE }, |
685 | }; |
686 |