FFmpeg: libavcodec/alac.c Source File

FFmpeg

[フレーム]

libavcodec

alac.c

Go to the documentation of this file.

1 /*

2 * ALAC (Apple Lossless Audio Codec) decoder

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

23 * @file

24 * ALAC (Apple Lossless Audio Codec) decoder

25 * @author 2005 David Hammerton

26 * @see http://crazney.net/programs/itunes/alac.html

27 *

28 * Note: This decoder expects a 36-byte QuickTime atom to be

29 * passed through the extradata[_size] fields. This atom is tacked onto

30 * the end of an 'alac' stsd atom and has the following format:

31 *

32 * 32 bits atom size

33 * 32 bits tag ("alac")

34 * 32 bits tag version (0)

35 * 32 bits samples per frame (used when not set explicitly in the frames)

36 * 8 bits compatible version (0)

37 * 8 bits sample size

38 * 8 bits history mult (40)

39 * 8 bits initial history (10)

40 * 8 bits rice param limit (14)

41 * 8 bits channels

42 * 16 bits maxRun (255)

43 * 32 bits max coded frame size (0 means unknown)

44 * 32 bits average bitrate (0 means unknown)

45 * 32 bits samplerate

46 */

48 #include <inttypes.h>

50 #include "libavutil/channel_layout.h"

51 #include "libavutil/opt.h"

52 #include "avcodec.h"

53 #include "get_bits.h"

54 #include "bytestream.h"

55 #include "internal.h"

56 #include "thread.h"

57 #include "unary.h"

58 #include "mathops.h"

59 #include "alac_data.h"

60 #include "alacdsp.h"

62 #define ALAC_EXTRADATA_SIZE 36

64 typedef struct ALACContext {

65 AVClass *class;

66 AVCodecContext *avctx;

67 GetBitContext gb;

68 int channels;

70 int32_t *predict_error_buffer[2];

71 int32_t *output_samples_buffer[2];

72 int32_t *extra_bits_buffer[2];

74 uint32_t max_samples_per_frame;

75 uint8_t sample_size;

76 uint8_t rice_history_mult;

77 uint8_t rice_initial_history;

78 uint8_t rice_limit;

79 int sample_rate;

81 int extra_bits; /**< number of extra bits beyond 16-bit */

82 int nb_samples; /**< number of samples in the current frame */

84 int direct_output;

85 int extra_bit_bug;

87 ALACDSPContext dsp;

88 } ALACContext;

90 static inline unsigned int decode_scalar(GetBitContext *gb, int k, int bps)

91 {

92 unsigned int x = get_unary_0_9(gb);

94 if (x > 8) { /* RICE THRESHOLD */

95 /* use alternative encoding */

96 x = get_bits_long(gb, bps);

97 } else if (k != 1) {

98 int extrabits = show_bits(gb, k);

100 /* multiply x by 2^k - 1, as part of their strange algorithm */

101 x = (x << k) - x;

102

103 if (extrabits > 1) {

104 x += extrabits - 1;

105 skip_bits(gb, k);

106 } else

107 skip_bits(gb, k - 1);

108 }

109 return x;

110 }

111

112 static int rice_decompress(ALACContext *alac, int32_t *output_buffer,

113 int nb_samples, int bps, int rice_history_mult)

