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 decorr_shift = get_bits(&alac->gb, 8);

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

321

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

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

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

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

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

327

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

329 return AVERROR_INVALIDDATA;

330

331 /* read the predictor table */

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

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

334 }

335

336 if (alac->extra_bits) {

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

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

339 return -1;

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

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

342 }

343 }

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

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

346 alac->nb_samples, bps,

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

348 if(ret<0)

349 return ret;

350

351 /* adaptive FIR filter */

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

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

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

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

356 *

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

358 * reference encoder.

359 */

360 lpc_prediction(alac->predict_error_buffer[ch],

361 alac->predict_error_buffer[ch],

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

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

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

365 prediction_type[ch]);

366 }

367 lpc_prediction(alac->predict_error_buffer[ch],

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

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

370 }

371 } else {

372 /* not compressed, easy case */

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

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

375 return -1;

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

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

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

379 }

380 }

381 alac->extra_bits = 0;

382 decorr_shift = 0;

383 decorr_left_weight = 0;

384 }

385

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

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

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

389 }

390

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

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

393 decorr_shift, decorr_left_weight);

394 }

395

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

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

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

399 }

400

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

402 switch(alac->sample_size) {

403 case 16: {

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

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

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

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

408 }}

409 break;

410 case 24: {

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

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

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

414 }}

415 break;

416 }

417 }else{

418 switch(alac->sample_size) {

419 case 16: {

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

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

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

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

424 outbuffer += alac->channels - channels;

425 }

426 }

427 break;

428 case 24: {

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

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

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

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

433 outbuffer += alac->channels - channels;

434 }

435 }

436 break;

437 case 32: {

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

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

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

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

442 outbuffer += alac->channels - channels;

443 }

444 }

445 break;

446 }

447 }

448

449 return 0;

450 }

451

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

453 int *got_frame_ptr, AVPacket *avpkt)

454 {

455 ALACContext *alac = avctx->priv_data;

456 AVFrame *frame = data;

457 enum AlacRawDataBlockType element;

458 int channels;

459 int ch, ret, got_end;

460

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

462 return ret;

463

464 got_end = 0;

465 alac->nb_samples = 0;

466 ch = 0;

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

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

469 if (element == TYPE_END) {

470 got_end = 1;

471 break;

472 }

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

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

475 return AVERROR_PATCHWELCOME;

476 }

477

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

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

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

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

482 return AVERROR_INVALIDDATA;

483 }

484

485 ret = decode_element(avctx, frame,

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

487 channels);

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

489 return ret;

490

491 ch += channels;

492 }

493 if (!got_end) {

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

495 return AVERROR_INVALIDDATA;

496 }

497

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

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

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

501 }

502

503 if (alac->channels == ch)

504 *got_frame_ptr = 1;

505 else

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

507

508 return avpkt->size;

509 }

510

511 static av_cold int alac_decode_close(AVCodecContext *avctx)

512 {

513 ALACContext *alac = avctx->priv_data;

514

515 int ch;

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

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

518 if (!alac->direct_output)

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

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

521 }

522

523 return 0;

524 }

525

526 static int allocate_buffers(ALACContext *alac)

527 {

528 int ch;

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

530

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

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

533 buf_size, buf_alloc_fail);

534

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

536 if (!alac->direct_output) {

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

538 buf_size, buf_alloc_fail);

539 }

540

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

542 buf_size, buf_alloc_fail);

543 }

544 return 0;

545 buf_alloc_fail:

546 alac_decode_close(alac->avctx);

547 return AVERROR(ENOMEM);

548 }

549

550 static int alac_set_info(ALACContext *alac)

551 {

552 GetByteContext gb;

553

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

555 alac->avctx->extradata_size);

556

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

558

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

560 if (!alac->max_samples_per_frame ||

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

562 av_log(alac->avctx, AV_LOG_ERROR,

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

564 alac->max_samples_per_frame);

565 return AVERROR_INVALIDDATA;

566 }

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

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

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

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

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

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

573 bytestream2_get_be16u(&gb); // maxRun

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

575 bytestream2_get_be32u(&gb); // average bitrate

576 bytestream2_get_be32u(&gb); // samplerate

577

578 return 0;

579 }

580

581 static av_cold int alac_decode_init(AVCodecContext * avctx)

582 {

583 int ret;

584 int req_packed;

585 ALACContext *alac = avctx->priv_data;

586 alac->avctx = avctx;

587

588 /* initialize from the extradata */

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

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

591 return AVERROR_INVALIDDATA;

592 }

593 if (alac_set_info(alac)) {

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

595 return -1;

596 }

597

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

599 switch (alac->sample_size) {

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

601 break;

602 case 24:

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

604 break;

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

606 return AVERROR_PATCHWELCOME;

607 }

608 avctx->bits_per_raw_sample = alac->sample_size;

609

610 if (alac->channels < 1) {

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

612 alac->channels = avctx->channels;

613 } else {

614 if (alac->channels > ALAC_MAX_CHANNELS)

615 alac->channels = avctx->channels;

616 else

617 avctx->channels = alac->channels;

618 }

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

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

621 avctx->channels);

622 return AVERROR_PATCHWELCOME;

623 }

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

625

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

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

628 return ret;

629 }

630

631 return 0;

632 }

633

634 static int init_thread_copy(AVCodecContext *avctx)

635 {

636 ALACContext *alac = avctx->priv_data;

637 alac->avctx = avctx;

638 return allocate_buffers(alac);

639 }

640

641 static const AVOption options[] = {

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

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

644 0, 1, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM },

645 { NULL },

646 };

647

648 static const AVClass alac_class = {

649 .class_name = "alac",

650 .item_name = av_default_item_name,

651 .option = options,

652 .version = LIBAVUTIL_VERSION_INT,

653 };

654

655 AVCodec ff_alac_decoder = {

656 .name = "alac",

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

658 .type = AVMEDIA_TYPE_AUDIO,

659 .id = AV_CODEC_ID_ALAC,

660 .priv_data_size = sizeof(ALACContext),

661 .init = alac_decode_init,

662 .close = alac_decode_close,

663 .decode = alac_decode_frame,

664 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

665 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

666 .priv_class = &alac_class

667 };

Generated on Sun Mar 8 2015 02:34:47 for FFmpeg by doxygen 1.8.2