FFmpeg: libavcodec/bsf/h265_metadata.c Source File

FFmpeg

[フレーム]

h265_metadata.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 #include "libavutil/common.h"

20 #include "libavutil/opt.h"

22 #include "bsf.h"

23 #include "bsf_internal.h"

24 #include "cbs.h"

25 #include "cbs_bsf.h"

26 #include "cbs_h265.h"

27 #include "h2645data.h"

28 #include "h265_profile_level.h"

30 #include "hevc/hevc.h"

32 enum {

33 LEVEL_UNSET = -2,

34 LEVEL_AUTO = -1,

35 };

37 typedef struct H265MetadataContext {

38 CBSBSFContext common;

40 H265RawAUD aud_nal;

42 int aud;

44 AVRational sample_aspect_ratio;

46 int video_format;

47 int video_full_range_flag;

48 int colour_primaries;

49 int transfer_characteristics;

50 int matrix_coefficients;

52 int chroma_sample_loc_type;

54 AVRational tick_rate;

55 int poc_proportional_to_timing_flag;

56 int num_ticks_poc_diff_one;

58 int crop_left;

59 int crop_right;

60 int crop_top;

61 int crop_bottom;

62 int width;

63 int height;

65 int level;

66 int level_guess;

67 int level_warned;

68 } H265MetadataContext;

71 static void h265_metadata_guess_level(AVBSFContext *bsf,

72 const CodedBitstreamFragment *au)

73 {

74 H265MetadataContext *ctx = bsf->priv_data;

75 const H265LevelDescriptor *desc;

76 const H265RawProfileTierLevel *ptl = NULL;

77 const H265RawHRDParameters *hrd = NULL;

78 int64_t bit_rate = 0;

79 int width = 0, height = 0;

80 int tile_cols = 0, tile_rows = 0;

81 int max_dec_pic_buffering = 0;

82 int i;

84 for (i = 0; i < au->nb_units; i++) {

85 const CodedBitstreamUnit *unit = &au->units[i];

87 if (unit->type == HEVC_NAL_VPS) {

88 const H265RawVPS *vps = unit->content;

90 ptl = &vps->profile_tier_level;

91 max_dec_pic_buffering = vps->vps_max_dec_pic_buffering_minus1[0] + 1;

93 if (vps->vps_num_hrd_parameters > 0)

94 hrd = &vps->hrd_parameters[0];

96 } else if (unit->type == HEVC_NAL_SPS) {

97 const H265RawSPS *sps = unit->content;

99 ptl = &sps->profile_tier_level;

100 max_dec_pic_buffering = sps->sps_max_dec_pic_buffering_minus1[0] + 1;

101

102 width = sps->pic_width_in_luma_samples;

103 height = sps->pic_height_in_luma_samples;

104

105 if (sps->vui.vui_hrd_parameters_present_flag)

106 hrd = &sps->vui.hrd_parameters;

107

108 } else if (unit->type == HEVC_NAL_PPS) {

109 const H265RawPPS *pps = unit->content;

110

111 if (pps->tiles_enabled_flag) {

112 tile_cols = pps->num_tile_columns_minus1 + 1;

113 tile_rows = pps->num_tile_rows_minus1 + 1;

114 }

115 }

116 }

117

118 if (hrd) {

119 if (hrd->nal_hrd_parameters_present_flag) {

120 bit_rate = (hrd->nal_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *

121 (INT64_C(1) << hrd->bit_rate_scale + 6);

122 } else if (hrd->vcl_hrd_parameters_present_flag) {

123 bit_rate = (hrd->vcl_sub_layer_hrd_parameters[0].bit_rate_value_minus1[0] + 1) *

124 (INT64_C(1) << hrd->bit_rate_scale + 6);

125 // Adjust for VCL vs. NAL limits.

126 bit_rate = bit_rate * 11 / 10;

127 }

128 }

129

130 desc = ff_h265_guess_level(ptl, bit_rate, width, height,

131 0, tile_rows, tile_cols,

132 max_dec_pic_buffering);

133 if (desc) {

134 av_log(bsf, AV_LOG_DEBUG, "Stream appears to conform to "

135 "level %s.\n", desc->name);

136 ctx->level_guess = desc->level_idc;

137 }

138 }

139

140 static void h265_metadata_update_level(AVBSFContext *bsf,

141 uint8_t *level_idc)

142 {

143 H265MetadataContext *ctx = bsf->priv_data;

144

145 if (ctx->level != LEVEL_UNSET) {

146 if (ctx->level == LEVEL_AUTO) {

147 if (ctx->level_guess) {

148 *level_idc = ctx->level_guess;

149 } else {

150 if (!ctx->level_warned) {

151 av_log(bsf, AV_LOG_WARNING, "Unable to determine level "

152 "of stream: using level 8.5.\n");

153 ctx->level_warned = 1;

154 }

155 *level_idc = 255;

156 }

157 } else {

158 *level_idc = ctx->level;

159 }

160 }

161 }

162

163 static int h265_metadata_update_vps(AVBSFContext *bsf,

164 H265RawVPS *vps)

165 {

166 H265MetadataContext *ctx = bsf->priv_data;

167

168 if (ctx->tick_rate.num && ctx->tick_rate.den) {

169 int num, den;

170

171 av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,

172 UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);

173

174 vps->vps_time_scale = num;

175 vps->vps_num_units_in_tick = den;

176

177 vps->vps_timing_info_present_flag = 1;

178

179 if (ctx->num_ticks_poc_diff_one > 0) {

180 vps->vps_num_ticks_poc_diff_one_minus1 =

181 ctx->num_ticks_poc_diff_one - 1;

182 vps->vps_poc_proportional_to_timing_flag = 1;

183 } else if (ctx->num_ticks_poc_diff_one == 0) {

184 vps->vps_poc_proportional_to_timing_flag = 0;

185 }

186 }

187

188 h265_metadata_update_level(bsf, &vps->profile_tier_level.general_level_idc);

189

190 return 0;

191 }