114 {

115 int i;

116 unsigned int history = alac->rice_initial_history;

117 int sign_modifier = 0;

118

119 for (i = 0; i < nb_samples; i++) {

120 int k;

121 unsigned int x;

122

123 if(get_bits_left(&alac->gb) <= 0)

124 return AVERROR_INVALIDDATA;

125

126 /* calculate rice param and decode next value */

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

128 k = FFMIN(k, alac->rice_limit);

129 x = decode_scalar(&alac->gb, k, bps);

130 x += sign_modifier;

131 sign_modifier = 0;

132 output_buffer[i] = (x >> 1) ^ -(x & 1);

133

134 /* update the history */

135 if (x > 0xffff)

136 history = 0xffff;

137 else

138 history += x * rice_history_mult -

139 ((history * rice_history_mult) >> 9);

140

141 /* special case: there may be compressed blocks of 0 */

142 if ((history < 128) && (i + 1 < nb_samples)) {

143 int block_size;

144

145 /* calculate rice param and decode block size */

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

147 k = FFMIN(k, alac->rice_limit);

148 block_size = decode_scalar(&alac->gb, k, 16);

149

150 if (block_size > 0) {

151 if (block_size >= nb_samples - i) {

152 av_log(alac->avctx, AV_LOG_ERROR,

153 "invalid zero block size of %d %d %d\n", block_size,

154 nb_samples, i);

155 block_size = nb_samples - i - 1;

156 }

157 memset(&output_buffer[i + 1], 0,

158 block_size * sizeof(*output_buffer));

159 i += block_size;

160 }

161 if (block_size <= 0xffff)

162 sign_modifier = 1;

163 history = 0;

164 }

165 }

166 return 0;

167 }

168

169 static inline int sign_only(int v)

170 {

171 return v ? FFSIGN(v) : 0;

172 }

173

174 static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out,

175 int nb_samples, int bps, int16_t *lpc_coefs,

176 int lpc_order, int lpc_quant)

177 {

178 int i;

179 uint32_t *pred = buffer_out;

180

181 /* first sample always copies */

182 *buffer_out = *error_buffer;

183

184 if (nb_samples <= 1)

185 return;

186

187 if (!lpc_order) {

188 memcpy(&buffer_out[1], &error_buffer[1],

189 (nb_samples - 1) * sizeof(*buffer_out));

190 return;

191 }

192

193 if (lpc_order == 31) {

194 /* simple 1st-order prediction */

195 for (i = 1; i < nb_samples; i++) {

196 buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i],

197 bps);

198 }

199 return;

200 }

201

202 /* read warm-up samples */

203 for (i = 1; i <= lpc_order && i < nb_samples; i++)

204 buffer_out[i] = sign_extend(buffer_out[i - 1] + error_buffer[i], bps);

205

206 /* NOTE: 4 and 8 are very common cases that could be optimized. */

207

208 for (; i < nb_samples; i++) {

209 int j;

210 int val = 0;

211 unsigned error_val = error_buffer[i];

212 int error_sign;

213 int d = *pred++;

214

215 /* LPC prediction */

216 for (j = 0; j < lpc_order; j++)

217 val += (pred[j] - d) * lpc_coefs[j];

218 val = (val + (1LL << (lpc_quant - 1))) >> lpc_quant;

219 val += d + error_val;

220 buffer_out[i] = sign_extend(val, bps);

221

222 /* adapt LPC coefficients */

223 error_sign = sign_only(error_val);

224 if (error_sign) {

225 for (j = 0; j < lpc_order && (int)(error_val * error_sign) > 0; j++) {

226 int sign;

227 val = d - pred[j];

228 sign = sign_only(val) * error_sign;

229 lpc_coefs[j] -= sign;

230 val *= (unsigned)sign;

231 error_val -= (val >> lpc_quant) * (j + 1U);

232 }

233 }

234 }

235 }

236

237 static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index,

238 int channels)

239 {

240 ALACContext *alac = avctx->priv_data;

241 int has_size, bps, is_compressed, decorr_shift, decorr_left_weight, ret;

242 uint32_t output_samples;

243 int i, ch;

244

245 skip_bits(&alac->gb, 4); /* element instance tag */

246 skip_bits(&alac->gb, 12); /* unused header bits */

247

248 /* the number of output samples is stored in the frame */

249 has_size = get_bits1(&alac->gb);

250

251 alac->extra_bits = get_bits(&alac->gb, 2) << 3;

252 bps = alac->sample_size - alac->extra_bits + channels - 1;

253 if (bps > 32) {

254 avpriv_report_missing_feature(avctx, "bps %d", bps);

255 return AVERROR_PATCHWELCOME;

256 }

257 if (bps < 1)

258 return AVERROR_INVALIDDATA;

259

260 /* whether the frame is compressed */

261 is_compressed = !get_bits1(&alac->gb);

262

263 if (has_size)

264 output_samples = get_bits_long(&alac->gb, 32);

265 else

266 output_samples = alac->max_samples_per_frame;

267 if (!output_samples || output_samples > alac->max_samples_per_frame) {

268 av_log(avctx, AV_LOG_ERROR, "invalid samples per frame: %"PRIu32"\n",

269 output_samples);

270 return AVERROR_INVALIDDATA;

271 }

272 if (!alac->nb_samples) {

273 ThreadFrame tframe = { .f = frame };

274 /* get output buffer */

275 frame->nb_samples = output_samples;

276 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)

277 return ret;

278 } else if (output_samples != alac->nb_samples) {

279 av_log(avctx, AV_LOG_ERROR, "sample count mismatch: %"PRIu32" != %d\n",

280 output_samples, alac->nb_samples);

281 return AVERROR_INVALIDDATA;

282 }

