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 * 32bit atom size

33 * 32bit tag ("alac")

34 * 32bit tag version (0)

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

36 * 8bit compatible version (0)

37 * 8bit sample size

38 * 8bit history mult (40)

39 * 8bit initial history (10)

40 * 8bit rice param limit (14)

41 * 8bit channels

42 * 16bit maxRun (255)

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

44 * 32bit average bitrate (0 means unknown)

45 * 32bit 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"

61 #define ALAC_EXTRADATA_SIZE 36

63 typedef struct ALACContext {

64 AVClass *class;

65 AVCodecContext *avctx;

66 GetBitContext gb;

67 int channels;

69 int32_t *predict_error_buffer[2];

70 int32_t *output_samples_buffer[2];

71 int32_t *extra_bits_buffer[2];

73 uint32_t max_samples_per_frame;

74 uint8_t sample_size;

75 uint8_t rice_history_mult;

76 uint8_t rice_initial_history;

77 uint8_t rice_limit;

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

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

82 int direct_output;

83 int extra_bit_bug;

84 } ALACContext;

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

87 {

88 unsigned int x = get_unary_0_9(gb);

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

91 /* use alternative encoding */

92 x = get_bits_long(gb, bps);

93 } else if (k != 1) {

94 int extrabits = show_bits(gb, k);

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

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

99 if (extrabits > 1) {

100 x += extrabits - 1;

101 skip_bits(gb, k);

102 } else

103 skip_bits(gb, k - 1);

104 }

105 return x;

106 }

107

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

109 int nb_samples, int bps, int rice_history_mult)

110 {

111 int i;

112 unsigned int history = alac->rice_initial_history;

113 int sign_modifier = 0;

114

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

116 int k;

117 unsigned int x;

118

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

120 return -1;

121

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

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

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

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

126 x += sign_modifier;

127 sign_modifier = 0;

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

129

130 /* update the history */

131 if (x > 0xffff)

132 history = 0xffff;

133 else

134 history += x * rice_history_mult -

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

136

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

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

139 int block_size;

140

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

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

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

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

145

146 if (block_size > 0) {

147 if (block_size >= nb_samples - i) {

148 av_log(alac->avctx, AV_LOG_ERROR,

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

150 nb_samples, i);

151 block_size = nb_samples - i - 1;

152 }

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

154 block_size * sizeof(*output_buffer));

155 i += block_size;

156 }

157 if (block_size <= 0xffff)

158 sign_modifier = 1;

159 history = 0;

160 }

161 }

162 return 0;

163 }

164

165 static inline int sign_only(int v)

166 {

167 return v ? FFSIGN(v) : 0;

168 }

169

170 static void lpc_prediction(int32_t *error_buffer, int32_t *buffer_out,

171 int nb_samples, int bps, int16_t *lpc_coefs,

172 int lpc_order, int lpc_quant)

173 {

174 int i;

175 int32_t *pred = buffer_out;

176

177 /* first sample always copies */

178 *buffer_out = *error_buffer;

179

180 if (nb_samples <= 1)

181 return;

182

183 if (!lpc_order) {

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

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

186 return;

187 }

188

189 if (lpc_order == 31) {

190 /* simple 1st-order prediction */

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

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

193 bps);

194 }

195 return;

196 }

197

198 /* read warm-up samples */

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

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

201

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

203

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

205 int j;

206 int val = 0;

207 int error_val = error_buffer[i];

208 int error_sign;

209 int d = *pred++;

210

211 /* LPC prediction */

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

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

214 val = (val + (1 << (lpc_quant - 1))) >> lpc_quant;

215 val += d + error_val;

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

217

218 /* adapt LPC coefficients */

219 error_sign = sign_only(error_val);

220 if (error_sign) {

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

222 int sign;

223 val = d - pred[j];

224 sign = sign_only(val) * error_sign;

225 lpc_coefs[j] -= sign;

226 val *= sign;

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

228 }

229 }

230 }

231 }

232

233 static void decorrelate_stereo(int32_t *buffer[2], int nb_samples,

234 int decorr_shift, int decorr_left_weight)

235 {

236 int i;

237

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

239 int32_t a, b;

240

241 a = buffer[0][i];

242 b = buffer[1][i];

243

244 a -= (b * decorr_left_weight) >> decorr_shift;

245 b += a;

246

247 buffer[0][i] = b;

248 buffer[1][i] = a;

249 }

250 }

251

252 static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2],

253 int extra_bits, int channels, int nb_samples)

