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), 'apco' (Proxy), 'ap4h' (4444), 'ap4x' (4444 XQ)

25 */

27 //#define DEBUG

29 #define LONG_BITSTREAM_READER

31 #include "config_components.h"

33 #include "libavutil/internal.h"

34 #include "libavutil/mem_internal.h"

36 #include "avcodec.h"

37 #include "codec_internal.h"

38 #include "decode.h"

39 #include "get_bits.h"

40 #include "hwconfig.h"

41 #include "idctdsp.h"

42 #include "profiles.h"

43 #include "proresdec.h"

44 #include "proresdata.h"

45 #include "thread.h"

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

48 {

49 int i;

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

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

52 }

54 #define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6)

55 #define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6))

56 #define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4)

57 #define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4))

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

60 const int num_bits, const int decode_precision) {

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

62 int i, idx, val, alpha_val;

64 idx = 0;

65 alpha_val = mask;

66 do {

67 do {

68 if (get_bits1(gb)) {

69 val = get_bits(gb, num_bits);

70 } else {

71 int sign;

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

73 sign = val & 1;

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

75 if (sign)

76 val = -val;

77 }

78 alpha_val = (alpha_val + val) & mask;

79 if (num_bits == 16) {

80 if (decode_precision == 10) {

81 dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);

82 } else { /* 12b */

83 dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);

84 }

85 } else {

86 if (decode_precision == 10) {

87 dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);

88 } else { /* 12b */

89 dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);

90 }

91 }

92 if (idx >= num_coeffs)

93 break;

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

95 val = get_bits(gb, 4);

96 if (!val)

97 val = get_bits(gb, 11);

98 if (idx + val > num_coeffs)

99 val = num_coeffs - idx;

100 if (num_bits == 16) {

101 for (i = 0; i < val; i++) {

102 if (decode_precision == 10) {

103 dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val);

104 } else { /* 12b */

105 dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val);

106 }

107 }

108 } else {

109 for (i = 0; i < val; i++) {

110 if (decode_precision == 10) {

111 dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val);

112 } else { /* 12b */

113 dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val);

114 }

115 }

116 }

117 } while (idx < num_coeffs);

118 }

119

120 static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs,

121 const int num_bits)

122 {

123 if (num_bits == 16) {

124 unpack_alpha(gb, dst, num_coeffs, 16, 10);

125 } else { /* 8 bits alpha */

126 unpack_alpha(gb, dst, num_coeffs, 8, 10);

127 }

128 }

129

130 static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs,

131 const int num_bits)

132 {

133 if (num_bits == 16) {

134 unpack_alpha(gb, dst, num_coeffs, 16, 12);

135 } else { /* 8 bits alpha */

136 unpack_alpha(gb, dst, num_coeffs, 8, 12);

137 }

138 }

139

140 static av_cold int decode_init(AVCodecContext *avctx)

141 {

142 int ret = 0;

143 ProresContext *ctx = avctx->priv_data;

144 uint8_t idct_permutation[64];

145

146 avctx->bits_per_raw_sample = 10;

147

148 switch (avctx->codec_tag) {

149 case MKTAG('a','p','c','o'):

150 avctx->profile = FF_PROFILE_PRORES_PROXY;

151 break;

152 case MKTAG('a','p','c','s'):

153 avctx->profile = FF_PROFILE_PRORES_LT;

154 break;

155 case MKTAG('a','p','c','n'):

156 avctx->profile = FF_PROFILE_PRORES_STANDARD;

157 break;

158 case MKTAG('a','p','c','h'):

159 avctx->profile = FF_PROFILE_PRORES_HQ;

160 break;

161 case MKTAG('a','p','4','h'):

162 avctx->profile = FF_PROFILE_PRORES_4444;

163 avctx->bits_per_raw_sample = 12;

164 break;

165 case MKTAG('a','p','4','x'):

166 avctx->profile = FF_PROFILE_PRORES_XQ;

167 avctx->bits_per_raw_sample = 12;

168 break;

169 default:

170 avctx->profile = FF_PROFILE_UNKNOWN;

171 av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag);

172 }

173