192

193 static int h265_metadata_deduce_crop(AVBSFContext *bsf, const H265RawSPS *sps,

194 int *crop_left, int *crop_right,

195 int *crop_top, int *crop_bottom)

196 {

197 const H265MetadataContext *ctx = bsf->priv_data;

198 int left = ctx->crop_left;

199 int right = ctx->crop_right;

200 int top = ctx->crop_top;

201 int bottom = ctx->crop_bottom;

202

203 if (ctx->width > 0) {

204 if (ctx->width > sps->pic_width_in_luma_samples) {

205 av_log(bsf, AV_LOG_ERROR,

206 "The width option value %d is larger than picture width %d\n",

207 ctx->width, sps->pic_width_in_luma_samples);

208 return AVERROR(EINVAL);

209 }

210

211 if (left < 0) {

212 if (right > 0)

213 left = sps->pic_width_in_luma_samples - ctx->width - right;

214 else

215 left = 0;

216 }

217

218 if (right < 0)

219 right = sps->pic_width_in_luma_samples - ctx->width - left;

220

221 if (left < 0 || right < 0 || (left + right + ctx->width) !=

222 sps->pic_width_in_luma_samples) {

223 av_log(bsf, AV_LOG_ERROR,

224 "Invalid value for crop_left %d, crop_right %d, width after "

225 "crop %d, with picture width %d\n",

226 ctx->crop_left, ctx->crop_right, ctx->width,

227 sps->pic_width_in_luma_samples);

228 return AVERROR(EINVAL);

229 }

230 }

231

232 if (ctx->height > 0) {

233 if (ctx->height > sps->pic_height_in_luma_samples) {

234 av_log(bsf, AV_LOG_ERROR,

235 "The height option value %d is larger than picture height %d\n",

236 ctx->height, sps->pic_height_in_luma_samples);

237 return AVERROR(EINVAL);

238 }

239

240 if (top < 0) {

241 if (bottom > 0)

242 top = sps->pic_height_in_luma_samples - ctx->height - bottom;

243 else

244 top = 0;

245 }

246

247 if (bottom < 0)

248 bottom = sps->pic_height_in_luma_samples - ctx->height - top;

249

250 if (top < 0 || bottom < 0 || (top + bottom + ctx->height) !=

251 sps->pic_height_in_luma_samples) {

252 av_log(bsf, AV_LOG_ERROR,

253 "Invalid value for crop_top %d, crop_bottom %d, height after "

254 "crop %d, with picture height %d\n",

255 ctx->crop_top, ctx->crop_bottom, ctx->height,

256 sps->pic_height_in_luma_samples);

257 return AVERROR(EINVAL);

258 }

259 }

260

261 *crop_left = left;

262 *crop_right = right;

263 *crop_top = top;

264 *crop_bottom = bottom;

265

266 return 0;

267 }

