FFmpeg: libavcodec/dnxhddec.c Source File

FFmpeg

[フレーム]

libavcodec

dnxhddec.c

Go to the documentation of this file.

1 /*

2 * VC3/DNxHD decoder.

6 *

7 * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>

8 * Slice multithreading and MB interlaced support added by Christophe Gisquet

9 *

10 * This file is part of FFmpeg.

11 *

12 * FFmpeg is free software; you can redistribute it and/or

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

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

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

16 *

17 * FFmpeg is distributed in the hope that it will be useful,

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

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

20 * Lesser General Public License for more details.

21 *

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

23 * License along with FFmpeg; if not, write to the Free Software

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

25 */

27 #include "libavutil/mem.h"

28 #include "libavutil/mem_internal.h"

29 #include "libavutil/pixdesc.h"

31 #include "avcodec.h"

32 #include "blockdsp.h"

33 #include "codec_internal.h"

34 #include "decode.h"

35 #define UNCHECKED_BITSTREAM_READER 1

36 #include "get_bits.h"

37 #include "dnxhddata.h"

38 #include "idctdsp.h"

39 #include "profiles.h"

40 #include "thread.h"

42 typedef struct RowContext {

43 DECLARE_ALIGNED(32, int16_t, blocks)[12][64];

44 int luma_scale[64];

45 int chroma_scale[64];

46 GetBitContext gb;

47 int last_dc[3];

48 int last_qscale;

49 int errors;

50 /** -1:not set yet 0:off=RGB 1:on=YUV 2:variable */

51 int format;

52 } RowContext;

54 typedef struct DNXHDContext {

55 AVCodecContext *avctx;

56 RowContext *rows;

57 BlockDSPContext bdsp;

58 const uint8_t* buf;

59 int buf_size;

60 int64_t cid; ///< compression id

61 unsigned int width, height;

62 enum AVPixelFormat pix_fmt;

63 unsigned int mb_width, mb_height;

64 uint32_t mb_scan_index[512];

65 int data_offset; // End of mb_scan_index, where macroblocks start

66 int cur_field; ///< current interlaced field

67 VLC ac_vlc, dc_vlc, run_vlc;

68 IDCTDSPContext idsp;

69 uint8_t permutated_scantable[64];

70 const CIDEntry *cid_table;

71 int bit_depth; // 8, 10, 12 or 0 if not initialized at all.

72 int is_444;

73 int alpha;

74 int lla;

75 int mbaff;

76 int act;

77 int (*decode_dct_block)(const struct DNXHDContext *ctx,

78 RowContext *row, int n);

79 } DNXHDContext;

81 #define DNXHD_VLC_BITS 9

82 #define DNXHD_DC_VLC_BITS 7

84 static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,

85 RowContext *row, int n);

86 static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx,

87 RowContext *row, int n);

88 static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx,

89 RowContext *row, int n);

90 static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx,

91 RowContext *row, int n);

92 static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx,

93 RowContext *row, int n);

95 static av_cold int dnxhd_decode_init(AVCodecContext *avctx)

96 {

97 DNXHDContext *ctx = avctx->priv_data;

99 ctx->avctx = avctx;

100 ctx->cid = -1;

101 if (avctx->colorspace == AVCOL_SPC_UNSPECIFIED) {

102 avctx->colorspace = AVCOL_SPC_BT709;

103 }

104

105 avctx->coded_width = FFALIGN(avctx->width, 16);

106 avctx->coded_height = FFALIGN(avctx->height, 16);

107

108 ctx->rows = av_calloc(avctx->thread_count, sizeof(*ctx->rows));

109 if (!ctx->rows)

110 return AVERROR(ENOMEM);

111

112 return 0;

113 }

114

115 static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)

116 {

117 int ret;

118 if (cid != ctx->cid) {

119 const CIDEntry *cid_table = ff_dnxhd_get_cid_table(cid);

120

121 if (!cid_table) {

122 av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %"PRIu32"\n", cid);

123 return AVERROR(ENOSYS);

124 }

125 if (cid_table->bit_depth != bitdepth &&

126 cid_table->bit_depth != DNXHD_VARIABLE) {

127 av_log(ctx->avctx, AV_LOG_ERROR, "bit depth mismatches %d %d\n",

128 cid_table->bit_depth, bitdepth);

129 return AVERROR_INVALIDDATA;

130 }

131 ctx->cid_table = cid_table;

132 av_log(ctx->avctx, AV_LOG_VERBOSE, "Profile cid %"PRIu32".\n", cid);

133

134 ff_vlc_free(&ctx->ac_vlc);

135 ff_vlc_free(&ctx->dc_vlc);

136 ff_vlc_free(&ctx->run_vlc);

137

138 if ((ret = vlc_init(&ctx->ac_vlc, DNXHD_VLC_BITS, 257,

139 ctx->cid_table->ac_bits, 1, 1,

140 ctx->cid_table->ac_codes, 2, 2, 0)) < 0)

141 goto out;

142 if ((ret = vlc_init(&ctx->dc_vlc, DNXHD_DC_VLC_BITS, bitdepth > 8 ? 14 : 12,

143 ctx->cid_table->dc_bits, 1, 1,

144 ctx->cid_table->dc_codes, 1, 1, 0)) < 0)

145 goto out;

146 if ((ret = ff_vlc_init_sparse(&ctx->run_vlc, DNXHD_VLC_BITS, 62,

147 ctx->cid_table->run_bits, 1, 1,

148 ctx->cid_table->run_codes, 2, 2,

149 ctx->cid_table->run, 1, 1, 0)) < 0)

150 goto out;

151

152 ctx->cid = cid;

153 }

154 ret = 0;

155 out:

156 if (ret < 0)

157 av_log(ctx->avctx, AV_LOG_ERROR, "vlc_init failed\n");

158 return ret;

159 }

