FFmpeg: libavcodec/av1dec.c Source File

FFmpeg

[フレーム]

libavcodec

av1dec.c

Go to the documentation of this file.

1 /*

2 * AV1 video decoder

3 *

4 * This file is part of FFmpeg.

5 *

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

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

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

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

10 *

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

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

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

14 * Lesser General Public License for more details.

15 *

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

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

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

19 */

21 #include "config_components.h"

23 #include "libavutil/hdr_dynamic_metadata.h"

24 #include "libavutil/film_grain_params.h"

25 #include "libavutil/mastering_display_metadata.h"

26 #include "libavutil/mem.h"

27 #include "libavutil/pixdesc.h"

28 #include "libavutil/opt.h"

29 #include "avcodec.h"

30 #include "av1_parse.h"

31 #include "av1dec.h"

32 #include "atsc_a53.h"

33 #include "bytestream.h"

34 #include "codec_internal.h"

35 #include "decode.h"

36 #include "hwaccel_internal.h"

37 #include "internal.h"

38 #include "itut35.h"

39 #include "hwconfig.h"

40 #include "profiles.h"

41 #include "progressframe.h"

42 #include "refstruct.h"

44 /**< same with Div_Lut defined in spec 7.11.3.7 */

45 static const uint16_t div_lut[AV1_DIV_LUT_NUM] = {

46 16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,

47 15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,

48 15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,

49 14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,

50 13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,

51 13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,

52 13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,

53 12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,

54 12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,

55 11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,

56 11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,

57 11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,

58 10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,

59 10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,

60 10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986,

61 9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732,

62 9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489,

63 9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259,

64 9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039,

65 9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830,

66 8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630,

67 8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439,

68 8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257,

69 8240, 8224, 8208, 8192

70 };

72 static uint32_t inverse_recenter(int r, uint32_t v)

73 {

74 if (v > 2 * r)

75 return v;

76 else if (v & 1)

77 return r - ((v + 1) >> 1);

78 else

79 return r + (v >> 1);

80 }

82 static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp,

83 int mx, int r)

84 {

85 if ((r << 1) <= mx) {

86 return inverse_recenter(r, sub_exp);

87 } else {

88 return mx - 1 - inverse_recenter(mx - 1 - r, sub_exp);

89 }

90 }

92 static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low,

93 int high, int r)

94 {

95 int32_t x = decode_unsigned_subexp_with_ref(sub_exp, high - low, r - low);

96 return x + low;

97 }

99 static void read_global_param(AV1DecContext *s, int type, int ref, int idx)

100 {

101 uint8_t primary_frame, prev_frame;

102 uint32_t abs_bits, prec_bits, round, prec_diff, sub, mx;

103 int32_t r, prev_gm_param;

104

105 primary_frame = s->raw_frame_header->primary_ref_frame;

106 prev_frame = s->raw_frame_header->ref_frame_idx[primary_frame];

107 abs_bits = AV1_GM_ABS_ALPHA_BITS;

108 prec_bits = AV1_GM_ALPHA_PREC_BITS;

109

110 /* setup_past_independence() sets PrevGmParams to default values. We can

111 * simply point to the current's frame gm_params as they will be initialized

112 * with defaults at this point.

113 */

114 if (s->raw_frame_header->primary_ref_frame == AV1_PRIMARY_REF_NONE)

115 prev_gm_param = s->cur_frame.gm_params[ref][idx];

116 else

117 prev_gm_param = s->ref[prev_frame].gm_params[ref][idx];

118

119 if (idx < 2) {

120 if (type == AV1_WARP_MODEL_TRANSLATION) {

121 abs_bits = AV1_GM_ABS_TRANS_ONLY_BITS -

122 !s->raw_frame_header->allow_high_precision_mv;

123 prec_bits = AV1_GM_TRANS_ONLY_PREC_BITS -

124 !s->raw_frame_header->allow_high_precision_mv;

125 } else {

126 abs_bits = AV1_GM_ABS_TRANS_BITS;

127 prec_bits = AV1_GM_TRANS_PREC_BITS;

128 }

129 }

130 round = (idx % 3) == 2 ? (1 << AV1_WARPEDMODEL_PREC_BITS) : 0;

131 prec_diff = AV1_WARPEDMODEL_PREC_BITS - prec_bits;

132 sub = (idx % 3) == 2 ? (1 << prec_bits) : 0;

133 mx = 1 << abs_bits;

134 r = (prev_gm_param >> prec_diff) - sub;

135

136 s->cur_frame.gm_params[ref][idx] =

137 (decode_signed_subexp_with_ref(s->raw_frame_header->gm_params[ref][idx],

138 -mx, mx + 1, r) << prec_diff) + round;

139 }

140

141 static uint64_t round_two(uint64_t x, uint16_t n)

142 {

143 if (n == 0)

144 return x;

145 return ((x + ((uint64_t)1 << (n - 1))) >> n);

146 }

147

148 static int64_t round_two_signed(int64_t x, uint16_t n)

149 {

150 return ((x<0) ? -((int64_t)round_two(-x, n)) : (int64_t)round_two(x, n));

151 }

152

153 /**

154 * Resolve divisor process.

155 * see spec 7.11.3.7

156 */

157 static int16_t resolve_divisor(uint32_t d, uint16_t *shift)

158 {

159 int32_t e, f;

160

161 *shift = av_log2(d);

162 e = d - (1 << (*shift));

163 if (*shift > AV1_DIV_LUT_BITS)

164 f = round_two(e, *shift - AV1_DIV_LUT_BITS);

165 else

166 f = e << (AV1_DIV_LUT_BITS - (*shift));

167

168 *shift += AV1_DIV_LUT_PREC_BITS;

169

170 return div_lut[f];

171 }

172

173 /**

174 * check if global motion params is valid.

175 * see spec 7.11.3.6

176 */

177 static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)

178 {

179 int16_t alpha, beta, gamma, delta, divf, divs;

180 int64_t v, w;

181 int32_t *param = &s->cur_frame.gm_params[idx][0];

182 if (param[2] <= 0)

183 return 0;

184

185 alpha = av_clip_int16(param[2] - (1 << AV1_WARPEDMODEL_PREC_BITS));

186 beta = av_clip_int16(param[3]);

187 divf = resolve_divisor(abs(param[2]), &divs);

188 v = (int64_t)param[4] * (1 << AV1_WARPEDMODEL_PREC_BITS);

189 w = (int64_t)param[3] * param[4];

190 gamma = av_clip_int16((int)round_two_signed((v * divf), divs));

191 delta = av_clip_int16(param[5] - (int)round_two_signed((w * divf), divs) - (1 << AV1_WARPEDMODEL_PREC_BITS));

192

193 alpha = round_two_signed(alpha, AV1_WARP_PARAM_REDUCE_BITS) << AV1_WARP_PARAM_REDUCE_BITS;

194 beta = round_two_signed(beta, AV1_WARP_PARAM_REDUCE_BITS) << AV1_WARP_PARAM_REDUCE_BITS;

195 gamma = round_two_signed(gamma, AV1_WARP_PARAM_REDUCE_BITS) << AV1_WARP_PARAM_REDUCE_BITS;

196 delta = round_two_signed(delta, AV1_WARP_PARAM_REDUCE_BITS) << AV1_WARP_PARAM_REDUCE_BITS;

197

198 if ((4 * abs(alpha) + 7 * abs(beta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS) ||

199 (4 * abs(gamma) + 4 * abs(delta)) >= (1 << AV1_WARPEDMODEL_PREC_BITS))

200 return 0;

201

202 return 1;

203 }

204

205 /**

206 * update gm type/params, since cbs already implemented part of this function,

207 * so we don't need to full implement spec.

208 */

209 static void global_motion_params(AV1DecContext *s)

210 {

211 const AV1RawFrameHeader *header = s->raw_frame_header;

212 int type, ref;

213

214 for (ref = AV1_REF_FRAME_LAST; ref <= AV1_REF_FRAME_ALTREF; ref++) {

215 s->cur_frame.gm_type[ref] = AV1_WARP_MODEL_IDENTITY;

216 for (int i = 0; i < 6; i++)

217 s->cur_frame.gm_params[ref][i] = (i % 3 == 2) ?

218 1 << AV1_WARPEDMODEL_PREC_BITS : 0;

219 }

220 if (header->frame_type == AV1_FRAME_KEY ||

221 header->frame_type == AV1_FRAME_INTRA_ONLY)

222 return;

223

224 for (ref = AV1_REF_FRAME_LAST; ref <= AV1_REF_FRAME_ALTREF; ref++) {

225 if (header->is_global[ref]) {

226 if (header->is_rot_zoom[ref]) {

227 type = AV1_WARP_MODEL_ROTZOOM;

228 } else {

229 type = header->is_translation[ref] ? AV1_WARP_MODEL_TRANSLATION

230 : AV1_WARP_MODEL_AFFINE;

231 }

232 } else {

233 type = AV1_WARP_MODEL_IDENTITY;

234 }

235 s->cur_frame.gm_type[ref] = type;

236

237 if (type >= AV1_WARP_MODEL_ROTZOOM) {

238 read_global_param(s, type, ref, 2);

239 read_global_param(s, type, ref, 3);

240 if (type == AV1_WARP_MODEL_AFFINE) {

241 read_global_param(s, type, ref, 4);

242 read_global_param(s, type, ref, 5);

243 } else {

244 s->cur_frame.gm_params[ref][4] = -s->cur_frame.gm_params[ref][3];

245 s->cur_frame.gm_params[ref][5] = s->cur_frame.gm_params[ref][2];

246 }

247 }

248 if (type >= AV1_WARP_MODEL_TRANSLATION) {

249 read_global_param(s, type, ref, 0);

250 read_global_param(s, type, ref, 1);

251 }

252 if (type <= AV1_WARP_MODEL_AFFINE) {

253 s->cur_frame.gm_invalid[ref] = !get_shear_params_valid(s, ref);

254 }

255 }

256 }

257

258 static int get_relative_dist(const AV1RawSequenceHeader *seq,

259 unsigned int a, unsigned int b)

260 {

261 unsigned int diff = a - b;

262 unsigned int m = 1 << seq->order_hint_bits_minus_1;

263 return (diff & (m - 1)) - (diff & m);

264 }

265

266 static void skip_mode_params(AV1DecContext *s)

267 {

268 const AV1RawFrameHeader *header = s->raw_frame_header;

269 const AV1RawSequenceHeader *seq = s->raw_seq;

270

271 int forward_idx, backward_idx;

272 int forward_hint, backward_hint;

273 int second_forward_idx, second_forward_hint;

274 int ref_hint, dist, i;

275

276 if (header->frame_type == AV1_FRAME_KEY ||

277 header->frame_type == AV1_FRAME_INTRA_ONLY ||

278 !header->reference_select || !seq->enable_order_hint)

279 return;

280

281 forward_idx = -1;

282 backward_idx = -1;

283 for (i = 0; i < AV1_REFS_PER_FRAME; i++) {

284 ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;

285 dist = get_relative_dist(seq, ref_hint, header->order_hint);

286 if (dist < 0) {

287 if (forward_idx < 0 ||

288 get_relative_dist(seq, ref_hint, forward_hint) > 0) {

289 forward_idx = i;

290 forward_hint = ref_hint;

291 }

292 } else if (dist > 0) {

293 if (backward_idx < 0 ||

294 get_relative_dist(seq, ref_hint, backward_hint) < 0) {

295 backward_idx = i;

296 backward_hint = ref_hint;

297 }

298 }

299 }

300

301 if (forward_idx < 0) {

302 return;

303 } else if (backward_idx >= 0) {

304 s->cur_frame.skip_mode_frame_idx[0] =

305 AV1_REF_FRAME_LAST + FFMIN(forward_idx, backward_idx);

306 s->cur_frame.skip_mode_frame_idx[1] =

307 AV1_REF_FRAME_LAST + FFMAX(forward_idx, backward_idx);

308 return;

309 }

310

311 second_forward_idx = -1;

312 for (i = 0; i < AV1_REFS_PER_FRAME; i++) {

313 ref_hint = s->ref[header->ref_frame_idx[i]].raw_frame_header->order_hint;

314 if (get_relative_dist(seq, ref_hint, forward_hint) < 0) {

315 if (second_forward_idx < 0 ||

316 get_relative_dist(seq, ref_hint, second_forward_hint) > 0) {

317 second_forward_idx = i;

318 second_forward_hint = ref_hint;

319 }

320 }

321 }

322

323 if (second_forward_idx < 0)

324 return;

325

326 s->cur_frame.skip_mode_frame_idx[0] =

327 AV1_REF_FRAME_LAST + FFMIN(forward_idx, second_forward_idx);

328 s->cur_frame.skip_mode_frame_idx[1] =

329 AV1_REF_FRAME_LAST + FFMAX(forward_idx, second_forward_idx);

330 }

331

332 static void coded_lossless_param(AV1DecContext *s)

333 {

334 const AV1RawFrameHeader *header = s->raw_frame_header;

335 int i;

336

337 if (header->delta_q_y_dc || header->delta_q_u_ac ||

338 header->delta_q_u_dc || header->delta_q_v_ac ||

339 header->delta_q_v_dc) {

340 s->cur_frame.coded_lossless = 0;

341 return;

342 }

343

344 s->cur_frame.coded_lossless = 1;

345 for (i = 0; i < AV1_MAX_SEGMENTS; i++) {

346 int qindex;

347 if (header->feature_enabled[i][AV1_SEG_LVL_ALT_Q]) {

348 qindex = (header->base_q_idx +

349 header->feature_value[i][AV1_SEG_LVL_ALT_Q]);

350 } else {

351 qindex = header->base_q_idx;

352 }

353 qindex = av_clip_uintp2(qindex, 8);

354

355 if (qindex) {

356 s->cur_frame.coded_lossless = 0;

357 return;

358 }

359 }

360 }

361

362 static void order_hint_info(AV1DecContext *s)

363 {

364 const AV1RawFrameHeader *header = s->raw_frame_header;

365 const AV1RawSequenceHeader *seq = s->raw_seq;

366 AV1Frame *frame = &s->cur_frame;

367

368 frame->order_hint = header->order_hint;

369

370 for (int i = 0; i < AV1_REFS_PER_FRAME; i++) {

371 int ref_name = i + AV1_REF_FRAME_LAST;

372 int ref_slot = header->ref_frame_idx[i];

373 int ref_order_hint = s->ref[ref_slot].order_hint;

374

375 frame->order_hints[ref_name] = ref_order_hint;

376 if (!seq->enable_order_hint) {

377 frame->ref_frame_sign_bias[ref_name] = 0;

378 } else {

379 frame->ref_frame_sign_bias[ref_name] =

380 get_relative_dist(seq, ref_order_hint,

381 frame->order_hint) > 0;

382 }

383 }

384 }

385

386 static void load_grain_params(AV1DecContext *s)

387 {

388 const AV1RawFrameHeader *header = s->raw_frame_header;

389 const AV1RawFilmGrainParams *film_grain = &header->film_grain, *src;

390 AV1RawFilmGrainParams *dst = &s->cur_frame.film_grain;

391

392 if (!film_grain->apply_grain)

393 return;

394

395 if (film_grain->update_grain) {

396 memcpy(dst, film_grain, sizeof(*dst));

397 return;

398 }

399

400 src = &s->ref[film_grain->film_grain_params_ref_idx].film_grain;

401

402 memcpy(dst, src, sizeof(*dst));

403 dst->grain_seed = film_grain->grain_seed;

404 }

405

406 static int init_tile_data(AV1DecContext *s)

407

408 {

409 int cur_tile_num =

410 s->raw_frame_header->tile_cols * s->raw_frame_header->tile_rows;

411 if (s->tile_num < cur_tile_num) {

412 int ret = av_reallocp_array(&s->tile_group_info, cur_tile_num,

413 sizeof(TileGroupInfo));

414 if (ret < 0) {

415 s->tile_num = 0;

416 return ret;

417 }

418 }

419 s->tile_num = cur_tile_num;

420

421 return 0;

422 }

423

424 static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)

