FFmpeg: libavcodec/proresdec_lgpl.c Source File

FFmpeg

[フレーム]

libavcodec

proresdec_lgpl.c

Go to the documentation of this file.

1 /*

2 * Apple ProRes compatible decoder

3 *

5 *

6 * This file is part of Libav.

7 *

8 * Libav is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * Libav is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with Libav; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * This is a decoder for Apple ProRes 422 SD/HQ/LT/Proxy and ProRes 4444.

26 * It is used for storing and editing high definition video data in Apple's Final Cut Pro.

27 *

28 * @see http://wiki.multimedia.cx/index.php?title=Apple_ProRes

29 */

31 #define LONG_BITSTREAM_READER // some ProRes vlc codes require up to 28 bits to be read at once

33 #include <stdint.h>

35 #include "libavutil/intmath.h"

36 #include "avcodec.h"

37 #include "dsputil.h"

38 #include "internal.h"

39 #include "proresdata.h"

40 #include "proresdsp.h"

41 #include "get_bits.h"

43 typedef struct {

44 const uint8_t *index; ///< pointers to the data of this slice

45 int slice_num;

46 int x_pos, y_pos;

47 int slice_width;

48 int prev_slice_sf; ///< scalefactor of the previous decoded slice

49 DECLARE_ALIGNED(16, int16_t, blocks)[8 * 4 * 64];

50 DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled)[64];

51 DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled)[64];

52 } ProresThreadData;

54 typedef struct {

55 ProresDSPContext dsp;

56 AVFrame *frame;

57 ScanTable scantable;

58 int scantable_type; ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced

60 int frame_type; ///< 0 = progressive, 1 = top-field first, 2 = bottom-field first

61 int pic_format; ///< 2 = 422, 3 = 444

62 uint8_t qmat_luma[64]; ///< dequantization matrix for luma

63 uint8_t qmat_chroma[64]; ///< dequantization matrix for chroma

64 int qmat_changed; ///< 1 - global quantization matrices changed

65 int total_slices; ///< total number of slices in a picture

66 ProresThreadData *slice_data;

67 int pic_num;

68 int chroma_factor;

69 int mb_chroma_factor;

70 int num_chroma_blocks; ///< number of chrominance blocks in a macroblock

71 int num_x_slices;

72 int num_y_slices;

73 int slice_width_factor;

74 int slice_height_factor;

75 int num_x_mbs;

76 int num_y_mbs;

77 int alpha_info;

78 } ProresContext;

81 static av_cold int decode_init(AVCodecContext *avctx)

82 {

83 ProresContext *ctx = avctx->priv_data;

85 ctx->total_slices = 0;

86 ctx->slice_data = NULL;

88 avctx->bits_per_raw_sample = PRORES_BITS_PER_SAMPLE;

89 ff_proresdsp_init(&ctx->dsp, avctx);

91 ctx->scantable_type = -1; // set scantable type to uninitialized

92 memset(ctx->qmat_luma, 4, 64);

93 memset(ctx->qmat_chroma, 4, 64);

95 return 0;

96 }

99 static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,

100 const int data_size, AVCodecContext *avctx)

101 {

102 int hdr_size, version, width, height, flags;

103 const uint8_t *ptr;

104

105 hdr_size = AV_RB16(buf);

106 if (hdr_size > data_size) {

107 av_log(avctx, AV_LOG_ERROR, "frame data too small\n");

108 return AVERROR_INVALIDDATA;

109 }

110

111 version = AV_RB16(buf + 2);

112 if (version >= 2) {

113 av_log(avctx, AV_LOG_ERROR,

114 "unsupported header version: %d\n", version);

115 return AVERROR_INVALIDDATA;

116 }

117

118 width = AV_RB16(buf + 8);

119 height = AV_RB16(buf + 10);

120 if (width != avctx->width || height != avctx->height) {

121 av_log(avctx, AV_LOG_ERROR,

122 "picture dimension changed: old: %d x %d, new: %d x %d\n",

123 avctx->width, avctx->height, width, height);

124 return AVERROR_INVALIDDATA;

125 }

126

127 ctx->frame_type = (buf[12] >> 2) & 3;

128 if (ctx->frame_type > 2) {

129 av_log(avctx, AV_LOG_ERROR,

130 "unsupported frame type: %d\n", ctx->frame_type);

131 return AVERROR_INVALIDDATA;

132 }

133

134 ctx->chroma_factor = (buf[12] >> 6) & 3;

135 ctx->mb_chroma_factor = ctx->chroma_factor + 2;

136 ctx->num_chroma_blocks = (1 << ctx->chroma_factor) >> 1;

137 ctx->alpha_info = buf[17] & 0xf;

138

139 if (ctx->alpha_info > 2) {

140 av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);

141 return AVERROR_INVALIDDATA;

142 }