283 alac->nb_samples = output_samples;

284 if (alac->direct_output) {

285 for (ch = 0; ch < channels; ch++)

286 alac->output_samples_buffer[ch] = (int32_t *)frame->extended_data[ch_index + ch];

287 }

288

289 if (is_compressed) {

290 int16_t lpc_coefs[2][32];

291 int lpc_order[2];

292 int prediction_type[2];

293 int lpc_quant[2];

294 int rice_history_mult[2];

295

296 if (!alac->rice_limit) {

297 avpriv_request_sample(alac->avctx,

298 "Compression with rice limit 0");

299 return AVERROR(ENOSYS);

300 }

301

302 decorr_shift = get_bits(&alac->gb, 8);

303 decorr_left_weight = get_bits(&alac->gb, 8);

304

305 if (channels == 2 && decorr_left_weight && decorr_shift > 31)

306 return AVERROR_INVALIDDATA;

307

308 for (ch = 0; ch < channels; ch++) {

309 prediction_type[ch] = get_bits(&alac->gb, 4);

310 lpc_quant[ch] = get_bits(&alac->gb, 4);

311 rice_history_mult[ch] = get_bits(&alac->gb, 3);

312 lpc_order[ch] = get_bits(&alac->gb, 5);

313

314 if (lpc_order[ch] >= alac->max_samples_per_frame || !lpc_quant[ch])

315 return AVERROR_INVALIDDATA;

316

317 /* read the predictor table */

318 for (i = lpc_order[ch] - 1; i >= 0; i--)

319 lpc_coefs[ch][i] = get_sbits(&alac->gb, 16);

320 }

321

322 if (alac->extra_bits) {

323 for (i = 0; i < alac->nb_samples; i++) {

324 if(get_bits_left(&alac->gb) <= 0)

325 return AVERROR_INVALIDDATA;

326 for (ch = 0; ch < channels; ch++)

327 alac->extra_bits_buffer[ch][i] = get_bits(&alac->gb, alac->extra_bits);

328 }

329 }

330 for (ch = 0; ch < channels; ch++) {

331 int ret=rice_decompress(alac, alac->predict_error_buffer[ch],

332 alac->nb_samples, bps,

333 rice_history_mult[ch] * alac->rice_history_mult / 4);

334 if(ret<0)

335 return ret;

336

337 /* adaptive FIR filter */

338 if (prediction_type[ch] == 15) {

339 /* Prediction type 15 runs the adaptive FIR twice.

340 * The first pass uses the special-case coef_num = 31, while

341 * the second pass uses the coefs from the bitstream.

342 *

343 * However, this prediction type is not currently used by the

344 * reference encoder.

345 */

346 lpc_prediction(alac->predict_error_buffer[ch],

347 alac->predict_error_buffer[ch],

348 alac->nb_samples, bps, NULL, 31, 0);

349 } else if (prediction_type[ch] > 0) {

350 av_log(avctx, AV_LOG_WARNING, "unknown prediction type: %i\n",

351 prediction_type[ch]);

352 }

353 lpc_prediction(alac->predict_error_buffer[ch],

354 alac->output_samples_buffer[ch], alac->nb_samples,

355 bps, lpc_coefs[ch], lpc_order[ch], lpc_quant[ch]);

356 }

357 } else {

358 /* not compressed, easy case */

359 for (i = 0; i < alac->nb_samples; i++) {

360 if(get_bits_left(&alac->gb) <= 0)

361 return AVERROR_INVALIDDATA;

362 for (ch = 0; ch < channels; ch++) {

363 alac->output_samples_buffer[ch][i] =

364 get_sbits_long(&alac->gb, alac->sample_size);

365 }

366 }

367 alac->extra_bits = 0;

368 decorr_shift = 0;

369 decorr_left_weight = 0;

370 }