268

269 static int h265_metadata_update_sps(AVBSFContext *bsf,

270 H265RawSPS *sps)

271 {

272 H265MetadataContext *ctx = bsf->priv_data;

273 int need_vui = 0;

274 int crop_unit_x, crop_unit_y;

275 /* Use local variables to avoid modifying context fields in case of video

276 * resolution changed. Crop doesn't work well with resolution change, this

277 * is the best we can do.

278 */

279 int crop_left, crop_right, crop_top, crop_bottom;

280 int ret;

281

282 if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {

283 int num, den, i;

284

285 av_reduce(&num, &den, ctx->sample_aspect_ratio.num,

286 ctx->sample_aspect_ratio.den, 65535);

287

288 for (i = 1; i < FF_ARRAY_ELEMS(ff_h2645_pixel_aspect); i++) {

289 if (num == ff_h2645_pixel_aspect[i].num &&

290 den == ff_h2645_pixel_aspect[i].den)

291 break;

292 }

293 if (i == FF_ARRAY_ELEMS(ff_h2645_pixel_aspect)) {

294 sps->vui.aspect_ratio_idc = 255;

295 sps->vui.sar_width = num;

296 sps->vui.sar_height = den;

297 } else {

298 sps->vui.aspect_ratio_idc = i;

299 }

300 sps->vui.aspect_ratio_info_present_flag = 1;

301 need_vui = 1;

302 }

303

304 #define SET_OR_INFER(field, value, present_flag, infer) do { \

305 if (value >= 0) { \

306 field = value; \

307 need_vui = 1; \

308 } else if (!present_flag) \

309 field = infer; \

310 } while (0)

311

312 if (ctx->video_format >= 0 ||

313 ctx->video_full_range_flag >= 0 ||

314 ctx->colour_primaries >= 0 ||

315 ctx->transfer_characteristics >= 0 ||

316 ctx->matrix_coefficients >= 0) {

317

318 SET_OR_INFER(sps->vui.video_format, ctx->video_format,

319 sps->vui.video_signal_type_present_flag, 5);

320

321 SET_OR_INFER(sps->vui.video_full_range_flag,

322 ctx->video_full_range_flag,

323 sps->vui.video_signal_type_present_flag, 0);

324

325 if (ctx->colour_primaries >= 0 ||

326 ctx->transfer_characteristics >= 0 ||

327 ctx->matrix_coefficients >= 0) {

328

329 SET_OR_INFER(sps->vui.colour_primaries,

330 ctx->colour_primaries,

331 sps->vui.colour_description_present_flag, 2);

332

333 SET_OR_INFER(sps->vui.transfer_characteristics,

334 ctx->transfer_characteristics,

335 sps->vui.colour_description_present_flag, 2);

336

337 SET_OR_INFER(sps->vui.matrix_coefficients,

338 ctx->matrix_coefficients,

339 sps->vui.colour_description_present_flag, 2);

340

341 sps->vui.colour_description_present_flag = 1;

342 }

343 sps->vui.video_signal_type_present_flag = 1;

344 need_vui = 1;

345 }

346

347 if (ctx->chroma_sample_loc_type >= 0) {

348 sps->vui.chroma_sample_loc_type_top_field =

349 ctx->chroma_sample_loc_type;

350 sps->vui.chroma_sample_loc_type_bottom_field =

351 ctx->chroma_sample_loc_type;

352 sps->vui.chroma_loc_info_present_flag = 1;

353 need_vui = 1;

354 }

355

356 if (ctx->tick_rate.num && ctx->tick_rate.den) {

357 int num, den;

358

359 av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,

360 UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);

