FFmpeg: libavcodec/alacenc.c Source File

FFmpeg

[フレーム]

libavcodec

alacenc.c

Go to the documentation of this file.

1 /*

2 * ALAC audio encoder

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 */

22 #include "libavutil/opt.h"

24 #include "avcodec.h"

25 #include "codec_internal.h"

26 #include "encode.h"

27 #include "put_bits.h"

28 #include "lpc.h"

29 #include "mathops.h"

30 #include "alac_data.h"

32 #define DEFAULT_FRAME_SIZE 4096

33 #define ALAC_EXTRADATA_SIZE 36

34 #define ALAC_FRAME_HEADER_SIZE 55

35 #define ALAC_FRAME_FOOTER_SIZE 3

37 #define ALAC_ESCAPE_CODE 0x1FF

38 #define ALAC_MAX_LPC_ORDER 30

39 #define DEFAULT_MAX_PRED_ORDER 6

40 #define DEFAULT_MIN_PRED_ORDER 4

41 #define ALAC_MAX_LPC_PRECISION 9

42 #define ALAC_MIN_LPC_SHIFT 0

43 #define ALAC_MAX_LPC_SHIFT 9

45 #define ALAC_CHMODE_LEFT_RIGHT 0

46 #define ALAC_CHMODE_LEFT_SIDE 1

47 #define ALAC_CHMODE_RIGHT_SIDE 2

48 #define ALAC_CHMODE_MID_SIDE 3

50 typedef struct RiceContext {

51 int history_mult;

52 int initial_history;

53 int k_modifier;

54 int rice_modifier;

55 } RiceContext;

57 typedef struct AlacLPCContext {

58 int lpc_order;

59 int lpc_coeff[ALAC_MAX_LPC_ORDER+1];

60 int lpc_quant;

61 } AlacLPCContext;

63 typedef struct AlacEncodeContext {

64 const AVClass *class;

65 AVCodecContext *avctx;

66 int frame_size; /**< current frame size */

67 int verbatim; /**< current frame verbatim mode flag */

68 int compression_level;

69 int min_prediction_order;

70 int max_prediction_order;

71 int max_coded_frame_size;

72 int write_sample_size;

73 int extra_bits;

74 int32_t sample_buf[2][DEFAULT_FRAME_SIZE];

75 int32_t predictor_buf[2][DEFAULT_FRAME_SIZE];

76 int interlacing_shift;

77 int interlacing_leftweight;

78 PutBitContext pbctx;

79 RiceContext rc;

80 AlacLPCContext lpc[2];

81 LPCContext lpc_ctx;

82 } AlacEncodeContext;

85 static void init_sample_buffers(AlacEncodeContext *s, int channels,

86 const uint8_t *samples[2])

87 {

88 int ch, i;

89 int shift = av_get_bytes_per_sample(s->avctx->sample_fmt) * 8 -

90 s->avctx->bits_per_raw_sample;

92 #define COPY_SAMPLES(type) do { \

93 for (ch = 0; ch < channels; ch++) { \

94 int32_t *bptr = s->sample_buf[ch]; \

95 const type *sptr = (const type *)samples[ch]; \

96 for (i = 0; i < s->frame_size; i++) \

97 bptr[i] = sptr[i] >> shift; \

98 } \

99 } while (0)

100

101 if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P)

102 COPY_SAMPLES(int32_t);

103 else

104 COPY_SAMPLES(int16_t);

105 }

106

107 static void encode_scalar(AlacEncodeContext *s, int x,

108 int k, int write_sample_size)

109 {

110 int divisor, q, r;

111

112 k = FFMIN(k, s->rc.k_modifier);

113 divisor = (1<<k) - 1;

114 q = x / divisor;

115 r = x % divisor;

116

117 if (q > 8) {

118 // write escape code and sample value directly

119 put_bits(&s->pbctx, 9, ALAC_ESCAPE_CODE);

120 put_bits(&s->pbctx, write_sample_size, x);

121 } else {

122 if (q)

123 put_bits(&s->pbctx, q, (1<<q) - 1);

124 put_bits(&s->pbctx, 1, 0);

125

126 if (k != 1) {

127 if (r > 0)

128 put_bits(&s->pbctx, k, r+1);

129 else

130 put_bits(&s->pbctx, k-1, 0);

131 }

132 }

133 }

