FFmpeg: libavcodec/proresdec2.c Source File

FFmpeg

[フレーム]

libavcodec

proresdec2.c

Go to the documentation of this file.

1 /*

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 * Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy), 'ap4h' (4444)

25 */

27 //#define DEBUG

29 #define LONG_BITSTREAM_READER

31 #include "avcodec.h"

32 #include "get_bits.h"

33 #include "idctdsp.h"

34 #include "internal.h"

35 #include "simple_idct.h"

36 #include "proresdec.h"

37 #include "proresdata.h"

39 static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64])

40 {

41 int i;

42 for (i = 0; i < 64; i++)

43 dst[i] = permutation[src[i]];

44 }

46 static av_cold int decode_init(AVCodecContext *avctx)

47 {

48 ProresContext *ctx = avctx->priv_data;

49 uint8_t idct_permutation[64];

51 avctx->bits_per_raw_sample = 10;

53 ff_dsputil_init(&ctx->dsp, avctx);

54 ff_blockdsp_init(&ctx->bdsp, avctx);

55 ff_proresdsp_init(&ctx->prodsp, avctx);

57 ff_init_scantable_permutation(idct_permutation,

58 ctx->prodsp.idct_permutation_type);

60 permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation);

61 permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation);

63 return 0;

64 }

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

67 const int data_size, AVCodecContext *avctx)

68 {

69 int hdr_size, width, height, flags;

70 int version;

71 const uint8_t *ptr;

73 hdr_size = AV_RB16(buf);

74 av_dlog(avctx, "header size %d\n", hdr_size);

75 if (hdr_size > data_size) {

76 av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n");

77 return AVERROR_INVALIDDATA;

78 }

80 version = AV_RB16(buf + 2);

81 av_dlog(avctx, "%.4s version %d\n", buf+4, version);

82 if (version > 1) {

83 av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version);

84 return AVERROR_PATCHWELCOME;

85 }

87 width = AV_RB16(buf + 8);

88 height = AV_RB16(buf + 10);

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

90 av_log(avctx, AV_LOG_ERROR, "picture resolution change: %dx%d -> %dx%d\n",

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

92 return AVERROR_PATCHWELCOME;

93 }

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

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

98 if (ctx->alpha_info > 2) {

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

100 return AVERROR_INVALIDDATA;

101 }

102 if (avctx->skip_alpha) ctx->alpha_info = 0;

103

104 av_dlog(avctx, "frame type %d\n", ctx->frame_type);

105

106 if (ctx->frame_type == 0) {

107 ctx->scan = ctx->progressive_scan; // permuted

108 } else {

109 ctx->scan = ctx->interlaced_scan; // permuted

110 ctx->frame->interlaced_frame = 1;

111 ctx->frame->top_field_first = ctx->frame_type == 1;

112 }

113

114 if (ctx->alpha_info) {

115 avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;

116 } else {

117 avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;

118 }

119

120 ptr = buf + 20;

121 flags = buf[19];

122 av_dlog(avctx, "flags %x\n", flags);

123

124 if (flags & 2) {

125 if(buf + data_size - ptr < 64) {

126 av_log(avctx, AV_LOG_ERROR, "Header truncated\n");

127 return AVERROR_INVALIDDATA;

128 }

129 permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr);

130 ptr += 64;

131 } else {

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

133 }

134

135 if (flags & 1) {

136 if(buf + data_size - ptr < 64) {

137 av_log(avctx, AV_LOG_ERROR, "Header truncated\n");

138 return AVERROR_INVALIDDATA;

139 }

140 permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr);

141 } else {

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

143 }

144

145 return hdr_size;

146 }

147

148 static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)