174 if (avctx->bits_per_raw_sample == 10) {

175 av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 10b decoding based on codec tag.\n");

176 } else { /* 12b */

177 av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 12b decoding based on codec tag.\n");

178 }

179

180 ff_blockdsp_init(&ctx->bdsp);

181 ret = ff_proresdsp_init(&ctx->prodsp, avctx);

182 if (ret < 0) {

183 av_log(avctx, AV_LOG_ERROR, "Fail to init proresdsp for bits per raw sample %d\n", avctx->bits_per_raw_sample);

184 return ret;

185 }

186

187 ff_init_scantable_permutation(idct_permutation,

188 ctx->prodsp.idct_permutation_type);

189

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

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

192

193 ctx->pix_fmt = AV_PIX_FMT_NONE;

194

195 if (avctx->bits_per_raw_sample == 10){

196 ctx->unpack_alpha = unpack_alpha_10;

197 } else if (avctx->bits_per_raw_sample == 12){

198 ctx->unpack_alpha = unpack_alpha_12;

199 } else {

200 av_log(avctx, AV_LOG_ERROR, "Fail to set unpack_alpha for bits per raw sample %d\n", avctx->bits_per_raw_sample);

201 return AVERROR_BUG;

202 }

203 return ret;

204 }

205

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

207 const int data_size, AVCodecContext *avctx)

208 {

209 int hdr_size, width, height, flags;

210 int version;

211 const uint8_t *ptr;

212 enum AVPixelFormat pix_fmt;

213

214 hdr_size = AV_RB16(buf);

215 ff_dlog(avctx, "header size %d\n", hdr_size);

216 if (hdr_size > data_size) {

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

218 return AVERROR_INVALIDDATA;

219 }

220

221 version = AV_RB16(buf + 2);

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

223 if (version > 1) {

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

225 return AVERROR_PATCHWELCOME;

226 }

227

228 width = AV_RB16(buf + 8);

229 height = AV_RB16(buf + 10);

230

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

232 int ret;

233

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

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

236 if ((ret = ff_set_dimensions(avctx, width, height)) < 0)

237 return ret;

238 }

239

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

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

242

243 if (ctx->alpha_info > 2) {

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

245 return AVERROR_INVALIDDATA;

246 }

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

248

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

250

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

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

253 } else {

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

255 ctx->frame->interlaced_frame = 1;

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

257 }

258

259 if (ctx->alpha_info) {

260 if (avctx->bits_per_raw_sample == 10) {

261 pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10;

262 } else { /* 12b */

263 pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12;

264 }

265 } else {

266 if (avctx->bits_per_raw_sample == 10) {

267 pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10;

268 } else { /* 12b */

269 pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12;

270 }

271 }

272

273 if (pix_fmt != ctx->pix_fmt) {

274 #define HWACCEL_MAX (CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL)

275 enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmtp = pix_fmts;

276 int ret;

277

278 ctx->pix_fmt = pix_fmt;

279

280 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL

281 *fmtp++ = AV_PIX_FMT_VIDEOTOOLBOX;

282 #endif

283 *fmtp++ = ctx->pix_fmt;

284 *fmtp = AV_PIX_FMT_NONE;

285

286 if ((ret = ff_thread_get_format(avctx, pix_fmts)) < 0)

287 return ret;

288

289 avctx->pix_fmt = ret;

290 }

291

292 ctx->frame->color_primaries = buf[14];

293 ctx->frame->color_trc = buf[15];

294 ctx->frame->colorspace = buf[16];

295 ctx->frame->color_range = AVCOL_RANGE_MPEG;

296

297 ptr = buf + 20;

298 flags = buf[19];

299 ff_dlog(avctx, "flags %x\n", flags);

300

301 if (flags & 2) {

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

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

304 return AVERROR_INVALIDDATA;

305 }

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

307 ptr += 64;

308 } else {

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

310 }

311

312 if (flags & 1) {

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

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

315 return AVERROR_INVALIDDATA;

316 }

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

318 } else {

319 memcpy(ctx->qmat_chroma, ctx->qmat_luma, 64);

320 }

321

322 return hdr_size;

323 }

324

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