371

372 if (channels == 2) {

373 if (alac->extra_bits && alac->extra_bit_bug) {

374 alac->dsp.append_extra_bits[1](alac->output_samples_buffer, alac->extra_bits_buffer,

375 alac->extra_bits, channels, alac->nb_samples);

376 }

377

378 if (decorr_left_weight) {

379 alac->dsp.decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples,

380 decorr_shift, decorr_left_weight);

381 }

382

383 if (alac->extra_bits && !alac->extra_bit_bug) {

384 alac->dsp.append_extra_bits[1](alac->output_samples_buffer, alac->extra_bits_buffer,

385 alac->extra_bits, channels, alac->nb_samples);

386 }

387 } else if (alac->extra_bits) {

388 alac->dsp.append_extra_bits[0](alac->output_samples_buffer, alac->extra_bits_buffer,

389 alac->extra_bits, channels, alac->nb_samples);

390 }

391

392 switch(alac->sample_size) {

393 case 16: {

394 for (ch = 0; ch < channels; ch++) {

395 int16_t *outbuffer = (int16_t *)frame->extended_data[ch_index + ch];

396 for (i = 0; i < alac->nb_samples; i++)

397 *outbuffer++ = alac->output_samples_buffer[ch][i];

398 }}

399 break;

400 case 20: {

401 for (ch = 0; ch < channels; ch++) {

402 for (i = 0; i < alac->nb_samples; i++)

403 alac->output_samples_buffer[ch][i] *= 1U << 12;

404 }}

405 break;

406 case 24: {

407 for (ch = 0; ch < channels; ch++) {

408 for (i = 0; i < alac->nb_samples; i++)

409 alac->output_samples_buffer[ch][i] *= 1U << 8;

410 }}

411 break;

412 }

413

414 return 0;

415 }

416

417 static int alac_decode_frame(AVCodecContext *avctx, void *data,

418 int *got_frame_ptr, AVPacket *avpkt)

419 {

420 ALACContext *alac = avctx->priv_data;

421 AVFrame *frame = data;

422 enum AlacRawDataBlockType element;

423 int channels;

424 int ch, ret, got_end;

425

426 if ((ret = init_get_bits8(&alac->gb, avpkt->data, avpkt->size)) < 0)

427 return ret;

428

429 got_end = 0;

430 alac->nb_samples = 0;

431 ch = 0;

432 while (get_bits_left(&alac->gb) >= 3) {

433 element = get_bits(&alac->gb, 3);

434 if (element == TYPE_END) {

435 got_end = 1;

436 break;

437 }

438 if (element > TYPE_CPE && element != TYPE_LFE) {

439 avpriv_report_missing_feature(avctx, "Syntax element %d", element);

440 return AVERROR_PATCHWELCOME;

441 }

442

443 channels = (element == TYPE_CPE) ? 2 : 1;

444 if (ch + channels > alac->channels ||

445 ff_alac_channel_layout_offsets[alac->channels - 1][ch] + channels > alac->channels) {

446 av_log(avctx, AV_LOG_ERROR, "invalid element channel count\n");

447 return AVERROR_INVALIDDATA;

448 }

449

450 ret = decode_element(avctx, frame,

451 ff_alac_channel_layout_offsets[alac->channels - 1][ch],

452 channels);

453 if (ret < 0 && get_bits_left(&alac->gb))

454 return ret;

455

456 ch += channels;

457 }

458 if (!got_end) {

459 av_log(avctx, AV_LOG_ERROR, "no end tag found. incomplete packet.\n");

460 return AVERROR_INVALIDDATA;

461 }

462

463 if (avpkt->size * 8 - get_bits_count(&alac->gb) > 8) {

464 av_log(avctx, AV_LOG_ERROR, "Error : %d bits left\n",

465 avpkt->size * 8 - get_bits_count(&alac->gb));

466 }

467

468 if (alac->channels == ch && alac->nb_samples)

469 *got_frame_ptr = 1;

470 else

471 av_log(avctx, AV_LOG_WARNING, "Failed to decode all channels\n");

472

473 return avpkt->size;

474 }