425 {

426 AV1DecContext *s = avctx->priv_data;

427 GetByteContext gb;

428 uint16_t tile_num, tile_row, tile_col;

429 uint32_t size = 0, size_bytes = 0;

430

431 bytestream2_init(&gb, tile_group->tile_data.data,

432 tile_group->tile_data.data_size);

433 s->tg_start = tile_group->tg_start;

434 s->tg_end = tile_group->tg_end;

435

436 for (tile_num = tile_group->tg_start; tile_num <= tile_group->tg_end; tile_num++) {

437 tile_row = tile_num / s->raw_frame_header->tile_cols;

438 tile_col = tile_num % s->raw_frame_header->tile_cols;

439

440 if (tile_num == tile_group->tg_end) {

441 s->tile_group_info[tile_num].tile_size = bytestream2_get_bytes_left(&gb);

442 s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);

443 s->tile_group_info[tile_num].tile_row = tile_row;

444 s->tile_group_info[tile_num].tile_column = tile_col;

445 return 0;

446 }

447 size_bytes = s->raw_frame_header->tile_size_bytes_minus1 + 1;

448 if (bytestream2_get_bytes_left(&gb) < size_bytes)

449 return AVERROR_INVALIDDATA;

450 size = 0;

451 for (int i = 0; i < size_bytes; i++)

452 size |= bytestream2_get_byteu(&gb) << 8 * i;

453 if (bytestream2_get_bytes_left(&gb) <= size)

454 return AVERROR_INVALIDDATA;

455 size++;

456

457 s->tile_group_info[tile_num].tile_size = size;

458 s->tile_group_info[tile_num].tile_offset = bytestream2_tell(&gb);

459 s->tile_group_info[tile_num].tile_row = tile_row;

460 s->tile_group_info[tile_num].tile_column = tile_col;

461

462 bytestream2_skipu(&gb, size);

463 }

464

465 return 0;

466

467 }

468

469 static enum AVPixelFormat get_sw_pixel_format(void *logctx,

470 const AV1RawSequenceHeader *seq)

471 {

472 int bit_depth;

473 enum AVPixelFormat pix_fmt = AV_PIX_FMT_NONE;

474

475 if (seq->seq_profile == 2 && seq->color_config.high_bitdepth)

476 bit_depth = seq->color_config.twelve_bit ? 12 : 10;

477 else if (seq->seq_profile <= 2)

478 bit_depth = seq->color_config.high_bitdepth ? 10 : 8;

479 else {

480 av_log(logctx, AV_LOG_ERROR,

481 "Unknown AV1 profile %d.\n", seq->seq_profile);

482 return AV_PIX_FMT_NONE;

483 }

484

485 if (!seq->color_config.mono_chrome) {

486 // 4:4:4 x:0 y:0, 4:2:2 x:1 y:0, 4:2:0 x:1 y:1

487 if (seq->color_config.subsampling_x == 0 &&

488 seq->color_config.subsampling_y == 0) {

489 if (bit_depth == 8)

490 pix_fmt = AV_PIX_FMT_YUV444P;

491 else if (bit_depth == 10)

492 pix_fmt = AV_PIX_FMT_YUV444P10;

493 else if (bit_depth == 12)

494 pix_fmt = AV_PIX_FMT_YUV444P12;

495 else

496 av_assert0(0);

497 } else if (seq->color_config.subsampling_x == 1 &&

498 seq->color_config.subsampling_y == 0) {

499 if (bit_depth == 8)

500 pix_fmt = AV_PIX_FMT_YUV422P;

501 else if (bit_depth == 10)

502 pix_fmt = AV_PIX_FMT_YUV422P10;

503 else if (bit_depth == 12)

504 pix_fmt = AV_PIX_FMT_YUV422P12;

505 else

506 av_assert0(0);

507 } else if (seq->color_config.subsampling_x == 1 &&

508 seq->color_config.subsampling_y == 1) {

509 if (bit_depth == 8)

510 pix_fmt = AV_PIX_FMT_YUV420P;

511 else if (bit_depth == 10)

512 pix_fmt = AV_PIX_FMT_YUV420P10;

513 else if (bit_depth == 12)

514 pix_fmt = AV_PIX_FMT_YUV420P12;

515 else

516 av_assert0(0);

517 }

518 } else {

519 if (bit_depth == 8)

520 pix_fmt = AV_PIX_FMT_GRAY8;

521 else if (bit_depth == 10)

522 pix_fmt = AV_PIX_FMT_GRAY10;

523 else if (bit_depth == 12)

524 pix_fmt = AV_PIX_FMT_GRAY12;

525 else

526 av_assert0(0);

527 }

528

529 return pix_fmt;

530 }

531

532 static int get_pixel_format(AVCodecContext *avctx)

533 {

534 AV1DecContext *s = avctx->priv_data;

535 const AV1RawSequenceHeader *seq = s->raw_seq;

536 int ret;

537 enum AVPixelFormat pix_fmt = get_sw_pixel_format(avctx, seq);

538 #define HWACCEL_MAX (CONFIG_AV1_DXVA2_HWACCEL + \

539 CONFIG_AV1_D3D11VA_HWACCEL * 2 + \

540 CONFIG_AV1_D3D12VA_HWACCEL + \

541 CONFIG_AV1_NVDEC_HWACCEL + \

542 CONFIG_AV1_VAAPI_HWACCEL + \

543 CONFIG_AV1_VDPAU_HWACCEL + \

544 CONFIG_AV1_VULKAN_HWACCEL)

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

546

547 if (pix_fmt == AV_PIX_FMT_NONE)

548 return -1;

549

550 switch (pix_fmt) {

551 case AV_PIX_FMT_YUV420P:

552 #if CONFIG_AV1_DXVA2_HWACCEL

553 *fmtp++ = AV_PIX_FMT_DXVA2_VLD;

554 #endif

555 #if CONFIG_AV1_D3D11VA_HWACCEL

556 *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;

557 *fmtp++ = AV_PIX_FMT_D3D11;

558 #endif

559 #if CONFIG_AV1_D3D12VA_HWACCEL

560 *fmtp++ = AV_PIX_FMT_D3D12;

561 #endif

562 #if CONFIG_AV1_NVDEC_HWACCEL

563 *fmtp++ = AV_PIX_FMT_CUDA;

564 #endif

565 #if CONFIG_AV1_VAAPI_HWACCEL

566 *fmtp++ = AV_PIX_FMT_VAAPI;

567 #endif

568 #if CONFIG_AV1_VDPAU_HWACCEL

569 *fmtp++ = AV_PIX_FMT_VDPAU;

570 #endif

571 #if CONFIG_AV1_VULKAN_HWACCEL

572 *fmtp++ = AV_PIX_FMT_VULKAN;

573 #endif

574 break;

575 case AV_PIX_FMT_YUV420P10:

576 #if CONFIG_AV1_DXVA2_HWACCEL

577 *fmtp++ = AV_PIX_FMT_DXVA2_VLD;

578 #endif

579 #if CONFIG_AV1_D3D11VA_HWACCEL

580 *fmtp++ = AV_PIX_FMT_D3D11VA_VLD;

581 *fmtp++ = AV_PIX_FMT_D3D11;

582 #endif

583 #if CONFIG_AV1_D3D12VA_HWACCEL

584 *fmtp++ = AV_PIX_FMT_D3D12;

585 #endif

586 #if CONFIG_AV1_NVDEC_HWACCEL

587 *fmtp++ = AV_PIX_FMT_CUDA;

588 #endif

589 #if CONFIG_AV1_VAAPI_HWACCEL

590 *fmtp++ = AV_PIX_FMT_VAAPI;

591 #endif

592 #if CONFIG_AV1_VDPAU_HWACCEL

593 *fmtp++ = AV_PIX_FMT_VDPAU;

594 #endif

595 #if CONFIG_AV1_VULKAN_HWACCEL

596 *fmtp++ = AV_PIX_FMT_VULKAN;

597 #endif

598 break;

599 case AV_PIX_FMT_YUV420P12:

600 #if CONFIG_AV1_VULKAN_HWACCEL

601 *fmtp++ = AV_PIX_FMT_VULKAN;

602 #endif

603 break;

604 case AV_PIX_FMT_YUV422P:

605 #if CONFIG_AV1_VULKAN_HWACCEL

606 *fmtp++ = AV_PIX_FMT_VULKAN;

607 #endif

608 break;

609 case AV_PIX_FMT_YUV422P10:

610 #if CONFIG_AV1_VULKAN_HWACCEL

611 *fmtp++ = AV_PIX_FMT_VULKAN;

612 #endif

613 break;

614 case AV_PIX_FMT_YUV422P12:

615 #if CONFIG_AV1_VULKAN_HWACCEL

616 *fmtp++ = AV_PIX_FMT_VULKAN;

617 #endif

618 break;

619 case AV_PIX_FMT_YUV444P:

620 #if CONFIG_AV1_VULKAN_HWACCEL

621 *fmtp++ = AV_PIX_FMT_VULKAN;

622 #endif

623 break;

624 case AV_PIX_FMT_YUV444P10:

625 #if CONFIG_AV1_VULKAN_HWACCEL

626 *fmtp++ = AV_PIX_FMT_VULKAN;

627 #endif

628 break;

629 case AV_PIX_FMT_YUV444P12:

630 #if CONFIG_AV1_VULKAN_HWACCEL

631 *fmtp++ = AV_PIX_FMT_VULKAN;

632 #endif

633 break;

634 case AV_PIX_FMT_GRAY8:

635 #if CONFIG_AV1_NVDEC_HWACCEL

636 *fmtp++ = AV_PIX_FMT_CUDA;

637 #endif

638 break;

639 case AV_PIX_FMT_GRAY10:

640 #if CONFIG_AV1_NVDEC_HWACCEL

641 *fmtp++ = AV_PIX_FMT_CUDA;

642 #endif

643 break;

644 }

645

646 *fmtp++ = pix_fmt;

647 *fmtp = AV_PIX_FMT_NONE;

648

649 for (int i = 0; pix_fmts[i] != pix_fmt; i++)

650 if (pix_fmts[i] == avctx->pix_fmt) {

651 s->pix_fmt = pix_fmt;

652 return 1;

653 }

654

655 ret = ff_get_format(avctx, pix_fmts);

656

657 /**

658 * check if the HW accel is inited correctly. If not, return un-implemented.

659 * Since now the av1 decoder doesn't support native decode, if it will be

660 * implemented in the future, need remove this check.

661 */

662 if (!avctx->hwaccel) {

663 av_log(avctx, AV_LOG_ERROR, "Your platform doesn't support"

664 " hardware accelerated AV1 decoding.\n");

665 avctx->pix_fmt = AV_PIX_FMT_NONE;

666 return AVERROR(ENOSYS);

667 }

668

669 s->pix_fmt = pix_fmt;

670 avctx->pix_fmt = ret;

671

672 av_log(avctx, AV_LOG_DEBUG, "AV1 decode get format: %s.\n",

673 av_get_pix_fmt_name(avctx->pix_fmt));

674

675 return 0;

676 }

677

678 static void av1_frame_unref(AV1Frame *f)

679 {

680 ff_progress_frame_unref(&f->pf);

681 ff_refstruct_unref(&f->hwaccel_picture_private);

682 ff_refstruct_unref(&f->header_ref);

683 f->raw_frame_header = NULL;

684 f->spatial_id = f->temporal_id = 0;

685 memset(f->skip_mode_frame_idx, 0,

686 2 * sizeof(uint8_t));

687 memset(&f->film_grain, 0, sizeof(f->film_grain));

688 f->coded_lossless = 0;

689 }

690

691 static void av1_frame_replace(AV1Frame *dst, const AV1Frame *src)