149 {

150 ProresContext *ctx = avctx->priv_data;

151 int i, hdr_size, slice_count;

152 unsigned pic_data_size;

153 int log2_slice_mb_width, log2_slice_mb_height;

154 int slice_mb_count, mb_x, mb_y;

155 const uint8_t *data_ptr, *index_ptr;

156

157 hdr_size = buf[0] >> 3;

158 if (hdr_size < 8 || hdr_size > buf_size) {

159 av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");

160 return AVERROR_INVALIDDATA;

161 }

162

163 pic_data_size = AV_RB32(buf + 1);

164 if (pic_data_size > buf_size) {

165 av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");

166 return AVERROR_INVALIDDATA;

167 }

168

169 log2_slice_mb_width = buf[7] >> 4;

170 log2_slice_mb_height = buf[7] & 0xF;

171 if (log2_slice_mb_width > 3 || log2_slice_mb_height) {

172 av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",

173 1 << log2_slice_mb_width, 1 << log2_slice_mb_height);

174 return AVERROR_INVALIDDATA;

175 }

176

177 ctx->mb_width = (avctx->width + 15) >> 4;

178 if (ctx->frame_type)

179 ctx->mb_height = (avctx->height + 31) >> 5;

180 else

181 ctx->mb_height = (avctx->height + 15) >> 4;

182

183 slice_count = AV_RB16(buf + 5);

184

185 if (ctx->slice_count != slice_count || !ctx->slices) {

186 av_freep(&ctx->slices);

187 ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices));

188 if (!ctx->slices)

189 return AVERROR(ENOMEM);

190 ctx->slice_count = slice_count;

191 }

192

193 if (!slice_count)

194 return AVERROR(EINVAL);

195

196 if (hdr_size + slice_count*2 > buf_size) {

197 av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");

198 return AVERROR_INVALIDDATA;

199 }

200

201 // parse slice information

202 index_ptr = buf + hdr_size;

203 data_ptr = index_ptr + slice_count*2;

204

205 slice_mb_count = 1 << log2_slice_mb_width;

206 mb_x = 0;

207 mb_y = 0;

208

209 for (i = 0; i < slice_count; i++) {

210 SliceContext *slice = &ctx->slices[i];

211

212 slice->data = data_ptr;

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

214

215 while (ctx->mb_width - mb_x < slice_mb_count)

216 slice_mb_count >>= 1;

217

218 slice->mb_x = mb_x;

219 slice->mb_y = mb_y;

220 slice->mb_count = slice_mb_count;

221 slice->data_size = data_ptr - slice->data;

222

223 if (slice->data_size < 6) {

224 av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");

225 return AVERROR_INVALIDDATA;

226 }

227

228 mb_x += slice_mb_count;

229 if (mb_x == ctx->mb_width) {

230 slice_mb_count = 1 << log2_slice_mb_width;

231 mb_x = 0;

232 mb_y++;

233 }

234 if (data_ptr > buf + buf_size) {

235 av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");

236 return AVERROR_INVALIDDATA;

237 }

238 }

239

240 if (mb_x || mb_y != ctx->mb_height) {

241 av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n",

242 mb_y, ctx->mb_height);

243 return AVERROR_INVALIDDATA;

244 }

245

246 return pic_data_size;

247 }

248

249 #define DECODE_CODEWORD(val, codebook) \

250 do { \

251 unsigned int rice_order, exp_order, switch_bits; \

252 unsigned int q, buf, bits; \

253 \

254 UPDATE_CACHE(re, gb); \

255 buf = GET_CACHE(re, gb); \

256 \

257 /* number of bits to switch between rice and exp golomb */ \

258 switch_bits = codebook & 3; \

259 rice_order = codebook >> 5; \

260 exp_order = (codebook >> 2) & 7; \

261 \

262 q = 31 - av_log2(buf); \

263 \

264 if (q > switch_bits) { /* exp golomb */ \

265 bits = exp_order - switch_bits + (q<<1); \

266 val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \

267 ((switch_bits + 1) << rice_order); \

268 SKIP_BITS(re, gb, bits); \

269 } else if (rice_order) { \

270 SKIP_BITS(re, gb, q+1); \

271 val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \

272 SKIP_BITS(re, gb, rice_order); \

273 } else { \

274 val = q; \

275 SKIP_BITS(re, gb, q+1); \

276 } \

277 } while (0)