475

476 static av_cold int alac_decode_close(AVCodecContext *avctx)

477 {

478 ALACContext *alac = avctx->priv_data;

479

480 int ch;

481 for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {

482 av_freep(&alac->predict_error_buffer[ch]);

483 if (!alac->direct_output)

484 av_freep(&alac->output_samples_buffer[ch]);

485 av_freep(&alac->extra_bits_buffer[ch]);

486 }

487

488 return 0;

489 }

490

491 static int allocate_buffers(ALACContext *alac)

492 {

493 int ch;

494 unsigned buf_size = alac->max_samples_per_frame * sizeof(int32_t);

495 unsigned extra_buf_size = buf_size + AV_INPUT_BUFFER_PADDING_SIZE;

496

497 for (ch = 0; ch < 2; ch++) {

498 alac->predict_error_buffer[ch] = NULL;

499 alac->output_samples_buffer[ch] = NULL;

500 alac->extra_bits_buffer[ch] = NULL;

501 }

502

503 for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {

504 if (!(alac->predict_error_buffer[ch] = av_malloc(buf_size)))

505 return AVERROR(ENOMEM);

506

507 alac->direct_output = alac->sample_size > 16;

508 if (!alac->direct_output) {

509 if (!(alac->output_samples_buffer[ch] = av_malloc(extra_buf_size)))

510 return AVERROR(ENOMEM);

511 }

512

513 if (!(alac->extra_bits_buffer[ch] = av_malloc(extra_buf_size)))

514 return AVERROR(ENOMEM);

515 }

516 return 0;

517 }

518

519 static int alac_set_info(ALACContext *alac)

520 {

521 GetByteContext gb;

522

523 bytestream2_init(&gb, alac->avctx->extradata,

524 alac->avctx->extradata_size);

525

526 bytestream2_skipu(&gb, 12); // size:4, alac:4, version:4

527

528 alac->max_samples_per_frame = bytestream2_get_be32u(&gb);

529 if (!alac->max_samples_per_frame ||

530 alac->max_samples_per_frame > 4096 * 4096) {

531 av_log(alac->avctx, AV_LOG_ERROR,

532 "max samples per frame invalid: %"PRIu32"\n",

533 alac->max_samples_per_frame);

534 return AVERROR_INVALIDDATA;

535 }

536 bytestream2_skipu(&gb, 1); // compatible version

537 alac->sample_size = bytestream2_get_byteu(&gb);

538 alac->rice_history_mult = bytestream2_get_byteu(&gb);

539 alac->rice_initial_history = bytestream2_get_byteu(&gb);

540 alac->rice_limit = bytestream2_get_byteu(&gb);

541 alac->channels = bytestream2_get_byteu(&gb);

542 bytestream2_get_be16u(&gb); // maxRun

543 bytestream2_get_be32u(&gb); // max coded frame size

544 bytestream2_get_be32u(&gb); // average bitrate

545 alac->sample_rate = bytestream2_get_be32u(&gb);

546

547 return 0;

548 }

549

550 static av_cold int alac_decode_init(AVCodecContext * avctx)