143

144 switch (ctx->chroma_factor) {

145 case 2:

146 avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA422P10

147 : AV_PIX_FMT_YUV422P10;

148 break;

149 case 3:

150 avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA444P10

151 : AV_PIX_FMT_YUV444P10;

152 break;

153 default:

154 av_log(avctx, AV_LOG_ERROR,

155 "unsupported picture format: %d\n", ctx->pic_format);

156 return AVERROR_INVALIDDATA;

157 }

158

159 if (ctx->scantable_type != ctx->frame_type) {

160 if (!ctx->frame_type)

161 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,

162 ff_prores_progressive_scan);

163 else

164 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,

165 ff_prores_interlaced_scan);

166 ctx->scantable_type = ctx->frame_type;

167 }

168

169 if (ctx->frame_type) { /* if interlaced */

170 ctx->frame->interlaced_frame = 1;

171 ctx->frame->top_field_first = ctx->frame_type & 1;

172 } else {

173 ctx->frame->interlaced_frame = 0;

174 }

175

176 avctx->color_primaries = buf[14];

177 avctx->color_trc = buf[15];

178 avctx->colorspace = buf[16];

179

180 ctx->qmat_changed = 0;

181 ptr = buf + 20;

182 flags = buf[19];

183 if (flags & 2) {

184 if (ptr - buf > hdr_size - 64) {

185 av_log(avctx, AV_LOG_ERROR, "header data too small\n");

186 return AVERROR_INVALIDDATA;

187 }

188 if (memcmp(ctx->qmat_luma, ptr, 64)) {

189 memcpy(ctx->qmat_luma, ptr, 64);

190 ctx->qmat_changed = 1;

191 }

192 ptr += 64;

193 } else {

194 memset(ctx->qmat_luma, 4, 64);

195 ctx->qmat_changed = 1;

196 }

197

198 if (flags & 1) {

199 if (ptr - buf > hdr_size - 64) {

200 av_log(avctx, AV_LOG_ERROR, "header data too small\n");

201 return -1;

202 }

203 if (memcmp(ctx->qmat_chroma, ptr, 64)) {

204 memcpy(ctx->qmat_chroma, ptr, 64);

205 ctx->qmat_changed = 1;

206 }

207 } else {

208 memset(ctx->qmat_chroma, 4, 64);

209 ctx->qmat_changed = 1;

210 }

211

212 return hdr_size;

213 }

214

215

216 static int decode_picture_header(ProresContext *ctx, const uint8_t *buf,

217 const int data_size, AVCodecContext *avctx)

