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