692 {

693 av_assert1(dst != src);

694

695 ff_refstruct_replace(&dst->header_ref, src->header_ref);

696

697 dst->raw_frame_header = src->raw_frame_header;

698

699 ff_progress_frame_replace(&dst->pf, &src->pf);

700

701 ff_refstruct_replace(&dst->hwaccel_picture_private,

702 src->hwaccel_picture_private);

703

704 dst->spatial_id = src->spatial_id;

705 dst->temporal_id = src->temporal_id;

706 memcpy(dst->gm_invalid,

707 src->gm_invalid,

708 AV1_NUM_REF_FRAMES * sizeof(uint8_t));

709 memcpy(dst->gm_type,

710 src->gm_type,

711 AV1_NUM_REF_FRAMES * sizeof(uint8_t));

712 memcpy(dst->gm_params,

713 src->gm_params,

714 AV1_NUM_REF_FRAMES * 6 * sizeof(int32_t));

715 memcpy(dst->skip_mode_frame_idx,

716 src->skip_mode_frame_idx,

717 2 * sizeof(uint8_t));

718 memcpy(&dst->film_grain,

719 &src->film_grain,

720 sizeof(dst->film_grain));

721 dst->coded_lossless = src->coded_lossless;

722

723 dst->order_hint = src->order_hint;

724 memcpy(dst->ref_frame_sign_bias, src->ref_frame_sign_bias,

725 sizeof(dst->ref_frame_sign_bias));

726 memcpy(dst->order_hints, src->order_hints,

727 sizeof(dst->order_hints));

728

729 dst->force_integer_mv = src->force_integer_mv;

730 }

731

732 static av_cold int av1_decode_free(AVCodecContext *avctx)

733 {

734 AV1DecContext *s = avctx->priv_data;

735 AV1RawMetadataITUTT35 itut_t35;

736

737 for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)

738 av1_frame_unref(&s->ref[i]);

739 av1_frame_unref(&s->cur_frame);

740 av_buffer_unref(&s->seq_data_ref);

741 ff_refstruct_unref(&s->seq_ref);

742 ff_refstruct_unref(&s->header_ref);

743 ff_refstruct_unref(&s->cll_ref);

744 ff_refstruct_unref(&s->mdcv_ref);

745 av_freep(&s->tile_group_info);

746

747 while (s->itut_t35_fifo && av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)

748 av_buffer_unref(&itut_t35.payload_ref);

749 av_fifo_freep2(&s->itut_t35_fifo);

750

751 ff_cbs_fragment_free(&s->current_obu);

752 ff_cbs_close(&s->cbc);

753 ff_dovi_ctx_unref(&s->dovi);

754

755 return 0;

756 }

757

758 static int set_context_with_sequence(AVCodecContext *avctx,

759 const AV1RawSequenceHeader *seq)

760 {

761 int width = seq->max_frame_width_minus_1 + 1;

762 int height = seq->max_frame_height_minus_1 + 1;

763

764 avctx->profile = seq->seq_profile;

765 avctx->level = seq->seq_level_idx[0];

766

767 avctx->color_range =

768 seq->color_config.color_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;

769 avctx->color_primaries = seq->color_config.color_primaries;

770 avctx->colorspace = seq->color_config.matrix_coefficients;

771 avctx->color_trc = seq->color_config.transfer_characteristics;

772

773 switch (seq->color_config.chroma_sample_position) {

774 case AV1_CSP_VERTICAL:

775 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

776 break;

777 case AV1_CSP_COLOCATED:

778 avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;

779 break;

780 }

781

782 if (seq->film_grain_params_present)

783 avctx->properties |= FF_CODEC_PROPERTY_FILM_GRAIN;

784 else

785 avctx->properties &= ~FF_CODEC_PROPERTY_FILM_GRAIN;

786

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

788 int ret = ff_set_dimensions(avctx, width, height);

789 if (ret < 0)

790 return ret;

791 }

792

793 if (seq->timing_info_present_flag)

794 avctx->framerate = ff_av1_framerate(1LL + seq->timing_info.num_ticks_per_picture_minus_1,

795 seq->timing_info.num_units_in_display_tick,

796 seq->timing_info.time_scale);

797

798 if (avctx->pix_fmt == AV_PIX_FMT_NONE)

799 avctx->pix_fmt = get_sw_pixel_format(avctx, seq);

800

801 return 0;

802 }

803

804 static int update_context_with_frame_header(AVCodecContext *avctx,

805 const AV1RawFrameHeader *header)

806 {

807 AVRational aspect_ratio;

808 int width = header->frame_width_minus_1 + 1;

809 int height = header->frame_height_minus_1 + 1;

810 int r_width = header->render_width_minus_1 + 1;

811 int r_height = header->render_height_minus_1 + 1;

812 int ret;

813

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

815 ret = ff_set_dimensions(avctx, width, height);

816 if (ret < 0)

817 return ret;

818 }

819

820 av_reduce(&aspect_ratio.num, &aspect_ratio.den,

821 (int64_t)height * r_width,

822 (int64_t)width * r_height,

823 INT_MAX);

824

825 if (av_cmp_q(avctx->sample_aspect_ratio, aspect_ratio)) {

826 ret = ff_set_sar(avctx, aspect_ratio);

827 if (ret < 0)

828 return ret;

829 }

830

831 return 0;

832 }

833

834 static const CodedBitstreamUnitType decompose_unit_types[] = {

835 AV1_OBU_FRAME,

836 AV1_OBU_FRAME_HEADER,

837 AV1_OBU_METADATA,

838 AV1_OBU_REDUNDANT_FRAME_HEADER,

839 AV1_OBU_SEQUENCE_HEADER,

840 AV1_OBU_TEMPORAL_DELIMITER,

841 AV1_OBU_TILE_GROUP,

842 };

843

844 static av_cold int av1_decode_init(AVCodecContext *avctx)

845 {

846 AV1DecContext *s = avctx->priv_data;

847 AV1RawSequenceHeader *seq;

848 const AVPacketSideData *sd;

849 int ret;

850

851 s->avctx = avctx;

852 s->pkt = avctx->internal->in_pkt;

853 s->pix_fmt = AV_PIX_FMT_NONE;

854

855 ret = ff_cbs_init(&s->cbc, AV_CODEC_ID_AV1, avctx);

856 if (ret < 0)

857 return ret;

858

859 s->cbc->decompose_unit_types = decompose_unit_types;

860 s->cbc->nb_decompose_unit_types = FF_ARRAY_ELEMS(decompose_unit_types);

861

862 s->itut_t35_fifo = av_fifo_alloc2(1, sizeof(AV1RawMetadataITUTT35),

863 AV_FIFO_FLAG_AUTO_GROW);

864 if (!s->itut_t35_fifo)

865 return AVERROR(ENOMEM);

866

867 av_opt_set_int(s->cbc->priv_data, "operating_point", s->operating_point, 0);

868

869 if (avctx->extradata && avctx->extradata_size) {

870 ret = ff_cbs_read_extradata_from_codec(s->cbc,

871 &s->current_obu,

872 avctx);

873 if (ret < 0) {

874 av_log(avctx, AV_LOG_WARNING, "Failed to read extradata.\n");

875 goto end;

876 }

877

878 seq = ((CodedBitstreamAV1Context *)(s->cbc->priv_data))->sequence_header;

879 if (!seq) {

880 av_log(avctx, AV_LOG_WARNING, "No sequence header available.\n");

881 goto end;

882 }

883

884 ret = set_context_with_sequence(avctx, seq);

885 if (ret < 0) {

886 av_log(avctx, AV_LOG_WARNING, "Failed to set decoder context.\n");

887 goto end;

888 }

889

890 end:

891 ff_cbs_fragment_reset(&s->current_obu);

892 }

893

894 s->dovi.logctx = avctx;

895 s->dovi.cfg.dv_profile = 10; // default for AV1

896 sd = ff_get_coded_side_data(avctx, AV_PKT_DATA_DOVI_CONF);

897 if (sd && sd->size >= sizeof(s->dovi.cfg))

898 s->dovi.cfg = *(AVDOVIDecoderConfigurationRecord *) sd->data;

899

900 return ret;

901 }

902

903 static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)

904 {

905 AV1DecContext *s = avctx->priv_data;

906 AV1RawFrameHeader *header= s->raw_frame_header;

907 AVFrame *frame;

908 int ret;

909

910 ret = update_context_with_frame_header(avctx, header);

911 if (ret < 0) {

912 av_log(avctx, AV_LOG_ERROR, "Failed to update context with frame header\n");

913 return ret;

914 }

915

916 ret = ff_progress_frame_get_buffer(avctx, &f->pf, AV_GET_BUFFER_FLAG_REF);

917 if (ret < 0)

918 goto fail;

919

920 frame = f->f;

921 if (header->frame_type == AV1_FRAME_KEY)

922 frame->flags |= AV_FRAME_FLAG_KEY;

923 else

924 frame->flags &= ~AV_FRAME_FLAG_KEY;

925

926 switch (header->frame_type) {

927 case AV1_FRAME_KEY:

928 case AV1_FRAME_INTRA_ONLY:

929 frame->pict_type = AV_PICTURE_TYPE_I;

930 break;

931 case AV1_FRAME_INTER:

932 frame->pict_type = AV_PICTURE_TYPE_P;

933 break;

934 case AV1_FRAME_SWITCH:

935 frame->pict_type = AV_PICTURE_TYPE_SP;

936 break;

937 }

938

939 ret = ff_hwaccel_frame_priv_alloc(avctx, &f->hwaccel_picture_private);

940 if (ret < 0)

941 goto fail;

942

943 return 0;

944

945 fail:

946 av1_frame_unref(f);

947 return ret;

948 }

949

950 static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame,

951 const AV1RawMetadataITUTT35 *itut_t35)

952 {

953 GetByteContext gb;

954 AV1DecContext *s = avctx->priv_data;

955 int ret, provider_code;

956

957 bytestream2_init(&gb, itut_t35->payload, itut_t35->payload_size);

958

959 provider_code = bytestream2_get_be16(&gb);

960 switch (provider_code) {

961 case ITU_T_T35_PROVIDER_CODE_ATSC: {

962 uint32_t user_identifier = bytestream2_get_be32(&gb);

963 switch (user_identifier) {

964 case MKBETAG('G', 'A', '9', '4'): { // closed captions

965 AVBufferRef *buf = NULL;

966

967 ret = ff_parse_a53_cc(&buf, gb.buffer, bytestream2_get_bytes_left(&gb));

968 if (ret < 0)

969 return ret;

970 if (!ret)

971 break;

972

973 ret = ff_frame_new_side_data_from_buf(avctx, frame, AV_FRAME_DATA_A53_CC, &buf);

974 if (ret < 0)

975 return ret;

976

977 avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;

978 break;

979 }

980 default: // ignore unsupported identifiers

981 break;

982 }

983 break;

984 }

985 case ITU_T_T35_PROVIDER_CODE_SMTPE: {

986 AVDynamicHDRPlus *hdrplus;

987 int provider_oriented_code = bytestream2_get_be16(&gb);

988 int application_identifier = bytestream2_get_byte(&gb);

989

990 if (itut_t35->itu_t_t35_country_code != ITU_T_T35_COUNTRY_CODE_US ||

991 provider_oriented_code != 1 || application_identifier != 4)

992 break;

993

994 hdrplus = av_dynamic_hdr_plus_create_side_data(frame);

995 if (!hdrplus)

996 return AVERROR(ENOMEM);

997

998 ret = av_dynamic_hdr_plus_from_t35(hdrplus, gb.buffer,

999 bytestream2_get_bytes_left(&gb));

1000 if (ret < 0)

1001 return ret;

1002 break;

1003 }

1004 case ITU_T_T35_PROVIDER_CODE_DOLBY: {

1005 int provider_oriented_code = bytestream2_get_be32(&gb);

1006 if (itut_t35->itu_t_t35_country_code != ITU_T_T35_COUNTRY_CODE_US ||

1007 provider_oriented_code != 0x800)

1008 break;

1009

1010 ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer,

1011 avctx->err_recognition);

1012 if (ret < 0) {

1013 av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");

1014 break; // ignore

1015 }

1016

1017 ret = ff_dovi_attach_side_data(&s->dovi, frame);

1018 if (ret < 0)

1019 return ret;

1020 break;

1021 }

1022 default: // ignore unsupported provider codes

1023 break;

1024 }

1025

1026 return 0;

1027 }

1028

1029 static int export_metadata(AVCodecContext *avctx, AVFrame *frame)

1030 {

1031 AV1DecContext *s = avctx->priv_data;

1032 AV1RawMetadataITUTT35 itut_t35;

1033 int ret = 0;

1034

1035 if (s->mdcv) {

1036 AVMasteringDisplayMetadata *mastering;

1037

1038 ret = ff_decode_mastering_display_new(avctx, frame, &mastering);

1039 if (ret < 0)

1040 return ret;

1041

1042 if (mastering) {

1043 for (int i = 0; i < 3; i++) {

1044 mastering->display_primaries[i][0] = av_make_q(s->mdcv->primary_chromaticity_x[i], 1 << 16);

1045 mastering->display_primaries[i][1] = av_make_q(s->mdcv->primary_chromaticity_y[i], 1 << 16);

1046 }

1047 mastering->white_point[0] = av_make_q(s->mdcv->white_point_chromaticity_x, 1 << 16);

1048 mastering->white_point[1] = av_make_q(s->mdcv->white_point_chromaticity_y, 1 << 16);

1049

1050 mastering->max_luminance = av_make_q(s->mdcv->luminance_max, 1 << 8);

1051 mastering->min_luminance = av_make_q(s->mdcv->luminance_min, 1 << 14);

1052

1053 mastering->has_primaries = 1;

1054 mastering->has_luminance = 1;

1055 }

1056 }

1057

1058 if (s->cll) {

1059 AVContentLightMetadata *light;

1060

1061 ret = ff_decode_content_light_new(avctx, frame, &light);

1062 if (ret < 0)

1063 return ret;

1064

1065 if (light) {

1066 light->MaxCLL = s->cll->max_cll;

1067 light->MaxFALL = s->cll->max_fall;

1068 }

1069 }

1070

1071 while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0) {

1072 if (ret >= 0)

1073 ret = export_itut_t35(avctx, frame, &itut_t35);

1074 av_buffer_unref(&itut_t35.payload_ref);

1075 }

