LCOV - code coverage report
Current view: top level - libavcodec - h264_metadata_bsf.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 82 279 29.4 %
Date: 2018-05-20 11:54:08 Functions: 4 4 100.0 %

          Line data    Source code
       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          40 : static int h264_metadata_update_sps(AVBSFContext *bsf,
      81             :                                     H264RawSPS *sps)
      82             : {
      83          40 :     H264MetadataContext *ctx = bsf->priv_data;
      84          40 :     int need_vui = 0;
      85             :     int crop_unit_x, crop_unit_y;
      86             : 
      87          40 :     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           0 :         av_reduce(&num, &den, ctx->sample_aspect_ratio.num,
      99           0 :                   ctx->sample_aspect_ratio.den, 65535);
     100             : 
     101           0 :         for (i = 1; i < FF_ARRAY_ELEMS(sar_idc); i++) {
     102           0 :             if (num == sar_idc[i].num &&
     103           0 :                 den == sar_idc[i].den)
     104           0 :                 break;
     105             :         }
     106           0 :         if (i == FF_ARRAY_ELEMS(sar_idc)) {
     107           0 :             sps->vui.aspect_ratio_idc = 255;
     108           0 :             sps->vui.sar_width  = num;
     109           0 :             sps->vui.sar_height = den;
     110             :         } else {
     111           0 :             sps->vui.aspect_ratio_idc = i;
     112             :         }
     113           0 :         sps->vui.aspect_ratio_info_present_flag = 1;
     114           0 :         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          80 :     if (ctx->video_format             >= 0 ||
     126          80 :         ctx->video_full_range_flag    >= 0 ||
     127          80 :         ctx->colour_primaries         >= 0 ||
     128          80 :         ctx->transfer_characteristics >= 0 ||
     129          40 :         ctx->matrix_coefficients      >= 0) {
     130             : 
     131           0 :         SET_OR_INFER(sps->vui.video_format, ctx->video_format,
     132             :                      sps->vui.video_signal_type_present_flag, 5);
     133             : 
     134           0 :         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           0 :         if (ctx->colour_primaries         >= 0 ||
     139           0 :             ctx->transfer_characteristics >= 0 ||
     140           0 :             ctx->matrix_coefficients      >= 0) {
     141             : 
     142           0 :             SET_OR_INFER(sps->vui.colour_primaries,
     143             :                          ctx->colour_primaries,
     144             :                          sps->vui.colour_description_present_flag, 2);
     145             : 
     146           0 :             SET_OR_INFER(sps->vui.transfer_characteristics,
     147             :                          ctx->transfer_characteristics,
     148             :                          sps->vui.colour_description_present_flag, 2);
     149             : 
     150           0 :             SET_OR_INFER(sps->vui.matrix_coefficients,
     151             :                          ctx->matrix_coefficients,
     152             :                          sps->vui.colour_description_present_flag, 2);
     153             : 
     154           0 :             sps->vui.colour_description_present_flag = 1;
     155             :         }
     156           0 :         sps->vui.video_signal_type_present_flag = 1;
     157           0 :         need_vui = 1;
     158             :     }
     159             : 
     160          40 :     if (ctx->chroma_sample_loc_type >= 0) {
     161           0 :         sps->vui.chroma_sample_loc_type_top_field =
     162           0 :             ctx->chroma_sample_loc_type;
     163           0 :         sps->vui.chroma_sample_loc_type_bottom_field =
     164           0 :             ctx->chroma_sample_loc_type;
     165           0 :         sps->vui.chroma_loc_info_present_flag = 1;
     166           0 :         need_vui = 1;
     167             :     }
     168             : 
     169          40 :     if (ctx->tick_rate.num && ctx->tick_rate.den) {
     170             :         int num, den;
     171             : 
     172           0 :         av_reduce(&num, &den, ctx->tick_rate.num, ctx->tick_rate.den,
     173             :                   UINT32_MAX > INT_MAX ? UINT32_MAX : INT_MAX);
     174             : 
     175           0 :         sps->vui.time_scale        = num;
     176           0 :         sps->vui.num_units_in_tick = den;
     177             : 
     178           0 :         sps->vui.timing_info_present_flag = 1;
     179           0 :         need_vui = 1;
     180             :     }
     181          40 :     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          40 :     if (sps->separate_colour_plane_flag || sps->chroma_format_idc == 0) {
     186           0 :         crop_unit_x = 1;
     187           0 :         crop_unit_y = 2 - sps->frame_mbs_only_flag;
     188             :     } else {
     189          40 :         crop_unit_x = 1 + (sps->chroma_format_idc < 3);
     190          80 :         crop_unit_y = (1 + (sps->chroma_format_idc < 2)) *
     191          40 :                        (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          40 :     CROP(left,   crop_unit_x);
     206          40 :     CROP(right,  crop_unit_x);
     207          40 :     CROP(top,    crop_unit_y);
     208          40 :     CROP(bottom, crop_unit_y);
     209             : #undef CROP
     210             : 
     211          40 :     if (need_vui)
     212           0 :         sps->vui_parameters_present_flag = 1;
     213             : 
     214          40 :     return 0;
     215             : }
     216             : 
     217        4670 : static int h264_metadata_filter(AVBSFContext *bsf, AVPacket *out)
     218             : {
     219        4670 :     H264MetadataContext *ctx = bsf->priv_data;
     220        4670 :     AVPacket *in = NULL;
     221        4670 :     CodedBitstreamFragment *au = &ctx->access_unit;
     222             :     int err, i, j, has_sps;
     223             :     H264RawAUD aud;
     224        4670 :     uint8_t *displaymatrix_side_data = NULL;
     225        4670 :     size_t displaymatrix_side_data_size = 0;
     226             : 
     227        4670 :     err = ff_bsf_get_packet(bsf, &in);
     228        4670 :     if (err < 0)
     229        2335 :         return err;
     230             : 
     231        2335 :     err = ff_cbs_read_packet(ctx->cbc, au, in);
     232        2335 :     if (err < 0) {
     233           0 :         av_log(bsf, AV_LOG_ERROR, "Failed to read packet.\n");
     234           0 :         goto fail;
     235             :     }
     236             : 
     237        2335 :     if (au->nb_units == 0) {
     238           0 :         av_log(bsf, AV_LOG_ERROR, "No NAL units in packet.\n");
     239           0 :         err = AVERROR_INVALIDDATA;
     240           0 :         goto fail;
     241             :     }
     242             : 
     243             :     // If an AUD is present, it must be the first NAL unit.
     244        2335 :     if (au->units[0].type == H264_NAL_AUD) {
     245         195 :         if (ctx->aud == REMOVE)
     246           0 :             ff_cbs_delete_unit(ctx->cbc, au, 0);
     247             :     } else {
     248        2140 :         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           0 :             int primary_pic_type_mask = 0xff;
     260             : 
     261           0 :             for (i = 0; i < au->nb_units; i++) {
     262           0 :                 if (au->units[i].type == H264_NAL_SLICE ||
     263           0 :                     au->units[i].type == H264_NAL_IDR_SLICE) {
     264           0 :                     H264RawSlice *slice = au->units[i].content;
     265           0 :                     for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++) {
     266           0 :                          if (!(primary_pic_type_table[j] &
     267           0 :                                (1 << slice->header.slice_type)))
     268           0 :                              primary_pic_type_mask &= ~(1 << j);
     269             :                     }
     270             :                 }
     271             :             }
     272           0 :             for (j = 0; j < FF_ARRAY_ELEMS(primary_pic_type_table); j++)
     273           0 :                 if (primary_pic_type_mask & (1 << j))
     274           0 :                     break;
     275           0 :             if (j >= FF_ARRAY_ELEMS(primary_pic_type_table)) {
     276           0 :                 av_log(bsf, AV_LOG_ERROR, "No usable primary_pic_type: "
     277             :                        "invalid slice types?\n");
     278           0 :                 err = AVERROR_INVALIDDATA;
     279           0 :                 goto fail;
     280             :             }
     281             : 
     282           0 :             aud = (H264RawAUD) {
     283             :                 .nal_unit_header.nal_unit_type = H264_NAL_AUD,
     284             :                 .primary_pic_type = j,
     285             :             };
     286             : 
     287           0 :             err = ff_cbs_insert_unit_content(ctx->cbc, au,
     288             :                                              0, H264_NAL_AUD, &aud, NULL);
     289           0 :             if (err < 0) {
     290           0 :                 av_log(bsf, AV_LOG_ERROR, "Failed to insert AUD.\n");
     291           0 :                 goto fail;
     292             :             }
     293             :         }
     294             :     }
     295             : 
     296        2335 :     has_sps = 0;
     297        8914 :     for (i = 0; i < au->nb_units; i++) {
     298        6579 :         if (au->units[i].type == H264_NAL_SPS) {
     299          25 :             err = h264_metadata_update_sps(bsf, au->units[i].content);
     300          25 :             if (err < 0)
     301           0 :                 goto fail;
     302          25 :             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        2335 :     if (ctx->sei_user_data && (has_sps || !ctx->done_first_au)) {
     309           0 :         H264RawSEIPayload payload = {
     310             :             .payload_type = H264_SEI_TYPE_USER_DATA_UNREGISTERED,
     311             :         };
     312           0 :         H264RawSEIUserDataUnregistered *udu =
     313             :             &payload.payload.user_data_unregistered;
     314             : 
     315           0 :         for (i = j = 0; j < 32 && ctx->sei_user_data[i]; i++) {
     316             :             int c, v;
     317           0 :             c = ctx->sei_user_data[i];
     318           0 :             if (c == '-') {
     319           0 :                 continue;
     320           0 :             } else if (av_isxdigit(c)) {
     321           0 :                 c = av_tolower(c);
     322           0 :                 v = (c <= '9' ? c - '0' : c - 'a' + 10);
     323             :             } else {
     324           0 :                 goto invalid_user_data;
     325             :             }
     326           0 :             if (i & 1)
     327           0 :                 udu->uuid_iso_iec_11578[j / 2] |= v;
     328             :             else
     329           0 :                 udu->uuid_iso_iec_11578[j / 2] = v << 4;
     330           0 :             ++j;
     331             :         }
     332           0 :         if (j == 32 && ctx->sei_user_data[i] == '+') {
     333           0 :             size_t len = strlen(ctx->sei_user_data + i + 1);
     334             : 
     335           0 :             udu->data_ref = av_buffer_alloc(len + 1);
     336           0 :             if (!udu->data_ref) {
     337           0 :                 err = AVERROR(ENOMEM);
     338           0 :                 goto fail;
     339             :             }
     340             : 
     341           0 :             udu->data        = udu->data_ref->data;
     342           0 :             udu->data_length = len + 1;
     343           0 :             memcpy(udu->data, ctx->sei_user_data + i + 1, len + 1);
     344             : 
     345           0 :             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
     346           0 :             if (err < 0) {
     347           0 :                 av_log(bsf, AV_LOG_ERROR, "Failed to add user data SEI "
     348             :                        "message to access unit.\n");
     349           0 :                 goto fail;
     350             :             }
     351             : 
     352             :         } else {
     353           0 :         invalid_user_data:
     354           0 :             av_log(bsf, AV_LOG_ERROR, "Invalid user data: "
     355             :                    "must be \"UUID+string\".\n");
     356           0 :             err = AVERROR(EINVAL);
     357           0 :             goto fail;
     358             :         }
     359             :     }
     360             : 
     361        2335 :     if (ctx->delete_filler) {
     362           0 :         for (i = 0; i < au->nb_units; i++) {
     363           0 :             if (au->units[i].type == H264_NAL_FILLER_DATA) {
     364             :                 // Filler NAL units.
     365           0 :                 err = ff_cbs_delete_unit(ctx->cbc, au, i);
     366           0 :                 if (err < 0) {
     367           0 :                     av_log(bsf, AV_LOG_ERROR, "Failed to delete "
     368             :                            "filler NAL.\n");
     369           0 :                     goto fail;
     370             :                 }
     371           0 :                 --i;
     372           0 :                 continue;
     373             :             }
     374             : 
     375           0 :             if (au->units[i].type == H264_NAL_SEI) {
     376             :                 // Filler SEI messages.
     377           0 :                 H264RawSEI *sei = au->units[i].content;
     378             : 
     379           0 :                 for (j = 0; j < sei->payload_count; j++) {
     380           0 :                     if (sei->payload[j].payload_type ==
     381             :                         H264_SEI_TYPE_FILLER_PAYLOAD) {
     382           0 :                         err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
     383           0 :                                                              &au->units[i], j);
     384           0 :                         if (err < 0) {
     385           0 :                             av_log(bsf, AV_LOG_ERROR, "Failed to delete "
     386             :                                    "filler SEI message.\n");
     387           0 :                             goto fail;
     388             :                         }
     389             :                         // Renumbering might have happened, start again at
     390             :                         // the same NAL unit position.
     391           0 :                         --i;
     392           0 :                         break;
     393             :                     }
     394             :                 }
     395             :             }
     396             :         }
     397             :     }
     398             : 
     399        2335 :     if (ctx->display_orientation != PASS) {
     400           0 :         for (i = 0; i < au->nb_units; i++) {
     401             :             H264RawSEI *sei;
     402           0 :             if (au->units[i].type != H264_NAL_SEI)
     403           0 :                 continue;
     404           0 :             sei = au->units[i].content;
     405             : 
     406           0 :             for (j = 0; j < sei->payload_count; j++) {
     407             :                 H264RawSEIDisplayOrientation *disp;
     408             :                 int32_t *matrix;
     409             : 
     410           0 :                 if (sei->payload[j].payload_type !=
     411             :                     H264_SEI_TYPE_DISPLAY_ORIENTATION)
     412           0 :                     continue;
     413           0 :                 disp = &sei->payload[j].payload.display_orientation;
     414             : 
     415           0 :                 if (ctx->display_orientation == REMOVE ||
     416           0 :                     ctx->display_orientation == INSERT) {
     417           0 :                     err = ff_cbs_h264_delete_sei_message(ctx->cbc, au,
     418           0 :                                                          &au->units[i], j);
     419           0 :                     if (err < 0) {
     420           0 :                         av_log(bsf, AV_LOG_ERROR, "Failed to delete "
     421             :                                "display orientation SEI message.\n");
     422           0 :                         goto fail;
     423             :                     }
     424           0 :                     --i;
     425           0 :                     break;
     426             :                 }
     427             : 
     428           0 :                 matrix = av_mallocz(9 * sizeof(int32_t));
     429           0 :                 if (!matrix) {
     430           0 :                     err = AVERROR(ENOMEM);
     431           0 :                     goto fail;
     432             :                 }
     433             : 
     434           0 :                 av_display_rotation_set(matrix,
     435           0 :                                         disp->anticlockwise_rotation *
     436             :                                         180.0 / 65536.0);
     437           0 :                 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           0 :                 av_freep(&displaymatrix_side_data);
     442             : 
     443           0 :                 displaymatrix_side_data      = (uint8_t*)matrix;
     444           0 :                 displaymatrix_side_data_size = 9 * sizeof(int32_t);
     445             :             }
     446             :         }
     447             :     }
     448        2335 :     if (ctx->display_orientation == INSERT) {
     449           0 :         H264RawSEIPayload payload = {
     450             :             .payload_type = H264_SEI_TYPE_DISPLAY_ORIENTATION,
     451             :         };
     452           0 :         H264RawSEIDisplayOrientation *disp =
     453             :             &payload.payload.display_orientation;
     454             :         uint8_t *data;
     455             :         int size;
     456           0 :         int write = 0;
     457             : 
     458           0 :         data = av_packet_get_side_data(in, AV_PKT_DATA_DISPLAYMATRIX, &size);
     459           0 :         if (data && size >= 9 * sizeof(int32_t)) {
     460             :             int32_t matrix[9];
     461             :             int hflip, vflip;
     462             :             double angle;
     463             : 
     464           0 :             memcpy(matrix, data, sizeof(matrix));
     465             : 
     466           0 :             hflip = vflip = 0;
     467           0 :             if (matrix[0] < 0 && matrix[4] > 0)
     468           0 :                 hflip = 1;
     469           0 :             else if (matrix[0] > 0 && matrix[4] < 0)
     470           0 :                 vflip = 1;
     471           0 :             av_display_matrix_flip(matrix, hflip, vflip);
     472             : 
     473           0 :             angle = av_display_rotation_get(matrix);
     474             : 
     475           0 :             if (!(angle >= -180.0 && angle <= 180.0 /* also excludes NaN */) ||
     476           0 :                 matrix[2] != 0 || matrix[5] != 0 ||
     477           0 :                 matrix[6] != 0 || matrix[7] != 0) {
     478           0 :                 av_log(bsf, AV_LOG_WARNING, "Input display matrix is not "
     479             :                        "representable in H.264 parameters.\n");
     480             :             } else {
     481           0 :                 disp->hor_flip = hflip;
     482           0 :                 disp->ver_flip = vflip;
     483           0 :                 disp->anticlockwise_rotation =
     484           0 :                     (uint16_t)rint((angle >= 0.0 ? angle
     485           0 :                                                  : angle + 360.0) *
     486             :                                    65536.0 / 360.0);
     487           0 :                 write = 1;
     488             :             }
     489             :         }
     490             : 
     491           0 :         if (has_sps || !ctx->done_first_au) {
     492           0 :             if (!isnan(ctx->rotate)) {
     493           0 :                 disp->anticlockwise_rotation =
     494           0 :                     (uint16_t)rint((ctx->rotate >= 0.0 ? ctx->rotate
     495           0 :                                                        : ctx->rotate + 360.0) *
     496             :                                    65536.0 / 360.0);
     497           0 :                 write = 1;
     498             :             }
     499           0 :             if (ctx->flip) {
     500           0 :                 disp->hor_flip = !!(ctx->flip & FLIP_HORIZONTAL);
     501           0 :                 disp->ver_flip = !!(ctx->flip & FLIP_VERTICAL);
     502           0 :                 write = 1;
     503             :             }
     504             :         }
     505             : 
     506           0 :         if (write) {
     507           0 :             disp->display_orientation_repetition_period = 1;
     508             : 
     509           0 :             err = ff_cbs_h264_add_sei_message(ctx->cbc, au, &payload);
     510           0 :             if (err < 0) {
     511           0 :                 av_log(bsf, AV_LOG_ERROR, "Failed to add display orientation "
     512             :                        "SEI message to access unit.\n");
     513           0 :                 goto fail;
     514             :             }
     515             :         }
     516             :     }
     517             : 
     518        2335 :     err = ff_cbs_write_packet(ctx->cbc, out, au);
     519        2335 :     if (err < 0) {
     520           0 :         av_log(bsf, AV_LOG_ERROR, "Failed to write packet.\n");
     521           0 :         goto fail;
     522             :     }
     523             : 
     524        2335 :     err = av_packet_copy_props(out, in);
     525        2335 :     if (err < 0)
     526           0 :         goto fail;
     527             : 
     528        2335 :     if (displaymatrix_side_data) {
     529           0 :         err = av_packet_add_side_data(out, AV_PKT_DATA_DISPLAYMATRIX,
     530             :                                       displaymatrix_side_data,
     531             :                                       displaymatrix_side_data_size);
     532           0 :         if (err) {
     533           0 :             av_log(bsf, AV_LOG_ERROR, "Failed to attach extracted "
     534             :                    "displaymatrix side data to packet.\n");
     535           0 :             goto fail;
     536             :         }
     537           0 :         displaymatrix_side_data = NULL;
     538             :     }
     539             : 
     540        2335 :     ctx->done_first_au = 1;
     541             : 
     542        2335 :     err = 0;
     543        2335 : fail:
     544        2335 :     ff_cbs_fragment_uninit(ctx->cbc, au);
     545        2335 :     av_freep(&displaymatrix_side_data);
     546             : 
     547        2335 :     if (err < 0)
     548           0 :         av_packet_unref(out);
     549        2335 :     av_packet_free(&in);
     550             : 
     551        2335 :     return err;
     552             : }
     553             : 
     554          15 : static int h264_metadata_init(AVBSFContext *bsf)
     555             : {
     556          15 :     H264MetadataContext *ctx = bsf->priv_data;
     557          15 :     CodedBitstreamFragment *au = &ctx->access_unit;
     558             :     int err, i;
     559             : 
     560          15 :     err = ff_cbs_init(&ctx->cbc, AV_CODEC_ID_H264, bsf);
     561          15 :     if (err < 0)
     562           0 :         return err;
     563             : 
     564          15 :     if (bsf->par_in->extradata) {
     565          15 :         err = ff_cbs_read_extradata(ctx->cbc, au, bsf->par_in);
     566          15 :         if (err < 0) {
     567           0 :             av_log(bsf, AV_LOG_ERROR, "Failed to read extradata.\n");
     568           0 :             goto fail;
     569             :         }
     570             : 
     571          52 :         for (i = 0; i < au->nb_units; i++) {
     572          37 :             if (au->units[i].type == H264_NAL_SPS) {
     573          15 :                 err = h264_metadata_update_sps(bsf, au->units[i].content);
     574          15 :                 if (err < 0)
     575           0 :                     goto fail;
     576             :             }
     577             :         }
     578             : 
     579          15 :         err = ff_cbs_write_extradata(ctx->cbc, bsf->par_out, au);
     580          15 :         if (err < 0) {
     581           0 :             av_log(bsf, AV_LOG_ERROR, "Failed to write extradata.\n");
     582           0 :             goto fail;
     583             :         }
     584             :     }
     585             : 
     586          15 :     err = 0;
     587          15 : fail:
     588          15 :     ff_cbs_fragment_uninit(ctx->cbc, au);
     589          15 :     return err;
     590             : }
     591             : 
     592          15 : static void h264_metadata_close(AVBSFContext *bsf)
     593             : {
     594          15 :     H264MetadataContext *ctx = bsf->priv_data;
     595          15 :     ff_cbs_close(&ctx->cbc);
     596          15 : }
     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             : };

Generated by: LCOV version 1.13