134

135 static void write_element_header(AlacEncodeContext *s,

136 enum AlacRawDataBlockType element,

137 int instance)

138 {

139 int encode_fs = 0;

140

141 if (s->frame_size < DEFAULT_FRAME_SIZE)

142 encode_fs = 1;

143

144 put_bits(&s->pbctx, 3, element); // element type

145 put_bits(&s->pbctx, 4, instance); // element instance

146 put_bits(&s->pbctx, 12, 0); // unused header bits

147 put_bits(&s->pbctx, 1, encode_fs); // Sample count is in the header

148 put_bits(&s->pbctx, 2, s->extra_bits >> 3); // Extra bytes (for 24-bit)

149 put_bits(&s->pbctx, 1, s->verbatim); // Audio block is verbatim

150 if (encode_fs)

151 put_bits32(&s->pbctx, s->frame_size); // No. of samples in the frame

152 }

153

154 static void calc_predictor_params(AlacEncodeContext *s, int ch)

155 {

156 int32_t coefs[MAX_LPC_ORDER][MAX_LPC_ORDER];

157 int shift[MAX_LPC_ORDER];

158 int opt_order;

159

160 if (s->compression_level == 1) {

161 s->lpc[ch].lpc_order = 6;

162 s->lpc[ch].lpc_quant = 6;

163 s->lpc[ch].lpc_coeff[0] = 160;

164 s->lpc[ch].lpc_coeff[1] = -190;

165 s->lpc[ch].lpc_coeff[2] = 170;

166 s->lpc[ch].lpc_coeff[3] = -130;

167 s->lpc[ch].lpc_coeff[4] = 80;

168 s->lpc[ch].lpc_coeff[5] = -25;

169 } else {

170 opt_order = ff_lpc_calc_coefs(&s->lpc_ctx, s->sample_buf[ch],

171 s->frame_size,

172 s->min_prediction_order,

173 s->max_prediction_order,

174 ALAC_MAX_LPC_PRECISION, coefs, shift,

175 FF_LPC_TYPE_LEVINSON, 0,

176 ORDER_METHOD_EST, ALAC_MIN_LPC_SHIFT,

177 ALAC_MAX_LPC_SHIFT, 1);

178

179 s->lpc[ch].lpc_order = opt_order;

180 s->lpc[ch].lpc_quant = shift[opt_order-1];

181 memcpy(s->lpc[ch].lpc_coeff, coefs[opt_order-1], opt_order*sizeof(int));

182 }

183 }

184

185 static int estimate_stereo_mode(int32_t *left_ch, int32_t *right_ch, int n)

186 {

187 int i, best;

188 int32_t lt, rt;

189 uint64_t sum[4];

190 uint64_t score[4];

191

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

193 sum[0] = sum[1] = sum[2] = sum[3] = 0;

194 for (i = 2; i < n; i++) {

195 lt = left_ch[i] - 2 * left_ch[i - 1] + left_ch[i - 2];

196 rt = right_ch[i] - 2 * right_ch[i - 1] + right_ch[i - 2];

197 sum[2] += FFABS((lt + rt) >> 1);

198 sum[3] += FFABS(lt - rt);

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

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

201 }

202

203 /* calculate score for each mode */

204 score[0] = sum[0] + sum[1];

205 score[1] = sum[0] + sum[3];

206 score[2] = sum[1] + sum[3];

207 score[3] = sum[2] + sum[3];

208

209 /* return mode with lowest score */

210 best = 0;

211 for (i = 1; i < 4; i++) {

212 if (score[i] < score[best])

213 best = i;

214 }

215 return best;

216 }

217

218 static void alac_stereo_decorrelation(AlacEncodeContext *s)