1076

1077 return ret;

1078 }

1079

1080 static int export_film_grain(AVCodecContext *avctx, AVFrame *frame)

1081 {

1082 AV1DecContext *s = avctx->priv_data;

1083 const AV1RawFilmGrainParams *film_grain = &s->cur_frame.film_grain;

1084 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(frame->format);

1085 AVFilmGrainParams *fgp;

1086 AVFilmGrainAOMParams *aom;

1087

1088 av_assert0(pixdesc);

1089 if (!film_grain->apply_grain)

1090 return 0;

1091

1092 fgp = av_film_grain_params_create_side_data(frame);

1093 if (!fgp)

1094 return AVERROR(ENOMEM);

1095

1096 fgp->type = AV_FILM_GRAIN_PARAMS_AV1;

1097 fgp->seed = film_grain->grain_seed;

1098 fgp->width = frame->width;

1099 fgp->height = frame->height;

1100 fgp->color_range = frame->color_range;

1101 fgp->color_primaries = frame->color_primaries;

1102 fgp->color_trc = frame->color_trc;

1103 fgp->color_space = frame->colorspace;

1104 fgp->subsampling_x = pixdesc->log2_chroma_w;

1105 fgp->subsampling_y = pixdesc->log2_chroma_h;

1106

1107 aom = &fgp->codec.aom;

1108 aom->chroma_scaling_from_luma = film_grain->chroma_scaling_from_luma;

1109 aom->scaling_shift = film_grain->grain_scaling_minus_8 + 8;

1110 aom->ar_coeff_lag = film_grain->ar_coeff_lag;

1111 aom->ar_coeff_shift = film_grain->ar_coeff_shift_minus_6 + 6;

1112 aom->grain_scale_shift = film_grain->grain_scale_shift;

1113 aom->overlap_flag = film_grain->overlap_flag;

1114 aom->limit_output_range = film_grain->clip_to_restricted_range;

1115

1116 aom->num_y_points = film_grain->num_y_points;

1117 for (int i = 0; i < film_grain->num_y_points; i++) {

1118 aom->y_points[i][0] = film_grain->point_y_value[i];

1119 aom->y_points[i][1] = film_grain->point_y_scaling[i];

1120 }

1121 aom->num_uv_points[0] = film_grain->num_cb_points;

1122 for (int i = 0; i < film_grain->num_cb_points; i++) {

1123 aom->uv_points[0][i][0] = film_grain->point_cb_value[i];

1124 aom->uv_points[0][i][1] = film_grain->point_cb_scaling[i];

1125 }

1126 aom->num_uv_points[1] = film_grain->num_cr_points;

1127 for (int i = 0; i < film_grain->num_cr_points; i++) {

1128 aom->uv_points[1][i][0] = film_grain->point_cr_value[i];

1129 aom->uv_points[1][i][1] = film_grain->point_cr_scaling[i];

1130 }

1131

1132 for (int i = 0; i < 24; i++) {

1133 aom->ar_coeffs_y[i] = film_grain->ar_coeffs_y_plus_128[i] - 128;

1134 }

1135 for (int i = 0; i < 25; i++) {

1136 aom->ar_coeffs_uv[0][i] = film_grain->ar_coeffs_cb_plus_128[i] - 128;

1137 aom->ar_coeffs_uv[1][i] = film_grain->ar_coeffs_cr_plus_128[i] - 128;

1138 }

1139

1140 aom->uv_mult[0] = film_grain->cb_mult;

1141 aom->uv_mult[1] = film_grain->cr_mult;

1142 aom->uv_mult_luma[0] = film_grain->cb_luma_mult;

1143 aom->uv_mult_luma[1] = film_grain->cr_luma_mult;

1144 aom->uv_offset[0] = film_grain->cb_offset;

1145 aom->uv_offset[1] = film_grain->cr_offset;

1146

1147 return 0;

1148 }

1149

1150 static int set_output_frame(AVCodecContext *avctx, AVFrame *frame)

1151 {

1152 AV1DecContext *s = avctx->priv_data;

1153 const AVFrame *srcframe = s->cur_frame.f;

1154 AVPacket *pkt = s->pkt;

1155 int ret;

1156

1157 // TODO: all layers

1158 if (s->operating_point_idc &&

1159 av_log2(s->operating_point_idc >> 8) > s->cur_frame.spatial_id)

1160 return 0;

1161

1162 ret = av_frame_ref(frame, srcframe);

1163 if (ret < 0)

1164 return ret;

1165

1166 ret = export_metadata(avctx, frame);

1167 if (ret < 0) {

1168 av_frame_unref(frame);

1169 return ret;

1170 }

1171

1172 if (avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN) {

1173 ret = export_film_grain(avctx, frame);

1174 if (ret < 0) {

1175 av_frame_unref(frame);

1176 return ret;

1177 }

1178 }

1179

1180 frame->pts = pkt->pts;

1181 frame->pkt_dts = pkt->dts;

1182 #if FF_API_FRAME_PKT

1183 FF_DISABLE_DEPRECATION_WARNINGS

1184 frame->pkt_size = pkt->size;

1185 frame->pkt_pos = pkt->pos;

1186 FF_ENABLE_DEPRECATION_WARNINGS

1187 #endif

1188

1189 av_packet_unref(pkt);

1190

1191 return 0;

1192 }

1193

1194 static void update_reference_list(AVCodecContext *avctx)

1195 {

1196 AV1DecContext *s = avctx->priv_data;

1197 const AV1RawFrameHeader *header = s->raw_frame_header;

1198

1199 for (int i = 0; i < AV1_NUM_REF_FRAMES; i++) {

1200 if (header->refresh_frame_flags & (1 << i))

1201 av1_frame_replace(&s->ref[i], &s->cur_frame);

1202 }

1203 }

1204

1205 static int get_current_frame(AVCodecContext *avctx)

1206 {

1207 AV1DecContext *s = avctx->priv_data;

1208 int ret;

1209

1210 av1_frame_unref(&s->cur_frame);

1211

1212 s->cur_frame.header_ref = ff_refstruct_ref(s->header_ref);

1213

1214 s->cur_frame.raw_frame_header = s->raw_frame_header;

1215

1216 ret = init_tile_data(s);

1217 if (ret < 0) {

1218 av_log(avctx, AV_LOG_ERROR, "Failed to init tile data.\n");

1219 return ret;

1220 }

1221

1222 if ((avctx->skip_frame >= AVDISCARD_NONINTRA &&

1223 (s->raw_frame_header->frame_type != AV1_FRAME_KEY &&

1224 s->raw_frame_header->frame_type != AV1_FRAME_INTRA_ONLY)) ||

1225 (avctx->skip_frame >= AVDISCARD_NONKEY &&

1226 s->raw_frame_header->frame_type != AV1_FRAME_KEY) ||

1227 avctx->skip_frame >= AVDISCARD_ALL)

1228 return 0;

1229

1230 if (s->pix_fmt == AV_PIX_FMT_NONE) {

1231 ret = get_pixel_format(avctx);

1232 if (ret < 0) {

1233 av_log(avctx, AV_LOG_ERROR, "Failed to get pixel format.\n");

1234 return ret;

1235 }

1236

1237 if (!ret && FF_HW_HAS_CB(avctx, decode_params)) {

1238 ret = FF_HW_CALL(avctx, decode_params, AV1_OBU_SEQUENCE_HEADER,

1239 s->seq_data_ref->data, s->seq_data_ref->size);

1240 if (ret < 0) {

1241 av_log(avctx, AV_LOG_ERROR, "HW accel decode params fail.\n");

1242 return ret;

1243 }

1244 }

1245 }

1246

1247 ret = av1_frame_alloc(avctx, &s->cur_frame);

1248 if (ret < 0) {

1249 av_log(avctx, AV_LOG_ERROR,

1250 "Failed to allocate space for current frame.\n");

1251 return ret;

1252 }

1253

1254 global_motion_params(s);

1255 skip_mode_params(s);

1256 coded_lossless_param(s);

1257 order_hint_info(s);

1258 load_grain_params(s);

1259

1260 s->cur_frame.force_integer_mv =

1261 s->raw_frame_header->force_integer_mv ||

1262 s->raw_frame_header->frame_type == AV1_FRAME_KEY ||

1263 s->raw_frame_header->frame_type == AV1_FRAME_INTRA_ONLY;

1264

1265 return ret;

1266 }

1267

1268 static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)

1269 {

1270 AV1DecContext *s = avctx->priv_data;

1271 AV1RawTileGroup *raw_tile_group = NULL;

1272 int i = 0, ret;

1273

1274 for (i = s->nb_unit; i < s->current_obu.nb_units; i++) {

1275 CodedBitstreamUnit *unit = &s->current_obu.units[i];

1276 AV1RawOBU *obu = unit->content;

1277 const AV1RawOBUHeader *header;

1278

1279 av_log(avctx, AV_LOG_DEBUG, "OBU idx:%d, type:%d, content available:%d.\n", i, unit->type, !!obu);

1280

1281 if (unit->type == AV1_OBU_TILE_LIST) {

1282 av_log(avctx, AV_LOG_ERROR, "Large scale tile decoding is unsupported.\n");

1283 ret = AVERROR_PATCHWELCOME;

1284 goto end;

1285 }

1286

1287 if (!obu)

1288 continue;

1289

1290 header = &obu->header;

1291

1292 switch (unit->type) {

1293 case AV1_OBU_SEQUENCE_HEADER:

1294 ret = av_buffer_replace(&s->seq_data_ref, unit->data_ref);

1295 if (ret < 0)

1296 goto end;

1297

1298 s->seq_data_ref->data = unit->data;

1299 s->seq_data_ref->size = unit->data_size;

1300 ff_refstruct_replace(&s->seq_ref, unit->content_ref);

1301

1302 s->raw_seq = &obu->obu.sequence_header;

1303

1304 ret = set_context_with_sequence(avctx, s->raw_seq);

1305 if (ret < 0) {

1306 av_log(avctx, AV_LOG_ERROR, "Failed to set context.\n");

1307 s->raw_seq = NULL;

1308 goto end;

1309 }

1310

1311 s->operating_point_idc = s->raw_seq->operating_point_idc[s->operating_point];

1312

1313 s->pix_fmt = AV_PIX_FMT_NONE;

1314

1315 break;

1316 case AV1_OBU_REDUNDANT_FRAME_HEADER:

1317 if (s->raw_frame_header)

1318 break;

1319 // fall-through

1320 case AV1_OBU_FRAME:

1321 case AV1_OBU_FRAME_HEADER:

1322 if (!s->raw_seq) {

1323 av_log(avctx, AV_LOG_ERROR, "Missing Sequence Header.\n");

1324 ret = AVERROR_INVALIDDATA;

1325 goto end;

1326 }

1327

1328 ff_refstruct_replace(&s->header_ref, unit->content_ref);

1329

1330 if (unit->type == AV1_OBU_FRAME)

1331 s->raw_frame_header = &obu->obu.frame.header;

1332 else

1333 s->raw_frame_header = &obu->obu.frame_header;

1334

1335 if (s->raw_frame_header->show_existing_frame) {

1336 av1_frame_replace(&s->cur_frame,

1337 &s->ref[s->raw_frame_header->frame_to_show_map_idx]);

1338

1339 update_reference_list(avctx);

1340

1341 if (s->cur_frame.f) {

1342 ret = set_output_frame(avctx, frame);

1343 if (ret < 0) {

1344 av_log(avctx, AV_LOG_ERROR, "Set output frame error.\n");

1345 goto end;

1346 }

1347 }

1348

1349 s->raw_frame_header = NULL;

1350 i++;

1351 ret = 0;

1352

1353 goto end;

1354 }

1355

1356 ret = get_current_frame(avctx);

1357 if (ret < 0) {

1358 av_log(avctx, AV_LOG_ERROR, "Get current frame error\n");

1359 goto end;

1360 }

1361

1362 s->cur_frame.spatial_id = header->spatial_id;

1363 s->cur_frame.temporal_id = header->temporal_id;

1364

1365 if (avctx->hwaccel && s->cur_frame.f) {

1366 ret = FF_HW_CALL(avctx, start_frame, unit->data, unit->data_size);

1367 if (ret < 0) {

1368 av_log(avctx, AV_LOG_ERROR, "HW accel start frame fail.\n");

1369 goto end;

1370 }

1371 }

1372 if (unit->type != AV1_OBU_FRAME)

1373 break;

1374 // fall-through

1375 case AV1_OBU_TILE_GROUP:

1376 if (!s->raw_frame_header) {

1377 av_log(avctx, AV_LOG_ERROR, "Missing Frame Header.\n");

1378 ret = AVERROR_INVALIDDATA;

1379 goto end;

1380 }

1381

1382 if (unit->type == AV1_OBU_FRAME)

1383 raw_tile_group = &obu->obu.frame.tile_group;

1384 else

1385 raw_tile_group = &obu->obu.tile_group;

1386

1387 ret = get_tiles_info(avctx, raw_tile_group);

1388 if (ret < 0)

1389 goto end;

1390

1391 if (avctx->hwaccel && s->cur_frame.f) {

1392 ret = FF_HW_CALL(avctx, decode_slice, raw_tile_group->tile_data.data,

1393 raw_tile_group->tile_data.data_size);

1394 if (ret < 0) {

1395 av_log(avctx, AV_LOG_ERROR,

1396 "HW accel decode slice fail.\n");

1397 goto end;

1398 }

1399 }

1400 break;

1401 case AV1_OBU_TILE_LIST:

1402 case AV1_OBU_TEMPORAL_DELIMITER:

1403 case AV1_OBU_PADDING:

1404 break;

1405 case AV1_OBU_METADATA:

1406 switch (obu->obu.metadata.metadata_type) {

1407 case AV1_METADATA_TYPE_HDR_CLL:

1408 ff_refstruct_replace(&s->cll_ref, unit->content_ref);

1409 s->cll = &obu->obu.metadata.metadata.hdr_cll;

1410 break;

1411 case AV1_METADATA_TYPE_HDR_MDCV:

1412 ff_refstruct_replace(&s->mdcv_ref, unit->content_ref);

1413 s->mdcv = &obu->obu.metadata.metadata.hdr_mdcv;

1414 break;

1415 case AV1_METADATA_TYPE_ITUT_T35: {

1416 AV1RawMetadataITUTT35 itut_t35;

1417 memcpy(&itut_t35, &obu->obu.metadata.metadata.itut_t35, sizeof(itut_t35));

1418 itut_t35.payload_ref = av_buffer_ref(obu->obu.metadata.metadata.itut_t35.payload_ref);

1419 if (!itut_t35.payload_ref) {

1420 ret = AVERROR(ENOMEM);

1421 goto end;

1422 }

1423 ret = av_fifo_write(s->itut_t35_fifo, &itut_t35, 1);

1424 if (ret < 0) {

1425 av_buffer_unref(&itut_t35.payload_ref);

1426 goto end;

1427 }

1428 break;

1429 }

1430 default:

1431 break;

1432 }

1433 break;

1434 default:

1435 av_log(avctx, AV_LOG_DEBUG,

1436 "Unknown obu type: %d (%"SIZE_SPECIFIER " bits).\n",

1437 unit->type, unit->data_size);

1438 }

1439

1440 if (raw_tile_group && (s->tile_num == raw_tile_group->tg_end + 1)) {

1441 int show_frame = s->raw_frame_header->show_frame;

1442 if (avctx->hwaccel && s->cur_frame.f) {

1443 ret = FF_HW_SIMPLE_CALL(avctx, end_frame);

1444 if (ret < 0) {

1445 av_log(avctx, AV_LOG_ERROR, "HW accel end frame fail.\n");

1446 goto end;

1447 }

1448 }

1449

1450 update_reference_list(avctx);

1451

1452 raw_tile_group = NULL;

1453 s->raw_frame_header = NULL;

1454

1455 if (show_frame) {

1456 // cur_frame.f needn't exist due to skip_frame.

1457 if (s->cur_frame.f) {

1458 ret = set_output_frame(avctx, frame);

1459 if (ret < 0) {

1460 av_log(avctx, AV_LOG_ERROR, "Set output frame error\n");

1461 goto end;

1462 }

1463 }

1464 i++;

1465 ret = 0;

1466 goto end;

1467 }

1468 }

1469 }

1470

1471 ret = AVERROR(EAGAIN);

1472 end:

1473 av_assert0(i <= s->current_obu.nb_units);

1474 s->nb_unit = i;

1475

1476 if ((ret < 0 && ret != AVERROR(EAGAIN)) || s->current_obu.nb_units == i) {

1477 if (ret < 0)

1478 s->raw_frame_header = NULL;

1479 av_packet_unref(s->pkt);

1480 ff_cbs_fragment_reset(&s->current_obu);

1481 s->nb_unit = 0;

1482 }

1483 if (!ret && !frame->buf[0])

1484 ret = AVERROR(EAGAIN);

1485

1486 return ret;

1487 }