218 {

219 int i, hdr_size, pic_data_size, num_slices;

220 int slice_width_factor, slice_height_factor;

221 int remainder, num_x_slices;

222 const uint8_t *data_ptr, *index_ptr;

223

224 hdr_size = data_size > 0 ? buf[0] >> 3 : 0;

225 if (hdr_size < 8 || hdr_size > data_size) {

226 av_log(avctx, AV_LOG_ERROR, "picture header too small\n");

227 return AVERROR_INVALIDDATA;

228 }

229

230 pic_data_size = AV_RB32(buf + 1);

231 if (pic_data_size > data_size) {

232 av_log(avctx, AV_LOG_ERROR, "picture data too small\n");

233 return AVERROR_INVALIDDATA;

234 }

235

236 slice_width_factor = buf[7] >> 4;

237 slice_height_factor = buf[7] & 0xF;

238 if (slice_width_factor > 3 || slice_height_factor) {

239 av_log(avctx, AV_LOG_ERROR,

240 "unsupported slice dimension: %d x %d\n",

241 1 << slice_width_factor, 1 << slice_height_factor);

242 return AVERROR_INVALIDDATA;

243 }

244

245 ctx->slice_width_factor = slice_width_factor;

246 ctx->slice_height_factor = slice_height_factor;

247

248 ctx->num_x_mbs = (avctx->width + 15) >> 4;

249 ctx->num_y_mbs = (avctx->height +

250 (1 << (4 + ctx->frame->interlaced_frame)) - 1) >>

251 (4 + ctx->frame->interlaced_frame);

252

253 remainder = ctx->num_x_mbs & ((1 << slice_width_factor) - 1);

254 num_x_slices = (ctx->num_x_mbs >> slice_width_factor) + (remainder & 1) +

255 ((remainder >> 1) & 1) + ((remainder >> 2) & 1);

256

257 num_slices = num_x_slices * ctx->num_y_mbs;

258 if (num_slices != AV_RB16(buf + 5)) {

259 av_log(avctx, AV_LOG_ERROR, "invalid number of slices\n");

260 return AVERROR_INVALIDDATA;

261 }

262

263 if (ctx->total_slices != num_slices) {

264 av_freep(&ctx->slice_data);

265 ctx->slice_data = av_malloc((num_slices + 1) * sizeof(ctx->slice_data[0]));

266 if (!ctx->slice_data)

267 return AVERROR(ENOMEM);

268 ctx->total_slices = num_slices;

269 }

270

271 if (hdr_size + num_slices * 2 > data_size) {

272 av_log(avctx, AV_LOG_ERROR, "slice table too small\n");

273 return AVERROR_INVALIDDATA;

274 }

275

276 /* parse slice table allowing quick access to the slice data */

277 index_ptr = buf + hdr_size;

278 data_ptr = index_ptr + num_slices * 2;

279

280 for (i = 0; i < num_slices; i++) {

281 ctx->slice_data[i].index = data_ptr;

282 ctx->slice_data[i].prev_slice_sf = 0;

283 data_ptr += AV_RB16(index_ptr + i * 2);

284 }

285 ctx->slice_data[i].index = data_ptr;

286 ctx->slice_data[i].prev_slice_sf = 0;

287

288 if (data_ptr > buf + data_size) {

289 av_log(avctx, AV_LOG_ERROR, "out of slice data\n");

290 return -1;

291 }

292

293 return pic_data_size;

294 }

295

296

297 /**

298 * Read an unsigned rice/exp golomb codeword.

299 */

300 static inline int decode_vlc_codeword(GetBitContext *gb, unsigned codebook)

301 {

302 unsigned int rice_order, exp_order, switch_bits;

303 unsigned int buf, code;

304 int log, prefix_len, len;

305

306 OPEN_READER(re, gb);

307 UPDATE_CACHE(re, gb);

308 buf = GET_CACHE(re, gb);

309

310 /* number of prefix bits to switch between Rice and expGolomb */

311 switch_bits = (codebook & 3) + 1;

312 rice_order = codebook >> 5; /* rice code order */

313 exp_order = (codebook >> 2) & 7; /* exp golomb code order */

314

315 log = 31 - av_log2(buf); /* count prefix bits (zeroes) */

316

317 if (log < switch_bits) { /* ok, we got a rice code */

318 if (!rice_order) {

319 /* shortcut for faster decoding of rice codes without remainder */

320 code = log;

321 LAST_SKIP_BITS(re, gb, log + 1);

322 } else {

323 prefix_len = log + 1;

324 code = (log << rice_order) + NEG_USR32(buf << prefix_len, rice_order);

325 LAST_SKIP_BITS(re, gb, prefix_len + rice_order);

326 }

327 } else { /* otherwise we got a exp golomb code */

328 len = (log << 1) - switch_bits + exp_order + 1;

329 code = NEG_USR32(buf, len) - (1 << exp_order) + (switch_bits << rice_order);

330 LAST_SKIP_BITS(re, gb, len);

331 }

332

333 CLOSE_READER(re, gb);

334

335 return code;

336 }