219 {

220 int32_t *left = s->sample_buf[0], *right = s->sample_buf[1];

221 int i, mode, n = s->frame_size;

222 int32_t tmp;

223

224 mode = estimate_stereo_mode(left, right, n);

225

226 switch (mode) {

227 case ALAC_CHMODE_LEFT_RIGHT:

228 s->interlacing_leftweight = 0;

229 s->interlacing_shift = 0;

230 break;

231 case ALAC_CHMODE_LEFT_SIDE:

232 for (i = 0; i < n; i++)

233 right[i] = left[i] - right[i];

234 s->interlacing_leftweight = 1;

235 s->interlacing_shift = 0;

236 break;

237 case ALAC_CHMODE_RIGHT_SIDE:

238 for (i = 0; i < n; i++) {

239 tmp = right[i];

240 right[i] = left[i] - right[i];

241 left[i] = tmp + (right[i] >> 31);

242 }

243 s->interlacing_leftweight = 1;

244 s->interlacing_shift = 31;

245 break;

246 default:

247 for (i = 0; i < n; i++) {

248 tmp = left[i];

249 left[i] = (tmp + right[i]) >> 1;

250 right[i] = tmp - right[i];

251 }

252 s->interlacing_leftweight = 1;

253 s->interlacing_shift = 1;

254 break;

255 }

256 }

257

258 static void alac_linear_predictor(AlacEncodeContext *s, int ch)

259 {

260 int i;

261 AlacLPCContext lpc = s->lpc[ch];

262 int32_t *residual = s->predictor_buf[ch];

263

264 if (lpc.lpc_order == 31) {

265 residual[0] = s->sample_buf[ch][0];

266

267 for (i = 1; i < s->frame_size; i++) {

268 residual[i] = s->sample_buf[ch][i ] -

269 s->sample_buf[ch][i - 1];

270 }

271

272 return;

273 }

274

275 // generalised linear predictor

276

277 if (lpc.lpc_order > 0) {

278 int32_t *samples = s->sample_buf[ch];

279

280 // generate warm-up samples

281 residual[0] = samples[0];

282 for (i = 1; i <= lpc.lpc_order; i++)

283 residual[i] = sign_extend(samples[i] - samples[i-1], s->write_sample_size);

284

285 // perform lpc on remaining samples

286 for (i = lpc.lpc_order + 1; i < s->frame_size; i++) {

287 int sum = 1 << (lpc.lpc_quant - 1), res_val, j;

288

289 for (j = 0; j < lpc.lpc_order; j++) {

290 sum += (samples[lpc.lpc_order-j] - samples[0]) *

291 lpc.lpc_coeff[j];

292 }

293

294 sum >>= lpc.lpc_quant;

295 sum += samples[0];

296 residual[i] = sign_extend(samples[lpc.lpc_order+1] - sum,

297 s->write_sample_size);

298 res_val = residual[i];

299

300 if (res_val) {

301 int index = lpc.lpc_order - 1;

302 int neg = (res_val < 0);

303

304 while (index >= 0 && (neg ? (res_val < 0) : (res_val > 0))) {

305 int val = samples[0] - samples[lpc.lpc_order - index];

306 int sign = (val ? FFSIGN(val) : 0);

307

308 if (neg)

309 sign *= -1;

310

311 lpc.lpc_coeff[index] -= sign;

312 val *= sign;

313 res_val -= (val >> lpc.lpc_quant) * (lpc.lpc_order - index);

314 index--;

315 }

316 }

317 samples++;

318 }

319 }

320 }

321

322 static void alac_entropy_coder(AlacEncodeContext *s, int ch)

323 {

324 unsigned int history = s->rc.initial_history;

325 int sign_modifier = 0, i, k;

326 int32_t *samples = s->predictor_buf[ch];

327

328 for (i = 0; i < s->frame_size;) {

329 int x;

330

331 k = av_log2((history >> 9) + 3);

332

333 x = -2 * (*samples) -1;

334 x ^= x >> 31;

335

336 samples++;

337 i++;

338

339 encode_scalar(s, x - sign_modifier, k, s->write_sample_size);

340

341 history += x * s->rc.history_mult -

342 ((history * s->rc.history_mult) >> 9);

343

344 sign_modifier = 0;

345 if (x > 0xFFFF)

346 history = 0xFFFF;

347

348 if (history < 128 && i < s->frame_size) {

349 unsigned int block_size = 0;

350

351 k = 7 - av_log2(history) + ((history + 16) >> 6);

352

353 while (*samples == 0 && i < s->frame_size) {

354 samples++;

355 i++;

356 block_size++;

357 }

358 encode_scalar(s, block_size, k, 16);

359 sign_modifier = (block_size <= 0xFFFF);

360 history = 0;

361 }

362

363 }

364 }