361

362 sps->vui.vui_time_scale = num;

363 sps->vui.vui_num_units_in_tick = den;

364

365 sps->vui.vui_timing_info_present_flag = 1;

366 need_vui = 1;

367

368 if (ctx->num_ticks_poc_diff_one > 0) {

369 sps->vui.vui_num_ticks_poc_diff_one_minus1 =

370 ctx->num_ticks_poc_diff_one - 1;

371 sps->vui.vui_poc_proportional_to_timing_flag = 1;

372 } else if (ctx->num_ticks_poc_diff_one == 0) {

373 sps->vui.vui_poc_proportional_to_timing_flag = 0;

374 }

375 }

376

377 ret = h265_metadata_deduce_crop(bsf, sps, &crop_left, &crop_right,

378 &crop_top, &crop_bottom);

379 if (ret < 0)

380 return ret;

381

382 if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {

383 crop_unit_x = 1;

384 crop_unit_y = 1;

385 } else {

386 crop_unit_x = 1 + (sps->chroma_format_idc < 3);

387 crop_unit_y = 1 + (sps->chroma_format_idc < 2);

388 }

389 #define CROP(border, unit) do { \

390 if (crop_ ## border >= 0) { \

391 if (crop_ ## border % unit != 0) { \

392 av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \

393 "must be a multiple of %d.\n", #border, unit); \

394 return AVERROR(EINVAL); \

395 } \

396 sps->conf_win_ ## border ## _offset = \

397 crop_ ## border / unit; \

398 sps->conformance_window_flag = 1; \

399 } \

400 } while (0)

401 CROP(left, crop_unit_x);

402 CROP(right, crop_unit_x);

403 CROP(top, crop_unit_y);

404 CROP(bottom, crop_unit_y);

405 #undef CROP

406

407 if (need_vui)

408 sps->vui_parameters_present_flag = 1;

409

410 h265_metadata_update_level(bsf, &sps->profile_tier_level.general_level_idc);

411

412 return 0;

413 }

414

415 static int h265_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt,

416 CodedBitstreamFragment *au)

417 {

418 H265MetadataContext *ctx = bsf->priv_data;

419 int err, i;

420

421 // If an AUD is present, it must be the first NAL unit.

422 if (au->nb_units && au->units[0].type == HEVC_NAL_AUD) {

423 if (ctx->aud == BSF_ELEMENT_REMOVE)

424 ff_cbs_delete_unit(au, 0);

425 } else {

426 if (pkt && ctx->aud == BSF_ELEMENT_INSERT) {

427 H265RawAUD *aud = &ctx->aud_nal;

428 int pic_type = 0, temporal_id = 8, layer_id = 0;

429

430 for (i = 0; i < au->nb_units; i++) {

431 const H265RawNALUnitHeader *nal = au->units[i].content;

432 if (!nal)

433 continue;

434 if (nal->nuh_temporal_id_plus1 < temporal_id + 1)

435 temporal_id = nal->nuh_temporal_id_plus1 - 1;

436

437 if (au->units[i].type <= HEVC_NAL_RSV_VCL31) {

438 const H265RawSlice *slice = au->units[i].content;

439 layer_id = nal->nuh_layer_id;

440 if (slice->header.slice_type == HEVC_SLICE_B &&

441 pic_type < 2)

442 pic_type = 2;

443 if (slice->header.slice_type == HEVC_SLICE_P &&

444 pic_type < 1)

445 pic_type = 1;

446 }

447 }

448

449 aud->nal_unit_header = (H265RawNALUnitHeader) {

450 .nal_unit_type = HEVC_NAL_AUD,

451 .nuh_layer_id = layer_id,

452 .nuh_temporal_id_plus1 = temporal_id + 1,

453 };

454 aud->pic_type = pic_type;

455

456 err = ff_cbs_insert_unit_content(au, 0, HEVC_NAL_AUD, aud, NULL);

457 if (err < 0) {

458 av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");

459 return err;

460 }

461 }

462 }

463

464 if (ctx->level == LEVEL_AUTO && !ctx->level_guess)

465 h265_metadata_guess_level(bsf, au);

466

467 for (i = 0; i < au->nb_units; i++) {

468 if (au->units[i].type == HEVC_NAL_VPS) {

469 err = h265_metadata_update_vps(bsf, au->units[i].content);

470 if (err < 0)

471 return err;

472 }

473 if (au->units[i].type == HEVC_NAL_SPS) {

474 err = h265_metadata_update_sps(bsf, au->units[i].content);

475 if (err < 0)

476 return err;

477 }

478 }

479

480 return 0;

481 }