254 {

255 int i, ch;

256

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

258 for (i = 0; i < nb_samples; i++)

259 buffer[ch][i] = (buffer[ch][i] << extra_bits) | extra_bits_buffer[ch][i];

260 }

261

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

263 int channels)

264 {

265 ALACContext *alac = avctx->priv_data;

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

267 uint32_t output_samples;

268 int i, ch;

269

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

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

272

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

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

275

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

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

278 if (bps > 32U) {

279 av_log(avctx, AV_LOG_ERROR, "bps is unsupported: %d\n", bps);

280 return AVERROR_PATCHWELCOME;

281 }

282

283 /* whether the frame is compressed */

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

285

286 if (has_size)

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

288 else

289 output_samples = alac->max_samples_per_frame;

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

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

292 output_samples);

293 return AVERROR_INVALIDDATA;

294 }

295 if (!alac->nb_samples) {

296 ThreadFrame tframe = { .f = frame };

297 /* get output buffer */

298 frame->nb_samples = output_samples;

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

300 return ret;

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

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

303 output_samples, alac->nb_samples);

304 return AVERROR_INVALIDDATA;

305 }

306 alac->nb_samples = output_samples;

307 if (alac->direct_output) {

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

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

310 }

311

312 if (is_compressed) {

313 int16_t lpc_coefs[2][32];

314 int lpc_order[2];

315 int prediction_type[2];

316 int lpc_quant[2];

317 int rice_history_mult[2];

318

319 if (!alac->rice_limit) {

320 avpriv_request_sample(alac->avctx,

321 "Compression with rice limit 0");

322 return AVERROR(ENOSYS);

323 }

324

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

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

327

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

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

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

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

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

333

334 if (lpc_order[ch] >= alac->max_samples_per_frame)

335 return AVERROR_INVALIDDATA;

336

337 /* read the predictor table */

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

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

340 }

341

342 if (alac->extra_bits) {

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

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

345 return -1;

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

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

348 }

349 }

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

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

352 alac->nb_samples, bps,

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

354 if(ret<0)

355 return ret;

356

357 /* adaptive FIR filter */

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

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

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

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

362 *

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

364 * reference encoder.

365 */

366 lpc_prediction(alac->predict_error_buffer[ch],

367 alac->predict_error_buffer[ch],

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

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

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

371 prediction_type[ch]);

372 }

373 lpc_prediction(alac->predict_error_buffer[ch],

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

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

376 }

377 } else {

378 /* not compressed, easy case */

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

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

381 return -1;

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

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

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

385 }

386 }

387 alac->extra_bits = 0;

388 decorr_shift = 0;

389 decorr_left_weight = 0;

390 }

391

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

393 append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer,

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

395 }

396

397 if (channels == 2 && decorr_left_weight) {

398 decorrelate_stereo(alac->output_samples_buffer, alac->nb_samples,

399 decorr_shift, decorr_left_weight);

400 }

401

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

403 append_extra_bits(alac->output_samples_buffer, alac->extra_bits_buffer,

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

405 }

406

407 if(av_sample_fmt_is_planar(avctx->sample_fmt)) {

408 switch(alac->sample_size) {

409 case 16: {

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

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

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

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

414 }}

415 break;

416 case 24: {

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

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

419 alac->output_samples_buffer[ch][i] <<= 8;

420 }}

421 break;

422 }

423 }else{

424 switch(alac->sample_size) {

425 case 16: {

426 int16_t *outbuffer = ((int16_t *)frame->extended_data[0]) + ch_index;

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

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

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

430 outbuffer += alac->channels - channels;

431 }

432 }

433 break;

434 case 24: {

435 int32_t *outbuffer = ((int32_t *)frame->extended_data[0]) + ch_index;

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

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

438 *outbuffer++ = alac->output_samples_buffer[ch][i] << 8;

439 outbuffer += alac->channels - channels;

440 }

441 }

442 break;

443 case 32: {

444 int32_t *outbuffer = ((int32_t *)frame->extended_data[0]) + ch_index;

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

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

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

448 outbuffer += alac->channels - channels;

449 }

450 }

451 break;

452 }

453 }

454

455 return 0;

456 }

457

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

459 int *got_frame_ptr, AVPacket *avpkt)