337

338 #define LSB2SIGN(x) (-((x) & 1))

339 #define TOSIGNED(x) (((x) >> 1) ^ LSB2SIGN(x))

340

341 /**

342 * Decode DC coefficients for all blocks in a slice.

343 */

344 static inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,

345 int nblocks)

346 {

347 int16_t prev_dc;

348 int i, sign;

349 int16_t delta;

350 unsigned int code;

351

352 code = decode_vlc_codeword(gb, FIRST_DC_CB);

353 out[0] = prev_dc = TOSIGNED(code);

354

355 out += 64; /* move to the DC coeff of the next block */

356 delta = 3;

357

358 for (i = 1; i < nblocks; i++, out += 64) {

359 code = decode_vlc_codeword(gb, ff_prores_dc_codebook[FFMIN(FFABS(delta), 3)]);

360

361 sign = -(((delta >> 15) & 1) ^ (code & 1));

362 delta = (((code + 1) >> 1) ^ sign) - sign;

363 prev_dc += delta;

364 out[0] = prev_dc;

365 }

366 }

367

368

369 /**

370 * Decode AC coefficients for all blocks in a slice.

371 */

372 static inline void decode_ac_coeffs(GetBitContext *gb, int16_t *out,

373 int blocks_per_slice,

374 int plane_size_factor,

375 const uint8_t *scan)

376 {

377 int pos, block_mask, run, level, sign, run_cb_index, lev_cb_index;

378 int max_coeffs, bits_left;

379

380 /* set initial prediction values */

381 run = 4;

382 level = 2;

383

384 max_coeffs = blocks_per_slice << 6;

385 block_mask = blocks_per_slice - 1;

386

387 for (pos = blocks_per_slice - 1; pos < max_coeffs;) {

388 run_cb_index = ff_prores_run_to_cb_index[FFMIN(run, 15)];

389 lev_cb_index = ff_prores_lev_to_cb_index[FFMIN(level, 9)];

390

391 bits_left = get_bits_left(gb);

392 if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))

393 return;

394

395 run = decode_vlc_codeword(gb, ff_prores_ac_codebook[run_cb_index]);

396

397 bits_left = get_bits_left(gb);

398 if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))

399 return;

400

401 level = decode_vlc_codeword(gb, ff_prores_ac_codebook[lev_cb_index]) + 1;

402

403 pos += run + 1;

404 if (pos >= max_coeffs)

405 break;

406

407 sign = get_sbits(gb, 1);

408 out[((pos & block_mask) << 6) + scan[pos >> plane_size_factor]] =

409 (level ^ sign) - sign;

410 }

411 }

412

413

414 /**

415 * Decode a slice plane (luma or chroma).

416 */

417 static void decode_slice_plane(ProresContext *ctx, ProresThreadData *td,

418 const uint8_t *buf,

419 int data_size, uint16_t *out_ptr,

420 int linesize, int mbs_per_slice,

421 int blocks_per_mb, int plane_size_factor,

422 const int16_t *qmat, int is_chroma)

423 {

424 GetBitContext gb;

425 int16_t *block_ptr;

426 int mb_num, blocks_per_slice;

427

428 blocks_per_slice = mbs_per_slice * blocks_per_mb;

429

430 memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));

431

432 init_get_bits(&gb, buf, data_size << 3);

433

434 decode_dc_coeffs(&gb, td->blocks, blocks_per_slice);

435

436 decode_ac_coeffs(&gb, td->blocks, blocks_per_slice,

437 plane_size_factor, ctx->scantable.permutated);

