FFmpeg: libavcodec/bsf/h264_metadata.c Source File

FFmpeg

[フレーム]

h264_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/avstring.h"

20 #include "libavutil/display.h"

21 #include "libavutil/common.h"

22 #include "libavutil/mem.h"

23 #include "libavutil/opt.h"

25 #include "bsf.h"

26 #include "bsf_internal.h"

27 #include "cbs.h"

28 #include "cbs_bsf.h"

29 #include "cbs_h264.h"

30 #include "cbs_sei.h"

31 #include "h264.h"

32 #include "h264_levels.h"

33 #include "h2645data.h"

34 #include "sei.h"

36 enum {

37 FLIP_HORIZONTAL = 1,

38 FLIP_VERTICAL = 2,

39 };

41 enum {

42 LEVEL_UNSET = -2,

43 LEVEL_AUTO = -1,

44 };

46 typedef struct H264MetadataContext {

47 CBSBSFContext common;

49 int done_first_au;

51 int aud;

52 H264RawAUD aud_nal;

54 AVRational sample_aspect_ratio;

56 int overscan_appropriate_flag;

58 int video_format;

59 int video_full_range_flag;

60 int colour_primaries;

61 int transfer_characteristics;

62 int matrix_coefficients;

64 int chroma_sample_loc_type;

66 AVRational tick_rate;

67 int fixed_frame_rate_flag;

68 int zero_new_constraint_set_flags;

70 int crop_left;

71 int crop_right;

72 int crop_top;

73 int crop_bottom;

75 const char *sei_user_data;

76 SEIRawUserDataUnregistered sei_user_data_payload;

78 int delete_filler;

80 int display_orientation;

81 double rotate;

82 int flip;

83 H264RawSEIDisplayOrientation display_orientation_payload;

85 int level;

86 } H264MetadataContext;

89 static int h264_metadata_insert_aud(AVBSFContext *bsf,

90 CodedBitstreamFragment *au)

91 {

92 H264MetadataContext *ctx = bsf->priv_data;

93 int primary_pic_type_mask = 0xff;

94 int err, i, j;

96 static const int primary_pic_type_table[] = {

97 0x084, // 2, 7

98 0x0a5, // 0, 2, 5, 7

99 0x0e7, // 0, 1, 2, 5, 6, 7

100 0x210, // 4, 9

101 0x318, // 3, 4, 8, 9

102 0x294, // 2, 4, 7, 9

103 0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9

104 0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

105 };

106

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

108 if (au->units[i].type == H264_NAL_SLICE ||

109 au->units[i].type == H264_NAL_IDR_SLICE) {

110 H264RawSlice *slice = au->units[i].content;

111 for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {

112 if (!(primary_pic_type_table[j] &

113 (1 << slice->header.slice_type)))

114 primary_pic_type_mask &= ~(1 << j);

115 }

116 }

117 }

118 for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)

119 if (primary_pic_type_mask & (1 << j))

120 break;

121 if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {

122 av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "

123 "invalid slice types?\n");

124 return AVERROR_INVALIDDATA;

125 }

126

127 ctx->aud_nal = (H264RawAUD) {

128 .nal_unit_header.nal_unit_type = H264_NAL_AUD,

129 .primary_pic_type = j,

130 };

131

132 err = ff_cbs_insert_unit_content(au, 0, H264_NAL_AUD,

133 &ctx->aud_nal, NULL);

134 if (err < 0) {

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

136 return err;

137 }

138

139 return 0;

140 }

141

142 static int h264_metadata_update_sps(AVBSFContext *bsf,

143 H264RawSPS *sps)

144 {

145 H264MetadataContext *ctx = bsf->priv_data;

146 int need_vui = 0;

147 int crop_unit_x, crop_unit_y;

148

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

150 int num, den, i;

151

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

153 ctx->sample_aspect_ratio.den, 65535);

154

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

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

157 den == ff_h2645_pixel_aspect[i].den)

158 break;

159 }

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

161 sps->vui.aspect_ratio_idc = 255;

162 sps->vui.sar_width = num;

163 sps->vui.sar_height = den;

164 } else {

165 sps->vui.aspect_ratio_idc = i;

166 }

167 sps->vui.aspect_ratio_info_present_flag = 1;

168 need_vui = 1;

169 }

170