460 {

461 ALACContext *alac = avctx->priv_data;

462 AVFrame *frame = data;

463 enum AlacRawDataBlockType element;

464 int channels;

465 int ch, ret, got_end;

466

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

468 return ret;

469

470 got_end = 0;

471 alac->nb_samples = 0;

472 ch = 0;

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

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

475 if (element == TYPE_END) {

476 got_end = 1;

477 break;

478 }

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

480 av_log(avctx, AV_LOG_ERROR, "syntax element unsupported: %d\n", element);

481 return AVERROR_PATCHWELCOME;

482 }

483

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

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

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

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

488 return AVERROR_INVALIDDATA;

489 }

490

491 ret = decode_element(avctx, frame,

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

493 channels);

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

495 return ret;

496

497 ch += channels;

498 }

499 if (!got_end) {

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

501 return AVERROR_INVALIDDATA;

502 }

503

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

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

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

507 }

508

509 if (alac->channels == ch)

510 *got_frame_ptr = 1;

511 else

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

513

514 return avpkt->size;

515 }

516

517 static av_cold int alac_decode_close(AVCodecContext *avctx)

518 {

519 ALACContext *alac = avctx->priv_data;

520

521 int ch;

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

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

524 if (!alac->direct_output)

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

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

527 }

528

529 return 0;

530 }

531

532 static int allocate_buffers(ALACContext *alac)

533 {

534 int ch;

535 int buf_size = alac->max_samples_per_frame * sizeof(int32_t);

536

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

538 FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch],

539 buf_size, buf_alloc_fail);

540

541 alac->direct_output = alac->sample_size > 16 && av_sample_fmt_is_planar(alac->avctx->sample_fmt);

542 if (!alac->direct_output) {

543 FF_ALLOC_OR_GOTO(alac->avctx, alac->output_samples_buffer[ch],

544 buf_size, buf_alloc_fail);

545 }

546

547 FF_ALLOC_OR_GOTO(alac->avctx, alac->extra_bits_buffer[ch],

548 buf_size, buf_alloc_fail);

549 }

550 return 0;

551 buf_alloc_fail:

552 alac_decode_close(alac->avctx);

553 return AVERROR(ENOMEM);

554 }

555

556 static int alac_set_info(ALACContext *alac)

557 {

558 GetByteContext gb;

559

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

561 alac->avctx->extradata_size);

562

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

564

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

566 if (!alac->max_samples_per_frame ||

567 alac->max_samples_per_frame > INT_MAX / sizeof(int32_t)) {

568 av_log(alac->avctx, AV_LOG_ERROR,

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

570 alac->max_samples_per_frame);

571 return AVERROR_INVALIDDATA;

572 }

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

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

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

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

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

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

579 bytestream2_get_be16u(&gb); // maxRun

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

581 bytestream2_get_be32u(&gb); // average bitrate

582 bytestream2_get_be32u(&gb); // samplerate

583

584 return 0;

585 }

586

587 static av_cold int alac_decode_init(AVCodecContext * avctx)

588 {

589 int ret;

590 int req_packed;

591 ALACContext *alac = avctx->priv_data;

592 alac->avctx = avctx;

593

594 /* initialize from the extradata */

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

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

597 return AVERROR_INVALIDDATA;

598 }

599 if (alac_set_info(alac)) {

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

601 return -1;

602 }

603

604 req_packed = LIBAVCODEC_VERSION_MAJOR < 55 && !av_sample_fmt_is_planar(avctx->request_sample_fmt);

605 switch (alac->sample_size) {

606 case 16: avctx->sample_fmt = req_packed ? AV_SAMPLE_FMT_S16 : AV_SAMPLE_FMT_S16P;

607 break;

608 case 24:

609 case 32: avctx->sample_fmt = req_packed ? AV_SAMPLE_FMT_S32 : AV_SAMPLE_FMT_S32P;

610 break;

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

612 return AVERROR_PATCHWELCOME;

613 }

614 avctx->bits_per_raw_sample = alac->sample_size;

615

616 if (alac->channels < 1) {

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

618 alac->channels = avctx->channels;

619 } else {

620 if (alac->channels > ALAC_MAX_CHANNELS)

621 alac->channels = avctx->channels;

622 else

623 avctx->channels = alac->channels;

624 }

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

626 av_log(avctx, AV_LOG_ERROR, "Unsupported channel count: %d\n",

627 avctx->channels);

628 return AVERROR_PATCHWELCOME;

629 }

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

631

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

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

634 return ret;

635 }

636

637 return 0;

638 }

639

640 static int init_thread_copy(AVCodecContext *avctx)

641 {

642 ALACContext *alac = avctx->priv_data;

643 alac->avctx = avctx;

644 return allocate_buffers(alac);

645 }