438

439 /* inverse quantization, inverse transform and output */

440 block_ptr = td->blocks;

441

442 if (!is_chroma) {

443 for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {

444 ctx->dsp.idct_put(out_ptr, linesize, block_ptr, qmat);

445 block_ptr += 64;

446 if (blocks_per_mb > 2) {

447 ctx->dsp.idct_put(out_ptr + 8, linesize, block_ptr, qmat);

448 block_ptr += 64;

449 }

450 ctx->dsp.idct_put(out_ptr + linesize * 4, linesize, block_ptr, qmat);

451 block_ptr += 64;

452 if (blocks_per_mb > 2) {

453 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);

454 block_ptr += 64;

455 }

456 }

457 } else {

458 for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {

459 ctx->dsp.idct_put(out_ptr, linesize, block_ptr, qmat);

460 block_ptr += 64;

461 ctx->dsp.idct_put(out_ptr + linesize * 4, linesize, block_ptr, qmat);

462 block_ptr += 64;

463 if (blocks_per_mb > 2) {

464 ctx->dsp.idct_put(out_ptr + 8, linesize, block_ptr, qmat);

465 block_ptr += 64;

466 ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);

467 block_ptr += 64;

468 }

469 }

470 }

471 }

472

473

474 static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,

475 const int num_bits)

476 {

477 const int mask = (1 << num_bits) - 1;

478 int i, idx, val, alpha_val;

479

480 idx = 0;

481 alpha_val = mask;

482 do {

483 do {

484 if (get_bits1(gb))

485 val = get_bits(gb, num_bits);

486 else {

487 int sign;

488 val = get_bits(gb, num_bits == 16 ? 7 : 4);

489 sign = val & 1;

490 val = (val + 2) >> 1;

491 if (sign)

492 val = -val;

493 }

494 alpha_val = (alpha_val + val) & mask;

495 if (num_bits == 16)

496 dst[idx++] = alpha_val >> 6;

497 else

498 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);

499 if (idx >= num_coeffs)

500 break;

501 } while (get_bits1(gb));

502 val = get_bits(gb, 4);

503 if (!val)

504 val = get_bits(gb, 11);

505 if (idx + val > num_coeffs)

506 val = num_coeffs - idx;

507 if (num_bits == 16)

508 for (i = 0; i < val; i++)

509 dst[idx++] = alpha_val >> 6;

510 else

511 for (i = 0; i < val; i++)

512 dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);

513 } while (idx < num_coeffs);

514 }

515

516 /**

517 * Decode alpha slice plane.

518 */

519 static void decode_alpha_plane(ProresContext *ctx, ProresThreadData *td,

520 const uint8_t *buf, int data_size,

521 uint16_t *out_ptr, int linesize,

522 int mbs_per_slice)

523 {

524 GetBitContext gb;

525 int i;

526 uint16_t *block_ptr;

527

528 memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));

529

530 init_get_bits(&gb, buf, data_size << 3);

531

532 if (ctx->alpha_info == 2)

533 unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 16);

534 else

535 unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 8);

536

537 block_ptr = td->blocks;

538

539 for (i = 0; i < 16; i++) {

540 memcpy(out_ptr, block_ptr, 16 * mbs_per_slice * sizeof(*out_ptr));

541 out_ptr += linesize >> 1;

542 block_ptr += 16 * mbs_per_slice;

543 }

544 }

545

546 static int decode_slice(AVCodecContext *avctx, void *tdata)