326 {

327 ProresContext *ctx = avctx->priv_data;

328 int i, hdr_size, slice_count;

329 unsigned pic_data_size;

330 int log2_slice_mb_width, log2_slice_mb_height;

331 int slice_mb_count, mb_x, mb_y;

332 const uint8_t *data_ptr, *index_ptr;

333

334 hdr_size = buf[0] >> 3;

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

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

337 return AVERROR_INVALIDDATA;

338 }

339

340 pic_data_size = AV_RB32(buf + 1);

341 if (pic_data_size > buf_size) {

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

343 return AVERROR_INVALIDDATA;

344 }

345

346 log2_slice_mb_width = buf[7] >> 4;

347 log2_slice_mb_height = buf[7] & 0xF;

348 if (log2_slice_mb_width > 3 || log2_slice_mb_height) {

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

350 1 << log2_slice_mb_width, 1 << log2_slice_mb_height);

351 return AVERROR_INVALIDDATA;

352 }

353

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

355 if (ctx->frame_type)

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

357 else

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

359

360 // QT ignores the written value

361 // slice_count = AV_RB16(buf + 5);

362 slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) +

363 av_popcount(ctx->mb_width & (1 << log2_slice_mb_width) - 1));

364

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

366 av_freep(&ctx->slices);

367 ctx->slice_count = 0;

368 ctx->slices = av_calloc(slice_count, sizeof(*ctx->slices));

369 if (!ctx->slices)

370 return AVERROR(ENOMEM);

371 ctx->slice_count = slice_count;

372 }

373

374 if (!slice_count)

375 return AVERROR(EINVAL);

376

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

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

379 return AVERROR_INVALIDDATA;

380 }

381

382 // parse slice information

383 index_ptr = buf + hdr_size;

384 data_ptr = index_ptr + slice_count*2;

385

386 slice_mb_count = 1 << log2_slice_mb_width;

387 mb_x = 0;

388 mb_y = 0;

389

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

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

392

393 slice->data = data_ptr;

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

395

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

397 slice_mb_count >>= 1;

398

399 slice->mb_x = mb_x;

400 slice->mb_y = mb_y;

401 slice->mb_count = slice_mb_count;

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

403

404 if (slice->data_size < 6) {

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

406 return AVERROR_INVALIDDATA;

407 }

408

409 mb_x += slice_mb_count;

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

411 slice_mb_count = 1 << log2_slice_mb_width;

412 mb_x = 0;

413 mb_y++;

414 }

415 if (data_ptr > buf + buf_size) {

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

417 return AVERROR_INVALIDDATA;

418 }

419 }

420

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

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

423 mb_y, ctx->mb_height);

424 return AVERROR_INVALIDDATA;

425 }

426

427 return pic_data_size;

428 }

429

430 #define DECODE_CODEWORD(val, codebook, SKIP) \

431 do { \

432 unsigned int rice_order, exp_order, switch_bits; \

433 unsigned int q, buf, bits; \

434 \

435 UPDATE_CACHE(re, gb); \

436 buf = GET_CACHE(re, gb); \

437 \

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

439 switch_bits = codebook & 3; \

440 rice_order = codebook >> 5; \

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

442 \

443 q = 31 - av_log2(buf); \

444 \

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

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

447 if (bits > FFMIN(MIN_CACHE_BITS, 31)) \

448 return AVERROR_INVALIDDATA; \

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

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

451 SKIP(re, gb, bits); \

452 } else if (rice_order) { \

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

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

455 SKIP(re, gb, rice_order); \

456 } else { \

457 val = q; \

458 SKIP(re, gb, q+1); \

459 } \

460 } while (0)

461

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

463

464 #define FIRST_DC_CB 0xB8

465

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

467

468 static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out,

469 int blocks_per_slice)

470 {

471 int16_t prev_dc;

472 int code, i, sign;

473

474 OPEN_READER(re, gb);

475

476 DECODE_CODEWORD(code, FIRST_DC_CB, LAST_SKIP_BITS);

477 prev_dc = TOSIGNED(code);

478 out[0] = prev_dc;

479

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

481

482 code = 5;

483 sign = 0;

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

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

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

487 else sign = 0;

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

489 out[0] = prev_dc;

490 }

