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     uint8_t *displaymatrix_side_data = NULL;
 224     size_t displaymatrix_side_data_size = 0;
 225
 226     err = ff_bsf_get_packet(bsf, &in);
 227     if (err < 0)
 228         return err;
 229
 230     err = ff_cbs_read_packet(ctx->cbc, au, in);
 231     if (err < 0) {
 232         av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
 233         goto fail;
 234     }
 235
 236     if (au->nb_units == 0) {
 237         av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
 238         err = AVERROR_INVALIDDATA;
 239         goto fail;
 240     }
 241
 242     // If an AUD is present, it must be the first NAL unit.
 243     if (au->units[0].type == H264_NAL_AUD) {
 244         if (ctx->aud == REMOVE)
 245             ff_cbs_delete_unit(ctx->cbc, au, 0);
 246     } else {
 247         if (ctx->aud == INSERT) {
 248             static const int primary_pic_type_table[] = {
 249                 0x084, // 2, 7
 250                 0x0a5, // 0, 2, 5, 7
 251                 0x0e7, // 0, 1, 2, 5, 6, 7
 252                 0x210, // 4, 9
 253                 0x318, // 3, 4, 8, 9
 254                 0x294, // 2, 4, 7, 9
 255                 0x3bd, // 0, 2, 3, 4, 5, 7, 8, 9
 256                 0x3ff, // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
 257             };
 258             int primary_pic_type_mask = 0xff;
 259             H264RawAUD aud = {
 260                 .nal_unit_header.nal_unit_type = H264_NAL_AUD,
 261             };
 262
 263             for (i = 0; i < au->nb_units; i++) {
 264                 if (au->units[i].type == H264_NAL_SLICE ||
 265                     au->units[i].type == H264_NAL_IDR_SLICE) {
 266                     H264RawSlice *slice = au->units[i].content;
 267                     for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
 268                          if (!(primary_pic_type_table[j] &
 269                                (1 << slice->header.slice_type)))
 270                              primary_pic_type_mask &= ~(1 << j);
 271                     }
 272                 }
 273             }
 274             for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
 275                 if (primary_pic_type_mask & (1 << j))
 276                     break;
 277             if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
 278                 av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
 279                        "invalid slice types?\n");
 280                 err = AVERROR_INVALIDDATA;
 281                 goto fail;
 282             }
 283
 284             aud.primary_pic_type = j;
 285
 286             err = ff_cbs_insert_unit_content(ctx->cbc, au,
 287                                              0, H264_NAL_AUD, &aud, NULL);
 288             if (err < 0) {
 289                 av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
 290                 goto fail;
 291             }
 292         }
 293     }
 294
 295     has_sps = 0;
 296     for (i = 0; i < au->nb_units; i++) {
 297         if (au->units[i].type == H264_NAL_SPS) {
 298             err = h264_metadata_update_sps(bsf, au->units[i].content);
 299             if (err < 0)
 300                 goto fail;
 301             has_sps = 1;
 302         }
 303     }
 304
 305     // Only insert the SEI in access units containing SPSs, and also
 306     // unconditionally in the first access unit we ever see.
 307     if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
 308         H264RawSEIPayload payload = {
 309             .payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED,
 310         };
 311         H264RawSEIUserDataUnregistered *udu =
 312             &payload.payload.user_data_unregistered;
 313
 314         for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
 315             int c, v;
 316             c = ctx->sei_user_data[i];
 317             if (c == '-') {
 318                 continue;
 319             } else if (av_isxdigit(c)) {
 320                 c = av_tolower(c);
 321                 v = (c <= '9' ? c - '0' : c - 'a' + 10);
 322             } else {
 323                 goto invalid_user_data;
 324             }
 325             if (i & 1)
 326                 udu->uuid_iso_iec_11578[j / 2] |= v;
 327             else
 328                 udu->uuid_iso_iec_11578[j / 2] = v << 4;
 329             ++j;
 330         }
 331         if (j == 32 && ctx->sei_user_data[i] == '+') {
 332             size_t len = strlen(ctx->sei_user_data + i + 1);
 333
 334             udu->data_ref = av_buffer_alloc(len + 1);
 335             if (!udu->data_ref) {
 336                 err = AVERROR(ENOMEM);
 337                 goto fail;
 338             }
 339
 340             udu->data        = udu->data_ref->data;
 341             udu->data_length = len + 1;
 342             memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
 343
 344             payload.payload_size = 16 + udu->data_length;
 345
 346             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
 347             if (err < 0) {
 348                 av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
 349                        "message to access unit.\n");
 350                 goto fail;
 351             }
 352
 353         } else {
 354         invalid_user_data:
 355             av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
 356                    "must be \"UUID+string\".\n");
 357             err = AVERROR(EINVAL);
 358             goto fail;
 359         }
 360     }
 361
 362     if (ctx->delete_filler) {
 363         for (i = 0; i < au->nb_units; i++) {
 364             if (au->units[i].type == H264_NAL_FILLER_DATA) {
 365                 // Filler NAL units.
 366                 err = ff_cbs_delete_unit(ctx->cbc, au, i);
 367                 if (err < 0) {
 368                     av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 369                            "filler NAL.\n");
 370                     goto fail;
 371                 }
 372                 --i;
 373                 continue;
 374             }
 375
 376             if (au->units[i].type == H264_NAL_SEI) {
 377                 // Filler SEI messages.
 378                 H264RawSEI *sei = au->units[i].content;
 379
 380                 for (j = 0; j < sei->payload_count; j++) {
 381                     if (sei->payload[j].payload_type ==
 382                         H264_SEI_TYPE_FILLER_PAYLOAD) {
 383                         err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
 384                                                              &au->units[i], j);
 385                         if (err < 0) {
 386                             av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 387                                    "filler SEI message.\n");
 388                             goto fail;
 389                         }
 390                         // Renumbering might have happened, start again at
 391                         // the same NAL unit position.
 392                         --i;
 393                         break;
 394                     }
 395                 }
 396             }
 397         }
 398     }
 399
 400     if (ctx->display_orientation != PASS) {
 401         for (i = 0; i < au->nb_units; i++) {
 402             H264RawSEI *sei;
 403             if (au->units[i].type != H264_NAL_SEI)
 404                 continue;
 405             sei = au->units[i].content;
 406
 407             for (j = 0; j < sei->payload_count; j++) {
 408                 H264RawSEIDisplayOrientation *disp;
 409                 int32_t *matrix;
 410
 411                 if (sei->payload[j].payload_type !=
 412                     H264_SEI_TYPE_DISPLAY_ORIENTATION)
 413                     continue;
 414                 disp = &sei->payload[j].payload.display_orientation;
 415
 416                 if (ctx->display_orientation == REMOVE ||
 417                     ctx->display_orientation == INSERT) {
 418                     err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
 419                                                          &au->units[i], j);
 420                     if (err < 0) {
 421                         av_log(bsf, AV_LOG_ERROR, "Failed to delete "
 422                                "display orientation SEI message.\n");
 423                         goto fail;
 424                     }
 425                     --i;
 426                     break;
 427                 }
 428
 429                 matrix = av_mallocz(9 * sizeof(int32_t));
 430                 if (!matrix) {
 431                     err = AVERROR(ENOMEM);
 432                     goto fail;
 433                 }
 434
 435                 av_display_rotation_set(matrix,
 436                                         disp->anticlockwise_rotation *
 437                                         180.0 / 65536.0);
 438                 av_display_matrix_flip(matrix, disp->hor_flip, disp->ver_flip);
 439
 440                 // If there are multiple display orientation messages in an
 441                 // access unit then ignore all but the last one.
 442                 av_freep(&displaymatrix_side_data);
 443
 444                 displaymatrix_side_data      = (uint8_t*)matrix;
 445                 displaymatrix_side_data_size = 9 * sizeof(int32_t);
 446             }
 447         }
 448     }
 449     if (ctx->display_orientation == INSERT) {
 450         H264RawSEIPayload payload = {
 451             .payload_type = H264_SEI_TYPE_DISPLAY_ORIENTATION,
 452         };
 453         H264RawSEIDisplayOrientation *disp =
 454             &payload.payload.display_orientation;
 455         uint8_t *data;
 456         int size;
 457         int write = 0;
 458
 459         data = av_packet_get_side_data(in, AV_PKT_DATA_DISPLAYMATRIX, &size);
 460         if (data && size >= 9 * sizeof(int32_t)) {
 461             int32_t matrix[9];
 462             int hflip, vflip;
 463             double angle;
 464
 465             memcpy(matrix, data, sizeof(matrix));
 466
 467             hflip = vflip = 0;
 468             if (matrix[0] < 0 && matrix[4] > 0)
 469                 hflip = 1;
 470             else if (matrix[0] > 0 && matrix[4] < 0)
 471                 vflip = 1;
 472             av_display_matrix_flip(matrix, hflip, vflip);
 473
 474             angle = av_display_rotation_get(matrix);
 475
 476             if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
 477                 matrix[2] != 0 || matrix[5] != 0 ||
 478                 matrix[6] != 0 || matrix[7] != 0) {
 479                 av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
 480                        "representable in H.264 parameters.\n");
 481             } else {
 482                 disp->hor_flip = hflip;
 483                 disp->ver_flip = vflip;
 484                 disp->anticlockwise_rotation =
 485                     (uint16_t)rint((angle >= 0.0 ? angle
 486                                                  : angle + 360.0) *
 487                                    65536.0 / 360.0);
 488                 write = 1;
 489             }
 490         }
 491
 492         if (has_sps || !ctx->done_first_au) {
 493             if (!isnan(ctx->rotate)) {
 494                 disp->anticlockwise_rotation =
 495                     (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
 496                                                        : ctx->rotate + 360.0) *
 497                                    65536.0 / 360.0);
 498                 write = 1;
 499             }
 500             if (ctx->flip) {
 501                 disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
 502                 disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
 503                 write = 1;
 504             }
 505         }
 506
 507         if (write) {
 508             disp->display_orientation_repetition_period = 1;
 509
 510             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
 511             if (err < 0) {
 512                 av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
 513                        "SEI message to access unit.\n");
 514                 goto fail;
 515             }
 516         }
 517     }
 518
 519     err = ff_cbs_write_packet(ctx->cbc, out, au);
 520     if (err < 0) {
 521         av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
 522         goto fail;
 523     }
 524
 525     err = av_packet_copy_props(out, in);
 526     if (err < 0)
 527         goto fail;
 528
 529     if (displaymatrix_side_data) {
 530         err = av_packet_add_side_data(out, AV_PKT_DATA_DISPLAYMATRIX,
 531                                       displaymatrix_side_data,
 532                                       displaymatrix_side_data_size);
 533         if (err) {
 534             av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
 535                    "displaymatrix side data to packet.\n");
 536             goto fail;
 537         }
 538         displaymatrix_side_data = NULL;
 539     }
 540
 541     ctx->done_first_au = 1;
 542
 543     err = 0;
 544 fail:
 545     ff_cbs_fragment_uninit(ctx->cbc, au);
 546     av_freep(&displaymatrix_side_data);
 547
 548     if (err < 0)
 549         av_packet_unref(out);
 550     av_packet_free(&in);
 551
 552     return err;
 553 }
 554
 555 static int h264_metadata_init(AVBSFContext *bsf)
 556 {
 557     H264MetadataContext *ctx = bsf->priv_data;
 558     CodedBitstreamFragment *au = &ctx->access_unit;
 559     int err, i;
 560
 561     err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
 562     if (err < 0)
 563         return err;
 564
 565     if (bsf->par_in->extradata) {
 566         err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
 567         if (err < 0) {
 568             av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
 569             goto fail;
 570         }
 571
 572         for (i = 0; i < au->nb_units; i++) {
 573             if (au->units[i].type == H264_NAL_SPS) {
 574                 err = h264_metadata_update_sps(bsf, au->units[i].content);
 575                 if (err < 0)
 576                     goto fail;
 577             }
 578         }
 579
 580         err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
 581         if (err < 0) {
 582             av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
 583             goto fail;
 584         }
 585     }
 586
 587     err = 0;
 588 fail:
 589     ff_cbs_fragment_uninit(ctx->cbc, au);
 590     return err;
 591 }
 592
 593 static void h264_metadata_close(AVBSFContext *bsf)
 594 {
 595     H264MetadataContext *ctx = bsf->priv_data;
 596     ff_cbs_close(&ctx->cbc);
 597 }
 598
 599 #define OFFSET(x) offsetof(H264MetadataContext, x)
 600 #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_BSF_PARAM)
 601 static const AVOption h264_metadata_options[] = {
 602     { "aud", "Access Unit Delimiter NAL units",
 603         OFFSET(aud), AV_OPT_TYPE_INT,
 604         { .i64 = PASS }, PASS, REMOVE, FLAGS, "aud" },
 605     { "pass",   NULL, 0, AV_OPT_TYPE_CONST,
 606         { .i64 = PASS   }, .flags = FLAGS, .unit = "aud" },
 607     { "insert", NULL, 0, AV_OPT_TYPE_CONST,
 608         { .i64 = INSERT }, .flags = FLAGS, .unit = "aud" },
 609     { "remove", NULL, 0, AV_OPT_TYPE_CONST,
 610         { .i64 = REMOVE }, .flags = FLAGS, .unit = "aud" },
 611
 612     { "sample_aspect_ratio", "Set sample aspect ratio (table E-1)",
 613         OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL,
 614         { .dbl = 0.0 }, 0, 65535, FLAGS },
 615
 616     { "video_format", "Set video format (table E-2)",
 617         OFFSET(video_format), AV_OPT_TYPE_INT,
 618         { .i64 = -1 }, -1, 7, FLAGS},
 619     { "video_full_range_flag", "Set video full range flag",
 620         OFFSET(video_full_range_flag), AV_OPT_TYPE_INT,
 621         { .i64 = -1 }, -1, 1, FLAGS },
 622     { "colour_primaries", "Set colour primaries (table E-3)",
 623         OFFSET(colour_primaries), AV_OPT_TYPE_INT,
 624         { .i64 = -1 }, -1, 255, FLAGS },
 625     { "transfer_characteristics", "Set transfer characteristics (table E-4)",
 626         OFFSET(transfer_characteristics), AV_OPT_TYPE_INT,
 627         { .i64 = -1 }, -1, 255, FLAGS },
 628     { "matrix_coefficients", "Set matrix coefficients (table E-5)",
 629         OFFSET(matrix_coefficients), AV_OPT_TYPE_INT,
 630         { .i64 = -1 }, -1, 255, FLAGS },
 631
 632     { "chroma_sample_loc_type", "Set chroma sample location type (figure E-1)",
 633         OFFSET(chroma_sample_loc_type), AV_OPT_TYPE_INT,
 634         { .i64 = -1 }, -1, 6, FLAGS },
 635
 636     { "tick_rate", "Set VUI tick rate (num_units_in_tick / time_scale)",
 637         OFFSET(tick_rate), AV_OPT_TYPE_RATIONAL,
 638         { .dbl = 0.0 }, 0, UINT_MAX, FLAGS },
 639     { "fixed_frame_rate_flag", "Set VUI fixed frame rate flag",
 640         OFFSET(fixed_frame_rate_flag), AV_OPT_TYPE_INT,
 641         { .i64 = -1 }, -1, 1, FLAGS },
 642
 643     { "crop_left", "Set left border crop offset",
 644         OFFSET(crop_left), AV_OPT_TYPE_INT,
 645         { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
 646     { "crop_right", "Set right border crop offset",
 647         OFFSET(crop_right), AV_OPT_TYPE_INT,
 648         { .i64 = -1 }, -1, H264_MAX_WIDTH, FLAGS },
 649     { "crop_top", "Set top border crop offset",
 650         OFFSET(crop_top), AV_OPT_TYPE_INT,
 651         { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
 652     { "crop_bottom", "Set bottom border crop offset",
 653         OFFSET(crop_bottom), AV_OPT_TYPE_INT,
 654         { .i64 = -1 }, -1, H264_MAX_HEIGHT, FLAGS },
 655
 656     { "sei_user_data", "Insert SEI user data (UUID+string)",
 657         OFFSET(sei_user_data), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },
 658
 659     { "delete_filler", "Delete all filler (both NAL and SEI)",
 660         OFFSET(delete_filler), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, FLAGS},
 661
 662     { "display_orientation", "Display orientation SEI",
 663         OFFSET(display_orientation), AV_OPT_TYPE_INT,
 664         { .i64 = PASS }, PASS, EXTRACT, FLAGS, "disp_or" },
 665     { "pass",    NULL, 0, AV_OPT_TYPE_CONST,
 666         { .i64 = PASS    }, .flags = FLAGS, .unit = "disp_or" },
 667     { "insert",  NULL, 0, AV_OPT_TYPE_CONST,
 668         { .i64 = INSERT  }, .flags = FLAGS, .unit = "disp_or" },
 669     { "remove",  NULL, 0, AV_OPT_TYPE_CONST,
 670         { .i64 = REMOVE  }, .flags = FLAGS, .unit = "disp_or" },
 671     { "extract", NULL, 0, AV_OPT_TYPE_CONST,
 672         { .i64 = EXTRACT }, .flags = FLAGS, .unit = "disp_or" },
 673
 674     { "rotate", "Set rotation in display orientation SEI (anticlockwise angle in degrees)",
 675         OFFSET(rotate), AV_OPT_TYPE_DOUBLE,
 676         { .dbl = NAN }, -360.0, +360.0, FLAGS },
 677     { "flip", "Set flip in display orientation SEI",
 678         OFFSET(flip), AV_OPT_TYPE_FLAGS,
 679         { .i64 = 0 }, 0, FLIP_HORIZONTAL | FLIP_VERTICAL, FLAGS, "flip" },
 680     { "horizontal", "Set hor_flip",
 681         0, AV_OPT_TYPE_CONST,
 682         { .i64 = FLIP_HORIZONTAL }, .flags = FLAGS, .unit = "flip" },
 683     { "vertical",   "Set ver_flip",
 684         0, AV_OPT_TYPE_CONST,
 685         { .i64 = FLIP_VERTICAL },   .flags = FLAGS, .unit = "flip" },
 686
 687     { NULL }
 688 };
 689
 690 static const AVClass h264_metadata_class = {
 691     .class_name = "h264_metadata_bsf",
 692     .item_name  = av_default_item_name,
 693     .option     = h264_metadata_options,
 694     .version    = LIBAVUTIL_VERSION_INT,
 695 };
 696
 697 static const enum AVCodecID h264_metadata_codec_ids[] = {
 698     AV_CODEC_ID_H264, AV_CODEC_ID_NONE,
 699 };
 700
 701 const AVBitStreamFilter ff_h264_metadata_bsf = {
 702     .name           = "h264_metadata",
 703     .priv_data_size = sizeof(H264MetadataContext),
 704     .priv_class     = &h264_metadata_class,
 705     .init           = &h264_metadata_init,
 706     .close          = &h264_metadata_close,
 707     .filter         = &h264_metadata_filter,
 708     .codec_ids      = h264_metadata_codec_ids,
 709 };