160

161 static int dnxhd_get_profile(int cid)

162 {

163 switch(cid) {

164 case 1270:

165 return AV_PROFILE_DNXHR_444;

166 case 1271:

167 return AV_PROFILE_DNXHR_HQX;

168 case 1272:

169 return AV_PROFILE_DNXHR_HQ;

170 case 1273:

171 return AV_PROFILE_DNXHR_SQ;

172 case 1274:

173 return AV_PROFILE_DNXHR_LB;

174 }

175 return AV_PROFILE_DNXHD;

176 }

177

178 static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame,

179 const uint8_t *buf, int buf_size,

180 int first_field)

181 {

182 int i, cid, ret;

183 int old_bit_depth = ctx->bit_depth, bitdepth;

184 uint64_t header_prefix;

185 if (buf_size < 0x280) {

186 av_log(ctx->avctx, AV_LOG_ERROR,

187 "buffer too small (%d < 640).\n", buf_size);

188 return AVERROR_INVALIDDATA;

189 }

190

191 header_prefix = ff_dnxhd_parse_header_prefix(buf);

192 if (header_prefix == 0) {

193 av_log(ctx->avctx, AV_LOG_ERROR,

194 "unknown header 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n",

195 buf[0], buf[1], buf[2], buf[3], buf[4]);

196 return AVERROR_INVALIDDATA;

197 }

198 if (buf[5] & 2) { /* interlaced */

199 ctx->cur_field = first_field ? buf[5] & 1 : !ctx->cur_field;

200 frame->flags |= AV_FRAME_FLAG_INTERLACED;

201 if (first_field ^ ctx->cur_field)

202 frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST;

203 av_log(ctx->avctx, AV_LOG_DEBUG,

204 "interlaced %d, cur field %d\n", buf[5] & 3, ctx->cur_field);

205 } else {

206 ctx->cur_field = 0;

207 }

208 ctx->mbaff = (buf[0x6] >> 5) & 1;

209 ctx->alpha = buf[0x7] & 1;

210 ctx->lla = (buf[0x7] >> 1) & 1;

211 if (ctx->alpha)

212 avpriv_request_sample(ctx->avctx, "alpha");

213

214 ctx->height = AV_RB16(buf + 0x18);

215 ctx->width = AV_RB16(buf + 0x1a);

216

217 switch(buf[0x21] >> 5) {

218 case 1: bitdepth = 8; break;

219 case 2: bitdepth = 10; break;

220 case 3: bitdepth = 12; break;

221 default:

222 av_log(ctx->avctx, AV_LOG_ERROR,

223 "Unknown bitdepth indicator (%d)\n", buf[0x21] >> 5);

224 return AVERROR_INVALIDDATA;

225 }

226

227 cid = AV_RB32(buf + 0x28);

228

229 ctx->avctx->profile = dnxhd_get_profile(cid);

230

231 if ((ret = dnxhd_init_vlc(ctx, cid, bitdepth)) < 0)

232 return ret;

233 if (ctx->mbaff && ctx->cid_table->cid != 1260)

234 av_log(ctx->avctx, AV_LOG_WARNING,

235 "Adaptive MB interlace flag in an unsupported profile.\n");

236

237 switch ((buf[0x2C] >> 1) & 3) {

238 case 0: frame->colorspace = AVCOL_SPC_BT709; break;

239 case 1: frame->colorspace = AVCOL_SPC_BT2020_NCL; break;

240 case 2: frame->colorspace = AVCOL_SPC_BT2020_CL; break;

241 case 3: frame->colorspace = AVCOL_SPC_UNSPECIFIED; break;

242 }

243

244 ctx->act = buf[0x2C] & 1;

245 if (ctx->act && ctx->cid_table->cid != 1256 && ctx->cid_table->cid != 1270)

246 av_log(ctx->avctx, AV_LOG_WARNING,

247 "Adaptive color transform in an unsupported profile.\n");

248

249 ctx->is_444 = (buf[0x2C] >> 6) & 1;

250 if (ctx->is_444) {

251 if (bitdepth == 8) {

252 avpriv_request_sample(ctx->avctx, "4:4:4 8 bits");

253 return AVERROR_INVALIDDATA;

254 } else if (bitdepth == 10) {

255 ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;

256 ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P10

257 : AV_PIX_FMT_GBRP10;

258 } else {

259 ctx->decode_dct_block = dnxhd_decode_dct_block_12_444;

260 ctx->pix_fmt = ctx->act ? AV_PIX_FMT_YUV444P12

261 : AV_PIX_FMT_GBRP12;

262 }

263 } else if (bitdepth == 12) {

264 ctx->decode_dct_block = dnxhd_decode_dct_block_12;

265 ctx->pix_fmt = AV_PIX_FMT_YUV422P12;

266 } else if (bitdepth == 10) {

267 if (ctx->avctx->profile == AV_PROFILE_DNXHR_HQX)

268 ctx->decode_dct_block = dnxhd_decode_dct_block_10_444;

269 else

270 ctx->decode_dct_block = dnxhd_decode_dct_block_10;

271 ctx->pix_fmt = AV_PIX_FMT_YUV422P10;

272 } else {

273 ctx->decode_dct_block = dnxhd_decode_dct_block_8;

274 ctx->pix_fmt = AV_PIX_FMT_YUV422P;

275 }

276

277 ctx->avctx->bits_per_raw_sample = ctx->bit_depth = bitdepth;

278 if (ctx->bit_depth != old_bit_depth) {

279 ff_blockdsp_init(&ctx->bdsp);

280 ff_idctdsp_init(&ctx->idsp, ctx->avctx);

281 ff_permute_scantable(ctx->permutated_scantable, ff_zigzag_direct,

282 ctx->idsp.idct_permutation);

283 }

284

285 // make sure profile size constraints are respected

286 // DNx100 allows 1920->1440 and 1280->960 subsampling

287 if (ctx->width != ctx->cid_table->width &&

288 ctx->cid_table->width != DNXHD_VARIABLE) {

289 av_reduce(&ctx->avctx->sample_aspect_ratio.num,

290 &ctx->avctx->sample_aspect_ratio.den,

291 ctx->width, ctx->cid_table->width, 255);

292 ctx->width = ctx->cid_table->width;

293 }

294

295 if (buf_size < ctx->cid_table->coding_unit_size) {

296 av_log(ctx->avctx, AV_LOG_ERROR, "incorrect frame size (%d < %u).\n",

297 buf_size, ctx->cid_table->coding_unit_size);

298 return AVERROR_INVALIDDATA;

299 }

300

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

302 ctx->mb_height = AV_RB16(buf + 0x16c);

303

304 if ((ctx->height + 15) >> 4 == ctx->mb_height && (frame->flags & AV_FRAME_FLAG_INTERLACED))

305 ctx->height <<= 1;

306

307 av_log(ctx->avctx, AV_LOG_VERBOSE, "%dx%d, 4:%s %d bits, MBAFF=%d ACT=%d\n",

308 ctx->width, ctx->height, ctx->is_444 ? "4:4" : "2:2",

309 ctx->bit_depth, ctx->mbaff, ctx->act);

310

311 // Newer format supports variable mb_scan_index sizes

312 if (ctx->mb_height > 68 && ff_dnxhd_check_header_prefix_hr(header_prefix)) {

313 ctx->data_offset = 0x170 + (ctx->mb_height << 2);

314 } else {

315 if (ctx->mb_height > 68) {

316 av_log(ctx->avctx, AV_LOG_ERROR,

317 "mb height too big: %d\n", ctx->mb_height);

318 return AVERROR_INVALIDDATA;

319 }

320 ctx->data_offset = 0x280;

321 }

322 if ((ctx->mb_height << !!(frame->flags & AV_FRAME_FLAG_INTERLACED)) > (ctx->height + 15) >> 4) {

323 av_log(ctx->avctx, AV_LOG_ERROR,

324 "mb height too big: %d\n", ctx->mb_height);

325 return AVERROR_INVALIDDATA;

326 }

327

328 if (buf_size < ctx->data_offset) {

329 av_log(ctx->avctx, AV_LOG_ERROR,

330 "buffer too small (%d < %d).\n", buf_size, ctx->data_offset);

331 return AVERROR_INVALIDDATA;

332 }

333

334 if (ctx->mb_height > FF_ARRAY_ELEMS(ctx->mb_scan_index)) {

335 av_log(ctx->avctx, AV_LOG_ERROR,

336 "mb_height too big (%d > %"SIZE_SPECIFIER ").\n", ctx->mb_height, FF_ARRAY_ELEMS(ctx->mb_scan_index));

337 return AVERROR_INVALIDDATA;

338 }

339

340 for (i = 0; i < ctx->mb_height; i++) {

341 ctx->mb_scan_index[i] = AV_RB32(buf + 0x170 + (i << 2));

342 ff_dlog(ctx->avctx, "mb scan index %d, pos %d: %"PRIu32"\n",

343 i, 0x170 + (i << 2), ctx->mb_scan_index[i]);

344 if (buf_size - ctx->data_offset < ctx->mb_scan_index[i]) {

345 av_log(ctx->avctx, AV_LOG_ERROR,

346 "invalid mb scan index (%"PRIu32" vs %u).\n",

347 ctx->mb_scan_index[i], buf_size - ctx->data_offset);

348 return AVERROR_INVALIDDATA;

349 }

350 }

351

352 return 0;

353 }

