git.sesse.net Git - ffmpeg/blob - libavcodec/h264_metadata_bsf.c

   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  */
  18
  19 #include "libavutil/avstring.h"
  20 #include "libavutil/display.h"
  21 #include "libavutil/common.h"
  22 #include "libavutil/opt.h"
  23
  24 #include "bsf.h"
  25 #include "cbs.h"
  26 #include "cbs_h264.h"
  27 #include "h264.h"
  28 #include "h264_sei.h"
  29
  30 enum {
  31     PASS,
  32     INSERT,
  33     REMOVE,
  34     EXTRACT,
  35 };
  36
  37 enum {
  38     FLIP_HORIZONTAL = 1,
  39     FLIP_VERTICAL   = 2,
  40 };
  41
  42 typedef struct H264MetadataContext {
  43     const AVClass *class;
  44
  45     CodedBitstreamContext *cbc;
  46     CodedBitstreamFragment access_unit;
  47
  48     int done_first_au;
  49
  50     int aud;
  51
  52     AVRational sample_aspect_ratio;
  53
  54     int video_format;
  55     int video_full_range_flag;
  56     int colour_primaries;
  57     int transfer_characteristics;
  58     int matrix_coefficients;
  59
  60     int chroma_sample_loc_type;
  61
  62     AVRational tick_rate;
  63     int fixed_frame_rate_flag;
  64
  65     int crop_left;
  66     int crop_right;
  67     int crop_top;
  68     int crop_bottom;
  69
  70     const char *sei_user_data;
  71
  72     int delete_filler;
  73
  74     int display_orientation;
  75     double rotate;
  76     int flip;
  77 } H264MetadataContext;
  78
  79
  80 static int h264_metadata_update_sps(AVBSFContext *bsf,
  81                                     H264RawSPS *sps)
  82 {
  83     H264MetadataContext *ctx = bsf->priv_data;
  84     int need_vui = 0;
  85     int crop_unit_x, crop_unit_y;
  86
  87     if (ctx->sample_aspect_ratio.num && ctx->sample_aspect_ratio.den) {
  88         // Table E-1.
  89         static const AVRational sar_idc[] = {
  90             {   0,  0 }, // Unspecified (never written here).
  91             {   1,  1 }, {  12, 11 }, {  10, 11 }, {  16, 11 },
  92             {  40, 33 }, {  24, 11 }, {  20, 11 }, {  32, 11 },
  93             {  80, 33 }, {  18, 11 }, {  15, 11 }, {  64, 33 },
  94             { 160, 99 }, {   4,  3 }, {   3,  2 }, {   2,  1 },
  95         };
  96         int num, den, i;
  97
  98         av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
  99                   ctx->sample_aspect_ratio.den, 65535);
 100
 101         for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
 102             if (num == sar_idc[i].num &&
 103                 den == sar_idc[i].den)
 104                 break;
 105         }
 106         if (i == FF_ARRAY_ELEMS(sar_idc)) {
 107             sps->vui.aspect_ratio_idc = 255;
 108             sps->vui.sar_width  = num;
 109             sps->vui.sar_height = den;
 110         } else {
 111             sps->vui.aspect_ratio_idc = i;
 112         }
 113         sps->vui.aspect_ratio_info_present_flag = 1;
 114         need_vui = 1;
 115     }
 116
 117 #define SET_OR_INFER(field, value, present_flag, infer) do { \
 118         if (value >= 0) { \
 119             field = value; \
 120             need_vui = 1; \
 121         } else if (!present_flag) \
 122             field = infer; \
 123     } while (0)
 124
 125     if (ctx->video_format             >= 0 ||
 126         ctx->video_full_range_flag    >= 0 ||
 127         ctx->colour_primaries         >= 0 ||
 128         ctx->transfer_characteristics >= 0 ||
 129         ctx->matrix_coefficients      >= 0) {
 130
 131         SET_OR_INFER(sps->vui.video_format, ctx->video_format,
 132                      sps->vui.video_signal_type_present_flag, 5);
 133
 134         SET_OR_INFER(sps->vui.video_full_range_flag,
 135                      ctx->video_full_range_flag,
 136                      sps->vui.video_signal_type_present_flag, 0);
 137
 138         if (ctx->colour_primaries         >= 0 ||
 139             ctx->transfer_characteristics >= 0 ||
 140             ctx->matrix_coefficients      >= 0) {
 141
 142             SET_OR_INFER(sps->vui.colour_primaries,
 143                          ctx->colour_primaries,
 144                          sps->vui.colour_description_present_flag, 2);
 145
 146             SET_OR_INFER(sps->vui.transfer_characteristics,
 147                          ctx->transfer_characteristics,
 148                          sps->vui.colour_description_present_flag, 2);
 149
 150             SET_OR_INFER(sps->vui.matrix_coefficients,
 151                          ctx->matrix_coefficients,
 152                          sps->vui.colour_description_present_flag, 2);
 153
 154             sps->vui.colour_description_present_flag = 1;
 155         }
 156         sps->vui.video_signal_type_present_flag = 1;
 157         need_vui = 1;
 158     }
 159
 160     if (ctx->chroma_sample_loc_type >= 0) {
 161         sps->vui.chroma_sample_loc_type_top_field =
 162             ctx->chroma_sample_loc_type;
 163         sps->vui.chroma_sample_loc_type_bottom_field =
 164             ctx->chroma_sample_loc_type;
 165         sps->vui.chroma_loc_info_present_flag = 1;
 166         need_vui = 1;
 167     }
 168
 169     if (ctx->tick_rate.num && ctx->tick_rate.den) {
 170         int num, den;
 171
 172         av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
 173                   UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
 174
 175         sps->vui.time_scale        = num;
 176         sps->vui.num_units_in_tick = den;
 177
 178         sps->vui.timing_info_present_flag = 1;
 179         need_vui = 1;
 180     }
 181     SET_OR_INFER(sps->vui.fixed_frame_rate_flag,
 182                  ctx->fixed_frame_rate_flag,
 183                  sps->vui.timing_info_present_flag, 0);
 184
 185     if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
 186         crop_unit_x = 1;
 187         crop_unit_y = 2 - sps->frame_mbs_only_flag;
 188     } else {
 189         crop_unit_x = 1 + (sps->chroma_format_idc < 3);
 190         crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
 191                        (2 - sps->frame_mbs_only_flag);
 192     }
 193 #define CROP(border, unit) do { \
 194         if (ctx->crop_ ## border >= 0) { \
 195             if (ctx->crop_ ## border % unit != 0) { \
 196                 av_log(bsf, AV_LOG_ERROR, "Invalid value for crop_%s: " \
 197                        "must be a multiple of %d.\n", #border, unit); \
 198                 return AVERROR(EINVAL); \
 199             } \
 200             sps->frame_crop_ ## border ## _offset = \
 201                   ctx->crop_ ## border / unit; \
 202             sps->frame_cropping_flag = 1; \
 203         } \
 204     } while (0)
 205     CROP(left,   crop_unit_x);
 206     CROP(right,  crop_unit_x);
 207     CROP(top,    crop_unit_y);
 208     CROP(bottom, crop_unit_y);
 209 #undef CROP
 210
 211     if (need_vui)
 212         sps->vui_parameters_present_flag = 1;
 213
 214     return 0;
 215 }
 216
 217 static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *out)
 218 {
 219     H264MetadataContext *ctx = bsf->priv_data;
 220     AVPacket *in = NULL;
 221     CodedBitstreamFragment *au = &ctx->access_unit;
 222     int err, i, j, has_sps;
 223     H264RawAUD aud;
 224     uint8_t *displaymatrix_side_data = NULL;
 225     size_t displaymatrix_side_data_size = 0;
 226
 227     err = ff_bsf_get_packet(bsf, &in);
 228     if (err < 0)
 229         return err;
 230
 231     err = ff_cbs_read_packet(ctx->cbc, au, in);
 232     if (err < 0) {
 233         av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
 234         goto fail;
 235     }
 236
 237     if (au->nb_units == 0) {
 238         av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
 239         err = AVERROR_INVALIDDATA;
 240         goto fail;
 241     }
 242
 243     // If an AUD is present, it must be the first NAL unit.
 244     if (au->units[0].type == H264_NAL_AUD) {
 245         if (ctx->aud == REMOVE)
 246             ff_cbs_delete_unit(ctx->cbc, au, 0);
 247     } else {
 248         if (ctx->aud == INSERT) {
 249             static const int primary_pic_type_table[] = {
 250                 0x084, // 2, 7
 251                 0x0a5, // 0, 2, 5, 7
 252                 0x0e7, // 0, 1, 2, 5, 6, 7
 253                 0x210, // 4, 9
 254                 0x318, // 3, 4, 8, 9
 255                 0x294, // 2, 4, 7, 9
 256                 0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
 257                 0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
 258             };
 259             int primary_pic_type_mask = 0xff;
 260
 261             for (i = 0; i < au->nb_units; i++) {
 262                 if (au->units[i].type == H264_NAL_SLICE ||
 263                     au->units[i].type == H264_NAL_IDR_SLICE) {
 264                     H264RawSlice *slice = au->units[i].content;
 265                     for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
 266                          if (!(primary_pic_type_table[j] &
 267                                (1 << slice->header.slice_type)))
 268                              primary_pic_type_mask &= ~(1 << j);
 269                     }
 270                 }
 271             }
 272             for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
 273                 if (primary_pic_type_mask & (1 << j))
 274                     break;
 275             if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
 276                 av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
 277                        "invalid slice types?\n");
 278                 err = AVERROR_INVALIDDATA;
 279                 goto fail;
 280             }
 281
 282             aud = (H264RawAUD) {
 283                 .nal_unit_header.nal_unit_type = H264_NAL_AUD,
 284                 .primary_pic_type = j,
 285             };
 286
 287             err = ff_cbs_insert_unit_content(ctx->cbc, au,
 288                                              0, H264_NAL_AUD, &aud, NULL);
 289             if (err < 0) {
 290                 av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
 291                 goto fail;
 292             }
 293         }
 294     }
 295
 296     has_sps = 0;
 297     for (i = 0; i < au->nb_units; i++) {
 298         if (au->units[i].type == H264_NAL_SPS) {
 299             err = h264_metadata_update_sps(bsf, au->units[i].content);
 300             if (err < 0)
 301                 goto fail;
 302             has_sps = 1;
 303         }
 304     }
 305
 306     // Only insert the SEI in access units containing SPSs, and also
 307     // unconditionally in the first access unit we ever see.
 308     if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
 309         H264RawSEIPayload payload = {
 310             .payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED,
 311         };
 312         H264RawSEIUserDataUnregistered *udu =
 313             &payload.payload.user_data_unregistered;
 314
 315         for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
 316             int c, v;
 317             c = ctx->sei_user_data[i];
 318             if (c == '-') {
 319                 continue;
 320             } else if (av_isxdigit(c)) {
 321                 c = av_tolower(c);
 322                 v = (c <= '9' ? c - '0' : c - 'a' + 10);
 323             } else {
 324                 goto invalid_user_data;
 325             }
 326             if (i & 1)
 327                 udu->uuid_iso_iec_11578[j / 2] |= v;
 328             else
 329                 udu->uuid_iso_iec_11578[j / 2] = v << 4;
 330             ++j;
 331         }
 332         if (j == 32 && ctx->sei_user_data[i] == '+') {
 333             size_t len = strlen(ctx->sei_user_data + i + 1);
 334
 335             udu->data_ref = av_buffer_alloc(len + 1);
 336             if (!udu->data_ref) {
 337                 err = AVERROR(ENOMEM);
 338                 goto fail;
 339             }
 340
 341             udu->data        = udu->data_ref->data;
 342             udu->data_length = len + 1;
 343             memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
 344
 345             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
 346             if (err < 0) {
 347                 av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
 348                        "message to access unit.\n");
 349                 goto fail;
 350             }
 351
 352         } else {
 353         invalid_user_data:
 354             av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
 355                    "must be \"UUID+string\".\n");
 356             err = AVERROR(EINVAL);
 357             goto fail;
 358         }
 359     }
 360
 361     if (ctx->delete_filler) {
 362         for (i = 0; i < au->nb_units; i++) {
 363             if (au->units[i].type == H264_NAL_FILLER_DATA) {
 364                 // Filler NAL units.
 365                 err = ff_cbs_delete_unit(ctx->cbc, au, i);
 366                 if (err < 0) {
 367                     av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 368                            "filler NAL.\n");
 369                     goto fail;
 370                 }
 371                 --i;
 372                 continue;
 373             }
 374
 375             if (au->units[i].type == H264_NAL_SEI) {
 376                 // Filler SEI messages.
 377                 H264RawSEI *sei = au->units[i].content;
 378
 379                 for (j = 0; j < sei->payload_count; j++) {
 380                     if (sei->payload[j].payload_type ==
 381                         H264_SEI_TYPE_FILLER_PAYLOAD) {
 382                         err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
 383                                                              &au->units[i], j);
 384                         if (err < 0) {
 385                             av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 386                                    "filler SEI message.\n");
 387                             goto fail;
 388                         }
 389                         // Renumbering might have happened, start again at
 390                         // the same NAL unit position.
 391                         --i;
 392                         break;
 393                     }
 394                 }
 395             }
 396         }
 397     }
 398
 399     if (ctx->display_orientation != PASS) {
 400         for (i = 0; i < au->nb_units; i++) {
 401             H264RawSEI *sei;
 402             if (au->units[i].type != H264_NAL_SEI)
 403                 continue;
 404             sei = au->units[i].content;
 405
 406             for (j = 0; j < sei->payload_count; j++) {
 407                 H264RawSEIDisplayOrientation *disp;
 408                 int32_t *matrix;
 409
 410                 if (sei->payload[j].payload_type !=
 411                     H264_SEI_TYPE_DISPLAY_ORIENTATION)
 412                     continue;
 413                 disp = &sei->payload[j].payload.display_orientation;
 414
 415                 if (ctx->display_orientation == REMOVE ||
 416                     ctx->display_orientation == INSERT) {
 417                     err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
 418                                                          &au->units[i], j);
 419                     if (err < 0) {
 420                         av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 421                                "display orientation SEI message.\n");
 422                         goto fail;
 423                     }
 424                     --i;
 425                     break;
 426                 }
 427
 428                 matrix = av_mallocz(9 * sizeof(int32_t));
 429                 if (!matrix) {
 430                     err = AVERROR(ENOMEM);
 431                     goto fail;
 432                 }
 433
 434                 av_display_rotation_set(matrix,
 435                                         disp->anticlockwise_rotation *
 436                                         180.0 / 65536.0);
 437                 av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
 438
 439                 // If there are multiple display orientation messages in an
 440                 // access unit then ignore all but the last one.
 441                 av_freep(&displaymatrix_side_data);
 442
 443                 displaymatrix_side_data      = (uint8_t*)matrix;
 444                 displaymatrix_side_data_size = 9 * sizeof(int32_t);
 445             }
 446         }
 447     }
 448     if (ctx->display_orientation == INSERT) {
 449         H264RawSEIPayload payload = {
 450             .payload_type = H264_SEI_TYPE_DISPLAY_ORIENTATION,
 451         };
 452         H264RawSEIDisplayOrientation *disp =
 453             &payload.payload.display_orientation;
 454         uint8_t *data;
 455         int size;
 456         int write = 0;
 457
 458         data = av_packet_get_side_data(in, AV_PKT_DATA_DISPLAYMATRIX, &size);
 459         if (data && size >= 9 * sizeof(int32_t)) {
 460             int32_t matrix[9];
 461             int hflip, vflip;
 462             double angle;
 463
 464             memcpy(matrix, data, sizeof(matrix));
 465
 466             hflip = vflip = 0;
 467             if (matrix[0] < 0 && matrix[4] > 0)
 468                 hflip = 1;
 469             else if (matrix[0] > 0 && matrix[4] < 0)
 470                 vflip = 1;
 471             av_display_matrix_flip(matrix, hflip, vflip);
 472
 473             angle = av_display_rotation_get(matrix);
 474
 475             if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
 476                 matrix[2] != 0 || matrix[5] != 0 ||
 477                 matrix[6] != 0 || matrix[7] != 0) {
 478                 av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
 479                        "representable in H.264 parameters.\n");
 480             } else {
 481                 disp->hor_flip = hflip;
 482                 disp->ver_flip = vflip;
 483                 disp->anticlockwise_rotation =
 484                     (uint16_t)rint((angle >= 0.0 ? angle
 485                                                  : angle + 360.0) *
 486                                    65536.0 / 360.0);
 487                 write = 1;
 488             }
 489         }
 490
 491         if (has_sps || !ctx->done_first_au) {
 492             if (!isnan(ctx->rotate)) {
 493                 disp->anticlockwise_rotation =
 494                     (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
 495                                                        : ctx->rotate + 360.0) *
 496                                    65536.0 / 360.0);
 497                 write = 1;
 498             }
 499             if (ctx->flip) {
 500                 disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
 501                 disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
 502                 write = 1;
 503             }
 504         }
 505
 506         if (write) {
 507             disp->display_orientation_repetition_period = 1;
 508
 509             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
 510             if (err < 0) {
 511                 av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
 512                        "SEI message to access unit.\n");
 513                 goto fail;
 514             }
 515         }
 516     }
 517
 518     err = ff_cbs_write_packet(ctx->cbc, out, au);
 519     if (err < 0) {
 520         av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
 521         goto fail;
 522     }
 523
 524     err = av_packet_copy_props(out, in);
 525     if (err < 0)
 526         goto fail;
 527
 528     if (displaymatrix_side_data) {
 529         err = av_packet_add_side_data(out, AV_PKT_DATA_DISPLAYMATRIX,
 530                                       displaymatrix_side_data,
 531                                       displaymatrix_side_data_size);
 532         if (err) {
 533             av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
 534                    "displaymatrix side data to packet.\n");
 535             goto fail;
 536         }
 537         displaymatrix_side_data = NULL;
 538     }
 539
 540     ctx->done_first_au = 1;
 541
 542     err = 0;
 543 fail:
 544     ff_cbs_fragment_uninit(ctx->cbc, au);
 545     av_freep(&displaymatrix_side_data);
 546
 547     if (err < 0)
 548         av_packet_unref(out);
 549     av_packet_free(&in);
 550
 551     return err;
 552 }
 553
 554 static int h264_metadata_init(AVBSFContext *bsf)
 555 {
 556     H264MetadataContext *ctx = bsf->priv_data;
 557     CodedBitstreamFragment *au = &ctx->access_unit;
 558     int err, i;
 559
 560     err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
 561     if (err < 0)
 562         return err;
 563
 564     if (bsf->par_in->extradata) {
 565         err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
 566         if (err < 0) {
 567             av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
 568             goto fail;
 569         }
 570
 571         for (i = 0; i < au->nb_units; i++) {
 572             if (au->units[i].type == H264_NAL_SPS) {
 573                 err = h264_metadata_update_sps(bsf, au->units[i].content);
 574                 if (err < 0)
 575                     goto fail;
 576             }
 577         }
 578
 579         err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
 580         if (err < 0) {
 581             av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
 582             goto fail;
 583         }
 584     }
 585
 586     err = 0;
 587 fail:
 588     ff_cbs_fragment_uninit(ctx->cbc, au);
 589     return err;
 590 }
 591
 592 static void h264_metadata_close(AVBSFContext *bsf)
 593 {
 594     H264MetadataContext *ctx = bsf->priv_data;
 595     ff_cbs_close(&ctx->cbc);
 596 }
 597
 598 #define OFFSET(x) offsetof(H264MetadataContext, x)
 599 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
 600 static const AVOption h264_metadata_options[] = {
 601     { "aud", "Access Unit Delimiter NAL units",
 602         OFFSET(aud), AV_OPT_TYPE_INT,
 603         { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
 604     { "pass",   NULL, 0, AV_OPT_TYPE_CONST,
 605         { .i64 = PASS   }, .flags = FLAGS, .unit = "aud" },
 606     { "insert", NULL, 0, AV_OPT_TYPE_CONST,
 607         { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
 608     { "remove", NULL, 0, AV_OPT_TYPE_CONST,
 609         { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
 610
 611     { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
 612         OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
 613         { .dbl = 0.0 }, 0, 65535, FLAGS },
 614
 615     { "video_format", "Set video format (table E-2)",
 616         OFFSET(video_format), AV_OPT_TYPE_INT,
 617         { .i64 = -1 }, -1, 7, FLAGS},
 618     { "video_full_range_flag", "Set video full range flag",
 619         OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
 620         { .i64 = -1 }, -1, 1, FLAGS },
 621     { "colour_primaries", "Set colour primaries (table E-3)",
 622         OFFSET(colour_primaries), AV_OPT_TYPE_INT,
 623         { .i64 = -1 }, -1, 255, FLAGS },
 624     { "transfer_characteristics", "Set transfer characteristics (table E-4)",
 625         OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
 626         { .i64 = -1 }, -1, 255, FLAGS },
 627     { "matrix_coefficients", "Set matrix coefficients (table E-5)",
 628         OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
 629         { .i64 = -1 }, -1, 255, FLAGS },
 630
 631     { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
 632         OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
 633         { .i64 = -1 }, -1, 6, FLAGS },
 634
 635     { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
 636         OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
 637         { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
 638     { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
 639         OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
 640         { .i64 = -1 }, -1, 1, FLAGS },
 641
 642     { "crop_left", "Set left border crop offset",
 643         OFFSET(crop_left), AV_OPT_TYPE_INT,
 644         { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
 645     { "crop_right", "Set right border crop offset",
 646         OFFSET(crop_right), AV_OPT_TYPE_INT,
 647         { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
 648     { "crop_top", "Set top border crop offset",
 649         OFFSET(crop_top), AV_OPT_TYPE_INT,
 650         { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
 651     { "crop_bottom", "Set bottom border crop offset",
 652         OFFSET(crop_bottom), AV_OPT_TYPE_INT,
 653         { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
 654
 655     { "sei_user_data", "Insert SEI user data (UUID+string)",
 656         OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
 657
 658     { "delete_filler", "Delete all filler (both NAL and SEI)",
 659         OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
 660
 661     { "display_orientation", "Display orientation SEI",
 662         OFFSET(display_orientation), AV_OPT_TYPE_INT,
 663         { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
 664     { "pass",    NULL, 0, AV_OPT_TYPE_CONST,
 665         { .i64 = PASS    }, .flags = FLAGS, .unit = "disp_or" },
 666     { "insert",  NULL, 0, AV_OPT_TYPE_CONST,
 667         { .i64 = INSERT  }, .flags = FLAGS, .unit = "disp_or" },
 668     { "remove",  NULL, 0, AV_OPT_TYPE_CONST,
 669         { .i64 = REMOVE  }, .flags = FLAGS, .unit = "disp_or" },
 670     { "extract", NULL, 0, AV_OPT_TYPE_CONST,
 671         { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
 672
 673     { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
 674         OFFSET(rotate), AV_OPT_TYPE_DOUBLE,
 675         { .dbl = NAN }, -360.0, +360.0, FLAGS },
 676     { "flip", "Set flip in display orientation SEI",
 677         OFFSET(flip), AV_OPT_TYPE_FLAGS,
 678         { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
 679     { "horizontal", "Set hor_flip",
 680         0, AV_OPT_TYPE_CONST,
 681         { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
 682     { "vertical",   "Set ver_flip",
 683         0, AV_OPT_TYPE_CONST,
 684         { .i64 = FLIP_VERTICAL },   .flags = FLAGS, .unit = "flip" },
 685
 686     { NULL }
 687 };
 688
 689 static const AVClass h264_metadata_class = {
 690     .class_name = "h264_metadata_bsf",
 691     .item_name  = av_default_item_name,
 692     .option     = h264_metadata_options,
 693     .version    = LIBAVUTIL_VERSION_INT,
 694 };
 695
 696 static const enum AVCodecID h264_metadata_codec_ids[] = {
 697     AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
 698 };
 699
 700 const AVBitStreamFilter ff_h264_metadata_bsf = {
 701     .name           = "h264_metadata",
 702     .priv_data_size = sizeof(H264MetadataContext),
 703     .priv_class     = &h264_metadata_class,
 704     .init           = &h264_metadata_init,
 705     .close          = &h264_metadata_close,
 706     .filter         = &h264_metadata_filter,
 707     .codec_ids      = h264_metadata_codec_ids,
 708 };