491 CLOSE_READER(re, gb);

492 return 0;

493 }

494

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

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

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

498

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

500 int16_t *out, int blocks_per_slice)

501 {

502 const ProresContext *ctx = avctx->priv_data;

503 int block_mask, sign;

504 unsigned pos, run, level;

505 int max_coeffs, i, bits_left;

506 int log2_block_count = av_log2(blocks_per_slice);

507

508 OPEN_READER(re, gb);

509 UPDATE_CACHE(re, gb); \

510 run = 4;

511 level = 2;

512

513 max_coeffs = 64 << log2_block_count;

514 block_mask = blocks_per_slice - 1;

515

516 for (pos = block_mask;;) {

517 bits_left = gb->size_in_bits - re_index;

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

519 break;

520

521 DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)], LAST_SKIP_BITS);

522 pos += run + 1;

523 if (pos >= max_coeffs) {

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

525 return AVERROR_INVALIDDATA;

526 }

527

528 DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)], SKIP_BITS);

529 level += 1;

530

531 i = pos >> log2_block_count;

532

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

534 SKIP_BITS(re, gb, 1);

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

536 }

537

538 CLOSE_READER(re, gb);

539 return 0;

540 }

541

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

543 uint16_t *dst, int dst_stride,

544 const uint8_t *buf, unsigned buf_size,

545 const int16_t *qmat)

546 {

547 const ProresContext *ctx = avctx->priv_data;

548 LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);

549 int16_t *block;

550 GetBitContext gb;

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

552 int ret;

553

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

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

556

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

558

559 if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)

560 return ret;

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

562 return ret;

563

564 block = blocks;

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

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

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

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

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

570 block += 4*64;

571 dst += 16;

572 }

573 return 0;

574 }

575

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

577 uint16_t *dst, int dst_stride,

578 const uint8_t *buf, unsigned buf_size,

579 const int16_t *qmat, int log2_blocks_per_mb)

580 {

581 ProresContext *ctx = avctx->priv_data;

582 LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);

583 int16_t *block;

584 GetBitContext gb;

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

586 int ret;

587

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

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

590

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

592

593 if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0)

594 return ret;

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

596 return ret;

597

598 block = blocks;

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

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

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

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

603 block += 2*64;

604 dst += 8;

605 }

606 }

607 return 0;

608 }

609

610 /**

611 * Decode alpha slice plane.

612 */

613 static void decode_slice_alpha(const ProresContext *ctx,

614 uint16_t *dst, int dst_stride,

615 const uint8_t *buf, int buf_size,

616 int blocks_per_slice)

617 {

618 GetBitContext gb;

619 int i;

620 LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]);

621 int16_t *block;

622

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

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

625

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

627

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

629 ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16);

630 } else {

631 ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8);

632 }

633

634 block = blocks;

635

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

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

638 dst += dst_stride >> 1;

639 block += 16 * blocks_per_slice;

640 }

641 }

642

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

644 {

645 const ProresContext *ctx = avctx->priv_data;

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

647 const uint8_t *buf = slice->data;

648 AVFrame *pic = ctx->frame;

649 int i, hdr_size, qscale, log2_chroma_blocks_per_mb;

650 int luma_stride, chroma_stride;

651 int y_data_size, u_data_size, v_data_size, a_data_size, offset;

652 uint8_t *dest_y, *dest_u, *dest_v;

653 LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]);

654 LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]);

655 int mb_x_shift;

656 int ret;

657 uint16_t val_no_chroma;

658

659 slice->ret = -1;

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

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

662

663 // slice header

664 hdr_size = buf[0] >> 3;

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

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

667 y_data_size = AV_RB16(buf + 2);

668 u_data_size = AV_RB16(buf + 4);

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

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

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

672 v_data_size - hdr_size;

673

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

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

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

677 return AVERROR_INVALIDDATA;

678 }

679

680 buf += hdr_size;

681

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

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

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

685 }

686

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

688 luma_stride = pic->linesize[0];

689 chroma_stride = pic->linesize[1];

690 } else {

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

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

693 }

694

695 if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 ||