171 #define SET_VUI_FIELD(field) do { \

172 if (ctx->field >= 0) { \

173 sps->vui.field = ctx->field; \

174 need_vui = 1; \

175 } \

176 } while (0)

177

178 if (ctx->overscan_appropriate_flag >= 0) {

179 SET_VUI_FIELD(overscan_appropriate_flag);

180 sps->vui.overscan_info_present_flag = 1;

181 }

182

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

184 ctx->video_full_range_flag >= 0 ||

185 ctx->colour_primaries >= 0 ||

186 ctx->transfer_characteristics >= 0 ||

187 ctx->matrix_coefficients >= 0) {

188

189 SET_VUI_FIELD(video_format);

190

191 SET_VUI_FIELD(video_full_range_flag);

192

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

194 ctx->transfer_characteristics >= 0 ||

195 ctx->matrix_coefficients >= 0) {

196

197 SET_VUI_FIELD(colour_primaries);

198 SET_VUI_FIELD(transfer_characteristics);

199 SET_VUI_FIELD(matrix_coefficients);

200

201 sps->vui.colour_description_present_flag = 1;

202 }

203 sps->vui.video_signal_type_present_flag = 1;

204 }

205

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

207 sps->vui.chroma_sample_loc_type_top_field =

208 ctx->chroma_sample_loc_type;

209 sps->vui.chroma_sample_loc_type_bottom_field =

210 ctx->chroma_sample_loc_type;

211 sps->vui.chroma_loc_info_present_flag = 1;

212 need_vui = 1;

213 }

214

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

216 int num, den;

217

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

219 UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);

220

221 sps->vui.time_scale = num;

222 sps->vui.num_units_in_tick = den;

223

224 sps->vui.timing_info_present_flag = 1;

225 need_vui = 1;

226 }

227 SET_VUI_FIELD(fixed_frame_rate_flag);

228 if (ctx->zero_new_constraint_set_flags) {

229 sps->constraint_set4_flag = 0;

230 sps->constraint_set5_flag = 0;

231 }

232

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

234 crop_unit_x = 1;

235 crop_unit_y = 2 - sps->frame_mbs_only_flag;

236 } else {

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

238 crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *

239 (2 - sps->frame_mbs_only_flag);

240 }

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

242 if (ctx->crop_ ## border >= 0) { \

243 if (ctx->crop_ ## border % unit != 0) { \

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

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

246 return AVERROR(EINVAL); \

247 } \

248 sps->frame_crop_ ## border ## _offset = \

249 ctx->crop_ ## border / unit; \

250 sps->frame_cropping_flag = 1; \

251 } \

252 } while (0)

253 CROP(left, crop_unit_x);

254 CROP(right, crop_unit_x);

255 CROP(top, crop_unit_y);

256 CROP(bottom, crop_unit_y);

257 #undef CROP

258

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

260 int level_idc;

261

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

263 const H264LevelDescriptor *desc;

264 int64_t bit_rate;

265 int width, height, dpb_frames;

266 int framerate;

267

268 if (sps->vui.nal_hrd_parameters_present_flag) {

269 bit_rate = (sps->vui.nal_hrd_parameters.bit_rate_value_minus1[0] + 1) *

270 (INT64_C(1) << (sps->vui.nal_hrd_parameters.bit_rate_scale + 6));

271 } else if (sps->vui.vcl_hrd_parameters_present_flag) {

272 bit_rate = (sps->vui.vcl_hrd_parameters.bit_rate_value_minus1[0] + 1) *

273 (INT64_C(1) << (sps->vui.vcl_hrd_parameters.bit_rate_scale + 6));

274 // Adjust for VCL vs. NAL limits.

275 bit_rate = bit_rate * 6 / 5;

276 } else {

277 bit_rate = 0;

278 }

279

280 // Don't use max_dec_frame_buffering if it is only inferred.

281 dpb_frames = sps->vui.bitstream_restriction_flag ?

282 sps->vui.max_dec_frame_buffering : H264_MAX_DPB_FRAMES;

283

284 width = 16 * (sps->pic_width_in_mbs_minus1 + 1);

285 height = 16 * (sps->pic_height_in_map_units_minus1 + 1) *

286 (2 - sps->frame_mbs_only_flag);

287

288 if (sps->vui.timing_info_present_flag)