278

279 #define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1)))

280

281 #define FIRST_DC_CB 0xB8

282

283 static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70};

284

285 static av_always_inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,

286 int blocks_per_slice)

287 {

288 int16_t prev_dc;

289 int code, i, sign;

290

291 OPEN_READER(re, gb);

292

293 DECODE_CODEWORD(code, FIRST_DC_CB);

294 prev_dc = TOSIGNED(code);

295 out[0] = prev_dc;

296

297 out += 64; // dc coeff for the next block

298

299 code = 5;

300 sign = 0;

301 for (i = 1; i < blocks_per_slice; i++, out += 64) {

302 DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)]);

303 if(code) sign ^= -(code & 1);

304 else sign = 0;

305 prev_dc += (((code + 1) >> 1) ^ sign) - sign;

306 out[0] = prev_dc;

307 }

308 CLOSE_READER(re, gb);

309 }

310

311 // adaptive codebook switching lut according to previous run/level values

312 static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C };

313 static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C };

314

315 static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb,

316 int16_t *out, int blocks_per_slice)

317 {

318 ProresContext *ctx = avctx->priv_data;

319 int block_mask, sign;

320 unsigned pos, run, level;

321 int max_coeffs, i, bits_left;

322 int log2_block_count = av_log2(blocks_per_slice);

323

324 OPEN_READER(re, gb);

325 UPDATE_CACHE(re, gb); \

326 run = 4;

327 level = 2;

328

329 max_coeffs = 64 << log2_block_count;

330 block_mask = blocks_per_slice - 1;

331

332 for (pos = block_mask;;) {

333 bits_left = gb->size_in_bits - re_index;

334 if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left)))

335 break;

336

337 DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)]);

338 pos += run + 1;

339 if (pos >= max_coeffs) {

340 av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs);

341 return AVERROR_INVALIDDATA;

342 }

343

344 DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)]);

345 level += 1;

346

347 i = pos >> log2_block_count;

348

349 sign = SHOW_SBITS(re, gb, 1);

350 SKIP_BITS(re, gb, 1);

351 out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign);

352 }

353

354 CLOSE_READER(re, gb);

355 return 0;

356 }

357

358 static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice,

359 uint16_t *dst, int dst_stride,

360 const uint8_t *buf, unsigned buf_size,

361 const int16_t *qmat)

362 {

363 ProresContext *ctx = avctx->priv_data;

364 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);

365 int16_t *block;

366 GetBitContext gb;

367 int i, blocks_per_slice = slice->mb_count<<2;

368 int ret;

369

370 for (i = 0; i < blocks_per_slice; i++)

371 ctx->bdsp.clear_block(blocks+(i<<6));

372

373 init_get_bits(&gb, buf, buf_size << 3);

374

375 decode_dc_coeffs(&gb, blocks, blocks_per_slice);

376 if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)

377 return ret;

378

379 block = blocks;

380 for (i = 0; i < slice->mb_count; i++) {

381 ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);

382 ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat);

383 ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat);

384 ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat);

385 block += 4*64;

386 dst += 16;

387 }

388 return 0;

389 }

390

391 static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,

392 uint16_t *dst, int dst_stride,

393 const uint8_t *buf, unsigned buf_size,

394 const int16_t *qmat, int log2_blocks_per_mb)

395 {

396 ProresContext *ctx = avctx->priv_data;

397 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);

398 int16_t *block;

399 GetBitContext gb;

400 int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;

401 int ret;

402

403 for (i = 0; i < blocks_per_slice; i++)

404 ctx->bdsp.clear_block(blocks+(i<<6));

405

406 init_get_bits(&gb, buf, buf_size << 3);

407

408 decode_dc_coeffs(&gb, blocks, blocks_per_slice);

409 if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)

410 return ret;

411

412 block = blocks;