696 avctx->pix_fmt == AV_PIX_FMT_YUV444P12 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P12) {

697 mb_x_shift = 5;

698 log2_chroma_blocks_per_mb = 2;

699 } else {

700 mb_x_shift = 4;

701 log2_chroma_blocks_per_mb = 1;

702 }

703

704 offset = (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5);

705 dest_y = pic->data[0] + offset;

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

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

708

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

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

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

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

713 offset += pic->linesize[3];

714 }

715

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

717 buf, y_data_size, qmat_luma_scaled);

718 if (ret < 0)

719 return ret;

720

721 if (!(avctx->flags & AV_CODEC_FLAG_GRAY) && (u_data_size + v_data_size) > 0) {

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

723 buf + y_data_size, u_data_size,

724 qmat_chroma_scaled, log2_chroma_blocks_per_mb);

725 if (ret < 0)

726 return ret;

727

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

729 buf + y_data_size + u_data_size, v_data_size,

730 qmat_chroma_scaled, log2_chroma_blocks_per_mb);

731 if (ret < 0)

732 return ret;

733 }

734 else {

735 size_t mb_max_x = slice->mb_count << (mb_x_shift - 1);

736 size_t i, j;

737 if (avctx->bits_per_raw_sample == 10) {

738 val_no_chroma = 511;

739 } else { /* 12b */

740 val_no_chroma = 511 * 4;

741 }

742 for (i = 0; i < 16; ++i)

743 for (j = 0; j < mb_max_x; ++j) {

744 *(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = val_no_chroma;

745 *(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = val_no_chroma;

746 }

747 }

748

749 /* decode alpha plane if available */

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

751 uint8_t *dest_a = pic->data[3] + offset;

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

753 buf + y_data_size + u_data_size + v_data_size,

754 a_data_size, slice->mb_count);

755 }

756

757 slice->ret = 0;

758 return 0;

759 }

760

761 static int decode_picture(AVCodecContext *avctx)

762 {

763 ProresContext *ctx = avctx->priv_data;

764 int i;

765 int error = 0;

766

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

768

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

770 error += ctx->slices[i].ret < 0;

771

772 if (error)

773 ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;

774 if (error < ctx->slice_count)

775 return 0;

776

777 return ctx->slices[0].ret;

778 }

779

780 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,

781 int *got_frame, AVPacket *avpkt)

782 {

783 ProresContext *ctx = avctx->priv_data;

784 const uint8_t *buf = avpkt->data;

785 int buf_size = avpkt->size;

786 int frame_hdr_size, pic_size, ret;

787

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

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

790 return AVERROR_INVALIDDATA;

791 }

792

793 ctx->frame = frame;

794 ctx->frame->pict_type = AV_PICTURE_TYPE_I;

795 ctx->frame->key_frame = 1;

796 ctx->first_field = 1;

797

798 buf += 8;

799 buf_size -= 8;

800

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

802 if (frame_hdr_size < 0)

803 return frame_hdr_size;

804

805 buf += frame_hdr_size;

806 buf_size -= frame_hdr_size;

807

808 if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)

809 return ret;

810 ff_thread_finish_setup(avctx);

811

812 if (avctx->hwaccel) {

813 ret = avctx->hwaccel->start_frame(avctx, NULL, 0);

814 if (ret < 0)

815 return ret;

816 ret = avctx->hwaccel->decode_slice(avctx, avpkt->data, avpkt->size);

817 if (ret < 0)

818 return ret;

819 ret = avctx->hwaccel->end_frame(avctx);

820 if (ret < 0)

821 return ret;

822 goto finish;

823 }

824

825 decode_picture:

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

827 if (pic_size < 0) {

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

829 return pic_size;

830 }

831

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

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

834 return ret;

835 }

836

837 buf += pic_size;

838 buf_size -= pic_size;

839

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

841 ctx->first_field = 0;

842 goto decode_picture;

843 }

844

845 finish:

846 *got_frame = 1;

847

848 return avpkt->size;

849 }

850

851 static av_cold int decode_close(AVCodecContext *avctx)

852 {

853 ProresContext *ctx = avctx->priv_data;

854

855 av_freep(&ctx->slices);

856

857 return 0;

858 }

859