1488

1489 static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)

1490 {

1491 AV1DecContext *s = avctx->priv_data;

1492 int ret;

1493

1494 do {

1495 if (!s->current_obu.nb_units) {

1496 ret = ff_decode_get_packet(avctx, s->pkt);

1497 if (ret < 0)

1498 return ret;

1499

1500 ret = ff_cbs_read_packet(s->cbc, &s->current_obu, s->pkt);

1501 if (ret < 0) {

1502 ff_cbs_fragment_reset(&s->current_obu);

1503 av_packet_unref(s->pkt);

1504 av_log(avctx, AV_LOG_ERROR, "Failed to read packet.\n");

1505 return ret;

1506 }

1507

1508 s->nb_unit = 0;

1509 av_log(avctx, AV_LOG_DEBUG, "Total OBUs on this packet: %d.\n",

1510 s->current_obu.nb_units);

1511 }

1512

1513 ret = av1_receive_frame_internal(avctx, frame);

1514 } while (ret == AVERROR(EAGAIN));

1515

1516 return ret;

1517 }

1518

1519 static void av1_decode_flush(AVCodecContext *avctx)

1520 {

1521 AV1DecContext *s = avctx->priv_data;

1522 AV1RawMetadataITUTT35 itut_t35;

1523

1524 for (int i = 0; i < FF_ARRAY_ELEMS(s->ref); i++)

1525 av1_frame_unref(&s->ref[i]);

1526

1527 av1_frame_unref(&s->cur_frame);

1528 s->operating_point_idc = 0;

1529 s->nb_unit = 0;

1530 s->raw_frame_header = NULL;

1531 s->raw_seq = NULL;

1532 s->cll = NULL;

1533 s->mdcv = NULL;

1534 while (av_fifo_read(s->itut_t35_fifo, &itut_t35, 1) >= 0)

1535 av_buffer_unref(&itut_t35.payload_ref);

1536

1537 ff_cbs_fragment_reset(&s->current_obu);

1538 ff_cbs_flush(s->cbc);

1539

1540 if (FF_HW_HAS_CB(avctx, flush))

1541 FF_HW_SIMPLE_CALL(avctx, flush);

1542 }

1543

1544 #define OFFSET(x) offsetof(AV1DecContext, x)

1545 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM

1546 static const AVOption av1_options[] = {

1547 { "operating_point", "Select an operating point of the scalable bitstream",

1548 OFFSET(operating_point), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, AV1_MAX_OPERATING_POINTS - 1, VD },

1549 { NULL }

1550 };

1551

1552 static const AVClass av1_class = {

1553 .class_name = "AV1 decoder",

1554 .item_name = av_default_item_name,

1555 .option = av1_options,

1556 .version = LIBAVUTIL_VERSION_INT,

1557 };

1558

1559 const FFCodec ff_av1_decoder = {

1560 .p.name = "av1",

1561 CODEC_LONG_NAME("Alliance for Open Media AV1"),

1562 .p.type = AVMEDIA_TYPE_VIDEO,

1563 .p.id = AV_CODEC_ID_AV1,

1564 .priv_data_size = sizeof(AV1DecContext),

1565 .init = av1_decode_init,

1566 .close = av1_decode_free,

1567 FF_CODEC_RECEIVE_FRAME_CB(av1_receive_frame),

1568 .p.capabilities = AV_CODEC_CAP_DR1,

1569 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |

1570 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM |

1571 FF_CODEC_CAP_USES_PROGRESSFRAMES,

1572 .flush = av1_decode_flush,

1573 .p.profiles = NULL_IF_CONFIG_SMALL(ff_av1_profiles),

1574 .p.priv_class = &av1_class,

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

1576 #if CONFIG_AV1_DXVA2_HWACCEL

1577 HWACCEL_DXVA2(av1),

1578 #endif

1579 #if CONFIG_AV1_D3D11VA_HWACCEL

1580 HWACCEL_D3D11VA(av1),

1581 #endif

1582 #if CONFIG_AV1_D3D11VA2_HWACCEL

1583 HWACCEL_D3D11VA2(av1),

1584 #endif

1585 #if CONFIG_AV1_D3D12VA_HWACCEL

1586 HWACCEL_D3D12VA(av1),

1587 #endif

1588 #if CONFIG_AV1_NVDEC_HWACCEL

1589 HWACCEL_NVDEC(av1),

1590 #endif

1591 #if CONFIG_AV1_VAAPI_HWACCEL

1592 HWACCEL_VAAPI(av1),

1593 #endif

1594 #if CONFIG_AV1_VDPAU_HWACCEL

1595 HWACCEL_VDPAU(av1),

1596 #endif

1597 #if CONFIG_AV1_VULKAN_HWACCEL

1598 HWACCEL_VULKAN(av1),

1599 #endif

1600

1601 NULL

1602 },

1603 };

update_reference_list

static void update_reference_list(AVCodecContext *avctx)

Definition: av1dec.c:1194

HWACCEL_D3D12VA

#define HWACCEL_D3D12VA(codec)

Definition: hwconfig.h:80

ff_get_coded_side_data

const AVPacketSideData * ff_get_coded_side_data(const AVCodecContext *avctx, enum AVPacketSideDataType type)

Get side data of the given type from a decoding context.

Definition: decode.c:1421

hwconfig.h

AVMasteringDisplayMetadata::has_primaries

int has_primaries

Flag indicating whether the display primaries (and white point) are set.

Definition: mastering_display_metadata.h:62

AV1RawTimingInfo::num_units_in_display_tick

uint32_t num_units_in_display_tick

Definition: cbs_av1.h:59

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: packet.c:429

AV1RawTimingInfo::time_scale

uint32_t time_scale

Definition: cbs_av1.h:60

AVCodecContext::hwaccel

const struct AVHWAccel * hwaccel

Hardware accelerator in use.

Definition: avcodec.h:1437

FF_ENABLE_DEPRECATION_WARNINGS

#define FF_ENABLE_DEPRECATION_WARNINGS

Definition: internal.h:73

AV1_GM_TRANS_PREC_BITS

@ AV1_GM_TRANS_PREC_BITS

Definition: av1.h:111

ff_decode_get_packet

int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)

Called by decoders to get the next packet for decoding.

Definition: decode.c:247

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

AV_PIX_FMT_CUDA

@ AV_PIX_FMT_CUDA

HW acceleration through CUDA.

Definition: pixfmt.h:260

AVMasteringDisplayMetadata::max_luminance

AVRational max_luminance

Max luminance of mastering display (cd/m^2).

Definition: mastering_display_metadata.h:57

CodedBitstreamUnit::content_ref

void * content_ref

If content is reference counted, a RefStruct reference backing content.

Definition: cbs.h:112

AVPixelFormat

Pixel format.

Definition: pixfmt.h:71

AV1RawColorConfig::color_primaries

uint8_t color_primaries

Definition: cbs_av1.h:47

av1_decode_init

static av_cold int av1_decode_init(AVCodecContext *avctx)

Definition: av1dec.c:844

AV1_OBU_REDUNDANT_FRAME_HEADER

@ AV1_OBU_REDUNDANT_FRAME_HEADER

Definition: av1.h:36

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:43

ff_refstruct_ref

void * ff_refstruct_ref(void *obj)

Create a new reference to an object managed via this API, i.e.

Definition: refstruct.c:140

AV1RawSequenceHeader::seq_level_idx

uint8_t seq_level_idx[AV1_MAX_OPERATING_POINTS]

Definition: cbs_av1.h:87

const char * r

Definition: vf_curves.c:127

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

decode_slice

static int decode_slice(AVCodecContext *c, void *arg)

Definition: ffv1dec.c:267

AV1RawFilmGrainParams::clip_to_restricted_range

uint8_t clip_to_restricted_range

Definition: cbs_av1.h:162

opt.h

ff_dovi_ctx_unref

void ff_dovi_ctx_unref(DOVIContext *s)

Completely reset a DOVIContext, preserving only logctx.

Definition: dovi_rpu.c:29

AV1RawFilmGrainParams::grain_seed

uint16_t grain_seed

Definition: cbs_av1.h:135

AVCodecContext::colorspace

enum AVColorSpace colorspace

YUV colorspace type.

Definition: avcodec.h:691

AV1RawSequenceHeader::timing_info_present_flag

uint8_t timing_info_present_flag

Definition: cbs_av1.h:78

AV1RawSequenceHeader

Definition: cbs_av1.h:73

ff_get_format

int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)

Select the (possibly hardware accelerated) pixel format.

Definition: decode.c:1272

order_hint_info

static void order_hint_info(AV1DecContext *s)

Definition: av1dec.c:362

AV1RawColorConfig::color_range

uint8_t color_range

Definition: cbs_av1.h:51

AV1_REF_FRAME_LAST

@ AV1_REF_FRAME_LAST

Definition: av1.h:63

coded_lossless_param

static void coded_lossless_param(AV1DecContext *s)

Definition: av1dec.c:332

GetByteContext

Definition: bytestream.h:33

AV1_GM_ABS_ALPHA_BITS

@ AV1_GM_ABS_ALPHA_BITS

Definition: av1.h:106

ff_cbs_fragment_free

av_cold void ff_cbs_fragment_free(CodedBitstreamFragment *frag)

Free the units array of a fragment in addition to what ff_cbs_fragment_reset does.

Definition: cbs.c:186

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:2965

av1_frame_alloc

static int av1_frame_alloc(AVCodecContext *avctx, AV1Frame *f)

Definition: av1dec.c:903

AV_FRAME_DATA_A53_CC

@ AV_FRAME_DATA_A53_CC

ATSC A53 Part 4 Closed Captions.

Definition: frame.h:59

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

AVMasteringDisplayMetadata::display_primaries

AVRational display_primaries[3][2]

CIE 1931 xy chromaticity coords of color primaries (r, g, b order).

Definition: mastering_display_metadata.h:42

AVMasteringDisplayMetadata::has_luminance

int has_luminance

Flag indicating whether the luminance (min_ and max_) have been set.

Definition: mastering_display_metadata.h:67

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1430

AV1RawFilmGrainParams::point_cb_value

uint8_t point_cb_value[10]

Definition: cbs_av1.h:143

CodedBitstreamUnit::content

void * content

Pointer to the decomposed form of this unit.

Definition: cbs.h:107

AV1RawFilmGrainParams::apply_grain

uint8_t apply_grain

Definition: cbs_av1.h:134

ff_dovi_rpu_parse

int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size, int err_recognition)

Parse the contents of a Dolby Vision RPU and update the parsed values in the DOVIContext struct.

Definition: dovi_rpudec.c:346

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:174

int64_t

long long int64_t

Definition: coverity.c:34

AV1_REFS_PER_FRAME