354

355 static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx,

356 RowContext *row,

357 int n,

358 int index_bits,

359 int level_bias,

360 int level_shift,

361 int dc_shift)

362 {

363 int i, j, index1, len, flags;

364 int level, component, sign;

365 const int *scale;

366 const uint8_t *weight_matrix;

367 const uint8_t *ac_info = ctx->cid_table->ac_info;

368 int16_t *block = row->blocks[n];

369 const int eob_index = ctx->cid_table->eob_index;

370 int ret = 0;

371 OPEN_READER(bs, &row->gb);

372

373 ctx->bdsp.clear_block(block);

374

375 if (!ctx->is_444) {

376 if (n & 2) {

377 component = 1 + (n & 1);

378 scale = row->chroma_scale;

379 weight_matrix = ctx->cid_table->chroma_weight;

380 } else {

381 component = 0;

382 scale = row->luma_scale;

383 weight_matrix = ctx->cid_table->luma_weight;

384 }

385 } else {

386 component = (n >> 1) % 3;

387 if (component) {

388 scale = row->chroma_scale;

389 weight_matrix = ctx->cid_table->chroma_weight;

390 } else {

391 scale = row->luma_scale;

392 weight_matrix = ctx->cid_table->luma_weight;

393 }

394 }

395

396 UPDATE_CACHE(bs, &row->gb);

397 GET_VLC(len, bs, &row->gb, ctx->dc_vlc.table, DNXHD_DC_VLC_BITS, 1);

398 if (len < 0) {

399 ret = len;

400 goto error;

401 }

402 if (len) {

403 level = GET_CACHE(bs, &row->gb);

404 LAST_SKIP_BITS(bs, &row->gb, len);

405 sign = ~level >> 31;

406 level = (NEG_USR32(sign ^ level, len) ^ sign) - sign;

407 row->last_dc[component] += level * (1 << dc_shift);

408 }

409 block[0] = row->last_dc[component];

410

411 i = 0;

412

413 UPDATE_CACHE(bs, &row->gb);

414 GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,

415 DNXHD_VLC_BITS, 2);