365

366 static void write_element(AlacEncodeContext *s,

367 enum AlacRawDataBlockType element, int instance,

368 const uint8_t *samples0, const uint8_t *samples1)

369 {

370 const uint8_t *samples[2] = { samples0, samples1 };

371 int i, j, channels;

372 int prediction_type = 0;

373 PutBitContext *pb = &s->pbctx;

374

375 channels = element == TYPE_CPE ? 2 : 1;

376

377 if (s->verbatim) {

378 write_element_header(s, element, instance);

379 /* samples are channel-interleaved in verbatim mode */

380 if (s->avctx->sample_fmt == AV_SAMPLE_FMT_S32P) {

381 int shift = 32 - s->avctx->bits_per_raw_sample;

382 const int32_t *samples_s32[2] = { (const int32_t *)samples0,

383 (const int32_t *)samples1 };

384 for (i = 0; i < s->frame_size; i++)

385 for (j = 0; j < channels; j++)

386 put_sbits(pb, s->avctx->bits_per_raw_sample,

387 samples_s32[j][i] >> shift);

388 } else {

389 const int16_t *samples_s16[2] = { (const int16_t *)samples0,

390 (const int16_t *)samples1 };

391 for (i = 0; i < s->frame_size; i++)

392 for (j = 0; j < channels; j++)

393 put_sbits(pb, s->avctx->bits_per_raw_sample,

394 samples_s16[j][i]);

395 }

396 } else {

397 s->write_sample_size = s->avctx->bits_per_raw_sample - s->extra_bits +

398 channels - 1;

399

400 init_sample_buffers(s, channels, samples);

401 write_element_header(s, element, instance);

402

403 // extract extra bits if needed

404 if (s->extra_bits) {

405 uint32_t mask = (1 << s->extra_bits) - 1;

406 for (j = 0; j < channels; j++) {

407 int32_t *extra = s->predictor_buf[j];

408 int32_t *smp = s->sample_buf[j];

409 for (i = 0; i < s->frame_size; i++) {

410 extra[i] = smp[i] & mask;

411 smp[i] >>= s->extra_bits;

412 }

413 }

414 }

415

416 if (channels == 2)

417 alac_stereo_decorrelation(s);

418 else

419 s->interlacing_shift = s->interlacing_leftweight = 0;

420 put_bits(pb, 8, s->interlacing_shift);

421 put_bits(pb, 8, s->interlacing_leftweight);

422

423 for (i = 0; i < channels; i++) {

424 calc_predictor_params(s, i);

425

426 put_bits(pb, 4, prediction_type);

427 put_bits(pb, 4, s->lpc[i].lpc_quant);

428

429 put_bits(pb, 3, s->rc.rice_modifier);

430 put_bits(pb, 5, s->lpc[i].lpc_order);

431 // predictor coeff. table

432 for (j = 0; j < s->lpc[i].lpc_order; j++)

433 put_sbits(pb, 16, s->lpc[i].lpc_coeff[j]);

434 }

435

436 // write extra bits if needed

437 if (s->extra_bits) {

438 for (i = 0; i < s->frame_size; i++) {

439 for (j = 0; j < channels; j++) {

440 put_bits(pb, s->extra_bits, s->predictor_buf[j][i]);

441 }

442 }

443 }

444

445 // apply lpc and entropy coding to audio samples

446 for (i = 0; i < channels; i++) {

447 alac_linear_predictor(s, i);

448

449 // TODO: determine when this will actually help. for now it's not used.

450 if (prediction_type == 15) {

451 // 2nd pass 1st order filter

452 int32_t *residual = s->predictor_buf[i];

453 for (j = s->frame_size - 1; j > 0; j--)

454 residual[j] -= residual[j - 1];

455 }

456 alac_entropy_coder(s, i);

457 }

458 }

459 }

