LCOV - code coverage report
Current view: top level - libavcodec - hevc_sei.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 99 196 50.5 %
Date: 2017-12-15 18:13:28 Functions: 10 16 62.5 %

          Line data    Source code
       1             : /*
       2             :  * HEVC Supplementary Enhancement Information messages
       3             :  *
       4             :  * Copyright (C) 2012 - 2013 Guillaume Martres
       5             :  * Copyright (C) 2012 - 2013 Gildas Cocherel
       6             :  * Copyright (C) 2013 Vittorio Giovara
       7             :  *
       8             :  * This file is part of FFmpeg.
       9             :  *
      10             :  * FFmpeg is free software; you can redistribute it and/or
      11             :  * modify it under the terms of the GNU Lesser General Public
      12             :  * License as published by the Free Software Foundation; either
      13             :  * version 2.1 of the License, or (at your option) any later version.
      14             :  *
      15             :  * FFmpeg is distributed in the hope that it will be useful,
      16             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      17             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      18             :  * Lesser General Public License for more details.
      19             :  *
      20             :  * You should have received a copy of the GNU Lesser General Public
      21             :  * License along with FFmpeg; if not, write to the Free Software
      22             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      23             :  */
      24             : 
      25             : #include "golomb.h"
      26             : #include "hevc_ps.h"
      27             : #include "hevc_sei.h"
      28             : 
      29        6844 : static int decode_nal_sei_decoded_picture_hash(HEVCSEIPictureHash *s, GetBitContext *gb)
      30             : {
      31             :     int cIdx, i;
      32             :     uint8_t hash_type;
      33             :     //uint16_t picture_crc;
      34             :     //uint32_t picture_checksum;
      35        6844 :     hash_type = get_bits(gb, 8);
      36             : 
      37       27376 :     for (cIdx = 0; cIdx < 3/*((s->sps->chroma_format_idc == 0) ? 1 : 3)*/; cIdx++) {
      38       20532 :         if (hash_type == 0) {
      39       19485 :             s->is_md5 = 1;
      40      331245 :             for (i = 0; i < 16; i++)
      41      311760 :                 s->md5[cIdx][i] = get_bits(gb, 8);
      42        1047 :         } else if (hash_type == 1) {
      43             :             // picture_crc = get_bits(gb, 16);
      44         291 :             skip_bits(gb, 16);
      45         756 :         } else if (hash_type == 2) {
      46             :             // picture_checksum = get_bits_long(gb, 32);
      47         756 :             skip_bits(gb, 32);
      48             :         }
      49             :     }
      50        6844 :     return 0;
      51             : }
      52             : 
      53           0 : static int decode_nal_sei_mastering_display_info(HEVCSEIMasteringDisplay *s, GetBitContext *gb)
      54             : {
      55             :     int i;
      56             :     // Mastering primaries
      57           0 :     for (i = 0; i < 3; i++) {
      58           0 :         s->display_primaries[i][0] = get_bits(gb, 16);
      59           0 :         s->display_primaries[i][1] = get_bits(gb, 16);
      60             :     }
      61             :     // White point (x, y)
      62           0 :     s->white_point[0] = get_bits(gb, 16);
      63           0 :     s->white_point[1] = get_bits(gb, 16);
      64             : 
      65             :     // Max and min luminance of mastering display
      66           0 :     s->max_luminance = get_bits_long(gb, 32);
      67           0 :     s->min_luminance = get_bits_long(gb, 32);
      68             : 
      69             :     // As this SEI message comes before the first frame that references it,
      70             :     // initialize the flag to 2 and decrement on IRAP access unit so it
      71             :     // persists for the coded video sequence (e.g., between two IRAPs)
      72           0 :     s->present = 2;
      73           0 :     return 0;
      74             : }
      75             : 
      76           0 : static int decode_nal_sei_content_light_info(HEVCSEIContentLight *s, GetBitContext *gb)
      77             : {
      78             :     // Max and average light levels
      79           0 :     s->max_content_light_level     = get_bits_long(gb, 16);
      80           0 :     s->max_pic_average_light_level = get_bits_long(gb, 16);
      81             :     // As this SEI message comes before the first frame that references it,
      82             :     // initialize the flag to 2 and decrement on IRAP access unit so it
      83             :     // persists for the coded video sequence (e.g., between two IRAPs)
      84           0 :     s->present = 2;
      85           0 :     return  0;
      86             : }
      87             : 
      88           0 : static int decode_nal_sei_frame_packing_arrangement(HEVCSEIFramePacking *s, GetBitContext *gb)
      89             : {
      90           0 :     get_ue_golomb_long(gb);             // frame_packing_arrangement_id
      91           0 :     s->present = !get_bits1(gb);
      92             : 
      93           0 :     if (s->present) {
      94           0 :         s->arrangement_type               = get_bits(gb, 7);
      95           0 :         s->quincunx_subsampling           = get_bits1(gb);
      96           0 :         s->content_interpretation_type    = get_bits(gb, 6);
      97             : 
      98             :         // spatial_flipping_flag, frame0_flipped_flag, field_views_flag
      99           0 :         skip_bits(gb, 3);
     100           0 :         s->current_frame_is_frame0_flag = get_bits1(gb);
     101             :         // frame0_self_contained_flag, frame1_self_contained_flag
     102           0 :         skip_bits(gb, 2);
     103             : 
     104           0 :         if (!s->quincunx_subsampling && s->arrangement_type != 5)
     105           0 :             skip_bits(gb, 16);  // frame[01]_grid_position_[xy]
     106           0 :         skip_bits(gb, 8);       // frame_packing_arrangement_reserved_byte
     107           0 :         skip_bits1(gb);         // frame_packing_arrangement_persistence_flag
     108             :     }
     109           0 :     skip_bits1(gb);             // upsampled_aspect_ratio_flag
     110           0 :     return 0;
     111             : }
     112             : 
     113           0 : static int decode_nal_sei_display_orientation(HEVCSEIDisplayOrientation *s, GetBitContext *gb)
     114             : {
     115           0 :     s->present = !get_bits1(gb);
     116             : 
     117           0 :     if (s->present) {
     118           0 :         s->hflip = get_bits1(gb);     // hor_flip
     119           0 :         s->vflip = get_bits1(gb);     // ver_flip
     120             : 
     121           0 :         s->anticlockwise_rotation = get_bits(gb, 16);
     122           0 :         skip_bits1(gb);     // display_orientation_persistence_flag
     123             :     }
     124             : 
     125           0 :     return 0;
     126             : }
     127             : 
     128        1141 : static int decode_nal_sei_pic_timing(HEVCSEI *s, GetBitContext *gb, const HEVCParamSets *ps,
     129             :                                      void *logctx, int size)
     130             : {
     131        1141 :     HEVCSEIPictureTiming *h = &s->picture_timing;
     132             :     HEVCSPS *sps;
     133             : 
     134        1141 :     if (!ps->sps_list[s->active_seq_parameter_set_id])
     135          22 :         return(AVERROR(ENOMEM));
     136        1119 :     sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data;
     137             : 
     138        1119 :     if (sps->vui.frame_field_info_present_flag) {
     139         636 :         int pic_struct = get_bits(gb, 4);
     140         636 :         h->picture_struct = AV_PICTURE_STRUCTURE_UNKNOWN;
     141         636 :         if (pic_struct == 2 || pic_struct == 10 || pic_struct == 12) {
     142          10 :             av_log(logctx, AV_LOG_DEBUG, "BOTTOM Field\n");
     143          10 :             h->picture_struct = AV_PICTURE_STRUCTURE_BOTTOM_FIELD;
     144         626 :         } else if (pic_struct == 1 || pic_struct == 9 || pic_struct == 11) {
     145          11 :             av_log(logctx, AV_LOG_DEBUG, "TOP Field\n");
     146          11 :             h->picture_struct = AV_PICTURE_STRUCTURE_TOP_FIELD;
     147             :         }
     148         636 :         get_bits(gb, 2);                   // source_scan_type
     149         636 :         get_bits(gb, 1);                   // duplicate_flag
     150         636 :         skip_bits1(gb);
     151         636 :         size--;
     152             :     }
     153        1119 :     skip_bits_long(gb, 8 * size);
     154             : 
     155        1119 :     return 0;
     156             : }
     157             : 
     158           0 : static int decode_registered_user_data_closed_caption(HEVCSEIA53Caption *s, GetBitContext *gb,
     159             :                                                       int size)
     160             : {
     161             :     int flag;
     162             :     int user_data_type_code;
     163             :     int cc_count;
     164             : 
     165           0 :     if (size < 3)
     166           0 :        return AVERROR(EINVAL);
     167             : 
     168           0 :     user_data_type_code = get_bits(gb, 8);
     169           0 :     if (user_data_type_code == 0x3) {
     170           0 :         skip_bits(gb, 1); // reserved
     171             : 
     172           0 :         flag = get_bits(gb, 1); // process_cc_data_flag
     173           0 :         if (flag) {
     174           0 :             skip_bits(gb, 1);
     175           0 :             cc_count = get_bits(gb, 5);
     176           0 :             skip_bits(gb, 8); // reserved
     177           0 :             size -= 2;
     178             : 
     179           0 :             if (cc_count && size >= cc_count * 3) {
     180           0 :                 const uint64_t new_size = (s->a53_caption_size + cc_count
     181           0 :                                            * UINT64_C(3));
     182             :                 int i, ret;
     183             : 
     184           0 :                 if (new_size > INT_MAX)
     185           0 :                     return AVERROR(EINVAL);
     186             : 
     187             :                 /* Allow merging of the cc data from two fields. */
     188           0 :                 ret = av_reallocp(&s->a53_caption, new_size);
     189           0 :                 if (ret < 0)
     190           0 :                     return ret;
     191             : 
     192           0 :                 for (i = 0; i < cc_count; i++) {
     193           0 :                     s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8);
     194           0 :                     s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8);
     195           0 :                     s->a53_caption[s->a53_caption_size++] = get_bits(gb, 8);
     196             :                 }
     197           0 :                 skip_bits(gb, 8); // marker_bits
     198             :             }
     199             :         }
     200             :     } else {
     201             :         int i;
     202           0 :         for (i = 0; i < size - 1; i++)
     203           0 :             skip_bits(gb, 8);
     204             :     }
     205             : 
     206           0 :     return 0;
     207             : }
     208             : 
     209          32 : static int decode_nal_sei_user_data_registered_itu_t_t35(HEVCSEI *s, GetBitContext *gb,
     210             :                                                          int size)
     211             : {
     212             :     uint32_t country_code;
     213             :     uint32_t user_identifier;
     214             : 
     215          32 :     if (size < 7)
     216           0 :         return AVERROR(EINVAL);
     217          32 :     size -= 7;
     218             : 
     219          32 :     country_code = get_bits(gb, 8);
     220          32 :     if (country_code == 0xFF) {
     221           0 :         skip_bits(gb, 8);
     222           0 :         size--;
     223             :     }
     224             : 
     225          32 :     skip_bits(gb, 8);
     226          32 :     skip_bits(gb, 8);
     227             : 
     228          32 :     user_identifier = get_bits_long(gb, 32);
     229             : 
     230          32 :     switch (user_identifier) {
     231           0 :         case MKBETAG('G', 'A', '9', '4'):
     232           0 :             return decode_registered_user_data_closed_caption(&s->a53_caption, gb, size);
     233          32 :         default:
     234          32 :             skip_bits_long(gb, size * 8);
     235          32 :             break;
     236             :     }
     237          32 :     return 0;
     238             : }
     239             : 
     240          27 : static int decode_nal_sei_active_parameter_sets(HEVCSEI *s, GetBitContext *gb, void *logctx)
     241             : {
     242             :     int num_sps_ids_minus1;
     243             :     int i;
     244             :     unsigned active_seq_parameter_set_id;
     245             : 
     246          27 :     get_bits(gb, 4); // active_video_parameter_set_id
     247          27 :     get_bits(gb, 1); // self_contained_cvs_flag
     248          27 :     get_bits(gb, 1); // num_sps_ids_minus1
     249          27 :     num_sps_ids_minus1 = get_ue_golomb_long(gb); // num_sps_ids_minus1
     250             : 
     251          27 :     if (num_sps_ids_minus1 < 0 || num_sps_ids_minus1 > 15) {
     252           0 :         av_log(logctx, AV_LOG_ERROR, "num_sps_ids_minus1 %d invalid\n", num_sps_ids_minus1);
     253           0 :         return AVERROR_INVALIDDATA;
     254             :     }
     255             : 
     256          27 :     active_seq_parameter_set_id = get_ue_golomb_long(gb);
     257          27 :     if (active_seq_parameter_set_id >= HEVC_MAX_SPS_COUNT) {
     258           0 :         av_log(logctx, AV_LOG_ERROR, "active_parameter_set_id %d invalid\n", active_seq_parameter_set_id);
     259           0 :         return AVERROR_INVALIDDATA;
     260             :     }
     261          27 :     s->active_seq_parameter_set_id = active_seq_parameter_set_id;
     262             : 
     263          27 :     for (i = 1; i <= num_sps_ids_minus1; i++)
     264           0 :         get_ue_golomb_long(gb); // active_seq_parameter_set_id[i]
     265             : 
     266          27 :     return 0;
     267             : }
     268             : 
     269           0 : static int decode_nal_sei_alternative_transfer(HEVCSEIAlternativeTransfer *s, GetBitContext *gb)
     270             : {
     271           0 :     s->present = 1;
     272           0 :     s->preferred_transfer_characteristics = get_bits(gb, 8);
     273           0 :     return 0;
     274             : }
     275             : 
     276        1317 : static int decode_nal_sei_prefix(GetBitContext *gb, void *logctx, HEVCSEI *s,
     277             :                                  const HEVCParamSets *ps, int type, int size)
     278             : {
     279        1317 :     switch (type) {
     280           0 :     case 256:  // Mismatched value from HM 8.1
     281           0 :         return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
     282           0 :     case HEVC_SEI_TYPE_FRAME_PACKING:
     283           0 :         return decode_nal_sei_frame_packing_arrangement(&s->frame_packing, gb);
     284           0 :     case HEVC_SEI_TYPE_DISPLAY_ORIENTATION:
     285           0 :         return decode_nal_sei_display_orientation(&s->display_orientation, gb);
     286        1141 :     case HEVC_SEI_TYPE_PICTURE_TIMING:
     287        1141 :         return decode_nal_sei_pic_timing(s, gb, ps, logctx, size);
     288           0 :     case HEVC_SEI_TYPE_MASTERING_DISPLAY_INFO:
     289           0 :         return decode_nal_sei_mastering_display_info(&s->mastering_display, gb);
     290           0 :     case HEVC_SEI_TYPE_CONTENT_LIGHT_LEVEL_INFO:
     291           0 :         return decode_nal_sei_content_light_info(&s->content_light, gb);
     292          27 :     case HEVC_SEI_TYPE_ACTIVE_PARAMETER_SETS:
     293          27 :         return decode_nal_sei_active_parameter_sets(s, gb, logctx);
     294          32 :     case HEVC_SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
     295          32 :         return decode_nal_sei_user_data_registered_itu_t_t35(s, gb, size);
     296           0 :     case HEVC_SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:
     297           0 :         return decode_nal_sei_alternative_transfer(&s->alternative_transfer, gb);
     298         117 :     default:
     299         117 :         av_log(logctx, AV_LOG_DEBUG, "Skipped PREFIX SEI %d\n", type);
     300         117 :         skip_bits_long(gb, 8 * size);
     301         117 :         return 0;
     302             :     }
     303             : }
     304             : 
     305        6844 : static int decode_nal_sei_suffix(GetBitContext *gb, void *logctx, HEVCSEI *s,
     306             :                                  int type, int size)
     307             : {
     308        6844 :     switch (type) {
     309        6844 :     case HEVC_SEI_TYPE_DECODED_PICTURE_HASH:
     310        6844 :         return decode_nal_sei_decoded_picture_hash(&s->picture_hash, gb);
     311           0 :     default:
     312           0 :         av_log(logctx, AV_LOG_DEBUG, "Skipped SUFFIX SEI %d\n", type);
     313           0 :         skip_bits_long(gb, 8 * size);
     314           0 :         return 0;
     315             :     }
     316             : }
     317             : 
     318        8161 : static int decode_nal_sei_message(GetBitContext *gb, void *logctx, HEVCSEI *s,
     319             :                                   const HEVCParamSets *ps, int nal_unit_type)
     320             : {
     321        8161 :     int payload_type = 0;
     322        8161 :     int payload_size = 0;
     323        8161 :     int byte = 0xFF;
     324        8161 :     av_log(logctx, AV_LOG_DEBUG, "Decoding SEI\n");
     325             : 
     326       24483 :     while (byte == 0xFF) {
     327        8161 :         byte          = get_bits(gb, 8);
     328        8161 :         payload_type += byte;
     329             :     }
     330        8161 :     byte = 0xFF;
     331       24517 :     while (byte == 0xFF) {
     332        8195 :         byte          = get_bits(gb, 8);
     333        8195 :         payload_size += byte;
     334             :     }
     335        8161 :     if (nal_unit_type == HEVC_NAL_SEI_PREFIX) {
     336        1317 :         return decode_nal_sei_prefix(gb, logctx, s, ps, payload_type, payload_size);
     337             :     } else { /* nal_unit_type == NAL_SEI_SUFFIX */
     338        6844 :         return decode_nal_sei_suffix(gb, logctx, s, payload_type, payload_size);
     339             :     }
     340             : }
     341             : 
     342        8139 : static int more_rbsp_data(GetBitContext *gb)
     343             : {
     344        8139 :     return get_bits_left(gb) > 0 && show_bits(gb, 8) != 0x80;
     345             : }
     346             : 
     347        8161 : int ff_hevc_decode_nal_sei(GetBitContext *gb, void *logctx, HEVCSEI *s,
     348             :                            const HEVCParamSets *ps, int type)
     349             : {
     350             :     int ret;
     351             : 
     352             :     do {
     353        8161 :         ret = decode_nal_sei_message(gb, logctx, s, ps, type);
     354        8161 :         if (ret < 0)
     355          22 :             return ret;
     356        8139 :     } while (more_rbsp_data(gb));
     357        8136 :     return 1;
     358             : }
     359             : 
     360       12321 : void ff_hevc_reset_sei(HEVCSEI *s)
     361             : {
     362       12321 :     s->a53_caption.a53_caption_size = 0;
     363       12321 :     av_freep(&s->a53_caption.a53_caption);
     364       12321 : }

Generated by: LCOV version 1.13