416

417 while (index1 != eob_index) {

418 level = ac_info[2*index1+0];

419 flags = ac_info[2*index1+1];

420

421 sign = SHOW_SBITS(bs, &row->gb, 1);

422 SKIP_BITS(bs, &row->gb, 1);

423

424 if (flags & 1) {

425 level += SHOW_UBITS(bs, &row->gb, index_bits) << 7;

426 SKIP_BITS(bs, &row->gb, index_bits);

427 }

428

429 if (flags & 2) {

430 int run;

431 UPDATE_CACHE(bs, &row->gb);

432 GET_VLC(run, bs, &row->gb, ctx->run_vlc.table,

433 DNXHD_VLC_BITS, 2);

434 i += run;

435 }

436

437 if (++i > 63) {

438 av_log(ctx->avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", n, i);

439 ret = -1;

440 break;

441 }

442

443 j = ctx->permutated_scantable[i];

444 level *= scale[i];

445 level += scale[i] >> 1;

446 if (level_bias < 32 || weight_matrix[i] != level_bias)

447 level += level_bias; // 1<<(level_shift-1)

448 level >>= level_shift;

449

450 block[j] = (level ^ sign) - sign;

451

452 UPDATE_CACHE(bs, &row->gb);

453 GET_VLC(index1, bs, &row->gb, ctx->ac_vlc.table,

454 DNXHD_VLC_BITS, 2);

455 }

456 error:

457 CLOSE_READER(bs, &row->gb);

458 return ret;

459 }

460

461 static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx,

462 RowContext *row, int n)

463 {

464 return dnxhd_decode_dct_block(ctx, row, n, 4, 32, 6, 0);

465 }

466

467 static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx,

468 RowContext *row, int n)

469 {

470 return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 0);

471 }

472

473 static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx,

474 RowContext *row, int n)

475 {

476 return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6, 0);

477 }

478

479 static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx,

480 RowContext *row, int n)

481 {

482 return dnxhd_decode_dct_block(ctx, row, n, 6, 8, 4, 2);

483 }

484

485 static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx,

486 RowContext *row, int n)

487 {

488 return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 4, 2);

489 }

490

491 static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row,

492 AVFrame *frame, int x, int y)

493 {

494 int shift1 = ctx->bit_depth >= 10;

495 int dct_linesize_luma = frame->linesize[0];

496 int dct_linesize_chroma = frame->linesize[1];

497 uint8_t *dest_y, *dest_u, *dest_v;

498 int dct_y_offset, dct_x_offset;

499 int qscale, i, act;

500 int interlaced_mb = 0;

501

502 if (ctx->mbaff) {

503 interlaced_mb = get_bits1(&row->gb);

504 qscale = get_bits(&row->gb, 10);

505 } else {

506 qscale = get_bits(&row->gb, 11);

507 }

508 act = get_bits1(&row->gb);

509 if (act) {

510 if (!ctx->act) {

511 static int act_warned;

512 if (!act_warned) {

513 act_warned = 1;

514 av_log(ctx->avctx, AV_LOG_ERROR,

515 "ACT flag set, in violation of frame header.\n");

516 }

517 } else if (row->format == -1) {

518 row->format = act;

519 } else if (row->format != act) {

520 row->format = 2; // Variable

521 }

522 }

523

524 if (qscale != row->last_qscale) {

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

526 row->luma_scale[i] = qscale * ctx->cid_table->luma_weight[i];

527 row->chroma_scale[i] = qscale * ctx->cid_table->chroma_weight[i];

528 }

529 row->last_qscale = qscale;

530 }

531

532 for (i = 0; i < 8 + 4 * ctx->is_444; i++) {

533 if (ctx->decode_dct_block(ctx, row, i) < 0)

534 return AVERROR_INVALIDDATA;

535 }

536

537 if (frame->flags & AV_FRAME_FLAG_INTERLACED) {

538 dct_linesize_luma <<= 1;

539 dct_linesize_chroma <<= 1;

540 }

541

542 dest_y = frame->data[0] + ((y * dct_linesize_luma) << 4) + (x << (4 + shift1));

543 dest_u = frame->data[1] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));

544 dest_v = frame->data[2] + ((y * dct_linesize_chroma) << 4) + (x << (3 + shift1 + ctx->is_444));

545