551 {

552 int ret;

553 ALACContext *alac = avctx->priv_data;

554 alac->avctx = avctx;

555

556 /* initialize from the extradata */

557 if (alac->avctx->extradata_size < ALAC_EXTRADATA_SIZE) {

558 av_log(avctx, AV_LOG_ERROR, "extradata is too small\n");

559 return AVERROR_INVALIDDATA;

560 }

561 if ((ret = alac_set_info(alac)) < 0) {

562 av_log(avctx, AV_LOG_ERROR, "set_info failed\n");

563 return ret;

564 }

565

566 switch (alac->sample_size) {

567 case 16: avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

568 break;

569 case 20:

570 case 24:

571 case 32: avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

572 break;

573 default: avpriv_request_sample(avctx, "Sample depth %d", alac->sample_size);

574 return AVERROR_PATCHWELCOME;

575 }

576 avctx->bits_per_raw_sample = alac->sample_size;

577 avctx->sample_rate = alac->sample_rate;

578

579 if (alac->channels < 1) {

580 av_log(avctx, AV_LOG_WARNING, "Invalid channel count\n");

581 alac->channels = avctx->channels;

582 } else {

583 if (alac->channels > ALAC_MAX_CHANNELS)

584 alac->channels = avctx->channels;

585 else

586 avctx->channels = alac->channels;

587 }

588 if (avctx->channels > ALAC_MAX_CHANNELS || avctx->channels <= 0 ) {

589 avpriv_report_missing_feature(avctx, "Channel count %d",

590 avctx->channels);

591 return AVERROR_PATCHWELCOME;

592 }

593 avctx->channel_layout = ff_alac_channel_layouts[alac->channels - 1];

594

595 if ((ret = allocate_buffers(alac)) < 0) {

596 av_log(avctx, AV_LOG_ERROR, "Error allocating buffers\n");

597 return ret;

598 }

599

600 ff_alacdsp_init(&alac->dsp);

601

602 return 0;

603 }

604

605 static const AVOption options[] = {

606 { "extra_bits_bug", "Force non-standard decoding process",

607 offsetof(ALACContext, extra_bit_bug), AV_OPT_TYPE_BOOL, { .i64 = 0 },

608 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM },

609 { NULL },

610 };

611

612 static const AVClass alac_class = {

613 .class_name = "alac",

614 .item_name = av_default_item_name,

615 .option = options,

616 .version = LIBAVUTIL_VERSION_INT,

617 };

618

619 const AVCodec ff_alac_decoder = {

620 .name = "alac",

621 .long_name = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),

622 .type = AVMEDIA_TYPE_AUDIO,

623 .id = AV_CODEC_ID_ALAC,

624 .priv_data_size = sizeof(ALACContext),

625 .init = alac_decode_init,

626 .close = alac_decode_close,

627 .decode = alac_decode_frame,

628 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_CHANNEL_CONF,

629 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

630 .priv_class = &alac_class

631 };

AVCodec

AVCodec.

Definition: codec.h:202

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: internal.h:42

ff_alacdsp_init

av_cold void ff_alacdsp_init(ALACDSPContext *c)

Definition: alacdsp.c:55

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:850

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

ALACDSPContext::decorrelate_stereo

void(* decorrelate_stereo)(int32_t *buffer[2], int nb_samples, int decorr_shift, int decorr_left_weight)

Definition: alacdsp.h:25

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:1043

get_unary_0_9

static int get_unary_0_9(GetBitContext *gb)

Definition: unary.h:64

alac_data.h

lpc_prediction

static void lpc_prediction(int32_t *error_buffer, uint32_t *buffer_out, int nb_samples, int bps, int16_t *lpc_coefs, int lpc_order, int lpc_quant)

Definition: alac.c:174

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:992

decode_scalar

static unsigned int decode_scalar(GetBitContext *gb, int k, int bps)

Definition: alac.c:90

ff_alac_decoder

const AVCodec ff_alac_decoder

Definition: alac.c:619

GetByteContext

Definition: bytestream.h:33

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:547

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:174

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:220

ALACContext::extra_bits

int extra_bits

number of extra bits beyond 16-bit

Definition: alac.c:81

alac_decode_close

static av_cold int alac_decode_close(AVCodecContext *avctx)

Definition: alac.c:476

AVFrame

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

Definition: frame.h:317

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

AVOption

AVOption.

Definition: opt.h:247

AV_SAMPLE_FMT_S32P

@ AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:68

data

const char data[16]

Definition: mxf.c:143

AV_CODEC_ID_ALAC

@ AV_CODEC_ID_ALAC

Definition: codec_id.h:439

ALACContext::rice_history_mult

uint8_t rice_history_mult