860 #if HAVE_THREADS

861 static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

862 {

863 ProresContext *csrc = src->priv_data;

864 ProresContext *cdst = dst->priv_data;

865

866 cdst->pix_fmt = csrc->pix_fmt;

867

868 return 0;

869 }

870 #endif

871

872 const FFCodec ff_prores_decoder = {

873 .p.name = "prores",

874 CODEC_LONG_NAME("Apple ProRes (iCodec Pro)"),

875 .p.type = AVMEDIA_TYPE_VIDEO,

876 .p.id = AV_CODEC_ID_PRORES,

877 .priv_data_size = sizeof(ProresContext),

878 .init = decode_init,

879 .close = decode_close,

880 FF_CODEC_DECODE_CB(decode_frame),

881 UPDATE_THREAD_CONTEXT(update_thread_context),

882 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,

883 .p.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles),

884 .hw_configs = (const AVCodecHWConfigInternal *const []) {

885 #if CONFIG_PRORES_VIDEOTOOLBOX_HWACCEL

886 HWACCEL_VIDEOTOOLBOX(prores),

887 #endif

888 NULL

889 },

890 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:31

hwconfig.h

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:1405

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

DECODE_CODEWORD

#define DECODE_CODEWORD(val, codebook, SKIP)

Definition: proresdec2.c:430

AVPixelFormat

Pixel format.

Definition: pixfmt.h:64

FF_PROFILE_PRORES_XQ

#define FF_PROFILE_PRORES_XQ

Definition: avcodec.h:1678

level

uint8_t level

Definition: svq3.c:204

av_clip

#define av_clip

Definition: common.h:95

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:664

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

mem_internal.h

out

FILE * out

Definition: movenc.c:54

ff_thread_get_format

#define ff_thread_get_format

Definition: thread.h:65

ff_prores_profiles

const AVProfile ff_prores_profiles[]

Definition: profiles.c:159

ff_proresdsp_init

av_cold int ff_proresdsp_init(ProresDSPContext *dsp, AVCodecContext *avctx)

Definition: proresdsp.c:79

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:110

AVFrame

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

Definition: frame.h:330

AVPacket::data

uint8_t * data

Definition: packet.h:374

ProresContext

Definition: proresdec.h:38

TOSIGNED

#define TOSIGNED(x)

Definition: proresdec2.c:462

SliceContext::mb_x

unsigned mb_x

Definition: proresdec.h:31

FFCodec

Definition: codec_internal.h:127

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:216

av_popcount

#define av_popcount

Definition: common.h:149

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

AV_PIX_FMT_YUVA422P10

#define AV_PIX_FMT_YUVA422P10

Definition: pixfmt.h:497

ff_prores_progressive_scan

const uint8_t ff_prores_progressive_scan[64]

Definition: proresdata.c:25

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:493

thread.h

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:351

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:325

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

finish

static void finish(void)

Definition: movenc.c:342

ProresContext::pix_fmt

enum AVPixelFormat pix_fmt

Definition: proresdec.h:55

GetBitContext

Definition: get_bits.h:107

ff_thread_get_buffer

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

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:506

proresdec.h

val

static double val(void *priv, double ch)

Definition: aeval.c:77

FF_PROFILE_PRORES_LT

#define FF_PROFILE_PRORES_LT

Definition: avcodec.h:1674

ALPHA_SHIFT_8_TO_10

#define ALPHA_SHIFT_8_TO_10(alpha_val)

Definition: proresdec2.c:55

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:462

unpack_alpha

static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits, const int decode_precision)

Definition: proresdec2.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

ff_prores_decoder

const FFCodec ff_prores_decoder

Definition: proresdec2.c:872

FIRST_DC_CB

#define FIRST_DC_CB

Definition: proresdec2.c:464

mask

static const uint16_t mask[17]

Definition: lzw.c:38

CLOSE_READER

#define CLOSE_READER(name, gb)

Definition: get_bits.h:187

decode_picture_header

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

Definition: proresdec2.c:325

width

#define width

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:306

ff_blockdsp_init

av_cold void ff_blockdsp_init(BlockDSPContext *c)

Definition: blockdsp.c:58