460

461 static int write_frame(AlacEncodeContext *s, AVPacket *avpkt,

462 uint8_t * const *samples)

463 {

464 PutBitContext *pb = &s->pbctx;

465 int channels = s->avctx->ch_layout.nb_channels;

466 const enum AlacRawDataBlockType *ch_elements = ff_alac_channel_elements[channels - 1];

467 const uint8_t *ch_map = ff_alac_channel_layout_offsets[channels - 1];

468 int ch, element, sce, cpe;

469

470 init_put_bits(pb, avpkt->data, avpkt->size);

471

472 ch = element = sce = cpe = 0;

473 while (ch < channels) {

474 if (ch_elements[element] == TYPE_CPE) {

475 write_element(s, TYPE_CPE, cpe, samples[ch_map[ch]],

476 samples[ch_map[ch + 1]]);

477 cpe++;

478 ch += 2;

479 } else {

480 write_element(s, TYPE_SCE, sce, samples[ch_map[ch]], NULL);

481 sce++;

482 ch++;

483 }

484 element++;

485 }

486

487 put_bits(pb, 3, TYPE_END);

488 flush_put_bits(pb);

489

490 return put_bytes_output(pb);

491 }

492

493 static av_always_inline int get_max_frame_size(int frame_size, int ch, int bps)

494 {

495 int header_bits = 23 + 32 * (frame_size < DEFAULT_FRAME_SIZE);

496 return FFALIGN(header_bits + bps * ch * frame_size + 3, 8) / 8;

497 }

498

499 static av_cold int alac_encode_close(AVCodecContext *avctx)

500 {

501 AlacEncodeContext *s = avctx->priv_data;

502 ff_lpc_end(&s->lpc_ctx);

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->ch_layout.nb_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 return AVERROR(ENOMEM);

542 avctx->extradata_size = ALAC_EXTRADATA_SIZE;

543

544 alac_extradata = avctx->extradata;

545 AV_WB32(alac_extradata, ALAC_EXTRADATA_SIZE);

546 AV_WB32(alac_extradata+4, MKBETAG('a','l','a','c'));

547 AV_WB32(alac_extradata+12, avctx->frame_size);

548 AV_WB8 (alac_extradata+17, avctx->bits_per_raw_sample);

549 AV_WB8 (alac_extradata+21, avctx->ch_layout.nb_channels);

550 AV_WB32(alac_extradata+24, s->max_coded_frame_size);

551 AV_WB32(alac_extradata+28,

552 avctx->sample_rate * avctx->ch_layout.nb_channels * avctx->bits_per_raw_sample); // average bitrate

553 AV_WB32(alac_extradata+32, avctx->sample_rate);

554

555 // Set relevant extradata fields

556 if (s->compression_level > 0) {

557 AV_WB8(alac_extradata+18, s->rc.history_mult);

558 AV_WB8(alac_extradata+19, s->rc.initial_history);

559 AV_WB8(alac_extradata+20, s->rc.k_modifier);

560 }

561

562 if (s->max_prediction_order < s->min_prediction_order) {

563 av_log(avctx, AV_LOG_ERROR,

564 "invalid prediction orders: min=%d max=%d\n",

565 s->min_prediction_order, s->max_prediction_order);

566 return AVERROR(EINVAL);

567 }

568

569 s->avctx = avctx;

570

571 if ((ret = ff_lpc_init(&s->lpc_ctx, avctx->frame_size,

572 s->max_prediction_order,

573 FF_LPC_TYPE_LEVINSON)) < 0) {

574 return ret;

575 }

576

577 return 0;

578 }

579

580 static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

581 const AVFrame *frame, int *got_packet_ptr)