289 framerate = sps->vui.time_scale / sps->vui.num_units_in_tick / 2;

290 else

291 framerate = 0;

292

293 desc = ff_h264_guess_level(sps->profile_idc, bit_rate, framerate,

294 width, height, dpb_frames);

295 if (desc) {

296 level_idc = desc->level_idc;

297 } else {

298 av_log(bsf, AV_LOG_WARNING, "Stream does not appear to "

299 "conform to any level: using level 6.2.\n");

300 level_idc = 62;

301 }

302 } else {

303 level_idc = ctx->level;

304 }

305

306 if (level_idc == 9) {

307 if (sps->profile_idc == 66 ||

308 sps->profile_idc == 77 ||

309 sps->profile_idc == 88) {

310 sps->level_idc = 11;

311 sps->constraint_set3_flag = 1;

312 } else {

313 sps->level_idc = 9;

314 }

315 } else {

316 sps->level_idc = level_idc;

317 }

318 }

319

320 if (need_vui)

321 sps->vui_parameters_present_flag = 1;

322

323 return 0;

324 }

325

326 static int h264_metadata_handle_display_orientation(AVBSFContext *bsf,

327 AVPacket *pkt,

328 CodedBitstreamFragment *au,

329 int seek_point)

330 {

331 H264MetadataContext *ctx = bsf->priv_data;

332 SEIRawMessage *message;

333 int err;

334

335 message = NULL;

336 while (ff_cbs_sei_find_message(ctx->common.output, au,

337 SEI_TYPE_DISPLAY_ORIENTATION,

338 &message) == 0) {

339 H264RawSEIDisplayOrientation *disp = message->payload;

340 double angle = disp->anticlockwise_rotation * 180.0 / 65536.0;

341 int32_t *matrix;

342

343 matrix = av_malloc(9 * sizeof(int32_t));

344 if (!matrix)

345 return AVERROR(ENOMEM);

346

347 /* av_display_rotation_set() expects the angle in the clockwise

348 * direction, hence the first minus.

349 * The below code applies the flips after the rotation, yet

350 * the H.2645 specs require flipping to be applied first.

351 * Because of R O(phi) = O(-phi) R (where R is flipping around

352 * an arbitatry axis and O(phi) is the proper rotation by phi)

353 * we can create display matrices as desired by negating

354 * the degree once for every flip applied. */

355 angle = -angle * (1 - 2 * !!disp->hor_flip) * (1 - 2 * !!disp->ver_flip);

356

357 av_display_rotation_set(matrix, angle);

358 av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);

359

360 // If there are multiple display orientation messages in an

361 // access unit, then the last one added to the packet (i.e.

362 // the first one in the access unit) will prevail.

363 err = av_packet_add_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX,

364 (uint8_t*)matrix,

365 9 * sizeof(int32_t));

366 if (err < 0) {

367 av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "

368 "displaymatrix side data to packet.\n");

369 av_free(matrix);

370 return AVERROR(ENOMEM);

371 }

372 }

373

374 if (ctx->display_orientation == BSF_ELEMENT_REMOVE ||

375 ctx->display_orientation == BSF_ELEMENT_INSERT) {

376 ff_cbs_sei_delete_message_type(ctx->common.output, au,

377 SEI_TYPE_DISPLAY_ORIENTATION);

378 }

379