SliceContext::data_size

unsigned data_size

Definition: proresdec.h:34

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

decode_picture

static int decode_picture(AVCodecContext *avctx)

Definition: proresdec2.c:761

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:250

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts_bsf.c:365

permute

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

Definition: proresdec2.c:47

LOCAL_ALIGNED_16

#define LOCAL_ALIGNED_16(t, v,...)

Definition: mem_internal.h:129

FF_PROFILE_UNKNOWN

#define FF_PROFILE_UNKNOWN

Definition: avcodec.h:1566

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:296

AV_PIX_FMT_YUVA444P12

#define AV_PIX_FMT_YUVA444P12

Definition: pixfmt.h:500

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:1487

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

ctx

AVFormatContext * ctx

Definition: movenc.c:48

decode.h

get_bits.h

SKIP_BITS

#define SKIP_BITS(name, gb, num)

Definition: get_bits.h:231

ff_prores_interlaced_scan

const uint8_t ff_prores_interlaced_scan[64]

Definition: proresdata.c:36

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:272

arg

const char * arg

Definition: jacosubdec.c:67

if(ret)

Definition: filter_design.txt:179

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:107

NULL

#define NULL

Definition: coverity.c:32

FF_DECODE_ERROR_INVALID_BITSTREAM

#define FF_DECODE_ERROR_INVALID_BITSTREAM

Definition: frame.h:649

bits_left

#define bits_left

Definition: bitstream.h:113

LOCAL_ALIGNED_32

#define LOCAL_ALIGNED_32(t, v,...)

Definition: mem_internal.h:135

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

run

uint8_t run

Definition: svq3.c:203

decode_ac_coeffs

static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, int16_t *out, int blocks_per_slice)

Definition: proresdec2.c:499

SliceContext::ret

int ret

Definition: proresdec.h:35

AVHWAccel::end_frame

int(* end_frame)(AVCodecContext *avctx)

Called at the end of each frame or field picture.

Definition: avcodec.h:2176

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:378

run_to_cb

static const uint8_t run_to_cb[16]

Definition: proresdec2.c:496

profiles.h

SliceContext::mb_y

unsigned mb_y

Definition: proresdec.h:32

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:237

UPDATE_THREAD_CONTEXT

#define UPDATE_THREAD_CONTEXT(func)

Definition: codec_internal.h:281

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:460

decode_slice_chroma

static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat, int log2_blocks_per_mb)

Definition: proresdec2.c:576

SliceContext

Definition: mss12.h:70

decode_slice_luma

static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, uint16_t *dst, int dst_stride, const uint8_t *buf, unsigned buf_size, const int16_t *qmat)

Definition: proresdec2.c:542

dc_codebook

static const uint8_t dc_codebook[7]

Definition: proresdec2.c:466

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: codec.h:52

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:301

AVPacket::size

int size

Definition: packet.h:375

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

FF_PROFILE_PRORES_HQ

#define FF_PROFILE_PRORES_HQ

Definition: avcodec.h:1676

codec_internal.h

FF_PROFILE_PRORES_STANDARD

#define FF_PROFILE_PRORES_STANDARD

Definition: avcodec.h:1675

AV_PIX_FMT_YUV422P12

#define AV_PIX_FMT_YUV422P12

Definition: pixfmt.h:464

SliceContext::mb_count

unsigned mb_count

Definition: proresdec.h:33

ALPHA_SHIFT_16_TO_12

#define ALPHA_SHIFT_16_TO_12(alpha_val)

Definition: proresdec2.c:56

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:96

AV_PIX_FMT_YUV444P12

#define AV_PIX_FMT_YUV444P12

Definition: pixfmt.h:466

proresdata.h

ALPHA_SHIFT_8_TO_12

#define ALPHA_SHIFT_8_TO_12(alpha_val)

Definition: proresdec2.c:57

AVCodecContext::skip_alpha

int skip_alpha

Skip processing alpha if supported by codec.

Definition: avcodec.h:1814

decode_close

static av_cold int decode_close(AVCodecContext *avctx)

Definition: proresdec2.c:851

AVCodecHWConfigInternal

Definition: hwconfig.h:29

decode_frame_header