546 if ((frame->flags & AV_FRAME_FLAG_INTERLACED) && ctx->cur_field) {

547 dest_y += frame->linesize[0];

548 dest_u += frame->linesize[1];

549 dest_v += frame->linesize[2];

550 }

551 if (interlaced_mb) {

552 dct_linesize_luma <<= 1;

553 dct_linesize_chroma <<= 1;

554 }

555

556 dct_y_offset = interlaced_mb ? frame->linesize[0] : (dct_linesize_luma << 3);

557 dct_x_offset = 8 << shift1;

558 if (!ctx->is_444) {

559 ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);

560 ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);

561 ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[4]);

562 ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[5]);

563

564 if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {

565 dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);

566 ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);

567 ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[3]);

568 ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[6]);

569 ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[7]);

570 }

571 } else {

572 ctx->idsp.idct_put(dest_y, dct_linesize_luma, row->blocks[0]);

573 ctx->idsp.idct_put(dest_y + dct_x_offset, dct_linesize_luma, row->blocks[1]);

574 ctx->idsp.idct_put(dest_y + dct_y_offset, dct_linesize_luma, row->blocks[6]);

575 ctx->idsp.idct_put(dest_y + dct_y_offset + dct_x_offset, dct_linesize_luma, row->blocks[7]);

576

577 if (!(ctx->avctx->flags & AV_CODEC_FLAG_GRAY)) {

578 dct_y_offset = interlaced_mb ? frame->linesize[1] : (dct_linesize_chroma << 3);

579 ctx->idsp.idct_put(dest_u, dct_linesize_chroma, row->blocks[2]);

580 ctx->idsp.idct_put(dest_u + dct_x_offset, dct_linesize_chroma, row->blocks[3]);

581 ctx->idsp.idct_put(dest_u + dct_y_offset, dct_linesize_chroma, row->blocks[8]);

582 ctx->idsp.idct_put(dest_u + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[9]);

583 ctx->idsp.idct_put(dest_v, dct_linesize_chroma, row->blocks[4]);

584 ctx->idsp.idct_put(dest_v + dct_x_offset, dct_linesize_chroma, row->blocks[5]);

585 ctx->idsp.idct_put(dest_v + dct_y_offset, dct_linesize_chroma, row->blocks[10]);

586 ctx->idsp.idct_put(dest_v + dct_y_offset + dct_x_offset, dct_linesize_chroma, row->blocks[11]);

587 }

588 }

589

590 return 0;

591 }

592

593 static int dnxhd_decode_row(AVCodecContext *avctx, void *data,

594 int rownb, int threadnb)

595 {

596 const DNXHDContext *ctx = avctx->priv_data;

597 uint32_t offset = ctx->mb_scan_index[rownb];

598 RowContext *row = ctx->rows + threadnb;

599 int x, ret;

600

601 row->last_dc[0] =

602 row->last_dc[1] =

603 row->last_dc[2] = 1 << (ctx->bit_depth + 2); // for levels +2^(bitdepth-1)

604 ret = init_get_bits8(&row->gb, ctx->buf + offset, ctx->buf_size - offset);

605 if (ret < 0) {

606 row->errors++;

607 return ret;

608 }

609 for (x = 0; x < ctx->mb_width; x++) {

610 int ret = dnxhd_decode_macroblock(ctx, row, data, x, rownb);

611 if (ret < 0) {

612 row->errors++;

613 return ret;

614 }

615 }

616

617 return 0;

618 }

619

620 static int dnxhd_decode_frame(AVCodecContext *avctx, AVFrame *picture,

621 int *got_frame, AVPacket *avpkt)

622 {

623 const uint8_t *buf = avpkt->data;

624 int buf_size = avpkt->size;

625 DNXHDContext *ctx = avctx->priv_data;

626 int first_field = 1;

627 int ret, i;

628

629 ff_dlog(avctx, "frame size %d\n", buf_size);

630

631 for (i = 0; i < avctx->thread_count; i++)

632 ctx->rows[i].format = -1;

633

634 decode_coding_unit:

635 if ((ret = dnxhd_decode_header(ctx, picture, buf, buf_size, first_field)) < 0)

636 return ret;

637

638 if ((avctx->width || avctx->height) &&

639 (ctx->width != avctx->width || ctx->height != avctx->height)) {

640 av_log(avctx, AV_LOG_WARNING, "frame size changed: %dx%d -> %ux%u\n",

641 avctx->width, avctx->height, ctx->width, ctx->height);

642 first_field = 1;

643 }

644 if (avctx->pix_fmt != AV_PIX_FMT_NONE && avctx->pix_fmt != ctx->pix_fmt) {

645 av_log(avctx, AV_LOG_WARNING, "pix_fmt changed: %s -> %s\n",

646 av_get_pix_fmt_name(avctx->pix_fmt), av_get_pix_fmt_name(ctx->pix_fmt));

647 first_field = 1;

648 }

649

650 avctx->pix_fmt = ctx->pix_fmt;

651 ret = ff_set_dimensions(avctx, ctx->width, ctx->height);

652 if (ret < 0)

653 return ret;

654

655 if (first_field) {

656 if ((ret = ff_thread_get_buffer(avctx, picture, 0)) < 0)

657 return ret;

658 }

659

660 ctx->buf_size = buf_size - ctx->data_offset;

661 ctx->buf = buf + ctx->data_offset;

662 avctx->execute2(avctx, dnxhd_decode_row, picture, NULL, ctx->mb_height);

663

664 if (first_field && (picture->flags & AV_FRAME_FLAG_INTERLACED)) {

665 buf += ctx->cid_table->coding_unit_size;

666 buf_size -= ctx->cid_table->coding_unit_size;

667 first_field = 0;

668 goto decode_coding_unit;

669 }

670

671 ret = 0;

672 for (i = 0; i < avctx->thread_count; i++) {

673 ret += ctx->rows[i].errors;

674 ctx->rows[i].errors = 0;

675 }

676

677 if (ctx->act) {

678 static int act_warned;

679 int format = ctx->rows[0].format;

680 for (i = 1; i < avctx->thread_count; i++) {

681 if (ctx->rows[i].format != format &&

682 ctx->rows[i].format != -1 /* not run */) {

683 format = 2;

684 break;

685 }

686 }

687 switch (format) {

688 case -1:

689 case 2:

690 if (!act_warned) {

691 act_warned = 1;

692 av_log(ctx->avctx, AV_LOG_ERROR,

693 "Unsupported: variable ACT flag.\n");

694 }

695 break;

696 case 0:

697 ctx->pix_fmt = ctx->bit_depth==10

698 ? AV_PIX_FMT_GBRP10 : AV_PIX_FMT_GBRP12;

699 break;

700 case 1:

701 ctx->pix_fmt = ctx->bit_depth==10

702 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV444P12;

703 break;

704 }

705 }

706 avctx->pix_fmt = ctx->pix_fmt;

707 if (ret) {

708 av_log(ctx->avctx, AV_LOG_ERROR, "%d lines with errors\n", ret);

709 return AVERROR_INVALIDDATA;

710 }

711

712 *got_frame = 1;

713 return avpkt->size;

714 }