380 if (ctx->display_orientation == BSF_ELEMENT_INSERT) {

381 H264RawSEIDisplayOrientation *disp =

382 &ctx->display_orientation_payload;

383 uint8_t *data;

384 size_t size;

385 int write = 0;

386

387 data = av_packet_get_side_data(pkt, AV_PKT_DATA_DISPLAYMATRIX, &size);

388 if (data && size >= 9 * sizeof(int32_t)) {

389 int32_t matrix[9];

390 double dmatrix[9];

391 int hflip, vflip, i;

392 double scale_x, scale_y, angle;

393

394 memcpy(matrix, data, sizeof(matrix));

395

396 for (i = 0; i < 9; i++)

397 dmatrix[i] = matrix[i] / 65536.0;

398

399 // Extract scale factors.

400 scale_x = hypot(dmatrix[0], dmatrix[3]);

401 scale_y = hypot(dmatrix[1], dmatrix[4]);

402

403 // Select flips to make the main diagonal positive.

404 hflip = dmatrix[0] < 0.0;

405 vflip = dmatrix[4] < 0.0;

406 if (hflip)

407 scale_x = -scale_x;

408 if (vflip)

409 scale_y = -scale_y;

410

411 // Rescale.

412 for (i = 0; i < 9; i += 3) {

413 dmatrix[i] /= scale_x;

414 dmatrix[i + 1] /= scale_y;

415 }

416

417 // Extract rotation.

418 angle = atan2(dmatrix[3], dmatrix[0]);

419

420 if (!(angle >= -M_PI && angle <= M_PI) ||

421 matrix[2] != 0.0 || matrix[5] != 0.0 ||

422 matrix[6] != 0.0 || matrix[7] != 0.0) {

423 av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "

424 "representable in H.264 parameters.\n");

425 } else {

426 disp->hor_flip = hflip;

427 disp->ver_flip = vflip;

428 disp->anticlockwise_rotation =

429 (uint16_t)rint((angle >= 0.0 ? angle

430 : angle + 2 * M_PI) *

431 32768.0 / M_PI);

432 write = 1;

433 }

434 }

435

436 if (seek_point) {

437 if (!isnan(ctx->rotate)) {

438 disp->anticlockwise_rotation =

439 (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate

440 : ctx->rotate + 360.0) *

441 65536.0 / 360.0);

442 write = 1;

443 }

444 if (ctx->flip) {

445 disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);

446 disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);

447 write = 1;

448 }

449 }

450

451 if (write) {

452 disp->display_orientation_repetition_period = 1;

453

454 err = ff_cbs_sei_add_message(ctx->common.output, au, 1,

455 SEI_TYPE_DISPLAY_ORIENTATION,

456 disp, NULL);

457 if (err < 0) {

458 av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "

459 "SEI message to access unit.\n");

460 return err;

461 }

462 }

463 }

464

465 return 0;

466 }

467

468 static int h264_metadata_update_fragment(AVBSFContext *bsf, AVPacket *pkt,

469 CodedBitstreamFragment *au)

470 {

471 H264MetadataContext *ctx = bsf->priv_data;

472 int err, i, has_sps, seek_point;

473

474 if (ctx->aud == BSF_ELEMENT_REMOVE) {

475 for (i = au->nb_units - 1; i >= 0; i--) {

476 if (au->units[i].type == H264_NAL_AUD)

477 ff_cbs_delete_unit(au, i);

478 }

479 } else if (ctx->aud == BSF_ELEMENT_INSERT) {

480 if (pkt) {

481 err = h264_metadata_insert_aud(bsf, au);

482 if (err < 0)

483 return err;

484 }

485 }

486

487 has_sps = 0;

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

489 if (au->units[i].type == H264_NAL_SPS) {

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

491 if (err < 0)

492 return err;

493 has_sps = 1;

494 }

495 }

496

497 if (pkt) {

498 // The current packet should be treated as a seek point for metadata

499 // insertion if any of:

500 // - It is the first packet in the stream.

501 // - It contains an SPS, indicating that a sequence might start here.

502 // - It is marked as containing a key frame.

503 seek_point = !ctx->done_first_au || has_sps ||

504 (pkt->flags & AV_PKT_FLAG_KEY);

505 } else {

506 seek_point = 0;

507 }

508

509 if (ctx->sei_user_data && seek_point) {

510 err = ff_cbs_sei_add_message(ctx->common.output, au, 1,

511 SEI_TYPE_USER_DATA_UNREGISTERED,

512 &ctx->sei_user_data_payload, NULL);

513 if (err < 0) {

514 av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "

515 "message to access unit.\n");

516 return err;

517 }

518 }

519

520 if (ctx->delete_filler) {

521 for (i = au->nb_units - 1; i >= 0; i--) {

522 if (au->units[i].type == H264_NAL_FILLER_DATA) {

523 ff_cbs_delete_unit(au, i);

524 continue;

525 }

526 }

527

528 ff_cbs_sei_delete_message_type(ctx->common.output, au,

529 SEI_TYPE_FILLER_PAYLOAD);

530 }

531

532 if (pkt && ctx->display_orientation != BSF_ELEMENT_PASS) {

533 err = h264_metadata_handle_display_orientation(bsf, pkt, au,

534 seek_point);

535 if (err < 0)

536 return err;

537 }