static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, const int data_size, AVCodecContext *avctx)

Definition: proresdec2.c:206

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:176

height

#define height

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

Codec supports slice-based (or partition-based) multithreading.

Definition: codec.h:111

AV_PIX_FMT_YUVA444P10

#define AV_PIX_FMT_YUVA444P10

Definition: pixfmt.h:498

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

version

Definition: libkvazaar.c:313

AV_PIX_FMT_VIDEOTOOLBOX

@ AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:302

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

Definition: cbs_h2645.c:269

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

AVHWAccel::decode_slice

int(* decode_slice)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)

Callback for each slice.

Definition: avcodec.h:2165

internal.h

SliceContext::data

const uint8_t * data

Definition: proresdec.h:30

HWACCEL_MAX

#define HWACCEL_MAX

av_always_inline

#define av_always_inline

Definition: attributes.h:49

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: proresdec2.c:780

decode_slice_alpha

static void decode_slice_alpha(const ProresContext *ctx, uint16_t *dst, int dst_stride, const uint8_t *buf, int buf_size, int blocks_per_slice)

Decode alpha slice plane.

Definition: proresdec2.c:613

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

update_thread_context

AVCodecContext::height

int height

Definition: avcodec.h:598

lev_to_cb

static const uint8_t lev_to_cb[10]

Definition: proresdec2.c:497

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:644

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:262

HWACCEL_VIDEOTOOLBOX

#define HWACCEL_VIDEOTOOLBOX(codec)

Definition: hwconfig.h:77

idctdsp.h

avcodec.h

ret

Definition: filter_design.txt:187

frame

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

Definition: filter_design.txt:264

FF_PROFILE_PRORES_4444

#define FF_PROFILE_PRORES_4444

Definition: avcodec.h:1677

FF_PROFILE_PRORES_PROXY

#define FF_PROFILE_PRORES_PROXY

Definition: avcodec.h:1673

unpack_alpha_10

static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)

Definition: proresdec2.c:120

pos

unsigned int pos

Definition: spdifenc.c:413

ff_thread_finish_setup

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

#define U(x)

Definition: vpx_arith.h:37

AVCodecContext

main external API structure.

Definition: avcodec.h:426

ALPHA_SHIFT_16_TO_10

#define ALPHA_SHIFT_16_TO_10(alpha_val)

Definition: proresdec2.c:54

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:249

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:65

AV_PIX_FMT_YUVA422P12

#define AV_PIX_FMT_YUVA422P12

Definition: pixfmt.h:499

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1565

decode_dc_coeffs

static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, int blocks_per_slice)

Definition: proresdec2.c:468

AVHWAccel::start_frame

int(* start_frame)(AVCodecContext *avctx, const uint8_t *buf, uint32_t buf_size)

Called at the beginning of each frame or field picture.

Definition: avcodec.h:2138

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

decode_slice_thread

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

Definition: proresdec2.c:643

ff_init_scantable_permutation

av_cold void ff_init_scantable_permutation(uint8_t *idct_permutation, enum idct_permutation_type perm_type)

Definition: idctdsp.c:39

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: proresdec2.c:140

AVCodecContext::codec_tag

unsigned int codec_tag

fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').

Definition: avcodec.h:451

AVPacket

This structure stores compressed data.

Definition: packet.h:351

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:453

unpack_alpha_12

static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, const int num_bits)

Definition: proresdec2.c:130

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

src

INIT_CLIP pixel * src

Definition: h264pred_template.c:418

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:598

flags

#define flags(name, subs,...)

Definition: cbs_av1.c:561

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:52

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:375

block

The exact code depends on how similar the blocks are and how related they are to the block

Definition: filter_design.txt:207

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

MKTAG

#define MKTAG(a, b, c, d)

Definition: macros.h:55

AVCodecContext::execute2

int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)

The codec may call this to execute several independent things.

Definition: avcodec.h:1551

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AV_CODEC_ID_PRORES

@ AV_CODEC_ID_PRORES

Definition: codec_id.h:200

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

float re

Definition: fft.c:79

Generated on Tue Feb 28 2023 21:33:34 for FFmpeg by doxygen 1.8.17