@ AV1_REFS_PER_FRAME

Definition: av1.h:85

AVFilmGrainAOMParams::uv_points

uint8_t uv_points[2][10][2]

Definition: film_grain_params.h:63

get_current_frame

static int get_current_frame(AVCodecContext *avctx)

Definition: av1dec.c:1205

AVContentLightMetadata::MaxCLL

unsigned MaxCLL

Max content light level (cd/m^2).

Definition: mastering_display_metadata.h:111

AVFilmGrainParams::aom

AVFilmGrainAOMParams aom

Definition: film_grain_params.h:260

AVFrame

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

Definition: frame.h:389

pixdesc.h

AVCodecContext::color_trc

enum AVColorTransferCharacteristic color_trc

Color Transfer Characteristic.

Definition: avcodec.h:684

AVPacketSideData

This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...

Definition: packet.h:390

set_context_with_sequence

static int set_context_with_sequence(AVCodecContext *avctx, const AV1RawSequenceHeader *seq)

Definition: av1dec.c:758

uint8_t w

Definition: llviddspenc.c:38

HWACCEL_DXVA2

#define HWACCEL_DXVA2(codec)

Definition: hwconfig.h:64

AV1RawFilmGrainParams::point_y_value

uint8_t point_y_value[14]

Definition: cbs_av1.h:139

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:686

ff_cbs_fragment_reset

void ff_cbs_fragment_reset(CodedBitstreamFragment *frag)

Free the units contained in a fragment as well as the fragment's own data buffer, but not the units a...

Definition: cbs.c:172

internal.h

AV1_DIV_LUT_NUM

@ AV1_DIV_LUT_NUM

Definition: av1.h:122

AVOption

AVOption.

Definition: opt.h:429

HWACCEL_D3D11VA2

#define HWACCEL_D3D11VA2(codec)

Definition: hwconfig.h:66

#define b

Definition: input.c:41

ff_progress_frame_get_buffer

int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)

This function sets up the ProgressFrame, i.e.

Definition: decode.c:1872

AV1RawSequenceHeader::timing_info

AV1RawTimingInfo timing_info

Definition: cbs_av1.h:83

AV_PIX_FMT_YUV420P10

#define AV_PIX_FMT_YUV420P10

Definition: pixfmt.h:478

high

int high

Definition: dovi_rpuenc.c:38

AVFilmGrainParams::color_space

enum AVColorSpace color_space

Definition: film_grain_params.h:282

AV1RawTileGroup::tg_end

uint16_t tg_end

Definition: cbs_av1.h:300

AV_PIX_FMT_D3D11VA_VLD

@ AV_PIX_FMT_D3D11VA_VLD

HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...

Definition: pixfmt.h:254

FFCodec

Definition: codec_internal.h:127

CodedBitstreamUnit::type

CodedBitstreamUnitType type

Codec-specific type of this unit.

Definition: cbs.h:74

FF_HW_SIMPLE_CALL

#define FF_HW_SIMPLE_CALL(avctx, function)

Definition: hwaccel_internal.h:174

AV1_METADATA_TYPE_ITUT_T35

@ AV1_METADATA_TYPE_ITUT_T35

Definition: av1.h:47

decompose_unit_types

static const CodedBitstreamUnitType decompose_unit_types[]

Definition: av1dec.c:834

FFMAX

#define FFMAX(a, b)

Definition: macros.h:47

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AV1_OBU_TEMPORAL_DELIMITER

@ AV1_OBU_TEMPORAL_DELIMITER

Definition: av1.h:31

AV1RawTileData::data

uint8_t * data

Definition: cbs_av1.h:292

bit_depth

static void bit_depth(AudioStatsContext *s, const uint64_t *const mask, uint8_t *depth)

Definition: af_astats.c:246

get_relative_dist

static int get_relative_dist(const AV1RawSequenceHeader *seq, unsigned int a, unsigned int b)

Definition: av1dec.c:258

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

AV1RawOBU::header

AV1RawOBUHeader header

Definition: cbs_av1.h:401

av1_frame_replace

static void av1_frame_replace(AV1Frame *dst, const AV1Frame *src)

Definition: av1dec.c:691

AVFilmGrainParams::color_trc

enum AVColorTransferCharacteristic color_trc

Definition: film_grain_params.h:281

AVFilmGrainParams::seed

uint64_t seed

Seed to use for the synthesis process, if the codec allows for it.

Definition: film_grain_params.h:250

AV_PIX_FMT_VULKAN

@ AV_PIX_FMT_VULKAN

Vulkan hardware images.

Definition: pixfmt.h:379

AV1RawSequenceHeader::seq_profile

uint8_t seq_profile

Definition: cbs_av1.h:74

AV1RawMetadata::itut_t35

AV1RawMetadataITUTT35 itut_t35

Definition: cbs_av1.h:387

CodedBitstreamUnit

Coded bitstream unit structure.

Definition: cbs.h:70

ff_cbs_close

av_cold void ff_cbs_close(CodedBitstreamContext **ctx_ptr)

Close a context and free all internal state.

Definition: cbs.c:142

AV1RawColorConfig::subsampling_y

uint8_t subsampling_y

Definition: cbs_av1.h:53

round_two

static uint64_t round_two(uint64_t x, uint16_t n)

Definition: av1dec.c:141

AVFilmGrainParams::codec

union AVFilmGrainParams::@426 codec

Additional fields may be added both here and in any structure included.

AV1RawFrame::header

AV1RawFrameHeader header

Definition: cbs_av1.h:306

AV1RawFilmGrainParams::cr_mult

uint8_t cr_mult

Definition: cbs_av1.h:158

AVContentLightMetadata

Content light level needed by to transmit HDR over HDMI (CTA-861.3).

Definition: mastering_display_metadata.h:107

AV_PKT_DATA_DOVI_CONF

@ AV_PKT_DATA_DOVI_CONF

DOVI configuration ref: dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2....

Definition: packet.h:280

AV1RawFilmGrainParams::chroma_scaling_from_luma

uint8_t chroma_scaling_from_luma

Definition: cbs_av1.h:141

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:566

AVPacketSideData::size

size_t size

Definition: packet.h:392

AV1RawFilmGrainParams::ar_coeffs_cr_plus_128

uint8_t ar_coeffs_cr_plus_128[25]

Definition: cbs_av1.h:152

AV1_CSP_COLOCATED

@ AV1_CSP_COLOCATED

Definition: av1.h:135

AV1RawSequenceHeader::film_grain_params_present

uint8_t film_grain_params_present

Definition: cbs_av1.h:130

av1_parse.h

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx

Definition: dsp.h:53

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AV1_CSP_VERTICAL

@ AV1_CSP_VERTICAL

Definition: av1.h:134

av1_options

static const AVOption av1_options[]

Definition: av1dec.c:1546

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:1830

fail

#define fail()

Definition: checkasm.h:188

AV1_OBU_FRAME_HEADER

@ AV1_OBU_FRAME_HEADER

Definition: av1.h:32

av_fifo_write

int av_fifo_write(AVFifo *f, const void *buf, size_t nb_elems)

Write data into a FIFO.

Definition: fifo.c:188

AVFilmGrainAOMParams::grain_scale_shift

int grain_scale_shift

Signals the down shift applied to the generated gaussian numbers during synthesis.

Definition: film_grain_params.h:99

AV1RawFilmGrainParams::point_cr_scaling

uint8_t point_cr_scaling[10]

Definition: cbs_av1.h:147

AV1RawMetadataITUTT35::payload_size

size_t payload_size

Definition: cbs_av1.h:356

inverse_recenter

static uint32_t inverse_recenter(int r, uint32_t v)

Definition: av1dec.c:72

HWACCEL_VDPAU

#define HWACCEL_VDPAU(codec)

Definition: hwconfig.h:72

type

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 type

Definition: writing_filters.txt:86

AV1RawFilmGrainParams::ar_coeff_shift_minus_6

uint8_t ar_coeff_shift_minus_6

Definition: cbs_av1.h:153

CodedBitstreamUnit::data

uint8_t * data

Pointer to the directly-parsable bitstream form of this unit.

Definition: cbs.h:81

AV1RawFilmGrainParams::num_y_points

uint8_t num_y_points

Definition: cbs_av1.h:138

AVFilmGrainAOMParams::limit_output_range

int limit_output_range

Signals to clip to limited color levels after film grain application.

Definition: film_grain_params.h:122

AV1_WARP_MODEL_IDENTITY

@ AV1_WARP_MODEL_IDENTITY

Definition: av1.h:114

AVFilmGrainAOMParams::num_y_points

int num_y_points

Number of points, and the scale and value for each point of the piecewise linear scaling function for...

Definition: film_grain_params.h:49

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

round_two_signed

static int64_t round_two_signed(int64_t x, uint16_t n)

Definition: av1dec.c:148

AVRational::num

int num

Numerator.

Definition: rational.h:59

progressframe.h

refstruct.h

ITU_T_T35_PROVIDER_CODE_ATSC

#define ITU_T_T35_PROVIDER_CODE_ATSC

Definition: itut35.h:26

AV1_FRAME_SWITCH

@ AV1_FRAME_SWITCH

Definition: av1.h:56

ff_frame_new_side_data_from_buf

int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)

Similar to ff_frame_new_side_data, but using an existing buffer ref.

Definition: decode.c:2161

AVFilmGrainAOMParams

This structure describes how to handle film grain synthesis for AOM codecs.

Definition: film_grain_params.h:44

AV1RawFilmGrainParams::num_cb_points

uint8_t num_cb_points

Definition: cbs_av1.h:142

AV_PIX_FMT_YUV444P10

#define AV_PIX_FMT_YUV444P10

Definition: pixfmt.h:481

AV1RawFilmGrainParams::cb_luma_mult

uint8_t cb_luma_mult

Definition: cbs_av1.h:156

AV1Frame

Definition: av1dec.h:37

AV1RawFilmGrainParams::overlap_flag

uint8_t overlap_flag

Definition: cbs_av1.h:161

FF_CODEC_CAP_USES_PROGRESSFRAMES

#define FF_CODEC_CAP_USES_PROGRESSFRAMES

The decoder might make use of the ProgressFrame API.

Definition: codec_internal.h:69

AVCodecContext::color_primaries

enum AVColorPrimaries color_primaries

Chromaticity coordinates of the source primaries.

Definition: avcodec.h:677

show_frame

static void show_frame(WriterContext *w, AVFrame *frame, AVStream *stream, AVFormatContext *fmt_ctx)

Definition: ffprobe.c:2931

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

film_grain_params.h

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

AV1_WARP_MODEL_AFFINE

@ AV1_WARP_MODEL_AFFINE

Definition: av1.h:117

av_fifo_read

int av_fifo_read(AVFifo *f, void *buf, size_t nb_elems)

Read data from a FIFO.

Definition: fifo.c:240

AVFilmGrainParams::width

int width

Intended display resolution.

Definition: film_grain_params.h:269

AV1RawFilmGrainParams::grain_scaling_minus_8

uint8_t grain_scaling_minus_8

Definition: cbs_av1.h:148

AV_FRAME_FLAG_KEY

#define AV_FRAME_FLAG_KEY

A flag to mark frames that are keyframes.

Definition: frame.h:640

global_motion_params

static void global_motion_params(AV1DecContext *s)

update gm type/params, since cbs already implemented part of this function, so we don't need to full ...

Definition: av1dec.c:209

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

ff_hwaccel_frame_priv_alloc

int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)

Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.

Definition: decode.c:2275

AVMasteringDisplayMetadata::white_point

AVRational white_point[2]

CIE 1931 xy chromaticity coords of white point.

Definition: mastering_display_metadata.h:47

AV_PIX_FMT_DXVA2_VLD

@ AV_PIX_FMT_DXVA2_VLD

HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.

Definition: pixfmt.h:134

AV1_GM_ALPHA_PREC_BITS

@ AV1_GM_ALPHA_PREC_BITS

Definition: av1.h:107

#define s(width, name)

Definition: cbs_vp9.c:198

AV1_FRAME_INTRA_ONLY

@ AV1_FRAME_INTRA_ONLY

Definition: av1.h:55

AV1_DIV_LUT_BITS

@ AV1_DIV_LUT_BITS

Definition: av1.h:120

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:431

pix_fmt

static enum AVPixelFormat pix_fmt

Definition: demux_decode.c:41

av_film_grain_params_create_side_data

AVFilmGrainParams * av_film_grain_params_create_side_data(AVFrame *frame)

Allocate a complete AVFilmGrainParams and add it to the frame.

Definition: film_grain_params.c:33

GetByteContext::buffer

const uint8_t * buffer

Definition: bytestream.h:34

av1_decode_free

static av_cold int av1_decode_free(AVCodecContext *avctx)

Definition: av1dec.c:732

AV1RawMetadata::hdr_cll

AV1RawMetadataHDRCLL hdr_cll

Definition: cbs_av1.h:384

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

AV1_METADATA_TYPE_HDR_CLL

@ AV1_METADATA_TYPE_HDR_CLL

Definition: av1.h:44

pix_fmts

static enum AVPixelFormat pix_fmts[]

Definition: libkvazaar.c:304

init_tile_data

static int init_tile_data(AV1DecContext *s)

Definition: av1dec.c:406

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

AVPacketSideData::data

uint8_t * data

Definition: packet.h:391

ff_progress_frame_unref

void ff_progress_frame_unref(ProgressFrame *f)

Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...

Definition: decode.c:1900

decode.h

ff_av1_profiles

const AVProfile ff_av1_profiles[]

Definition: profiles.c:163

get_sw_pixel_format

static enum AVPixelFormat get_sw_pixel_format(void *logctx, const AV1RawSequenceHeader *seq)

Definition: av1dec.c:469

AV1RawColorConfig::transfer_characteristics

uint8_t transfer_characteristics

Definition: cbs_av1.h:48

AVPixFmtDescriptor::log2_chroma_w

uint8_t log2_chroma_w