538

539 if (pkt)

540 ctx->done_first_au = 1;

541

542 return 0;

543 }

544

545 static const CBSBSFType h264_metadata_type = {

546 .codec_id = AV_CODEC_ID_H264,

547 .fragment_name = "access unit",

548 .unit_name = "NAL unit",

549 .update_fragment = &h264_metadata_update_fragment,

550 };

551

552 static int h264_metadata_init(AVBSFContext *bsf)

553 {

554 H264MetadataContext *ctx = bsf->priv_data;

555

556 if (ctx->sei_user_data) {

557 SEIRawUserDataUnregistered *udu = &ctx->sei_user_data_payload;

558 int i, j;

559

560 // Parse UUID. It must be a hex string of length 32, possibly

561 // containing '-'s between hex digits (which we ignore).

562 for (i = j = 0; j < 32 && i < 64 && ctx->sei_user_data[i]; i++) {

563 int c, v;

564 c = ctx->sei_user_data[i];

565 if (c == '-') {

566 continue;

567 } else if (av_isxdigit(c)) {

568 c = av_tolower(c);

569 v = (c <= '9' ? c - '0' : c - 'a' + 10);

570 } else {

571 break;

572 }

573 if (j & 1)

574 udu->uuid_iso_iec_11578[j / 2] |= v;

575 else

576 udu->uuid_iso_iec_11578[j / 2] = v << 4;

577 ++j;

578 }

579 if (j == 32 && ctx->sei_user_data[i] == '+') {

580 udu->data = (uint8_t*)ctx->sei_user_data + i + 1;

581 udu->data_length = strlen(udu->data) + 1;

582 } else {

583 av_log(bsf, AV_LOG_ERROR, "Invalid user data: "

584 "must be \"UUID+string\".\n");

585 return AVERROR(EINVAL);

586 }

587 }

588

589 return ff_cbs_bsf_generic_init(bsf, &h264_metadata_type);

590 }

591

592 #define OFFSET(x) offsetof(H264MetadataContext, x)

593 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)

594 static const AVOption h264_metadata_options[] = {

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

596 aud, FLAGS),

597

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

599 OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,

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

601