582 {

583 AlacEncodeContext *s = avctx->priv_data;

584 int out_bytes, max_frame_size, ret;

585

586 s->frame_size = frame->nb_samples;

587

588 if (frame->nb_samples < DEFAULT_FRAME_SIZE)

589 max_frame_size = get_max_frame_size(s->frame_size, avctx->ch_layout.nb_channels,

590 avctx->bits_per_raw_sample);

591 else

592 max_frame_size = s->max_coded_frame_size;

593

594 if ((ret = ff_alloc_packet(avctx, avpkt, 4 * max_frame_size)) < 0)

595 return ret;

596

597 /* use verbatim mode for compression_level 0 */

598 if (s->compression_level) {

599 s->verbatim = 0;

600 s->extra_bits = avctx->bits_per_raw_sample - 16;

601 } else {

602 s->verbatim = 1;

603 s->extra_bits = 0;

604 }

605

606 out_bytes = write_frame(s, avpkt, frame->extended_data);

607

608 if (out_bytes > max_frame_size) {

609 /* frame too large. use verbatim mode */

610 s->verbatim = 1;

611 s->extra_bits = 0;

612 out_bytes = write_frame(s, avpkt, frame->extended_data);

613 }

614

615 avpkt->size = out_bytes;

616 *got_packet_ptr = 1;

617 return 0;

618 }

619

620 #define OFFSET(x) offsetof(AlacEncodeContext, x)

621 #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