413 for (i = 0; i < slice->mb_count; i++) {

414 for (j = 0; j < log2_blocks_per_mb; j++) {

415 ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);

416 ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);

417 block += 2*64;

418 dst += 8;

419 }

420 }

421 return 0;

422 }

423

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

425 const int num_bits)

426 {

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

428 int i, idx, val, alpha_val;

429

430 idx = 0;

431 alpha_val = mask;

432 do {

433 do {

434 if (get_bits1(gb)) {

435 val = get_bits(gb, num_bits);

436 } else {

437 int sign;

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

439 sign = val & 1;

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

441 if (sign)

442 val = -val;

443 }

444 alpha_val = (alpha_val + val) & mask;

445 if (num_bits == 16) {

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

447 } else {

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

449 }

450 if (idx >= num_coeffs)

451 break;

452 } while (get_bits_left(gb)>0 && get_bits1(gb));

453 val = get_bits(gb, 4);

454 if (!val)

455 val = get_bits(gb, 11);

456 if (idx + val > num_coeffs)

457 val = num_coeffs - idx;

458 if (num_bits == 16) {

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

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

461 } else {

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

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

464

465 }

466 } while (idx < num_coeffs);

467 }

468

469 /**

470 * Decode alpha slice plane.

471 */

472 static void decode_slice_alpha(ProresContext *ctx,

473 uint16_t *dst, int dst_stride,

474 const uint8_t *buf, int buf_size,

475 int blocks_per_slice)

476 {

477 GetBitContext gb;

478 int i;

479 LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);

480 int16_t *block;

481

482 for (i = 0; i < blocks_per_slice<<2; i++)

483 ctx->bdsp.clear_block(blocks+(i<<6));

484

485 init_get_bits(&gb, buf, buf_size << 3);

486

487 if (ctx->alpha_info == 2) {

488 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);

489 } else {

490 unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);

491 }

492

493 block = blocks;

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

495 memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst));

496 dst += dst_stride >> 1;

497 block += 16 * blocks_per_slice;

498 }

499 }

500

501 static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)

502 {

503 ProresContext *ctx = avctx->priv_data;

504 SliceContext *slice = &ctx->slices[jobnr];

505 const uint8_t *buf = slice->data;

506 AVFrame *pic = ctx->frame;

507 int i, hdr_size, qscale, log2_chroma_blocks_per_mb;

508 int luma_stride, chroma_stride;

509 int y_data_size, u_data_size, v_data_size, a_data_size;

510 uint8_t *dest_y, *dest_u, *dest_v, *dest_a;

511 int16_t qmat_luma_scaled[64];

512 int16_t qmat_chroma_scaled[64];

513 int mb_x_shift;

514 int ret;

515

516 slice->ret = -1;

517 //av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n",

518 // jobnr, slice->mb_count, slice->mb_x, slice->mb_y);

519

520 // slice header

521 hdr_size = buf[0] >> 3;

522 qscale = av_clip(buf[1], 1, 224);

523 qscale = qscale > 128 ? qscale - 96 << 2: qscale;

524 y_data_size = AV_RB16(buf + 2);

525 u_data_size = AV_RB16(buf + 4);

526 v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size;

527 if (hdr_size > 7) v_data_size = AV_RB16(buf + 6);

528 a_data_size = slice->data_size - y_data_size - u_data_size -

529 v_data_size - hdr_size;

530

531 if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0

532 || hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){

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

534 return AVERROR_INVALIDDATA;

535 }

536

537 buf += hdr_size;

538

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

540 qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale;

541 qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale;

542 }

543

544 if (ctx->frame_type == 0) {

545 luma_stride = pic->linesize[0];

546 chroma_stride = pic->linesize[1];

547 } else {

548 luma_stride = pic->linesize[0] << 1;

549 chroma_stride = pic->linesize[1] << 1;

550 }

551