602 { "overscan_appropriate_flag", "Set VUI overscan appropriate flag",

603 OFFSET(overscan_appropriate_flag), AV_OPT_TYPE_INT,

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

605

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

607 OFFSET(video_format), AV_OPT_TYPE_INT,

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

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

610 OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,

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

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

613 OFFSET(colour_primaries), AV_OPT_TYPE_INT,

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

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

616 OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,

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

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

619 OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,

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

621

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

623 OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,

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

625

626 { "tick_rate", "Set VUI tick rate (time_scale / num_units_in_tick)",

627 OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,

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

629 { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",

630 OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,

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

632 { "zero_new_constraint_set_flags", "Set constraint_set4_flag / constraint_set5_flag to zero",

633 OFFSET(zero_new_constraint_set_flags), AV_OPT_TYPE_BOOL,

634 { .i64 = 0 }, 0, 1, FLAGS },

635

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

637 OFFSET(crop_left), AV_OPT_TYPE_INT,

638 { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },

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

640 OFFSET(crop_right), AV_OPT_TYPE_INT,

641 { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },

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

643 OFFSET(crop_top), AV_OPT_TYPE_INT,

644 { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },

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

646 OFFSET(crop_bottom), AV_OPT_TYPE_INT,

647 { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },

648

649 { "sei_user_data", "Insert SEI user data (UUID+string)",

650 OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },

651

652 { "delete_filler", "Delete all filler (both NAL and SEI)",

653 OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},

654

655 BSF_ELEMENT_OPTIONS_PIRE("display_orientation",

656 "Display orientation SEI",

657 display_orientation, FLAGS),

658

659 { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",

660 OFFSET(rotate), AV_OPT_TYPE_DOUBLE,

661 { .dbl = NAN }, -360.0, +360.0, FLAGS },

662 { "flip", "Set flip in display orientation SEI",

663 OFFSET(flip), AV_OPT_TYPE_FLAGS,

664 { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, .unit = "flip" },

665 { "horizontal", "Set hor_flip",

666 0, AV_OPT_TYPE_CONST,

667 { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },

668 { "vertical", "Set ver_flip",

669 0, AV_OPT_TYPE_CONST,

670 { .i64 = FLIP_VERTICAL }, .flags = FLAGS, .unit = "flip" },

671

672 { "level", "Set level (table A-1)",

673 OFFSET(level), AV_OPT_TYPE_INT,

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

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

676 0, AV_OPT_TYPE_CONST,

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

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

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

680 { LEVEL("1", 10) },

681 { LEVEL("1b", 9) },

682 { LEVEL("1.1", 11) },

683 { LEVEL("1.2", 12) },

684 { LEVEL("1.3", 13) },

685 { LEVEL("2", 20) },

686 { LEVEL("2.1", 21) },

687 { LEVEL("2.2", 22) },

688 { LEVEL("3", 30) },

689 { LEVEL("3.1", 31) },

690 { LEVEL("3.2", 32) },

691 { LEVEL("4", 40) },

692 { LEVEL("4.1", 41) },

693 { LEVEL("4.2", 42) },

694 { LEVEL("5", 50) },

695 { LEVEL("5.1", 51) },

696 { LEVEL("5.2", 52) },

697 { LEVEL("6", 60) },

698 { LEVEL("6.1", 61) },

699 { LEVEL("6.2", 62) },

700 #undef LEVEL

701

702 { NULL }

703 };

704

705 static const AVClass h264_metadata_class = {

706 .class_name = "h264_metadata_bsf",

707 .item_name = av_default_item_name,

708 .option = h264_metadata_options,

709 .version = LIBAVUTIL_VERSION_INT,

710 };

711

712 static const enum AVCodecID h264_metadata_codec_ids[] = {

713 AV_CODEC_ID_H264, AV_CODEC_ID_NONE,

714 };

715

716 const FFBitStreamFilter ff_h264_metadata_bsf = {

717 .p.name = "h264_metadata",

718 .p.codec_ids = h264_metadata_codec_ids,

719 .p.priv_class = &h264_metadata_class,

720 .priv_data_size = sizeof(H264MetadataContext),

721 .init = &h264_metadata_init,

722 .close = &ff_cbs_bsf_generic_close,

723 .filter = &ff_cbs_bsf_generic_filter,

724 };

AV_PKT_DATA_DISPLAYMATRIX

@ AV_PKT_DATA_DISPLAYMATRIX

This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...

Definition: packet.h:105

av_isxdigit

static av_const int av_isxdigit(int c)

Locale-independent conversion of ASCII isxdigit.

Definition: avstring.h:247

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

H264MetadataContext::video_full_range_flag

int video_full_range_flag

Definition: h264_metadata.c:59

H264MetadataContext::sei_user_data

const char * sei_user_data

Definition: h264_metadata.c:75

SET_VUI_FIELD

#define SET_VUI_FIELD(field)

CBSBSFType::codec_id

enum AVCodecID codec_id

Definition: cbs_bsf.h:32

message

Definition: api-threadmessage-test.c:47

h264_levels.h

ff_cbs_sei_add_message

int ff_cbs_sei_add_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, int prefix, uint32_t payload_type, void *payload_data, void *payload_ref)

Add an SEI message to an access unit.

Definition: cbs_sei.c:267

H264MetadataContext::sei_user_data_payload

SEIRawUserDataUnregistered sei_user_data_payload

Definition: h264_metadata.c:76

matrix

Definition: vc1dsp.c:43

cbs_h264.h

dpb_frames

int dpb_frames

Definition: h264_levels.c:163

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

SEIRawMessage

Definition: cbs_sei.h:140

FLIP_VERTICAL

@ FLIP_VERTICAL

Definition: h264_metadata.c:38

ff_cbs_sei_delete_message_type

void ff_cbs_sei_delete_message_type(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, uint32_t payload_type)

Delete all messages with the given payload type from an access unit.

Definition: cbs_sei.c:367

av_display_matrix_flip

void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)

Flip the input matrix horizontally and/or vertically.

Definition: display.c:66

level_idc

int level_idc

Definition: h264_levels.c:29

AVOption

AVOption.

Definition: opt.h:429

LEVEL_AUTO

@ LEVEL_AUTO

Definition: h264_metadata.c:43

H264MetadataContext::aud_nal

H264RawAUD aud_nal

Definition: h264_metadata.c:52

data

const char data[16]

Definition: mxf.c:149

h264_metadata_update_fragment

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

Definition: h264_metadata.c:468

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

av_display_rotation_set

void av_display_rotation_set(int32_t matrix[9], double angle)

Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...

Definition: display.c:51

H264MetadataContext::chroma_sample_loc_type

int chroma_sample_loc_type

Definition: h264_metadata.c:64

H264MetadataContext::crop_top

int crop_top

Definition: h264_metadata.c:72

H264MetadataContext::crop_right

int crop_right

Definition: h264_metadata.c:71

H264LevelDescriptor

Definition: h264_levels.h:25

AV_OPT_TYPE_RATIONAL

@ AV_OPT_TYPE_RATIONAL

Underlying C type is AVRational.

Definition: opt.h:280

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:643

AVBSFContext

The bitstream filter state.

Definition: bsf.h:68

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

bsf.h

h264_metadata_update_sps

static int h264_metadata_update_sps(AVBSFContext *bsf, H264RawSPS *sps)

Definition: h264_metadata.c:142

av_packet_add_side_data

int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)

Wrap an existing array as a packet side data.

Definition: packet.c:197

cbs_bsf.h

ff_h264_guess_level

const H264LevelDescriptor * ff_h264_guess_level(int profile_idc, int64_t bitrate, int framerate, int width, int height, int max_dec_frame_buffering)

Guess the level of a stream from some parameters.

Definition: h264_levels.c:79

ff_h264_metadata_bsf

const FFBitStreamFilter ff_h264_metadata_bsf

Definition: h264_metadata.c:716

SEIRawUserDataUnregistered::data

uint8_t * data

RefStruct reference.

Definition: cbs_sei.h:42

H264_NAL_SLICE

@ H264_NAL_SLICE

Definition: h264.h:35

H264MetadataContext::overscan_appropriate_flag

int overscan_appropriate_flag

Definition: h264_metadata.c:56

SEIRawUserDataUnregistered

Definition: cbs_sei.h:40

H264_MAX_WIDTH

@ H264_MAX_WIDTH

Definition: h264.h:108

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

h264_metadata_options

static const AVOption h264_metadata_options[]

Definition: h264_metadata.c:594

SEI_TYPE_FILLER_PAYLOAD

@ SEI_TYPE_FILLER_PAYLOAD

Definition: sei.h:33

rotate

static void rotate(const float rot_quaternion[2][4], float *vec)

Rotate vector with given rotation quaternion.

Definition: vf_v360.c:4071

H264MetadataContext::rotate

double rotate

Definition: h264_metadata.c:81

H264MetadataContext::display_orientation

int display_orientation

Definition: h264_metadata.c:80

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

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

H264MetadataContext::fixed_frame_rate_flag

int fixed_frame_rate_flag

Definition: h264_metadata.c:67

BSF_ELEMENT_OPTIONS_PIRE

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

Definition: cbs_bsf.h:123

CodedBitstreamFragment

Coded bitstream fragment structure, combining one or more units.

Definition: cbs.h:129

h264_metadata_insert_aud

static int h264_metadata_insert_aud(AVBSFContext *bsf, CodedBitstreamFragment *au)

Definition: h264_metadata.c:89

CROP

#define CROP(border, unit)

AV_OPT_TYPE_DOUBLE

@ AV_OPT_TYPE_DOUBLE

Underlying C type is double.

Definition: opt.h:267

H264MetadataContext::common

CBSBSFContext common

Definition: h264_metadata.c:47

H264MetadataContext::transfer_characteristics

int transfer_characteristics

Definition: h264_metadata.c:61

SEIRawUserDataUnregistered::data_length

size_t data_length

Definition: cbs_sei.h:43

ctx

AVFormatContext * ctx

Definition: movenc.c:49

H264RawSEIDisplayOrientation::display_orientation_repetition_period

uint16_t display_orientation_repetition_period

Definition: cbs_h264.h:321

h2645data.h

NAN

#define NAN

Definition: mathematics.h:115

AV_CODEC_ID_H264

@ AV_CODEC_ID_H264

Definition: codec_id.h:79

H264_NAL_SPS

@ H264_NAL_SPS

Definition: h264.h:41

framerate

float framerate

Definition: av1_levels.c:29

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

rint

#define rint

Definition: tablegen.h:41

NULL

#define NULL

Definition: coverity.c:32

FLAGS

#define FLAGS

Definition: h264_metadata.c:593

FFBitStreamFilter

Definition: bsf_internal.h:27

cbs_sei.h

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

H264RawSEIDisplayOrientation::anticlockwise_rotation

uint16_t anticlockwise_rotation

Definition: cbs_h264.h:320

isnan

#define isnan(x)

Definition: libm.h:342

H264_NAL_AUD

@ H264_NAL_AUD

Definition: h264.h:43

H264MetadataContext::delete_filler

int delete_filler

Definition: h264_metadata.c:78

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

LEVEL_UNSET

@ LEVEL_UNSET

Definition: h264_metadata.c:42

h264_metadata_codec_ids

static enum AVCodecID h264_metadata_codec_ids[]

Definition: h264_metadata.c:712

H264MetadataContext::crop_bottom

int crop_bottom

Definition: h264_metadata.c:73

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

h264_metadata_handle_display_orientation

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

Definition: h264_metadata.c:326

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

H264MetadataContext::flip

int flip

Definition: h264_metadata.c:82

H264RawSEIDisplayOrientation::hor_flip

uint8_t hor_flip

Definition: cbs_h264.h:318

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

flip

static void flip(AVCodecContext *avctx, AVFrame *frame)

Definition: rawdec.c:131

h264_metadata_class

static const AVClass h264_metadata_class

Definition: h264_metadata.c:705

height

#define height

Definition: dsp.h:89

H264RawSliceHeader::slice_type

uint8_t slice_type

Definition: cbs_h264.h:334

H264_MAX_DPB_FRAMES

@ H264_MAX_DPB_FRAMES

Definition: h264.h:76

CBSBSFType

Definition: cbs_bsf.h:31

hypot

static av_const double hypot(double x, double y)

Definition: libm.h:368

size

int size

Definition: twinvq_data.h:10344

h264_metadata_init

static int h264_metadata_init(AVBSFContext *bsf)

Definition: h264_metadata.c:552

H264RawSEIDisplayOrientation

Definition: cbs_h264.h:316

H264MetadataContext::aud

int aud

Definition: h264_metadata.c:51

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:594

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

H264MetadataContext::colour_primaries

int colour_primaries

Definition: h264_metadata.c:60

M_PI

#define M_PI

Definition: mathematics.h:67

H264MetadataContext

Definition: h264_metadata.c:46

H264RawSlice::header

H264RawSliceHeader header

Definition: cbs_h264.h:409

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

h264_metadata_type

static const CBSBSFType h264_metadata_type

Definition: h264_metadata.c:545

av_packet_get_side_data

uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)

Get side information from packet.

Definition: packet.c:252

ff_cbs_sei_find_message

int ff_cbs_sei_find_message(CodedBitstreamContext *ctx, CodedBitstreamFragment *au, uint32_t payload_type, SEIRawMessage **iter)

Iterate over messages with the given payload type in an access unit.

Definition: cbs_sei.c:314

display.h

common.h

H264_NAL_FILLER_DATA

@ H264_NAL_FILLER_DATA

Definition: h264.h:46

SEI_TYPE_DISPLAY_ORIENTATION

@ SEI_TYPE_DISPLAY_ORIENTATION

Definition: sei.h:77

ff_h2645_pixel_aspect

const AVRational ff_h2645_pixel_aspect[]

Definition: h2645data.c:21

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

H264RawSEIDisplayOrientation::ver_flip

uint8_t ver_flip

Definition: cbs_h264.h:319

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

sps

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

Definition: cbs_h264_syntax_template.c:260

BSF_ELEMENT_OPTIONS_PIR

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

Definition: cbs_bsf.h:112

H264_MAX_HEIGHT

@ H264_MAX_HEIGHT

Definition: h264.h:109

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

H264MetadataContext::video_format

int video_format

Definition: h264_metadata.c:58

H264MetadataContext::display_orientation_payload

H264RawSEIDisplayOrientation display_orientation_payload

Definition: h264_metadata.c:83

H264RawAUD

Definition: cbs_h264.h:218

SEI_TYPE_USER_DATA_UNREGISTERED

@ SEI_TYPE_USER_DATA_UNREGISTERED

Definition: sei.h:35