715

716 static av_cold int dnxhd_decode_close(AVCodecContext *avctx)

717 {

718 DNXHDContext *ctx = avctx->priv_data;

719

720 ff_vlc_free(&ctx->ac_vlc);

721 ff_vlc_free(&ctx->dc_vlc);

722 ff_vlc_free(&ctx->run_vlc);

723

724 av_freep(&ctx->rows);

725

726 return 0;

727 }

728

729 const FFCodec ff_dnxhd_decoder = {

730 .p.name = "dnxhd",

731 CODEC_LONG_NAME("VC3/DNxHD"),

732 .p.type = AVMEDIA_TYPE_VIDEO,

733 .p.id = AV_CODEC_ID_DNXHD,

734 .priv_data_size = sizeof(DNXHDContext),

735 .init = dnxhd_decode_init,

736 .close = dnxhd_decode_close,

737 FF_CODEC_DECODE_CB(dnxhd_decode_frame),

738 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |

739 AV_CODEC_CAP_SLICE_THREADS,

740 .p.profiles = NULL_IF_CONFIG_SMALL(ff_dnxhd_profiles),

741 };

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

level

uint8_t level

Definition: svq3.c:205

ff_dnxhd_check_header_prefix_hr

static av_always_inline uint64_t ff_dnxhd_check_header_prefix_hr(uint64_t prefix)

Definition: dnxhddata.h:66

blockdsp.h

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

RowContext::errors

int errors

Definition: dnxhddec.c:49

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:691

mem_internal.h

out

FILE * out

Definition: movenc.c:55

DNXHDContext::buf_size

int buf_size

Definition: dnxhddec.c:59

DNXHDContext::is_444

int is_444

Definition: dnxhddec.c:72

GET_VLC

#define GET_VLC(code, name, gb, table, bits, max_depth)

If the vlc code is invalid and max_depth=1, then no bits will be removed.

Definition: get_bits.h:574

int64_t

long long int64_t

Definition: coverity.c:34

AVFrame

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

Definition: frame.h:389

pixdesc.h

AV_PROFILE_DNXHR_444

#define AV_PROFILE_DNXHR_444

Definition: defs.h:85

AVPacket::data

uint8_t * data

Definition: packet.h:539

bitdepth

#define bitdepth

Definition: aom_film_grain_template.c:67

data

const char data[16]

Definition: mxf.c:148

DNXHDContext::rows

RowContext * rows

Definition: dnxhddec.c:56

FFCodec

Definition: codec_internal.h:127

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:196

DNXHDContext::alpha

int alpha

Definition: dnxhddec.c:73

UPDATE_CACHE

#define UPDATE_CACHE(name, gb)

Definition: get_bits.h:225

AVFrame::flags

int flags

Frame flags, a combination of AV_FRAME_FLAGS.

Definition: frame.h:661

BlockDSPContext

Definition: blockdsp.h:32

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

AVCOL_SPC_BT2020_CL

@ AVCOL_SPC_BT2020_CL

ITU-R BT2020 constant luminance system.

Definition: pixfmt.h:621

thread.h

ff_idctdsp_init

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)

Definition: idctdsp.c:228

dnxhd_decode_header

static int dnxhd_decode_header(DNXHDContext *ctx, AVFrame *frame, const uint8_t *buf, int buf_size, int first_field)

Definition: dnxhddec.c:178

CIDEntry::coding_unit_size

unsigned int coding_unit_size

Definition: dnxhddata.h:47

DNXHDContext::ac_vlc

VLC ac_vlc

Definition: dnxhddec.c:67

DNXHDContext::height

unsigned int height

Definition: dnxhddec.c:61

AV_FRAME_FLAG_TOP_FIELD_FIRST

