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