622 static const AVOption options[] = {

623 { "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 },

624 { "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 },

625

626 { NULL },

627 };

628

629 static const AVClass alacenc_class = {

630 .class_name = "alacenc",

631 .item_name = av_default_item_name,

632 .option = options,

633 .version = LIBAVUTIL_VERSION_INT,

634 };

635

636 const FFCodec ff_alac_encoder = {

637 .p.name = "alac",

638 CODEC_LONG_NAME("ALAC (Apple Lossless Audio Codec)"),

639 .p.type = AVMEDIA_TYPE_AUDIO,

640 .p.id = AV_CODEC_ID_ALAC,

641 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SMALL_LAST_FRAME |

642 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

643 .priv_data_size = sizeof(AlacEncodeContext),

644 .p.priv_class = &alacenc_class,

645 .init = alac_encode_init,

646 FF_CODEC_ENCODE_CB(alac_encode_frame),

647 .close = alac_encode_close,

648 .p.ch_layouts = ff_alac_ch_layouts,

649 .p.sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32P,

650 AV_SAMPLE_FMT_S16P,

651 AV_SAMPLE_FMT_NONE },

652 };

DEFAULT_FRAME_SIZE

#define DEFAULT_FRAME_SIZE

Definition: alacenc.c:32

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1077

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

alac_stereo_decorrelation

static void alac_stereo_decorrelation(AlacEncodeContext *s)

Definition: alacenc.c:218

OFFSET

#define OFFSET(x)

Definition: alacenc.c:620

ALAC_ESCAPE_CODE

#define ALAC_ESCAPE_CODE

Definition: alacenc.c:37

av_clip

#define av_clip

Definition: common.h:98

const char * r

Definition: vf_curves.c:126

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

AlacEncodeContext::compression_level

int compression_level

Definition: alacenc.c:68

put_bits32

static void av_unused put_bits32(PutBitContext *s, uint32_t value)

Write exactly 32 bits into a bitstream.

Definition: put_bits.h:291

AlacEncodeContext::verbatim

int verbatim

current frame verbatim mode flag

Definition: alacenc.c:67

alac_data.h

put_bytes_output

static int put_bytes_output(const PutBitContext *s)

Definition: put_bits.h:89

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1050

DEFAULT_MIN_PRED_ORDER

#define DEFAULT_MIN_PRED_ORDER

Definition: alacenc.c:40

AlacEncodeContext::predictor_buf

int32_t predictor_buf[2][DEFAULT_FRAME_SIZE]

Definition: alacenc.c:75

AlacLPCContext::lpc_quant

int lpc_quant

Definition: alacenc.c:60

ff_lpc_calc_coefs

int ff_lpc_calc_coefs(LPCContext *s, const int32_t *samples, int blocksize, int min_order, int max_order, int precision, int32_t coefs[][MAX_LPC_ORDER], int *shift, enum FFLPCType lpc_type, int lpc_passes, int omethod, int min_shift, int max_shift, int zero_shift)

Calculate LPC coefficients for multiple orders.

Definition: lpc.c:238

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:281

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

ff_lpc_init

av_cold int ff_lpc_init(LPCContext *s, int blocksize, int max_order, enum FFLPCType lpc_type)

Initialize LPCContext.

Definition: lpc.c:340

RiceContext

Definition: alacenc.c:50

write_element_header

static void write_element_header(AlacEncodeContext *s, enum AlacRawDataBlockType element, int instance)

Definition: alacenc.c:135

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:344

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:222

alac_encode_init

static av_cold int alac_encode_init(AVCodecContext *avctx)

Definition: alacenc.c:506

AlacEncodeContext::avctx

AVCodecContext * avctx

Definition: alacenc.c:65

AVPacket::data

uint8_t * data

Definition: packet.h:522

AVOption

AVOption.

Definition: opt.h:346

encode.h

AV_SAMPLE_FMT_S32P

@ AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:65

AV_CODEC_ID_ALAC

@ AV_CODEC_ID_ALAC

Definition: codec_id.h:456

FFCodec

Definition: codec_internal.h:127

AlacLPCContext::lpc_order

int lpc_order

Definition: alacenc.c:58

lpc.h

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:313

FF_COMPRESSION_DEFAULT

#define FF_COMPRESSION_DEFAULT

Definition: avcodec.h:1246

alac_linear_predictor

static void alac_linear_predictor(AlacEncodeContext *s, int ch)

Definition: alacenc.c:258

COPY_SAMPLES

#define COPY_SAMPLES(type)

LPCContext

Definition: lpc.h:51

AlacEncodeContext::lpc

AlacLPCContext lpc[2]

Definition: alacenc.c:80

DEFAULT_MAX_PRED_ORDER

#define DEFAULT_MAX_PRED_ORDER

Definition: alacenc.c:39

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1065

FFSIGN

#define FFSIGN(a)

Definition: common.h:73

TYPE_CPE

@ TYPE_CPE

Definition: aac.h:44

AlacEncodeContext::write_sample_size

int write_sample_size

Definition: alacenc.c:72

write_element

static void write_element(AlacEncodeContext *s, enum AlacRawDataBlockType element, int instance, const uint8_t *samples0, const uint8_t *samples1)

Definition: alacenc.c:366

val

static double val(void *priv, double ch)

Definition: aeval.c:78

alacenc_class

static const AVClass alacenc_class

Definition: alacenc.c:629

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:296

AlacEncodeContext::extra_bits

int extra_bits

Definition: alacenc.c:73

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

calc_predictor_params

static void calc_predictor_params(AlacEncodeContext *s, int ch)

Definition: alacenc.c:154

mask

static const uint16_t mask[17]

Definition: lzw.c:38

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:524

alac_encode_frame

static int alac_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Definition: alacenc.c:580

#define s(width, name)

Definition: cbs_vp9.c:198

frame_size

int frame_size

Definition: mxfenc.c:2422

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:159

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1574

RiceContext::rice_modifier

int rice_modifier

Definition: alacenc.c:54

RiceContext::k_modifier

int k_modifier

Definition: alacenc.c:53

channels

Definition: aptx.h:31

alac_entropy_coder

static void alac_entropy_coder(AlacEncodeContext *s, int ch)

Definition: alacenc.c:322

PutBitContext

Definition: put_bits.h:50

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

frame

static AVFrame * frame

Definition: demux_decode.c:54

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:72

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

ALAC_MAX_LPC_PRECISION

#define ALAC_MAX_LPC_PRECISION

Definition: alacenc.c:41

AlacEncodeContext::pbctx

PutBitContext pbctx

Definition: alacenc.c:78

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

ff_lpc_end

av_cold void ff_lpc_end(LPCContext *s)

Uninitialize LPCContext.

Definition: lpc.c:365

mathops.h

#define AE

Definition: alacenc.c:621

AlacEncodeContext::interlacing_shift

int interlacing_shift

Definition: alacenc.c:76

ff_alac_channel_elements

enum AlacRawDataBlockType ff_alac_channel_elements[ALAC_MAX_CHANNELS][5]

Definition: alac_data.c:47

index

int index

Definition: gxfenc.c:89

AlacLPCContext

Definition: alacenc.c:57

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:417

options

static const AVOption options[]

Definition: alacenc.c:622

ch_map

static const int ch_map[SC_NB]

Definition: af_surround.c:37

AlacEncodeContext::max_coded_frame_size

int max_coded_frame_size

Definition: alacenc.c:71

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:523

codec_internal.h

TYPE_END

@ TYPE_END

Definition: aac.h:50

shift

static int shift(int a, int b)

Definition: bonk.c:262

MAX_LPC_ORDER

#define MAX_LPC_ORDER

Definition: lpc.h:37

AlacEncodeContext::rc

RiceContext rc

Definition: alacenc.c:79

bps

unsigned bps

Definition: movenc.c:1792

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1057

AV_SAMPLE_FMT_NONE

@ AV_SAMPLE_FMT_NONE

Definition: samplefmt.h:56

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: macros.h:56

ALAC_MAX_LPC_SHIFT

#define ALAC_MAX_LPC_SHIFT

Definition: alacenc.c:43

MIN_LPC_ORDER

#define MIN_LPC_ORDER

Definition: lpc.h:36

get_max_frame_size

static av_always_inline int get_max_frame_size(int frame_size, int ch, int bps)

Definition: alacenc.c:493

AlacEncodeContext::max_prediction_order

int max_prediction_order

Definition: alacenc.c:70

RiceContext::history_mult

int history_mult

Definition: alacenc.c:51

ORDER_METHOD_EST

#define ORDER_METHOD_EST

Definition: lpc.h:29

ff_alac_encoder

const FFCodec ff_alac_encoder

Definition: alacenc.c:636

ALAC_CHMODE_LEFT_SIDE

#define ALAC_CHMODE_LEFT_SIDE

Definition: alacenc.c:46

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:64

ALAC_MAX_LPC_ORDER

#define ALAC_MAX_LPC_ORDER

Definition: alacenc.c:38

ALAC_MIN_LPC_SHIFT

#define ALAC_MIN_LPC_SHIFT

Definition: alacenc.c:42

AlacEncodeContext::frame_size

int frame_size

current frame size

Definition: alacenc.c:66

AlacEncodeContext::min_prediction_order

int min_prediction_order

Definition: alacenc.c:69

AVFrame::nb_samples

int nb_samples

number of audio samples (per channel) described by this frame

Definition: frame.h:424

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

ff_alac_channel_layout_offsets

const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]