Amount to shift the luma width right to find the chroma width.

Definition: pixdesc.h:80

AV1_WARP_PARAM_REDUCE_BITS

@ AV1_WARP_PARAM_REDUCE_BITS

Definition: av1.h:118

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

av1dec.h

get_tiles_info

static int get_tiles_info(AVCodecContext *avctx, const AV1RawTileGroup *tile_group)

Definition: av1dec.c:424

export_itut_t35

static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame, const AV1RawMetadataITUTT35 *itut_t35)

Definition: av1dec.c:950

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

ff_decode_mastering_display_new

int ff_decode_mastering_display_new(const AVCodecContext *avctx, AVFrame *frame, AVMasteringDisplayMetadata **mdm)

Wrapper around av_mastering_display_metadata_create_side_data(), which rejects side data overridden b...

Definition: decode.c:2202

FF_CODEC_PROPERTY_FILM_GRAIN

#define FF_CODEC_PROPERTY_FILM_GRAIN

Definition: avcodec.h:1809

load_grain_params

static void load_grain_params(AV1DecContext *s)

Definition: av1dec.c:386

AV_PIX_FMT_GRAY10

#define AV_PIX_FMT_GRAY10

Definition: pixfmt.h:459

ff_av1_decoder

const FFCodec ff_av1_decoder

Definition: av1dec.c:1559

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:221

AVFilmGrainAOMParams::uv_mult_luma

int uv_mult_luma[2]

Definition: film_grain_params.h:106

ff_parse_a53_cc

int ff_parse_a53_cc(AVBufferRef **pbuf, const uint8_t *data, int size)

Parse a data array for ATSC A53 Part 4 Closed Captions and store them in an AVBufferRef.

Definition: atsc_a53.c:69

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AV1_NUM_REF_FRAMES

@ AV1_NUM_REF_FRAMES

Definition: av1.h:84

AV1RawOBU

Definition: cbs_av1.h:400

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

AV1_GM_ABS_TRANS_ONLY_BITS

@ AV1_GM_ABS_TRANS_ONLY_BITS

Definition: av1.h:108

av_clip_int16

#define av_clip_int16

Definition: common.h:115

HWACCEL_MAX

#define HWACCEL_MAX

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

AV1RawFilmGrainParams::cb_mult

uint8_t cb_mult

Definition: cbs_av1.h:155

AVCodecContext::color_range

enum AVColorRange color_range

MPEG vs JPEG YUV range.

Definition: avcodec.h:701

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:280

hwaccel_internal.h

AV1RawFrameHeader

Definition: cbs_av1.h:165

AVCHROMA_LOC_LEFT

@ AVCHROMA_LOC_LEFT

MPEG-2/4 4:2:0, H.264 default for 4:2:0.

Definition: pixfmt.h:707

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVCHROMA_LOC_TOPLEFT

@ AVCHROMA_LOC_TOPLEFT

ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.

Definition: pixfmt.h:709

AVCodecContext::internal

struct AVCodecInternal * internal

Private context used for internal data.

Definition: avcodec.h:486

AV1RawTileData::data_size

size_t data_size

Definition: cbs_av1.h:294

av1_frame_unref

static void av1_frame_unref(AV1Frame *f)

Definition: av1dec.c:678

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

AV1RawColorConfig::chroma_sample_position

uint8_t chroma_sample_position

Definition: cbs_av1.h:54

profiles.h

CodedBitstreamUnit::data_size

size_t data_size

The number of bytes in the bitstream (including any padding bits in the final byte).

Definition: cbs.h:86

ff_set_sar

int ff_set_sar(AVCodecContext *avctx, AVRational sar)

Check that the provided sample aspect ratio is valid and set it on the codec context.

Definition: utils.c:109

flush

void(* flush)(AVBSFContext *ctx)

Definition: dts2pts.c:370

AV1_OBU_TILE_GROUP

@ AV1_OBU_TILE_GROUP

Definition: av1.h:33

update_context_with_frame_header

static int update_context_with_frame_header(AVCodecContext *avctx, const AV1RawFrameHeader *header)

Definition: av1dec.c:804

abs

#define abs(x)

Definition: cuda_runtime.h:35

AV_PIX_FMT_D3D12

@ AV_PIX_FMT_D3D12

Hardware surfaces for Direct3D 12.

Definition: pixfmt.h:440

AV_PIX_FMT_YUV422P10

#define AV_PIX_FMT_YUV422P10

Definition: pixfmt.h:479

skip_mode_params

static void skip_mode_params(AV1DecContext *s)

Definition: av1dec.c:266

AV_PIX_FMT_GRAY8

@ AV_PIX_FMT_GRAY8

Y , 8bpp.

Definition: pixfmt.h:81

AVFilmGrainParams::subsampling_x

int subsampling_x

Intended subsampling ratio, or 0 for luma-only streams.

Definition: film_grain_params.h:274

FF_HW_HAS_CB

#define FF_HW_HAS_CB(avctx, function)

Definition: hwaccel_internal.h:177

AVCodecContext::level

int level

Encoding level descriptor.

Definition: avcodec.h:1794

AV_PICTURE_TYPE_SP

@ AV_PICTURE_TYPE_SP

Switching Predicted.

Definition: avutil.h:284

av_opt_set_int

int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)

Definition: opt.c:800

AV1RawMetadata::metadata

union AV1RawMetadata::@66 metadata

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

bytestream2_tell

static av_always_inline int bytestream2_tell(GetByteContext *g)

Definition: bytestream.h:192

AV1RawSequenceHeader::max_frame_height_minus_1

uint16_t max_frame_height_minus_1

Definition: cbs_av1.h:99

AV1_WARP_MODEL_TRANSLATION

@ AV1_WARP_MODEL_TRANSLATION

Definition: av1.h:115

resolve_divisor

static int16_t resolve_divisor(uint32_t d, uint16_t *shift)

Resolve divisor process.

Definition: av1dec.c:157

AV1_OBU_FRAME

@ AV1_OBU_FRAME

Definition: av1.h:35

AVFilmGrainAOMParams::num_uv_points

int num_uv_points[2]

If chroma_scaling_from_luma is set to 0, signals the chroma scaling function parameters.

Definition: film_grain_params.h:62

ITU_T_T35_PROVIDER_CODE_DOLBY

#define ITU_T_T35_PROVIDER_CODE_DOLBY

Definition: itut35.h:28

AV1RawFilmGrainParams::point_cr_value

uint8_t point_cr_value[10]

Definition: cbs_av1.h:146

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:220

Definition: af_crystalizer.c:122

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

AV1RawOBU::obu

union AV1RawOBU::@67 obu

AVPacket::size

int size

Definition: packet.h:540

AV1RawFilmGrainParams::cb_offset

uint16_t cb_offset

Definition: cbs_av1.h:157

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

ff_dovi_attach_side_data

int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)

Attach the decoded AVDOVIMetadata as side data to an AVFrame.

Definition: dovi_rpudec.c:64

height

#define height

Definition: dsp.h:85

av_frame_ref

int av_frame_ref(AVFrame *dst, const AVFrame *src)

Set up a new reference to the data described by the source frame.

Definition: frame.c:388

decode_unsigned_subexp_with_ref

static uint32_t decode_unsigned_subexp_with_ref(uint32_t sub_exp, int mx, int r)

Definition: av1dec.c:82

codec_internal.h

AV1RawTimingInfo::num_ticks_per_picture_minus_1

uint32_t num_ticks_per_picture_minus_1

Definition: cbs_av1.h:63

shift

static int shift(int a, int b)

Definition: bonk.c:261

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

AV_PIX_FMT_YUV422P12

#define AV_PIX_FMT_YUV422P12

Definition: pixfmt.h:483

size

int size

Definition: twinvq_data.h:10344

AV1DecContext

Definition: av1dec.h:85

AV1RawOBU::sequence_header

AV1RawSequenceHeader sequence_header

Definition: cbs_av1.h:406

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

MKBETAG

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

Definition: macros.h:56

FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM

#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM

The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...

Definition: codec_internal.h:55

AV_PIX_FMT_YUV444P12

#define AV_PIX_FMT_YUV444P12

Definition: pixfmt.h:485

AVFilmGrainParams

This structure describes how to handle film grain synthesis in video for specific codecs.

Definition: film_grain_params.h:238

AV1_OBU_SEQUENCE_HEADER

@ AV1_OBU_SEQUENCE_HEADER

Definition: av1.h:30

AVCodecHWConfigInternal

Definition: hwconfig.h:25

ff_av1_framerate

AVRational ff_av1_framerate(int64_t ticks_per_frame, int64_t units_per_tick, int64_t time_scale)

Definition: av1_parse.c:110

header

static const uint8_t header[24]

Definition: sdr2.c:68

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

AV1_METADATA_TYPE_HDR_MDCV

@ AV1_METADATA_TYPE_HDR_MDCV

Definition: av1.h:45

AVPacket::dts

int64_t dts

Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.

Definition: packet.h:538

The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a

Definition: undefined.txt:41

av_reallocp_array

int av_reallocp_array(void *ptr, size_t nmemb, size_t size)

Allocate, reallocate an array through a pointer to a pointer.

Definition: mem.c:225

#define VD

Definition: av1dec.c:1545

HWACCEL_D3D11VA

#define HWACCEL_D3D11VA(codec)

Definition: hwconfig.h:78

AV_PIX_FMT_D3D11

@ AV_PIX_FMT_D3D11

Hardware surfaces for Direct3D11.

Definition: pixfmt.h:336

AV1RawFilmGrainParams::grain_scale_shift

uint8_t grain_scale_shift

Definition: cbs_av1.h:154

HWACCEL_NVDEC

#define HWACCEL_NVDEC(codec)

Definition: hwconfig.h:68

AV1_REF_FRAME_ALTREF

@ AV1_REF_FRAME_ALTREF

Definition: av1.h:69

AVFilmGrainAOMParams::ar_coeffs_y

int8_t ar_coeffs_y[24]

Luma auto-regression coefficients.

Definition: film_grain_params.h:80

AV_PIX_FMT_VAAPI

@ AV_PIX_FMT_VAAPI

Hardware acceleration through VA-API, data[3] contains a VASurfaceID.

Definition: pixfmt.h:126

AV1RawOBU::frame_header

AV1RawFrameHeader frame_header

Definition: cbs_av1.h:407

ff_cbs_read_extradata_from_codec

int ff_cbs_read_extradata_from_codec(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVCodecContext *avctx)

Definition: cbs.c:295

AV1_PRIMARY_REF_NONE

@ AV1_PRIMARY_REF_NONE

Definition: av1.h:87

av1_receive_frame

static int av1_receive_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: av1dec.c:1489

av1_decode_flush

static void av1_decode_flush(AVCodecContext *avctx)

Definition: av1dec.c:1519

AV_PIX_FMT_VDPAU

@ AV_PIX_FMT_VDPAU

HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.

Definition: pixfmt.h:194

AV1RawOBU::metadata

AV1RawMetadata metadata

Definition: cbs_av1.h:411

AV1RawMetadata::metadata_type

uint64_t metadata_type

Definition: cbs_av1.h:382

export_film_grain

static int export_film_grain(AVCodecContext *avctx, AVFrame *frame)

Definition: av1dec.c:1080

AV1_OBU_PADDING

@ AV1_OBU_PADDING

Definition: av1.h:39

AVFilmGrainParams::color_primaries

enum AVColorPrimaries color_primaries

Definition: film_grain_params.h:280

AVDISCARD_NONINTRA

@ AVDISCARD_NONINTRA

discard all non intra frames

Definition: defs.h:219

CodedBitstreamUnit::data_ref

AVBufferRef * data_ref

A reference to the buffer containing data.

Definition: cbs.h:98

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

Definition: cbs_h2645.c:256

AVPacket::pts

int64_t pts

Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...

Definition: packet.h:532

AVCodecContext::properties

unsigned properties

Properties of the stream that gets decoded.

Definition: avcodec.h:1806

round

static av_always_inline av_const double round(double x)

Definition: libm.h:444

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

div_lut

static const uint16_t div_lut[AV1_DIV_LUT_NUM]

< same with Div_Lut defined in spec 7.11.3.7

Definition: av1dec.c:45

AV1RawMetadata::hdr_mdcv

AV1RawMetadataHDRMDCV hdr_mdcv

Definition: cbs_av1.h:385

AVFilmGrainParams::subsampling_y

int subsampling_y

Definition: film_grain_params.h:274

AVCodecInternal::in_pkt

AVPacket * in_pkt

This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...

Definition: internal.h:83

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:56

delta

float delta

Definition: vorbis_enc_data.h:430

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:610

AV1RawSequenceHeader::max_frame_width_minus_1

uint16_t max_frame_width_minus_1

Definition: cbs_av1.h:98

AV1RawSequenceHeader::color_config

AV1RawColorConfig color_config

Definition: cbs_av1.h:128

AV1RawMetadataITUTT35::payload

uint8_t * payload

Definition: cbs_av1.h:354

AVFilmGrainAOMParams::scaling_shift

int scaling_shift

Specifies the shift applied to the chroma components.

Definition: film_grain_params.h:69

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

av_buffer_replace

int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)

Ensure dst refers to the same data as src.

Definition: buffer.c:233

AVCodecContext::chroma_sample_location

enum AVChromaLocation chroma_sample_location

This defines the location of chroma samples.

Definition: avcodec.h:708

AV1RawTileGroup::tg_start

uint16_t tg_start

Definition: cbs_av1.h:299

AVMasteringDisplayMetadata

Mastering display metadata capable of representing the color volume of the display used to master the...

Definition: mastering_display_metadata.h:38

AV1RawSequenceHeader::enable_order_hint

uint8_t enable_order_hint

Definition: cbs_av1.h:113

AVCodecContext::height

int height

Definition: avcodec.h:624

GetByteContext::buffer_end

const uint8_t * buffer_end

Definition: bytestream.h:34

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:669

AV1RawMetadataITUTT35::payload_ref