646

647 static const AVOption options[] = {

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

649 offsetof(ALACContext, extra_bit_bug), AV_OPT_TYPE_INT, { .i64 = 0 },

650 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM },

651 { NULL },

652 };

653

654 static const AVClass alac_class = {

655 .class_name = "alac",

656 .item_name = av_default_item_name,

657 .option = options,

658 .version = LIBAVUTIL_VERSION_INT,

659 };

660

661 AVCodec ff_alac_decoder = {

662 .name = "alac",

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

664 .type = AVMEDIA_TYPE_AUDIO,

665 .id = AV_CODEC_ID_ALAC,

666 .priv_data_size = sizeof(ALACContext),

667 .init = alac_decode_init,

668 .close = alac_decode_close,

669 .decode = alac_decode_frame,

670 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

671 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

672 .priv_class = &alac_class

673 };

extra_bits

#define extra_bits(eb)

Definition: intrax8.c:152

ALACContext::extra_bit_bug

int extra_bit_bug

Definition: alac.c:83

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:634

GetByteContext

Definition: bytestream.h:33

float v

Definition: avf_showspectrum.c:96

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

ALACContext::nb_samples

int nb_samples

number of samples in the current frame

Definition: alac.c:80

AVFrame

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

Definition: frame.h:171

ALAC_EXTRADATA_SIZE

#define ALAC_EXTRADATA_SIZE

Definition: alac.c:61

AVOption

AVOption.

Definition: opt.h:255

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:260

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

ThreadFrame::f

AVFrame * f

Definition: thread.h:36

decode_element

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

Definition: alac.c:262

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:62

TYPE_END

Definition: aac.h:56

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

AV_OPT_TYPE_INT

Definition: opt.h:223

TYPE_CPE

Definition: aac.h:50

AV_OPT_FLAG_AUDIO_PARAM

#define AV_OPT_FLAG_AUDIO_PARAM

Definition: opt.h:290

AVPacket::size

int size

Definition: avcodec.h:1163

const char * b

Definition: vf_curves.c:109

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:131

options

static const AVOption options[]

Definition: alac.c:647

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:2727

ALACContext::extra_bits_buffer

int32_t * extra_bits_buffer[2]

Definition: alac.c:71

AVCodec

AVCodec.

Definition: avcodec.h:3181

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:245

AV_CODEC_ID_ALAC

Definition: avcodec.h:436

get_sbits_long

static int get_sbits_long(GetBitContext *s, int n)

Read 0-32 bits as a signed integer.

Definition: get_bits.h:375

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

ALACContext::predict_error_buffer

int32_t * predict_error_buffer[2]

Definition: alac.c:69

get_unary_0_9

static int get_unary_0_9(GetBitContext *gb)

Definition: unary.h:51

LIBAVCODEC_VERSION_MAJOR

#define LIBAVCODEC_VERSION_MAJOR

Definition: version.h:31

avpriv_request_sample

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

Log a generic warning message about a missing feature.

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1993

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:74

opt.h

AVOptions.

ALACContext::rice_initial_history

uint8_t rice_initial_history

Definition: alac.c:76

TYPE_LFE

Definition: aac.h:52

alac_decode_close

static av_cold int alac_decode_close(AVCodecContext *avctx)

Definition: alac.c:517

thread.h

Multithreading support functions.

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:1355

CODEC_CAP_DR1

#define CODEC_CAP_DR1

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

Definition: avcodec.h:789

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

AVPacket::data

uint8_t * data

Definition: avcodec.h:1162

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:212

bytestream2_skipu

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

Definition: bytestream.h:168

alac_class

static const AVClass alac_class

Definition: alac.c:654

get_bits.h

bitstream reader API header.

ALACContext::output_samples_buffer

int32_t * output_samples_buffer[2]

Definition: alac.c:70

alac_decode_frame

static int alac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)

Definition: alac.c:458

ALACContext

Definition: alac.c:63

AV_SAMPLE_FMT_S32

signed 32 bits

Definition: samplefmt.h:63

ALACContext::extra_bits

int extra_bits

number of extra bits beyond 16-bit

Definition: alac.c:79

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

av_sample_fmt_is_planar

int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)

Check if the sample format is planar.

Definition: samplefmt.c:110

#define U(x)

Definition: vp56_arith.h:37

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:588

append_extra_bits

static void append_extra_bits(int32_t *buffer[2], int32_t *extra_bits_buffer[2], int extra_bits, int channels, int nb_samples)