Definition: alac_data.c:24

av_get_bytes_per_sample

int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)

Return number of bytes per sample.

Definition: samplefmt.c:108

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:523

ff_alac_ch_layouts

const AVChannelLayout ff_alac_ch_layouts[ALAC_MAX_CHANNELS+1]

Definition: alac_data.c:35

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:405

AVSampleFormat

Audio sample formats.

Definition: samplefmt.h:55

init_sample_buffers

static void init_sample_buffers(AlacEncodeContext *s, int channels, const uint8_t *samples[2])

Definition: alacenc.c:85

av_always_inline

#define av_always_inline

Definition: attributes.h:49

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

TYPE_SCE

@ TYPE_SCE

Definition: aac.h:43

avcodec.h

AV_WB8

#define AV_WB8(p, d)

Definition: intreadwrite.h:394

ret

Definition: filter_design.txt:187

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

ALAC_CHMODE_LEFT_RIGHT

#define ALAC_CHMODE_LEFT_RIGHT

Definition: alacenc.c:45

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

write_frame

static int write_frame(AlacEncodeContext *s, AVPacket *avpkt, uint8_t *const *samples)

Definition: alacenc.c:461

AVCodecContext

main external API structure.

Definition: avcodec.h:445

mode

Definition: ebur128.h:83

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:235