AVBufferRef * payload_ref

Definition: cbs_av1.h:355

AV1RawOBU::tile_group

AV1RawTileGroup tile_group

Definition: cbs_av1.h:409

AVDynamicHDRPlus

This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...

Definition: hdr_dynamic_metadata.h:243

AV1RawFilmGrainParams::update_grain

uint8_t update_grain

Definition: cbs_av1.h:136

avcodec.h

AV1RawTileGroup::tile_data

AV1RawTileData tile_data

Definition: cbs_av1.h:302

av_cmp_q

static int av_cmp_q(AVRational a, AVRational b)

Compare two rationals.

Definition: rational.h:89

av1_class

static const AVClass av1_class

Definition: av1dec.c:1552

av_dynamic_hdr_plus_create_side_data

AVDynamicHDRPlus * av_dynamic_hdr_plus_create_side_data(AVFrame *frame)

Allocate a complete AVDynamicHDRPlus and add it to the frame.

Definition: hdr_dynamic_metadata.c:48

AVFilmGrainParams::height

int height

Definition: film_grain_params.h:269

ret

Definition: filter_design.txt:187

AV1RawColorConfig::subsampling_x

uint8_t subsampling_x

Definition: cbs_av1.h:52

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:71

AV1_OBU_TILE_LIST

@ AV1_OBU_TILE_LIST

Definition: av1.h:37

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

atsc_a53.h

AV1RawColorConfig::high_bitdepth

uint8_t high_bitdepth

Definition: cbs_av1.h:42

AV1RawFilmGrainParams::cr_luma_mult

uint8_t cr_luma_mult

Definition: cbs_av1.h:159

AV1_MAX_SEGMENTS

@ AV1_MAX_SEGMENTS

Definition: av1.h:89

ff_decode_content_light_new

int ff_decode_content_light_new(const AVCodecContext *avctx, AVFrame *frame, AVContentLightMetadata **clm)

Wrapper around av_content_light_metadata_create_side_data(), which rejects side data overridden by th...

Definition: decode.c:2247

ff_refstruct_replace

void ff_refstruct_replace(void *dstp, const void *src)

Ensure *dstp refers to the same object as src.

Definition: refstruct.c:160

AV1RawFilmGrainParams::film_grain_params_ref_idx

uint8_t film_grain_params_ref_idx

Definition: cbs_av1.h:137

read_global_param

static void read_global_param(AV1DecContext *s, int type, int ref, int idx)

Definition: av1dec.c:99

av_fifo_alloc2

AVFifo * av_fifo_alloc2(size_t nb_elems, size_t elem_size, unsigned int flags)

Allocate and initialize an AVFifo with a given element size.

Definition: fifo.c:47

AV_PIX_FMT_YUV420P12

#define AV_PIX_FMT_YUV420P12

Definition: pixfmt.h:482

AV1_SEG_LVL_ALT_Q

@ AV1_SEG_LVL_ALT_Q

Definition: av1.h:92

SIZE_SPECIFIER

#define SIZE_SPECIFIER

Definition: internal.h:129

ff_progress_frame_replace

void ff_progress_frame_replace(ProgressFrame *dst, const ProgressFrame *src)

Do nothing if dst and src already refer to the same AVFrame; otherwise unreference dst and if src is ...

Definition: decode.c:1907

HWACCEL_VULKAN

#define HWACCEL_VULKAN(codec)

Definition: hwconfig.h:76

AV1_DIV_LUT_PREC_BITS

@ AV1_DIV_LUT_PREC_BITS

Definition: av1.h:121

AV1RawMetadataITUTT35

Definition: cbs_av1.h:350

AVCodecContext

main external API structure.

Definition: avcodec.h:451

get_shear_params_valid

static uint8_t get_shear_params_valid(AV1DecContext *s, int idx)

check if global motion params is valid.

Definition: av1dec.c:177

AVFilmGrainAOMParams::ar_coeff_lag

int ar_coeff_lag

Specifies the auto-regression lag.

Definition: film_grain_params.h:74

itut35.h

FF_CODEC_RECEIVE_FRAME_CB

#define FF_CODEC_RECEIVE_FRAME_CB(func)

Definition: codec_internal.h:317

AVFilmGrainAOMParams::y_points

uint8_t y_points[14][2]

Definition: film_grain_params.h:50

CodedBitstreamUnitType

uint32_t CodedBitstreamUnitType

The codec-specific type of a bitstream unit.

Definition: cbs.h:47

AVFilmGrainAOMParams::uv_offset

int uv_offset[2]

Offset used for component scaling function.

Definition: film_grain_params.h:112

AVRational::den

int den

Denominator.

Definition: rational.h:60

AV_PIX_FMT_NONE

@ AV_PIX_FMT_NONE

Definition: pixfmt.h:72

FF_HW_CALL

#define FF_HW_CALL(avctx, function,...)

Definition: hwaccel_internal.h:171

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

AV1RawFilmGrainParams::ar_coeff_lag

uint8_t ar_coeff_lag

Definition: cbs_av1.h:149

AVCodecContext::profile

int profile

profile

Definition: avcodec.h:1650

AV1RawColorConfig::mono_chrome

uint8_t mono_chrome

Definition: cbs_av1.h:44

export_metadata

static int export_metadata(AVCodecContext *avctx, AVFrame *frame)

Definition: av1dec.c:1029

AVFilmGrainAOMParams::uv_mult

int uv_mult[2]

Specifies the luma/chroma multipliers for the index to the component scaling function.

Definition: film_grain_params.h:105

hdr_dynamic_metadata.h

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:112

AVCodecContext::export_side_data

int export_side_data

Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...

Definition: avcodec.h:1937

AV1RawFilmGrainParams::ar_coeffs_cb_plus_128

uint8_t ar_coeffs_cb_plus_128[25]

Definition: cbs_av1.h:151

AV1_WARP_MODEL_ROTZOOM

@ AV1_WARP_MODEL_ROTZOOM

Definition: av1.h:116

AV1RawFilmGrainParams::ar_coeffs_y_plus_128

uint8_t ar_coeffs_y_plus_128[24]

Definition: cbs_av1.h:150

AVMasteringDisplayMetadata::min_luminance

AVRational min_luminance

Min luminance of mastering display (cd/m^2).

Definition: mastering_display_metadata.h:52

FF_CODEC_PROPERTY_CLOSED_CAPTIONS

#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS

Definition: avcodec.h:1808

ff_cbs_read_packet

int ff_cbs_read_packet(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, const AVPacket *pkt)

Read the data bitstream from a packet into a fragment, then split into units and decompose.

Definition: cbs.c:304

AV1RawSequenceHeader::order_hint_bits_minus_1

uint8_t order_hint_bits_minus_1

Definition: cbs_av1.h:122

AV1RawColorConfig::matrix_coefficients

uint8_t matrix_coefficients

Definition: cbs_av1.h:49

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

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

Definition: pixfmt.h:78

AV1RawTileGroup

Definition: cbs_av1.h:297

AVFilmGrainParams::color_range

enum AVColorRange color_range

Intended video signal characteristics.

Definition: film_grain_params.h:279

AV1_GM_TRANS_ONLY_PREC_BITS

@ AV1_GM_TRANS_ONLY_PREC_BITS

Definition: av1.h:109

AV1RawFilmGrainParams::cr_offset

uint16_t cr_offset

Definition: cbs_av1.h:160

AV1_GM_ABS_TRANS_BITS

@ AV1_GM_ABS_TRANS_BITS

Definition: av1.h:110

AV1RawFilmGrainParams::point_y_scaling

uint8_t point_y_scaling[14]

Definition: cbs_av1.h:140

FF_DISABLE_DEPRECATION_WARNINGS

#define FF_DISABLE_DEPRECATION_WARNINGS

Definition: internal.h:72

AVFilmGrainAOMParams::overlap_flag

int overlap_flag

Signals whether to overlap film grain blocks.

Definition: film_grain_params.h:117

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AV1RawOBU::frame

AV1RawFrame frame

Definition: cbs_av1.h:408

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

AVBufferRef

A reference to a data buffer.

Definition: buffer.h:82

AV1RawFilmGrainParams::point_cb_scaling

uint8_t point_cb_scaling[10]

Definition: cbs_av1.h:144

AV1RawMetadataITUTT35::itu_t_t35_country_code

uint8_t itu_t_t35_country_code

Definition: cbs_av1.h:351

mastering_display_metadata.h

AV1RawFrame::tile_group

AV1RawTileGroup tile_group

Definition: cbs_av1.h:307

ITU_T_T35_COUNTRY_CODE_US

#define ITU_T_T35_COUNTRY_CODE_US

Definition: itut35.h:24

AV1_WARPEDMODEL_PREC_BITS

@ AV1_WARPEDMODEL_PREC_BITS

Definition: av1.h:112

decode_signed_subexp_with_ref

static int32_t decode_signed_subexp_with_ref(uint32_t sub_exp, int low, int high, int r)

Definition: av1dec.c:92

AVPixFmtDescriptor

Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...

Definition: pixdesc.h:69

ff_cbs_init

av_cold int ff_cbs_init(CodedBitstreamContext **ctx_ptr, enum AVCodecID codec_id, void *log_ctx)

Create and initialise a new context for the given codec.

Definition: cbs.c:90

AV1RawColorConfig::twelve_bit

uint8_t twelve_bit

Definition: cbs_av1.h:43

AV1_FRAME_INTER

@ AV1_FRAME_INTER

Definition: av1.h:54

AV1_FRAME_KEY

@ AV1_FRAME_KEY

Definition: av1.h:53

get_pixel_format

static int get_pixel_format(AVCodecContext *avctx)

Definition: av1dec.c:532

alpha

static const int16_t alpha[]

Definition: ilbcdata.h:55

ITU_T_T35_PROVIDER_CODE_SMTPE

#define ITU_T_T35_PROVIDER_CODE_SMTPE

Definition: itut35.h:30

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVContentLightMetadata::MaxFALL

unsigned MaxFALL

Max average light level per frame (cd/m^2).

Definition: mastering_display_metadata.h:116

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

AV1_MAX_OPERATING_POINTS

@ AV1_MAX_OPERATING_POINTS

Definition: av1.h:74

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

OFFSET

#define OFFSET(x)

Definition: av1dec.c:1544

AVPacket::pos

int64_t pos

byte position in stream, -1 if unknown

Definition: packet.h:559

av_dynamic_hdr_plus_from_t35

int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data, size_t size)

Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).

Definition: hdr_dynamic_metadata.c:61

HWACCEL_VAAPI

#define HWACCEL_VAAPI(codec)

Definition: hwconfig.h:70

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:624

TileGroupInfo

Definition: av1dec.h:78

int32_t

Definition: audioconvert.c:56

bytestream.h

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:137

AV1RawFilmGrainParams

Definition: cbs_av1.h:133

sequence_header

static int FUNC() sequence_header(CodedBitstreamContext *ctx, RWContext *rw, MPEG2RawSequenceHeader *current)

Definition: cbs_mpeg2_syntax_template.c:19

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

av_fifo_freep2

void av_fifo_freep2(AVFifo **f)

Free an AVFifo and reset pointer to NULL.

Definition: fifo.c:286

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

av1_receive_frame_internal

static int av1_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)

Definition: av1dec.c:1268

width

#define width

Definition: dsp.h:85

AV_PIX_FMT_GRAY12

#define AV_PIX_FMT_GRAY12

Definition: pixfmt.h:460

AVFilmGrainAOMParams::chroma_scaling_from_luma

int chroma_scaling_from_luma

Signals whether to derive the chroma scaling function from the luma.

Definition: film_grain_params.h:56

ff_cbs_flush

av_cold void ff_cbs_flush(CodedBitstreamContext *ctx)

Reset all internal state in a context.

Definition: cbs.c:136

AV_FILM_GRAIN_PARAMS_AV1

@ AV_FILM_GRAIN_PARAMS_AV1

The union is valid when interpreted as AVFilmGrainAOMParams (codec.aom)

Definition: film_grain_params.h:30

AV1RawOBUHeader

Definition: cbs_av1.h:29

AVFilmGrainParams::type

enum AVFilmGrainParamsType type

Specifies the codec for which this structure is valid.

Definition: film_grain_params.h:242

set_output_frame

static int set_output_frame(AVCodecContext *avctx, AVFrame *frame)

Definition: av1dec.c:1150

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AV1_OBU_METADATA

@ AV1_OBU_METADATA

Definition: av1.h:34

AV1RawFilmGrainParams::num_cr_points

uint8_t num_cr_points

Definition: cbs_av1.h:145

ff_refstruct_unref

void ff_refstruct_unref(void *objp)

Decrement the reference count of the underlying object and automatically free the object if there are...

Definition: refstruct.c:120

AVCodecContext::sample_aspect_ratio

AVRational sample_aspect_ratio

sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.

Definition: avcodec.h:648

AVPixFmtDescriptor::log2_chroma_h

uint8_t log2_chroma_h

Amount to shift the luma height right to find the chroma height.

Definition: pixdesc.h:89

src

#define src

Definition: vp8dsp.c:248

AV_CODEC_EXPORT_DATA_FILM_GRAIN

#define AV_CODEC_EXPORT_DATA_FILM_GRAIN

Decoding only.

Definition: avcodec.h:420

AV_FIFO_FLAG_AUTO_GROW

#define AV_FIFO_FLAG_AUTO_GROW

Automatically resize the FIFO on writes, so that the data fits.

Definition: fifo.h:63

AVFilmGrainAOMParams::ar_coeff_shift

int ar_coeff_shift

Specifies the range of the auto-regressive coefficients.

Definition: film_grain_params.h:93

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

AVDOVIDecoderConfigurationRecord

Definition: dovi_meta.h:55

AVFilmGrainAOMParams::ar_coeffs_uv

int8_t ar_coeffs_uv[2][25]

Chroma auto-regression coefficients.

Definition: film_grain_params.h:86

CodedBitstreamAV1Context

Definition: cbs_av1.h:438

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