modules/packetizer/hxxx_sei.c

   1 /*****************************************************************************
   2  * hxxx_sei.c: AVC/HEVC packetizers SEI handling
   3  *****************************************************************************
   4  * Copyright (C) 2001-2016 VLC authors and VideoLAN
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published by
   8  * the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include <vlc_common.h>
  25 #include <vlc_block.h>
  26 #include <vlc_bits.h>
  27
  28 #include "hxxx_sei.h"
  29 #include "hxxx_nal.h"
  30 #include "hxxx_ep3b.h"
  31
  32 void HxxxParse_AnnexB_SEI(const uint8_t *p_buf, size_t i_buf,
  33                           uint8_t i_header, pf_hxxx_sei_callback cb, void *cbdata)
  34 {
  35     if( hxxx_strip_AnnexB_startcode( &p_buf, &i_buf ) )
  36         HxxxParseSEI(p_buf, i_buf, i_header, cb, cbdata);
  37 }
  38
  39 void HxxxParseSEI(const uint8_t *p_buf, size_t i_buf,
  40                   uint8_t i_header, pf_hxxx_sei_callback pf_callback, void *cbdata)
  41 {
  42     bs_t s;
  43     bool b_continue = true;
  44
  45     if( i_buf <= i_header )
  46         return;
  47
  48     struct hxxx_bsfw_ep3b_ctx_s bsctx;
  49     hxxx_bsfw_ep3b_ctx_init( &bsctx );
  50     bs_init_custom( &s, &p_buf[i_header], i_buf - i_header, /* skip nal unit header */
  51                     &hxxx_bsfw_ep3b_callbacks, &bsctx );
  52
  53
  54     while( !bs_eof( &s ) && bs_aligned( &s ) && b_continue )
  55     {
  56         /* Read type */
  57         unsigned i_type = 0;
  58         while( !bs_eof( &s ) )
  59         {
  60             const uint8_t i_byte = bs_read( &s, 8 );
  61             i_type += i_byte;
  62             if( i_byte != 0xff )
  63                 break;
  64         }
  65
  66         if( bs_error( &s ) )
  67             return;
  68
  69         /* Read size */
  70         unsigned i_size = 0;
  71         while( !bs_eof( &s ) )
  72         {
  73             const uint8_t i_byte = bs_read( &s, 8 );
  74             i_size += i_byte;
  75             if( i_byte != 0xff )
  76                 break;
  77         }
  78
  79         if( bs_error( &s ) )
  80             return;
  81
  82         /* Check room */
  83         if( bs_eof( &s ) )
  84             break;
  85
  86         hxxx_sei_data_t sei_data;
  87         sei_data.i_type = i_type;
  88
  89         /* Save start offset */
  90         const unsigned i_start_bit_pos = bs_pos( &s );
  91         switch( i_type )
  92         {
  93             /* Look for pic timing, do not decode locally */
  94             case HXXX_SEI_PIC_TIMING:
  95             {
  96                 sei_data.p_bs = &s;
  97                 b_continue = pf_callback( &sei_data, cbdata );
  98             } break;
  99
 100             /* Look for user_data_registered_itu_t_t35 */
 101             case HXXX_SEI_USER_DATA_REGISTERED_ITU_T_T35:
 102             {
 103                 size_t i_t35;
 104                 uint8_t *p_t35 = malloc( i_size );
 105                 if( !p_t35 )
 106                     break;
 107
 108                 for( i_t35 = 0; i_t35<i_size && !bs_eof( &s ); i_t35++ )
 109                     p_t35[i_t35] = bs_read( &s, 8 );
 110
 111                 if( bs_error( &s ) )
 112                     break;
 113
 114                 /* TS 101 154 Auxiliary Data and H264/AVC video */
 115                 if( i_t35 > 4 && p_t35[0] == 0xb5 /* United States */ )
 116                 {
 117                     if( p_t35[1] == 0x00 && p_t35[2] == 0x31 && /* US provider code for ATSC / DVB1 */
 118                         i_t35 > 7 )
 119                     {
 120                         switch( VLC_FOURCC(p_t35[3],p_t35[4],p_t35[5],p_t35[6]) )
 121                         {
 122                             case VLC_FOURCC('G', 'A', '9', '4'):
 123                                 if( p_t35[7] == 0x03 )
 124                                 {
 125                                     sei_data.itu_t35.type = HXXX_ITU_T35_TYPE_CC;
 126                                     sei_data.itu_t35.u.cc.i_data = i_t35 - 8;
 127                                     sei_data.itu_t35.u.cc.p_data = &p_t35[8];
 128                                     b_continue = pf_callback( &sei_data, cbdata );
 129                                 }
 130                                 break;
 131                             default:
 132                                 break;
 133                         }
 134                     }
 135                     else if( p_t35[1] == 0x00 && p_t35[2] == 0x2f && /* US provider code for DirecTV */
 136                              p_t35[3] == 0x03 && i_t35 > 5 )
 137                     {
 138                         /* DirecTV does not use GA94 user_data identifier */
 139                         sei_data.itu_t35.type = HXXX_ITU_T35_TYPE_CC;
 140                         sei_data.itu_t35.u.cc.i_data = i_t35 - 5;
 141                         sei_data.itu_t35.u.cc.p_data = &p_t35[5];
 142                         b_continue = pf_callback( &sei_data, cbdata );
 143                     }
 144                 }
 145
 146                 free( p_t35 );
 147             } break;
 148
 149             case HXXX_SEI_FRAME_PACKING_ARRANGEMENT:
 150             {
 151                 bs_read_ue( &s );
 152                 if ( !bs_read1( &s ) )
 153                 {
 154                     sei_data.frame_packing.type = bs_read( &s, 7 );
 155                     bs_read( &s, 1 );
 156                     if( bs_read( &s, 6 ) == 2 ) /*intpr type*/
 157                         sei_data.frame_packing.b_left_first = false;
 158                     else
 159                         sei_data.frame_packing.b_left_first = true;
 160                     sei_data.frame_packing.b_flipped = bs_read1( &s );
 161                     sei_data.frame_packing.b_fields = bs_read1( &s );
 162                     sei_data.frame_packing.b_frame0 = bs_read1( &s );
 163                 }
 164                 else sei_data.frame_packing.type = FRAME_PACKING_CANCEL;
 165
 166             } break;
 167
 168             /* Look for SEI recovery point */
 169             case HXXX_SEI_RECOVERY_POINT:
 170             {
 171                 sei_data.p_bs = &s;
 172                 b_continue = pf_callback( &sei_data, cbdata );
 173             } break;
 174
 175             case HXXX_SEI_MASTERING_DISPLAY_COLOUR_VOLUME:
 176             {
 177                 for ( size_t i = 0; i < 6 ; ++i)
 178                     sei_data.colour_volume.primaries[i] = bs_read( &s, 16 );
 179                 for ( size_t i = 0; i < 2 ; ++i)
 180                     sei_data.colour_volume.white_point[i] = bs_read( &s, 16 );
 181                 sei_data.colour_volume.max_luminance = bs_read( &s, 32 );
 182                 sei_data.colour_volume.min_luminance = bs_read( &s, 32 );
 183                 if( bs_error( &s ) ) /* not enough data */
 184                     break;
 185                 b_continue = pf_callback( &sei_data, cbdata );
 186             } break;
 187
 188             case HXXX_SEI_CONTENT_LIGHT_LEVEL:
 189             {
 190                 sei_data.content_light_lvl.MaxCLL = bs_read( &s, 16 );
 191                 sei_data.content_light_lvl.MaxFALL = bs_read( &s, 16 );
 192                 if( bs_error( &s ) ) /* not enough data */
 193                     break;
 194                 b_continue = pf_callback( &sei_data, cbdata );
 195             } break;
 196
 197             default:
 198                 /* Will skip */
 199                 break;
 200         }
 201         const unsigned i_end_bit_pos = bs_pos( &s );
 202
 203         /* Skip unsparsed content */
 204         if( i_end_bit_pos - i_start_bit_pos > i_size * 8 ) /* Something went wrong with _ue reads */
 205             break;
 206         bs_skip( &s, i_size * 8 - ( i_end_bit_pos - i_start_bit_pos ) );
 207     }
 208 }