552 if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10) {

553 mb_x_shift = 5;

554 log2_chroma_blocks_per_mb = 2;

555 } else {

556 mb_x_shift = 4;

557 log2_chroma_blocks_per_mb = 1;

558 }

559

560 dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);

561 dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);

562 dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift);

563 dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);

564

565 if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) {

566 dest_y += pic->linesize[0];

567 dest_u += pic->linesize[1];

568 dest_v += pic->linesize[2];

569 dest_a += pic->linesize[3];

570 }

571

572 ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride,

573 buf, y_data_size, qmat_luma_scaled);

574 if (ret < 0)

575 return ret;

576

577 if (!(avctx->flags & CODEC_FLAG_GRAY)) {

578 ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride,

579 buf + y_data_size, u_data_size,

580 qmat_chroma_scaled, log2_chroma_blocks_per_mb);

581 if (ret < 0)

582 return ret;

583

584 ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride,

585 buf + y_data_size + u_data_size, v_data_size,

586 qmat_chroma_scaled, log2_chroma_blocks_per_mb);

587 if (ret < 0)

588 return ret;

589 }

590 /* decode alpha plane if available */

591 if (ctx->alpha_info && pic->data[3] && a_data_size)

592 decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride,

593 buf + y_data_size + u_data_size + v_data_size,

594 a_data_size, slice->mb_count);

595

596 slice->ret = 0;

597 return 0;

598 }

599

600 static int decode_picture(AVCodecContext *avctx)

601 {

602 ProresContext *ctx = avctx->priv_data;

603 int i;

604

605 avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count);

606

607 for (i = 0; i < ctx->slice_count; i++)

608 if (ctx->slices[i].ret < 0)

609 return ctx->slices[i].ret;

610

611 return 0;

612 }

613

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

615 AVPacket *avpkt)

616 {

617 ProresContext *ctx = avctx->priv_data;

618 AVFrame *frame = data;

619 const uint8_t *buf = avpkt->data;

620 int buf_size = avpkt->size;

621 int frame_hdr_size, pic_size, ret;

622

623 if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) {

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

625 return AVERROR_INVALIDDATA;

626 }

627

628 ctx->frame = frame;

629 ctx->frame->pict_type = AV_PICTURE_TYPE_I;

630 ctx->frame->key_frame = 1;

631 ctx->first_field = 1;

632

633 buf += 8;

634 buf_size -= 8;

635

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

637 if (frame_hdr_size < 0)

638 return frame_hdr_size;

639

640 buf += frame_hdr_size;

641 buf_size -= frame_hdr_size;

642

643 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

644 return ret;

645

646 decode_picture:

647 pic_size = decode_picture_header(avctx, buf, buf_size);

648 if (pic_size < 0) {

649 av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n");

650 return pic_size;

651 }

652

653 if ((ret = decode_picture(avctx)) < 0) {

654 av_log(avctx, AV_LOG_ERROR, "error decoding picture\n");

655 return ret;

656 }

657

658 buf += pic_size;

659 buf_size -= pic_size;

660

661 if (ctx->frame_type && buf_size > 0 && ctx->first_field) {

662 ctx->first_field = 0;

663 goto decode_picture;

664 }

665

666 *got_frame = 1;

667

668 return avpkt->size;

669 }

670

671 static av_cold int decode_close(AVCodecContext *avctx)

672 {

673 ProresContext *ctx = avctx->priv_data;

674

675 av_freep(&ctx->slices);

676

677 return 0;

678 }

679

680 AVCodec ff_prores_decoder = {

681 .name = "prores",

682 .long_name = NULL_IF_CONFIG_SMALL("ProRes"),

683 .type = AVMEDIA_TYPE_VIDEO,

684 .id = AV_CODEC_ID_PRORES,

685 .priv_data_size = sizeof(ProresContext),

686 .init = decode_init,

687 .close = decode_close,

688 .decode = decode_frame,

689 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,

690 };

Generated on Sun Jul 20 2014 23:05:53 for FFmpeg by doxygen 1.8.2