#define AV_FRAME_FLAG_TOP_FIELD_FIRST

A flag to mark frames where the top field is displayed first if the content is interlaced.

Definition: frame.h:653

DNXHDContext::mb_scan_index

uint32_t mb_scan_index[512]

Definition: dnxhddec.c:64

GET_CACHE

#define GET_CACHE(name, gb)

Definition: get_bits.h:263

DNXHD_VLC_BITS

#define DNXHD_VLC_BITS

Definition: dnxhddec.c:81

ff_permute_scantable

av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])

Definition: idctdsp.c:30

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

DNXHDContext::mb_height

unsigned int mb_height

Definition: dnxhddec.c:63

RowContext::chroma_scale

int chroma_scale[64]

Definition: dnxhddec.c:45

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

DNXHDContext::cur_field

int cur_field

current interlaced field

Definition: dnxhddec.c:66

dnxhd_decode_frame

static int dnxhd_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_frame, AVPacket *avpkt)

Definition: dnxhddec.c:620

AVCodecContext::thread_count

int thread_count

thread count is used to decide how many independent tasks should be passed to execute()

Definition: avcodec.h:1593

DNXHDContext

Definition: dnxhddec.c:54

AV_PIX_FMT_GBRP10

#define AV_PIX_FMT_GBRP10

Definition: pixfmt.h:494

DNXHDContext::idsp

IDCTDSPContext idsp

Definition: dnxhddec.c:68

GetBitContext

Definition: get_bits.h:108

DNXHDContext::bit_depth

int bit_depth

Definition: dnxhddec.c:71

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:639

AV_PROFILE_DNXHR_SQ

#define AV_PROFILE_DNXHR_SQ

Definition: defs.h:82

ff_dnxhd_decoder

const FFCodec ff_dnxhd_decoder

Definition: dnxhddec.c:729

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

CIDEntry

Definition: dnxhddata.h:43

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:481

CIDEntry::bit_depth

int bit_depth

Definition: dnxhddata.h:50

dnxhddata.h

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

AV_PROFILE_DNXHR_LB

#define AV_PROFILE_DNXHR_LB

Definition: defs.h:81

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:545

CLOSE_READER

#define CLOSE_READER(name, gb)

Definition: get_bits.h:188

dnxhd_decode_close

static av_cold int dnxhd_decode_close(AVCodecContext *avctx)

Definition: dnxhddec.c:716

dnxhd_get_profile

static int dnxhd_get_profile(int cid)

Definition: dnxhddec.c:161

AV_PROFILE_DNXHR_HQ

#define AV_PROFILE_DNXHR_HQ

Definition: defs.h:83

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

ff_blockdsp_init

av_cold void ff_blockdsp_init(BlockDSPContext *c)

Definition: blockdsp.c:58

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1438

format

ff_thread_get_buffer

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

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:1049

SHOW_SBITS

#define SHOW_SBITS(name, gb, num)

Definition: get_bits.h:260

DNXHD_DC_VLC_BITS

#define DNXHD_DC_VLC_BITS

Definition: dnxhddec.c:82

AV_PROFILE_DNXHR_HQX

#define AV_PROFILE_DNXHR_HQX

Definition: defs.h:84

vlc_init

#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:62

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

RowContext::luma_scale

int luma_scale[64]

Definition: dnxhddec.c:44

decode.h

get_bits.h

DNXHDContext::act

int act

Definition: dnxhddec.c:76

SKIP_BITS

#define SKIP_BITS(name, gb, num)

Definition: get_bits.h:241

DNXHDContext::mb_width

unsigned int mb_width

Definition: dnxhddec.c:63

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

ff_dnxhd_profiles

const AVProfile ff_dnxhd_profiles[]

Definition: profiles.c:62

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

DNXHDContext::data_offset

int data_offset

Definition: dnxhddec.c:65

dnxhd_decode_dct_block_12_444