Definition: alac.c:76

rice_decompress

static int rice_decompress(ALACContext *alac, int32_t *output_buffer, int nb_samples, int bps, int rice_history_mult)

Definition: alac.c:112

thread.h

ThreadFrame::f

AVFrame * f

Definition: thread.h:35

alacdsp.h

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

init

static int init

Definition: av_tx.c:47

sign_only

static int sign_only(int v)

Definition: alac.c:169

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:468

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:380

#define U(x)

Definition: vp56_arith.h:37

FFSIGN

#define FFSIGN(a)

Definition: common.h:66

TYPE_CPE

@ TYPE_CPE

Definition: aac.h:58

GetBitContext

Definition: get_bits.h:62

ff_thread_get_buffer

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere

val

static double val(void *priv, double ch)

Definition: aeval.c:76

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

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:678

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:71

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

ALACContext::channels

int channels

Definition: alac.c:68

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:1425

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:360

channels

Definition: aptx.h:33

get_bits.h

ALACContext::predict_error_buffer

int32_t * predict_error_buffer[2]

Definition: alac.c:70

AV_OPT_FLAG_AUDIO_PARAM

#define AV_OPT_FLAG_AUDIO_PARAM

Definition: opt.h:279

decode_element

static int decode_element(AVCodecContext *avctx, AVFrame *frame, int ch_index, int channels)

Definition: alac.c:237

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:113

ALACContext::dsp

ALACDSPContext dsp

Definition: alac.c:87

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

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

options

static const AVOption options[]

Definition: alac.c:605

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:235

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

mathops.h

ALACDSPContext

Definition: alacdsp.h:24

ALACContext::nb_samples

int nb_samples

number of samples in the current frame

Definition: alac.c:82

ALACContext::max_samples_per_frame

uint32_t max_samples_per_frame

Definition: alac.c:74

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

ALACContext::rice_initial_history

uint8_t rice_initial_history

Definition: alac.c:77

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:109

alac_decode_init

static av_cold int alac_decode_init(AVCodecContext *avctx)

Definition: alac.c:550

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:374

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

TYPE_END

@ TYPE_END

Definition: aac.h:64

bps

unsigned bps

Definition: movenc.c:1597

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1000

ALACContext::output_samples_buffer

int32_t * output_samples_buffer[2]

Definition: alac.c:71

avpriv_report_missing_feature

void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

ALACContext

Definition: alac.c:64

ALACContext::direct_output

int direct_output

Definition: alac.c:84

ALACContext::rice_limit

uint8_t rice_limit

Definition: alac.c:78

ALAC_MAX_CHANNELS

#define ALAC_MAX_CHANNELS

Definition: alac_data.h:38

unary.h

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:67

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:993

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

Definition: cbs_h2645.c:271

ff_alac_channel_layout_offsets

const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]

Definition: alac_data.c:24

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

show_bits

static unsigned int show_bits(GetBitContext *s, int n)

Show 1-25 bits.

Definition: get_bits.h:447

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: internal.h:50

alac_class

static const AVClass alac_class

Definition: alac.c:612

ALACContext::avctx

AVCodecContext * avctx

Definition: alac.c:66

AV_OPT_FLAG_DECODING_PARAM

#define AV_OPT_FLAG_DECODING_PARAM

a generic parameter which can be set by the user for demuxing or decoding

Definition: opt.h:278

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

TYPE_LFE

@ TYPE_LFE

Definition: aac.h:60

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

ff_alac_channel_layouts

const uint64_t ff_alac_channel_layouts[ALAC_MAX_CHANNELS+1]

Definition: alac_data.c:35

ALACContext::extra_bit_bug

int extra_bit_bug

Definition: alac.c:85

avcodec.h

ret

Definition: filter_design.txt:187

pred

static const float pred[4]

Definition: siprdata.h:259

ALACContext::sample_size

uint8_t sample_size

Definition: alac.c:75

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

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

ALACContext::sample_rate

int sample_rate

Definition: alac.c:79

AVCodecContext

main external API structure.

Definition: avcodec.h:383

ThreadFrame

Definition: thread.h:34