547 {

548 ProresThreadData *td = tdata;

549 ProresContext *ctx = avctx->priv_data;

550 int mb_x_pos = td->x_pos;

551 int mb_y_pos = td->y_pos;

552 int pic_num = ctx->pic_num;

553 int slice_num = td->slice_num;

554 int mbs_per_slice = td->slice_width;

555 const uint8_t *buf;

556 uint8_t *y_data, *u_data, *v_data, *a_data;

557 AVFrame *pic = ctx->frame;

558 int i, sf, slice_width_factor;

559 int slice_data_size, hdr_size;

560 int y_data_size, u_data_size, v_data_size, a_data_size;

561 int y_linesize, u_linesize, v_linesize, a_linesize;

562 int coff[4];

563

564 buf = ctx->slice_data[slice_num].index;

565 slice_data_size = ctx->slice_data[slice_num + 1].index - buf;

566

567 slice_width_factor = av_log2(mbs_per_slice);

568

569 y_data = pic->data[0];

570 u_data = pic->data[1];

571 v_data = pic->data[2];

572 a_data = pic->data[3];

573 y_linesize = pic->linesize[0];

574 u_linesize = pic->linesize[1];

575 v_linesize = pic->linesize[2];

576 a_linesize = pic->linesize[3];

577

578 if (pic->interlaced_frame) {

579 if (!(pic_num ^ pic->top_field_first)) {

580 y_data += y_linesize;

581 u_data += u_linesize;

582 v_data += v_linesize;

583 if (a_data)

584 a_data += a_linesize;

585 }

586 y_linesize <<= 1;

587 u_linesize <<= 1;

588 v_linesize <<= 1;

589 a_linesize <<= 1;

590 }

591 y_data += (mb_y_pos << 4) * y_linesize + (mb_x_pos << 5);

592 u_data += (mb_y_pos << 4) * u_linesize + (mb_x_pos << ctx->mb_chroma_factor);

593 v_data += (mb_y_pos << 4) * v_linesize + (mb_x_pos << ctx->mb_chroma_factor);

594 if (a_data)

595 a_data += (mb_y_pos << 4) * a_linesize + (mb_x_pos << 5);

596

597 if (slice_data_size < 6) {

598 av_log(avctx, AV_LOG_ERROR, "slice data too small\n");

599 return AVERROR_INVALIDDATA;

600 }

601

602 /* parse slice header */

603 hdr_size = buf[0] >> 3;

604 coff[0] = hdr_size;

605 y_data_size = AV_RB16(buf + 2);

606 coff[1] = coff[0] + y_data_size;

607 u_data_size = AV_RB16(buf + 4);

608 coff[2] = coff[1] + u_data_size;

609 v_data_size = hdr_size > 7 ? AV_RB16(buf + 6) : slice_data_size - coff[2];

610 coff[3] = coff[2] + v_data_size;

611 a_data_size = slice_data_size - coff[3];

612

613 /* if V or alpha component size is negative that means that previous

614 component sizes are too large */

615 if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6) {

616 av_log(avctx, AV_LOG_ERROR, "invalid data size\n");

617 return AVERROR_INVALIDDATA;

618 }

619

620 sf = av_clip(buf[1], 1, 224);

621 sf = sf > 128 ? (sf - 96) << 2 : sf;

622

623 /* scale quantization matrixes according with slice's scale factor */

624 /* TODO: this can be SIMD-optimized a lot */

625 if (ctx->qmat_changed || sf != td->prev_slice_sf) {

626 td->prev_slice_sf = sf;

627 for (i = 0; i < 64; i++) {

628 td->qmat_luma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_luma[i] * sf;

629 td->qmat_chroma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_chroma[i] * sf;

630 }

631 }

632

633 /* decode luma plane */

634 decode_slice_plane(ctx, td, buf + coff[0], y_data_size,

635 (uint16_t*) y_data, y_linesize,

636 mbs_per_slice, 4, slice_width_factor + 2,

637 td->qmat_luma_scaled, 0);

638

639 /* decode U chroma plane */

640 decode_slice_plane(ctx, td, buf + coff[1], u_data_size,

641 (uint16_t*) u_data, u_linesize,

642 mbs_per_slice, ctx->num_chroma_blocks,

643 slice_width_factor + ctx->chroma_factor - 1,

644 td->qmat_chroma_scaled, 1);

645

646 /* decode V chroma plane */