482

483 static const CBSBSFType h265_metadata_type = {

484 .codec_id = AV_CODEC_ID_HEVC,

485 .fragment_name = "access unit",

486 .unit_name = "NAL unit",

487 .update_fragment = &h265_metadata_update_fragment,

488 };

489

490 static int h265_metadata_init(AVBSFContext *bsf)

491 {

492 return ff_cbs_bsf_generic_init(bsf, &h265_metadata_type);

493 }

494

495 #define OFFSET(x) offsetof(H265MetadataContext, x)

496 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)

497 static const AVOption h265_metadata_options[] = {

498 BSF_ELEMENT_OPTIONS_PIR("aud", "Access Unit Delimiter NAL units",

499 aud, FLAGS),

500

501 { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",

502 OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,

503 { .dbl = 0.0 }, 0, 65535, FLAGS },

504

505 { "video_format", "Set video format (table E-2)",

506 OFFSET(video_format), AV_OPT_TYPE_INT,

507 { .i64 = -1 }, -1, 7, FLAGS },

508 { "video_full_range_flag", "Set video full range flag",

509 OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,

510 { .i64 = -1 }, -1, 1, FLAGS },

511 { "colour_primaries", "Set colour primaries (table E-3)",

512 OFFSET(colour_primaries), AV_OPT_TYPE_INT,

513 { .i64 = -1 }, -1, 255, FLAGS },

514 { "transfer_characteristics", "Set transfer characteristics (table E-4)",

515 OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,

516 { .i64 = -1 }, -1, 255, FLAGS },

517 { "matrix_coefficients", "Set matrix coefficients (table E-5)",

518 OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,

519 { .i64 = -1 }, -1, 255, FLAGS },

520

521 { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",

522 OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,

523 { .i64 = -1 }, -1, 5, FLAGS },

524

525 { "tick_rate",

526 "Set VPS and VUI tick rate (time_scale / num_units_in_tick)",

527 OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,

528 { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },

529 { "num_ticks_poc_diff_one",

530 "Set VPS and VUI number of ticks per POC increment",

531 OFFSET(num_ticks_poc_diff_one), AV_OPT_TYPE_INT,

532 { .i64 = -1 }, -1, INT_MAX, FLAGS },

533

534 { "crop_left", "Set left border crop offset",

535 OFFSET(crop_left), AV_OPT_TYPE_INT,

536 { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },

537 { "crop_right", "Set right border crop offset",

538 OFFSET(crop_right), AV_OPT_TYPE_INT,

539 { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },

540 { "crop_top", "Set top border crop offset",

541 OFFSET(crop_top), AV_OPT_TYPE_INT,

542 { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },

543 { "crop_bottom", "Set bottom border crop offset",

544 OFFSET(crop_bottom), AV_OPT_TYPE_INT,

545 { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },

546 { "width", "Set width after crop",

547 OFFSET(width), AV_OPT_TYPE_INT,

548 { .i64 = -1 }, -1, HEVC_MAX_WIDTH, FLAGS },

549 { "height", "Set height after crop",

550 OFFSET(height), AV_OPT_TYPE_INT,

551 { .i64 = -1 }, -1, HEVC_MAX_HEIGHT, FLAGS },

552

553 { "level", "Set level (tables A.6 and A.7)",

554 OFFSET(level), AV_OPT_TYPE_INT,

555 { .i64 = LEVEL_UNSET }, LEVEL_UNSET, 0xff, FLAGS, .unit = "level" },

556 { "auto", "Attempt to guess level from stream properties",

557 0, AV_OPT_TYPE_CONST,

558 { .i64 = LEVEL_AUTO }, .flags = FLAGS, .unit = "level" },

559 #define LEVEL(name, value) name, NULL, 0, AV_OPT_TYPE_CONST, \

560 { .i64 = value }, .flags = FLAGS, .unit = "level"

561 { LEVEL("1", 30) },

562 { LEVEL("2", 60) },

563 { LEVEL("2.1", 63) },

564 { LEVEL("3", 90) },

565 { LEVEL("3.1", 93) },

566 { LEVEL("4", 120) },

567 { LEVEL("4.1", 123) },

568 { LEVEL("5", 150) },

569 { LEVEL("5.1", 153) },

570 { LEVEL("5.2", 156) },

571 { LEVEL("6", 180) },

572 { LEVEL("6.1", 183) },

573 { LEVEL("6.2", 186) },

574 { LEVEL("8.5", 255) },

575 #undef LEVEL

576

577 { NULL }

578 };

579

580 static const AVClass h265_metadata_class = {

581 .class_name = "h265_metadata_bsf",

582 .item_name = av_default_item_name,

583 .option = h265_metadata_options,

584 .version = LIBAVUTIL_VERSION_INT,

585 };

586

587 static const enum AVCodecID h265_metadata_codec_ids[] = {

588 AV_CODEC_ID_HEVC, AV_CODEC_ID_NONE,

589 };

590

591 const FFBitStreamFilter ff_hevc_metadata_bsf = {

592 .p.name = "hevc_metadata",

593 .p.codec_ids = h265_metadata_codec_ids,

594 .p.priv_class = &h265_metadata_class,

595 .priv_data_size = sizeof(H265MetadataContext),

596 .init = &h265_metadata_init,

597 .close = &ff_cbs_bsf_generic_close,

598 .filter = &ff_cbs_bsf_generic_filter,

599 };

HEVC_NAL_AUD

@ HEVC_NAL_AUD

Definition: hevc.h:64

H265MetadataContext::crop_bottom

int crop_bottom

Definition: h265_metadata.c:61

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

level

uint8_t level

Definition: svq3.c:208

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

bsf_internal.h

opt.h

H265MetadataContext::chroma_sample_loc_type

int chroma_sample_loc_type

Definition: h265_metadata.c:52

HEVC_MAX_WIDTH

@ HEVC_MAX_WIDTH

Definition: hevc.h:141

H265RawSubLayerHRDParameters::bit_rate_value_minus1

uint32_t bit_rate_value_minus1[HEVC_MAX_CPB_CNT]

Definition: cbs_h265.h:94

CBSBSFType::codec_id

enum AVCodecID codec_id

Definition: cbs_bsf.h:32

H265MetadataContext::transfer_characteristics

int transfer_characteristics

Definition: h265_metadata.c:49

LEVEL_AUTO

@ LEVEL_AUTO

Definition: h265_metadata.c:34

CodedBitstreamUnit::content

void * content

Pointer to the decomposed form of this unit.

Definition: cbs.h:114

AVBitStreamFilter::name

const char * name

Definition: bsf.h:112

int64_t

long long int64_t

Definition: coverity.c:34

H265RawSlice::header

H265RawSliceHeader header

Definition: cbs_h265.h:584

LEVEL

#define LEVEL(name, value)

h265_metadata_options

static const AVOption h265_metadata_options[]

Definition: h265_metadata.c:497

level_idc

int level_idc

Definition: h264_levels.c:29

AVOption

AVOption.

Definition: opt.h:429

H265RawNALUnitHeader::nuh_temporal_id_plus1

uint8_t nuh_temporal_id_plus1

Definition: cbs_h265.h:33

CBSBSFContext

Definition: cbs_bsf.h:53

filter

void(* filter)(uint8_t *src, int stride, int qscale)

Definition: h263dsp.c:29

CodedBitstreamUnit::type

CodedBitstreamUnitType type

Codec-specific type of this unit.

Definition: cbs.h:81

ff_cbs_bsf_generic_close

av_cold void ff_cbs_bsf_generic_close(AVBSFContext *bsf)

Close a generic CBS BSF instance.

Definition: cbs_bsf.c:157

cbs_h265.h

H265MetadataContext::matrix_coefficients

int matrix_coefficients

Definition: h265_metadata.c:50

AV_OPT_TYPE_RATIONAL

@ AV_OPT_TYPE_RATIONAL

Underlying C type is AVRational.

Definition: opt.h:280

H265MetadataContext::aud_nal

H265RawAUD aud_nal

Definition: h265_metadata.c:40

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

CodedBitstreamUnit

Coded bitstream unit structure.

Definition: cbs.h:77

H265LevelDescriptor

Definition: h265_profile_level.h:27

H265RawSPS

Definition: cbs_h265.h:245

H265RawVPS

Definition: cbs_h265.h:184

H265RawPPS

Definition: cbs_h265.h:356

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

bsf.h

cbs_bsf.h

H265RawHRDParameters::vcl_hrd_parameters_present_flag

uint8_t vcl_hrd_parameters_present_flag

Definition: cbs_h265.h:103

H265MetadataContext::level

int level

Definition: h265_metadata.c:65

H265MetadataContext::crop_left

int crop_left

Definition: h265_metadata.c:58

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

h265_metadata_guess_level

static void h265_metadata_guess_level(AVBSFContext *bsf, const CodedBitstreamFragment *au)

Definition: h265_metadata.c:71

CodedBitstreamFragment::units

CodedBitstreamUnit * units

Pointer to an array of units of length nb_units_allocated.

Definition: cbs.h:175

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

HEVC_SLICE_B

@ HEVC_SLICE_B

Definition: hevc.h:96

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

transfer_characteristics

static const struct TransferCharacteristics transfer_characteristics[]

Definition: vf_colorspace.c:174

ptl

const H265RawProfileTierLevel * ptl

Definition: h265_levels.c:170

ff_h265_guess_level

const H265LevelDescriptor * ff_h265_guess_level(const H265RawProfileTierLevel *ptl, int64_t bitrate, int width, int height, int slice_segments, int tile_rows, int tile_cols, int max_dec_pic_buffering)

Guess the level of a stream from some parameters.

Definition: h265_profile_level.c:162

CodedBitstreamFragment

Coded bitstream fragment structure, combining one or more units.

Definition: cbs.h:129

H265MetadataContext::video_full_range_flag

int video_full_range_flag

Definition: h265_metadata.c:47

HEVC_NAL_VPS

@ HEVC_NAL_VPS

Definition: hevc.h:61

tile_rows

int tile_rows

Definition: h265_levels.c:217

H265RawHRDParameters::bit_rate_scale

uint8_t bit_rate_scale

Definition: cbs_h265.h:111

tile_cols

int tile_cols

Definition: av1_levels.c:73

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

ctx

AVFormatContext * ctx

Definition: movenc.c:49

hevc.h

h265_metadata_update_fragment

static int h265_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt, CodedBitstreamFragment *au)

Definition: h265_metadata.c:415

h2645data.h

H265MetadataContext::common

CBSBSFContext common

Definition: h265_metadata.c:38

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

H265RawAUD

Definition: cbs_h265.h:487

FFBitStreamFilter

Definition: bsf_internal.h:27

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

h265_metadata_update_vps

static int h265_metadata_update_vps(AVBSFContext *bsf, H265RawVPS *vps)

Definition: h265_metadata.c:163

H265MetadataContext::level_warned

int level_warned

Definition: h265_metadata.c:67

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

HEVC_NAL_RSV_VCL31

@ HEVC_NAL_RSV_VCL31

Definition: hevc.h:60

vps

static int FUNC() vps(CodedBitstreamContext *ctx, RWContext *rw, H265RawVPS *current)

Definition: cbs_h265_syntax_template.c:423

H265RawSliceHeader::slice_type

uint8_t slice_type

Definition: cbs_h265.h:504

H265RawNALUnitHeader

Definition: cbs_h265.h:30

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

H265MetadataContext::level_guess

int level_guess

Definition: h265_metadata.c:66

OFFSET

#define OFFSET(x)

Definition: h265_metadata.c:495

FFBitStreamFilter::p

AVBitStreamFilter p

The public AVBitStreamFilter.

Definition: bsf_internal.h:31

aud

static int FUNC() aud(CodedBitstreamContext *ctx, RWContext *rw, H264RawAUD *current)

Definition: cbs_h264_syntax_template.c:875

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

height

#define height

Definition: dsp.h:89

CBSBSFType

Definition: cbs_bsf.h:31

HEVC_NAL_SPS

@ HEVC_NAL_SPS

Definition: hevc.h:62

h265_profile_level.h

H265RawHRDParameters

Definition: cbs_h265.h:101

HEVC_NAL_PPS

@ HEVC_NAL_PPS

Definition: hevc.h:63

H265MetadataContext

Definition: h265_metadata.c:37

LEVEL_UNSET

@ LEVEL_UNSET

Definition: h265_metadata.c:33

ff_cbs_bsf_generic_init

av_cold int ff_cbs_bsf_generic_init(AVBSFContext *bsf, const CBSBSFType *type)

Initialise generic CBS BSF setup.

Definition: cbs_bsf.c:112

H265MetadataContext::tick_rate

AVRational tick_rate

Definition: h265_metadata.c:54

H265RawNALUnitHeader::nuh_layer_id

uint8_t nuh_layer_id

Definition: cbs_h265.h:32

H265MetadataContext::poc_proportional_to_timing_flag

int poc_proportional_to_timing_flag

Definition: h265_metadata.c:55

AV_CODEC_ID_NONE

@ AV_CODEC_ID_NONE

Definition: codec_id.h:50

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

Definition: cbs_h2645.c:256

SET_OR_INFER

#define SET_OR_INFER(field, value, present_flag, infer)

FLAGS

#define FLAGS

Definition: h265_metadata.c:496

common.h

H265MetadataContext::video_format

int video_format

Definition: h265_metadata.c:46

AV_CODEC_ID_HEVC

@ AV_CODEC_ID_HEVC

Definition: codec_id.h:228

h265_metadata_codec_ids

static enum AVCodecID h265_metadata_codec_ids[]

Definition: h265_metadata.c:587

ff_h2645_pixel_aspect

const AVRational ff_h2645_pixel_aspect[]

Definition: h2645data.c:21

H265RawProfileTierLevel

Definition: cbs_h265.h:36

H265RawHRDParameters::nal_hrd_parameters_present_flag

uint8_t nal_hrd_parameters_present_flag

Definition: cbs_h265.h:102

AVBSFContext::priv_data

void * priv_data

Opaque filter-specific private data.

Definition: bsf.h:83

ff_cbs_bsf_generic_filter

int ff_cbs_bsf_generic_filter(AVBSFContext *bsf, AVPacket *pkt)

Filter operation for CBS BSF.

Definition: cbs_bsf.c:63

ret

Definition: filter_design.txt:187

H265MetadataContext::colour_primaries

int colour_primaries

Definition: h265_metadata.c:48

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

h265_metadata_type

static const CBSBSFType h265_metadata_type

Definition: h265_metadata.c:483

sps

static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)

Definition: cbs_h264_syntax_template.c:260

h265_metadata_update_level

static void h265_metadata_update_level(AVBSFContext *bsf, uint8_t *level_idc)

Definition: h265_metadata.c:140

BSF_ELEMENT_OPTIONS_PIR

#define BSF_ELEMENT_OPTIONS_PIR(name, help, field, opt_flags)

Definition: cbs_bsf.h:112

H265MetadataContext::height

int height

Definition: h265_metadata.c:63

h265_metadata_init

static int h265_metadata_init(AVBSFContext *bsf)

Definition: h265_metadata.c:490

left

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left

Definition: snow.txt:386

h265_metadata_update_sps

static int h265_metadata_update_sps(AVBSFContext *bsf, H265RawSPS *sps)

Definition: h265_metadata.c:269

CROP

#define CROP(border, unit)

H265MetadataContext::crop_top

int crop_top

Definition: h265_metadata.c:60

H265RawHRDParameters::vcl_sub_layer_hrd_parameters

H265RawSubLayerHRDParameters vcl_sub_layer_hrd_parameters[HEVC_MAX_SUB_LAYERS]

Definition: cbs_h265.h:125