Definition: alac.c:252

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

lpc_prediction

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

Definition: alac.c:170

av_default_item_name

Definition: libopenh264enc.c:59

AVERROR

#define AVERROR(e)

Definition: error.h:43

AVCodecContext::request_sample_fmt

enum AVSampleFormat request_sample_fmt

desired sample format

Definition: avcodec.h:2068

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

sign_only

static int sign_only(int v)

Definition: alac.c:165

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:195

AlacRawDataBlockType

Definition: alac_data.h:26

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3188

avcodec.h

Libavcodec external API header.

bytestream.h

AVCodecContext::channel_layout

uint64_t channel_layout

Audio channel layout.

Definition: avcodec.h:2046

ALAC_MAX_CHANNELS

#define ALAC_MAX_CHANNELS

Definition: alac_data.h:38

ALACContext::max_samples_per_frame

uint32_t max_samples_per_frame

Definition: alac.c:73

ONLY_IF_THREADS_ENABLED

#define ONLY_IF_THREADS_ENABLED(x)

Define a function with only the non-default version specified.

Definition: internal.h:214

decorrelate_stereo

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

Definition: alac.c:233

channel_layout.h

audio channel layout utility functions

FFMIN

#define FFMIN(a, b)

Definition: common.h:66

AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:69

FFSIGN

#define FFSIGN(a)

Definition: common.h:62

ret

Definition: avfilter.c:974

ALACContext::gb

GetBitContext gb

Definition: alac.c:66

mathops.h

int32_t

Definition: audio_convert.c:194

show_bits

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

Show 1-25 bits.

Definition: get_bits.h:287

alac_set_info

static int alac_set_info(ALACContext *alac)

Definition: alac.c:556

ALACContext::rice_history_mult

uint8_t rice_history_mult

Definition: alac.c:75

ThreadFrame

Definition: thread.h:35

ff_alac_channel_layouts

const uint64_t ff_alac_channel_layouts[ALAC_MAX_CHANNELS+1]

Definition: alac_data.c:35

pred

static const float pred[4]

Definition: siprdata.h:259

alac_data.h

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:441

ff_thread_get_buffer

int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:853

AVCodecContext

main external API structure.

Definition: avcodec.h:1241

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:1356

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:304

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:297

unary.h

decode_scalar

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

Definition: alac.c:86

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

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:337

ff_alac_channel_layout_offsets

const uint8_t ff_alac_channel_layout_offsets[ALAC_MAX_CHANNELS][ALAC_MAX_CHANNELS]

Definition: alac_data.c:24

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:139

ALACContext::sample_size

uint8_t sample_size

Definition: alac.c:74

decode

static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)

Definition: ccaption_dec.c:522

ALACContext::channels

int channels

Definition: alac.c:67

GetBitContext

Definition: get_bits.h:54

ff_alac_decoder

AVCodec ff_alac_decoder

Definition: alac.c:661

internal.h

common internal api header.

alac_decode_init

static av_cold int alac_decode_init(AVCodecContext *avctx)

Definition: alac.c:587

CODEC_CAP_FRAME_THREADS

#define CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: avcodec.h:866

FF_ALLOC_OR_GOTO

#define FF_ALLOC_OR_GOTO(ctx, p, size, label)

Definition: internal.h:129

AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:62

ALACContext::rice_limit

uint8_t rice_limit

Definition: alac.c:77

bps

unsigned bps

Definition: movenc.c:1334

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1283

allocate_buffers

static int allocate_buffers(ALACContext *alac)

Definition: alac.c:532

AVCodecContext::channels

int channels

number of audio channels

Definition: avcodec.h:1986

av_log2

#define av_log2

Definition: intmath.h:105

ALACContext::avctx

AVCodecContext * avctx

Definition: alac.c:65

rice_decompress

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

Definition: alac.c:108

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

init_thread_copy

static int init_thread_copy(AVCodecContext *avctx)

Definition: alac.c:640

AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:68

AVFrame::extended_data

uint8_t ** extended_data

pointers to the data planes/channels.

Definition: frame.h:215

ALACContext::direct_output

int direct_output

Definition: alac.c:82

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1139

AVFrame::nb_samples

int nb_samples

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

Definition: frame.h:225

for

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

Definition: h264pred_template.c:469

buffer

GLuint buffer

Definition: opengl_enc.c:102

Definition: h264pred_template.c:468

Generated on Wed Jun 10 2015 01:56:37 for FFmpeg by doxygen 1.8.6