static int dnxhd_decode_dct_block_12_444(const DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:485

NULL

#define NULL

Definition: coverity.c:32

run

uint8_t run

Definition: svq3.c:204

DNXHDContext::avctx

AVCodecContext * avctx

Definition: dnxhddec.c:55

DNXHD_VARIABLE

#define DNXHD_VARIABLE

Indicate that a CIDEntry value must be read in the bitstream.

Definition: dnxhddata.h:41

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

DNXHDContext::lla

int lla

Definition: dnxhddec.c:74

profiles.h

DNXHDContext::bdsp

BlockDSPContext bdsp

Definition: dnxhddec.c:57

LAST_SKIP_BITS

#define LAST_SKIP_BITS(name, gb, num)

Definition: get_bits.h:247

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:479

dnxhd_decode_init

static av_cold int dnxhd_decode_init(AVCodecContext *avctx)

Definition: dnxhddec.c:95

cid

uint16_t cid

Definition: mxfenc.c:2264

RowContext::format

int format

-1:not set yet 0:off=RGB 1:on=YUV 2:variable

Definition: dnxhddec.c:51

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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

dnxhd_decode_dct_block

static av_always_inline int dnxhd_decode_dct_block(const DNXHDContext *ctx, RowContext *row, int n, int index_bits, int level_bias, int level_shift, int dc_shift)

Definition: dnxhddec.c:355

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:322

AVPacket::size

int size

Definition: packet.h:540

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

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

AV_PIX_FMT_YUV422P12

#define AV_PIX_FMT_YUV422P12

Definition: pixfmt.h:483

RowContext

Definition: dnxhddec.c:42

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

RowContext::gb

GetBitContext gb

Definition: dnxhddec.c:46

OPEN_READER

#define OPEN_READER(name, gb)

Definition: get_bits.h:177

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

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

Definition: codec.h:114

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

RowContext::blocks

int16_t blocks[12][64]

Definition: dnxhddec.c:43

RowContext::last_qscale

int last_qscale

Definition: dnxhddec.c:48

ff_vlc_init_sparse

int ff_vlc_init_sparse(VLC *vlc, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)

Build VLC decoding tables suitable for use with get_vlc2().

Definition: vlc.c:250

DNXHDContext::permutated_scantable

uint8_t permutated_scantable[64]

Definition: dnxhddec.c:69

ff_dnxhd_get_cid_table

const CIDEntry * ff_dnxhd_get_cid_table(int cid)

Definition: dnxhddata.c:1080

DNXHDContext::cid

int64_t cid

compression id

Definition: dnxhddec.c:60

NEG_USR32

#define NEG_USR32(a, s)

Definition: mathops.h:176

DNXHDContext::decode_dct_block

int(* decode_dct_block)(const struct DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:77

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

Definition: cbs_h2645.c:256

AVCOL_SPC_BT2020_NCL

@ AVCOL_SPC_BT2020_NCL

ITU-R BT2020 non-constant luminance system.

Definition: pixfmt.h:620

AV_PIX_FMT_GBRP12

#define AV_PIX_FMT_GBRP12

Definition: pixfmt.h:495

av_always_inline

#define av_always_inline

Definition: attributes.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

len

int len

Definition: vorbis_enc_data.h:426

DNXHDContext::run_vlc

VLC run_vlc

Definition: dnxhddec.c:67

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:612

AVCodecContext::height

int height

Definition: avcodec.h:624

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

AV_FRAME_FLAG_INTERLACED

#define AV_FRAME_FLAG_INTERLACED

A flag to mark frames whose content is interlaced.

Definition: frame.h:648

DNXHDContext::pix_fmt

enum AVPixelFormat pix_fmt

Definition: dnxhddec.c:62

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

idctdsp.h

avcodec.h

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:98

AV_PROFILE_DNXHD

#define AV_PROFILE_DNXHD

Definition: defs.h:80

ff_vlc_free

void ff_vlc_free(VLC *vlc)

Definition: vlc.c:580

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_dnxhd_parse_header_prefix

static av_always_inline uint64_t ff_dnxhd_parse_header_prefix(const uint8_t *buf)

Definition: dnxhddata.h:85

RowContext::last_dc

int last_dc[3]

Definition: dnxhddec.c:47

IDCTDSPContext

Definition: idctdsp.h:43

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:129

DNXHDContext::buf

const uint8_t * buf

Definition: dnxhddec.c:58

AVCodecContext

main external API structure.

Definition: avcodec.h:451

SHOW_UBITS

#define SHOW_UBITS(name, gb, num)

Definition: get_bits.h:259

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

VLC

Definition: vlc.h:36

dnxhd_init_vlc

static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid, int bitdepth)

Definition: dnxhddec.c:115

AVCodecContext::coded_width

int coded_width

Bitstream width / height, may be different from width/height e.g.

Definition: avcodec.h:639

DNXHDContext::width

unsigned int width

Definition: dnxhddec.c:61

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV_PIX_FMT_YUV422P

@ AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:77

mem.h

DNXHDContext::mbaff

int mbaff

Definition: dnxhddec.c:75

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:36

scale

static void scale(int *out, const int *in, const int w, const int h, const int shift)

Definition: intra.c:291

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

dnxhd_decode_macroblock

static int dnxhd_decode_macroblock(const DNXHDContext *ctx, RowContext *row, AVFrame *frame, int x, int y)

Definition: dnxhddec.c:491

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:624

dnxhd_decode_dct_block_10_444

static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:473

flags

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

Definition: cbs_av1.c:482

dnxhd_decode_row

static int dnxhd_decode_row(AVCodecContext *avctx, void *data, int rownb, int threadnb)

Definition: dnxhddec.c:593

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

DNXHDContext::dc_vlc

VLC dc_vlc

Definition: dnxhddec.c:67

AVCOL_SPC_BT709

@ AVCOL_SPC_BT709

also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B

Definition: pixfmt.h:611

first_field

static int first_field(const struct video_data *s)

Definition: v4l2.c:256

dnxhd_decode_dct_block_8

static int dnxhd_decode_dct_block_8(const DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:461

shift1

static const uint8_t shift1[6]

Definition: dxa.c:48

DNXHDContext::cid_table

const CIDEntry * cid_table

Definition: dnxhddec.c:70

dnxhd_decode_dct_block_10

static int dnxhd_decode_dct_block_10(const DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:467

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

AV_CODEC_ID_DNXHD

@ AV_CODEC_ID_DNXHD

Definition: codec_id.h:151

dnxhd_decode_dct_block_12

static int dnxhd_decode_dct_block_12(const DNXHDContext *ctx, RowContext *row, int n)

Definition: dnxhddec.c:479

av_get_pix_fmt_name

const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)

Return the short name for a pixel format, NULL in case pix_fmt is unknown.

Definition: pixdesc.c:2885

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

Generated on Fri Aug 22 2025 13:58:17 for FFmpeg by doxygen 1.8.17