647 decode_slice_plane(ctx, td, buf + coff[2], v_data_size,

648 (uint16_t*) v_data, v_linesize,

649 mbs_per_slice, ctx->num_chroma_blocks,

650 slice_width_factor + ctx->chroma_factor - 1,

651 td->qmat_chroma_scaled, 1);

652

653 /* decode alpha plane if available */

654 if (a_data && a_data_size)

655 decode_alpha_plane(ctx, td, buf + coff[3], a_data_size,

656 (uint16_t*) a_data, a_linesize,

657 mbs_per_slice);

658

659 return 0;

660 }

661

662

663 static int decode_picture(ProresContext *ctx, int pic_num,

664 AVCodecContext *avctx)

665 {

666 int slice_num, slice_width, x_pos, y_pos;

667

668 slice_num = 0;

669

670 ctx->pic_num = pic_num;

671 for (y_pos = 0; y_pos < ctx->num_y_mbs; y_pos++) {

672 slice_width = 1 << ctx->slice_width_factor;

673

674 for (x_pos = 0; x_pos < ctx->num_x_mbs && slice_width;

675 x_pos += slice_width) {

676 while (ctx->num_x_mbs - x_pos < slice_width)

677 slice_width >>= 1;

678

679 ctx->slice_data[slice_num].slice_num = slice_num;

680 ctx->slice_data[slice_num].x_pos = x_pos;

681 ctx->slice_data[slice_num].y_pos = y_pos;

682 ctx->slice_data[slice_num].slice_width = slice_width;

683

684 slice_num++;

685 }

686 }

687

688 return avctx->execute(avctx, decode_slice,

689 ctx->slice_data, NULL, slice_num,

690 sizeof(ctx->slice_data[0]));

691 }

692

693

694 #define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)

695

696 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

697 AVPacket *avpkt)

698 {

699 ProresContext *ctx = avctx->priv_data;

700 const uint8_t *buf = avpkt->data;

701 int buf_size = avpkt->size;

702 int frame_hdr_size, pic_num, pic_data_size;

703

704 ctx->frame = data;

705 ctx->frame->pict_type = AV_PICTURE_TYPE_I;

706 ctx->frame->key_frame = 1;

707

708 /* check frame atom container */

709 if (buf_size < 28 || buf_size < AV_RB32(buf) ||

710 AV_RB32(buf + 4) != FRAME_ID) {

711 av_log(avctx, AV_LOG_ERROR, "invalid frame\n");

712 return AVERROR_INVALIDDATA;

713 }

714

715 MOVE_DATA_PTR(8);

716

717 frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);

718 if (frame_hdr_size < 0)

719 return AVERROR_INVALIDDATA;

720

721 MOVE_DATA_PTR(frame_hdr_size);

722

723 if (ff_get_buffer(avctx, ctx->frame, 0) < 0)

724 return -1;

725

726 for (pic_num = 0; ctx->frame->interlaced_frame - pic_num + 1; pic_num++) {

727 pic_data_size = decode_picture_header(ctx, buf, buf_size, avctx);

728 if (pic_data_size < 0)

729 return AVERROR_INVALIDDATA;

730

731 if (decode_picture(ctx, pic_num, avctx))

732 return -1;

733

734 MOVE_DATA_PTR(pic_data_size);

735 }

736

737 ctx->frame = NULL;

738 *got_frame = 1;

739

740 return avpkt->size;

741 }

742

743

744 static av_cold int decode_close(AVCodecContext *avctx)

745 {

746 ProresContext *ctx = avctx->priv_data;

747

748 av_freep(&ctx->slice_data);

749

750 return 0;

751 }

752

753

754 AVCodec ff_prores_lgpl_decoder = {

755 .name = "prores_lgpl",

756 .type = AVMEDIA_TYPE_VIDEO,

757 .id = AV_CODEC_ID_PRORES,

758 .priv_data_size = sizeof(ProresContext),

759 .init = decode_init,

760 .close = decode_close,

761 .decode = decode_frame,

762 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,

763 .long_name = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)")

764 };

Generated on Wed Jul 10 2013 23:48:03 for FFmpeg by doxygen 1.8.2