packetizer: h264: extract spsext with sps/pps
[vlc.git] / modules / packetizer / h264_nal.c
1 /*****************************************************************************
2  * Copyright © 2010-2014 VideoLAN
3  *
4  * Authors: Jean-Baptiste Kempf <jb@videolan.org>
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 "h264_nal.h"
25 #include "hxxx_nal.h"
26
27 #include <vlc_bits.h>
28 #include <vlc_boxes.h>
29 #include <vlc_es.h>
30 #include <limits.h>
31
32 /*
33  * For avcC specification, see ISO/IEC 14496-15,
34  * For Annex B specification, see ISO/IEC 14496-10
35  */
36
37 bool h264_isavcC( const uint8_t *p_buf, size_t i_buf )
38 {
39     return ( i_buf >= H264_MIN_AVCC_SIZE &&
40              p_buf[0] == 0x01 &&
41             (p_buf[4] & 0xFC) == 0xFC &&
42             (p_buf[4] & 0x03) != 0x02 &&
43             (p_buf[5] & 0x1F) > 0x00 ); /* Broken quicktime streams using reserved bits */
44 }
45
46 static size_t get_avcC_to_AnnexB_NAL_size( const uint8_t *p_buf, size_t i_buf )
47 {
48     size_t i_total = 0;
49
50     p_buf += 5;
51     i_buf -= 5;
52
53     if( i_buf < H264_MIN_AVCC_SIZE )
54         return 0;
55
56     for ( unsigned int j = 0; j < 2; j++ )
57     {
58         /* First time is SPS, Second is PPS */
59         const unsigned int i_loop_end = p_buf[0] & (j == 0 ? 0x1f : 0xff);
60         p_buf++; i_buf--;
61
62         for ( unsigned int i = 0; i < i_loop_end; i++ )
63         {
64             uint16_t i_nal_size = (p_buf[0] << 8) | p_buf[1];
65             if(i_nal_size > i_buf - 2)
66                 return 0;
67             i_total += i_nal_size + 4;
68             p_buf += i_nal_size + 2;
69             i_buf -= i_nal_size + 2;
70         }
71     }
72     return i_total;
73 }
74
75 uint8_t *h264_avcC_to_AnnexB_NAL( const uint8_t *p_buf, size_t i_buf,
76                                   size_t *pi_result, uint8_t *pi_nal_length_size )
77 {
78     *pi_result = get_avcC_to_AnnexB_NAL_size( p_buf, i_buf ); /* Does check min size */
79     if( *pi_result == 0 )
80         return NULL;
81
82     /* Read infos in first 6 bytes */
83     if ( pi_nal_length_size )
84         *pi_nal_length_size = (p_buf[4] & 0x03) + 1;
85
86     uint8_t *p_ret;
87     uint8_t *p_out_buf = p_ret = malloc( *pi_result );
88     if( !p_out_buf )
89     {
90         *pi_result = 0;
91         return NULL;
92     }
93
94     p_buf += 5;
95
96     for ( unsigned int j = 0; j < 2; j++ )
97     {
98         const unsigned int i_loop_end = p_buf[0] & (j == 0 ? 0x1f : 0xff);
99         p_buf++;
100
101         for ( unsigned int i = 0; i < i_loop_end; i++)
102         {
103             uint16_t i_nal_size = (p_buf[0] << 8) | p_buf[1];
104             p_buf += 2;
105
106             memcpy( p_out_buf, annexb_startcode4, 4 );
107             p_out_buf += 4;
108
109             memcpy( p_out_buf, p_buf, i_nal_size );
110             p_out_buf += i_nal_size;
111             p_buf += i_nal_size;
112         }
113     }
114
115     return p_ret;
116 }
117
118 void h264_AVC_to_AnnexB( uint8_t *p_buf, uint32_t i_len,
119                              uint8_t i_nal_length_size )
120 {
121     uint32_t nal_len = 0;
122     uint8_t nal_pos = 0;
123
124     if( i_nal_length_size != 4 )
125         return;
126
127     /* This only works for a NAL length size of 4 */
128     /* TODO: realloc/memmove if i_nal_length_size is 2 or 1 */
129     while( i_len > 0 )
130     {
131         if( nal_pos < i_nal_length_size ) {
132             unsigned int i;
133             for( i = 0; nal_pos < i_nal_length_size && i < i_len; i++, nal_pos++ ) {
134                 nal_len = (nal_len << 8) | p_buf[i];
135                 p_buf[i] = 0;
136             }
137             if( nal_pos < i_nal_length_size )
138                 return;
139             p_buf[i - 1] = 1;
140             p_buf += i;
141             i_len -= i;
142         }
143         if( nal_len > INT_MAX )
144             return;
145         if( nal_len > i_len )
146         {
147             nal_len -= i_len;
148             return;
149         }
150         else
151         {
152             p_buf += nal_len;
153             i_len -= nal_len;
154             nal_len = 0;
155             nal_pos = 0;
156         }
157     }
158 }
159
160 int h264_get_spspps( uint8_t *p_buf, size_t i_buf,
161                      uint8_t **pp_sps, size_t *p_sps_size,
162                      uint8_t **pp_pps, size_t *p_pps_size,
163                      uint8_t **pp_ext, size_t *p_ext_size )
164 {
165     uint8_t *p_sps = NULL, *p_pps = NULL, *p_ext = NULL;
166     size_t i_sps_size = 0, i_pps_size = 0, i_ext_size = 0;
167     int i_nal_type = H264_NAL_UNKNOWN;
168     bool b_first_nal = true;
169     bool b_has_zero_byte = false;
170
171     while( i_buf > 0 )
172     {
173         unsigned int i_move = 1;
174
175         /* cf B.1.1: a NAL unit starts and ends with 0x000001 or 0x00000001 */
176         if( i_buf > 3 && !memcmp( p_buf, annexb_startcode3, 3 ) )
177         {
178             if( i_nal_type != H264_NAL_UNKNOWN )
179             {
180                 /* update SPS/PPS size */
181                 if( i_nal_type == H264_NAL_SPS )
182                     i_sps_size = p_buf - p_sps - (b_has_zero_byte ? 1 : 0);
183                 if( i_nal_type == H264_NAL_PPS )
184                     i_pps_size = p_buf - p_pps - (b_has_zero_byte ? 1 : 0);
185                 if( i_nal_type == H264_NAL_SPS_EXT )
186                     i_ext_size = p_buf - p_pps - (b_has_zero_byte ? 1 : 0);
187
188                 if( i_sps_size && i_pps_size && i_ext_size ) /* early end */
189                     break;
190             }
191
192             i_nal_type = p_buf[3] & 0x1F;
193
194             /* The start prefix is always 0x00000001 (annexb_startcode + a
195              * leading zero byte) for SPS, PPS or the first NAL */
196             if( !b_has_zero_byte && ( b_first_nal || i_nal_type == H264_NAL_SPS
197              || i_nal_type == H264_NAL_PPS ) )
198                 return -1;
199             b_first_nal = false;
200
201             /* Pointer to the beginning of the SPS/PPS starting with the
202              * leading zero byte */
203             if( i_nal_type == H264_NAL_SPS && !p_sps )
204                 p_sps = p_buf - 1;
205             if( i_nal_type == H264_NAL_PPS && !p_pps )
206                 p_pps = p_buf - 1;
207             if( i_nal_type == H264_NAL_SPS_EXT && !p_ext )
208                 p_ext = p_buf - 1;
209
210             /* cf. 7.4.1.2.3 */
211             if( i_nal_type > 18 || ( i_nal_type >= 10 && i_nal_type <= 12 ) )
212                 return -1;
213
214             /* SPS/PPS are before the slices */
215             if ( i_nal_type >= H264_NAL_SLICE && i_nal_type <= H264_NAL_SLICE_IDR )
216                 break;
217             i_move = 4;
218         }
219         else if( b_first_nal && p_buf[0] != 0 )
220         {
221             /* leading_zero_8bits only before the first NAL */
222             return -1;
223         }
224         b_has_zero_byte = *p_buf == 0;
225         i_buf -= i_move;
226         p_buf += i_move;
227     }
228
229     if( i_buf == 0 )
230     {
231         /* update SPS/PPS size if we reach the end of the bytestream */
232         if( !i_sps_size && i_nal_type == H264_NAL_SPS )
233             i_sps_size = p_buf - p_sps;
234         if( !i_pps_size && i_nal_type == H264_NAL_PPS )
235             i_pps_size = p_buf - p_pps;
236         if( !i_ext_size && i_nal_type == H264_NAL_SPS_EXT )
237             i_ext_size = p_buf - p_ext;
238     }
239     if( ( !p_sps || !i_sps_size ) && ( !p_pps || !i_pps_size ) )
240         return -1;
241     *pp_sps = p_sps;
242     *p_sps_size = i_sps_size;
243     *pp_pps = p_pps;
244     *p_pps_size = i_pps_size;
245     *pp_ext = p_ext;
246     *p_ext_size = i_ext_size;
247
248     return 0;
249 }
250
251 void h264_release_sps( h264_sequence_parameter_set_t *p_sps )
252 {
253     free( p_sps );
254 }
255
256 static bool h264_parse_sequence_parameter_set_rbsp( bs_t *p_bs,
257                                                     h264_sequence_parameter_set_t *p_sps )
258 {
259     int i_tmp;
260
261     int i_profile_idc = bs_read( p_bs, 8 );
262     p_sps->i_profile = i_profile_idc;
263     p_sps->i_profile_compatibility = bs_read( p_bs, 8 );
264     p_sps->i_level = bs_read( p_bs, 8 );
265     /* sps id */
266     p_sps->i_id = bs_read_ue( p_bs );
267     if( p_sps->i_id >= H264_SPS_MAX )
268         return false;
269
270     if( i_profile_idc == PROFILE_H264_HIGH ||
271         i_profile_idc == PROFILE_H264_HIGH_10 ||
272         i_profile_idc == PROFILE_H264_HIGH_422 ||
273         i_profile_idc == PROFILE_H264_HIGH_444 || /* Old one, no longer on spec */
274         i_profile_idc == PROFILE_H264_HIGH_444_PREDICTIVE ||
275         i_profile_idc == PROFILE_H264_CAVLC_INTRA ||
276         i_profile_idc == PROFILE_H264_SVC_BASELINE ||
277         i_profile_idc == PROFILE_H264_SVC_HIGH ||
278         i_profile_idc == PROFILE_H264_MVC_MULTIVIEW_HIGH ||
279         i_profile_idc == PROFILE_H264_MVC_STEREO_HIGH ||
280         i_profile_idc == PROFILE_H264_MVC_MULTIVIEW_DEPTH_HIGH ||
281         i_profile_idc == PROFILE_H264_MVC_ENHANCED_MULTIVIEW_DEPTH_HIGH ||
282         i_profile_idc == PROFILE_H264_MFC_HIGH )
283     {
284         /* chroma_format_idc */
285         p_sps->i_chroma_idc = bs_read_ue( p_bs );
286         if( p_sps->i_chroma_idc == 3 )
287             bs_skip( p_bs, 1 ); /* separate_colour_plane_flag */
288         /* bit_depth_luma_minus8 */
289         p_sps->i_bit_depth_luma = bs_read_ue( p_bs ) + 8;
290         /* bit_depth_chroma_minus8 */
291         p_sps->i_bit_depth_chroma = bs_read_ue( p_bs ) + 8;
292         /* qpprime_y_zero_transform_bypass_flag */
293         bs_skip( p_bs, 1 );
294         /* seq_scaling_matrix_present_flag */
295         i_tmp = bs_read( p_bs, 1 );
296         if( i_tmp )
297         {
298             for( int i = 0; i < ((3 != p_sps->i_chroma_idc) ? 8 : 12); i++ )
299             {
300                 /* seq_scaling_list_present_flag[i] */
301                 i_tmp = bs_read( p_bs, 1 );
302                 if( !i_tmp )
303                     continue;
304                 const int i_size_of_scaling_list = (i < 6 ) ? 16 : 64;
305                 /* scaling_list (...) */
306                 int i_lastscale = 8;
307                 int i_nextscale = 8;
308                 for( int j = 0; j < i_size_of_scaling_list; j++ )
309                 {
310                     if( i_nextscale != 0 )
311                     {
312                         /* delta_scale */
313                         i_tmp = bs_read_se( p_bs );
314                         i_nextscale = ( i_lastscale + i_tmp + 256 ) % 256;
315                         /* useDefaultScalingMatrixFlag = ... */
316                     }
317                     /* scalinglist[j] */
318                     i_lastscale = ( i_nextscale == 0 ) ? i_lastscale : i_nextscale;
319                 }
320             }
321         }
322     }
323
324     /* Skip i_log2_max_frame_num */
325     p_sps->i_log2_max_frame_num = bs_read_ue( p_bs );
326     if( p_sps->i_log2_max_frame_num > 12)
327         p_sps->i_log2_max_frame_num = 12;
328     /* Read poc_type */
329     p_sps->i_pic_order_cnt_type = bs_read_ue( p_bs );
330     if( p_sps->i_pic_order_cnt_type == 0 )
331     {
332         /* skip i_log2_max_poc_lsb */
333         p_sps->i_log2_max_pic_order_cnt_lsb = bs_read_ue( p_bs );
334         if( p_sps->i_log2_max_pic_order_cnt_lsb > 12 )
335             p_sps->i_log2_max_pic_order_cnt_lsb = 12;
336     }
337     else if( p_sps->i_pic_order_cnt_type == 1 )
338     {
339         int i_cycle;
340         /* skip b_delta_pic_order_always_zero */
341         p_sps->i_delta_pic_order_always_zero_flag = bs_read( p_bs, 1 );
342         /* skip i_offset_for_non_ref_pic */
343         bs_read_se( p_bs );
344         /* skip i_offset_for_top_to_bottom_field */
345         bs_read_se( p_bs );
346         /* read i_num_ref_frames_in_poc_cycle */
347         i_cycle = bs_read_ue( p_bs );
348         if( i_cycle > 256 ) i_cycle = 256;
349         while( i_cycle > 0 )
350         {
351             /* skip i_offset_for_ref_frame */
352             bs_read_se(p_bs );
353             i_cycle--;
354         }
355     }
356     /* i_num_ref_frames */
357     bs_read_ue( p_bs );
358     /* b_gaps_in_frame_num_value_allowed */
359     bs_skip( p_bs, 1 );
360
361     /* Read size */
362     p_sps->pic_width_in_mbs_minus1 = bs_read_ue( p_bs );
363     p_sps->pic_height_in_map_units_minus1 = bs_read_ue( p_bs );
364
365     /* b_frame_mbs_only */
366     p_sps->frame_mbs_only_flag = bs_read( p_bs, 1 );
367     if( !p_sps->frame_mbs_only_flag )
368         bs_skip( p_bs, 1 );
369
370     /* b_direct8x8_inference */
371     bs_skip( p_bs, 1 );
372
373     /* crop */
374     if( bs_read1( p_bs ) ) /* frame_cropping_flag */
375     {
376         p_sps->frame_crop.left_offset = bs_read_ue( p_bs );
377         p_sps->frame_crop.right_offset = bs_read_ue( p_bs );
378         p_sps->frame_crop.right_offset = bs_read_ue( p_bs );
379         p_sps->frame_crop.bottom_offset = bs_read_ue( p_bs );
380     }
381
382     /* vui */
383     i_tmp = bs_read( p_bs, 1 );
384     if( i_tmp )
385     {
386         p_sps->vui.b_valid = true;
387         /* read the aspect ratio part if any */
388         i_tmp = bs_read( p_bs, 1 );
389         if( i_tmp )
390         {
391             static const struct { int w, h; } sar[17] =
392             {
393                 { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
394                 { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
395                 { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
396                 { 64, 33 }, { 160,99 }, {  4,  3 }, {  3,  2 },
397                 {  2,  1 },
398             };
399             int i_sar = bs_read( p_bs, 8 );
400             int w, h;
401
402             if( i_sar < 17 )
403             {
404                 w = sar[i_sar].w;
405                 h = sar[i_sar].h;
406             }
407             else if( i_sar == 255 )
408             {
409                 w = bs_read( p_bs, 16 );
410                 h = bs_read( p_bs, 16 );
411             }
412             else
413             {
414                 w = 0;
415                 h = 0;
416             }
417
418             if( w != 0 && h != 0 )
419             {
420                 p_sps->vui.i_sar_num = w;
421                 p_sps->vui.i_sar_den = h;
422             }
423             else
424             {
425                 p_sps->vui.i_sar_num = 1;
426                 p_sps->vui.i_sar_den = 1;
427             }
428         }
429
430         /* overscan */
431         i_tmp = bs_read( p_bs, 1 );
432         if ( i_tmp )
433             bs_read( p_bs, 1 );
434
435         /* video signal type */
436         i_tmp = bs_read( p_bs, 1 );
437         if( i_tmp )
438         {
439             bs_read( p_bs, 3 );
440             p_sps->vui.colour.b_full_range = bs_read( p_bs, 1 );
441             /* colour desc */
442             i_tmp = bs_read( p_bs, 1 );
443             if ( i_tmp )
444             {
445                 p_sps->vui.colour.i_colour_primaries = bs_read( p_bs, 8 );
446                 p_sps->vui.colour.i_transfer_characteristics = bs_read( p_bs, 8 );
447                 p_sps->vui.colour.i_matrix_coefficients = bs_read( p_bs, 8 );
448             }
449             else
450             {
451                 p_sps->vui.colour.i_colour_primaries = HXXX_PRIMARIES_UNSPECIFIED;
452                 p_sps->vui.colour.i_transfer_characteristics = HXXX_TRANSFER_UNSPECIFIED;
453                 p_sps->vui.colour.i_matrix_coefficients = HXXX_MATRIX_UNSPECIFIED;
454             }
455         }
456
457         /* chroma loc info */
458         i_tmp = bs_read( p_bs, 1 );
459         if( i_tmp )
460         {
461             bs_read_ue( p_bs );
462             bs_read_ue( p_bs );
463         }
464
465         /* timing info */
466         p_sps->vui.b_timing_info_present_flag = bs_read( p_bs, 1 );
467         if( p_sps->vui.b_timing_info_present_flag )
468         {
469             p_sps->vui.i_num_units_in_tick = bs_read( p_bs, 32 );
470             p_sps->vui.i_time_scale = bs_read( p_bs, 32 );
471             p_sps->vui.b_fixed_frame_rate = bs_read( p_bs, 1 );
472         }
473
474         /* Nal hrd & VC1 hrd parameters */
475         p_sps->vui.b_cpb_dpb_delays_present_flag = false;
476         for ( int i=0; i<2; i++ )
477         {
478             i_tmp = bs_read( p_bs, 1 );
479             if( i_tmp )
480             {
481                 p_sps->vui.b_cpb_dpb_delays_present_flag = true;
482                 uint32_t count = bs_read_ue( p_bs ) + 1;
483                 bs_read( p_bs, 4 );
484                 bs_read( p_bs, 4 );
485                 for( uint32_t i=0; i<count; i++ )
486                 {
487                     bs_read_ue( p_bs );
488                     bs_read_ue( p_bs );
489                     bs_read( p_bs, 1 );
490                 }
491                 bs_read( p_bs, 5 );
492                 p_sps->vui.i_cpb_removal_delay_length_minus1 = bs_read( p_bs, 5 );
493                 p_sps->vui.i_dpb_output_delay_length_minus1 = bs_read( p_bs, 5 );
494                 bs_read( p_bs, 5 );
495             }
496         }
497
498         if( p_sps->vui.b_cpb_dpb_delays_present_flag )
499             bs_read( p_bs, 1 );
500
501         /* pic struct info */
502         p_sps->vui.b_pic_struct_present_flag = bs_read( p_bs, 1 );
503
504         /* + unparsed remains */
505     }
506
507     return true;
508 }
509
510 void h264_release_pps( h264_picture_parameter_set_t *p_pps )
511 {
512     free( p_pps );
513 }
514
515 static bool h264_parse_picture_parameter_set_rbsp( bs_t *p_bs,
516                                                    h264_picture_parameter_set_t *p_pps )
517 {
518     p_pps->i_id = bs_read_ue( p_bs ); // pps id
519     p_pps->i_sps_id = bs_read_ue( p_bs ); // sps id
520     if( p_pps->i_id >= H264_PPS_MAX || p_pps->i_sps_id >= H264_SPS_MAX )
521         return false;
522
523     bs_skip( p_bs, 1 ); // entropy coding mode flag
524     p_pps->i_pic_order_present_flag = bs_read( p_bs, 1 );
525     /* TODO */
526
527     return true;
528 }
529
530 #define IMPL_h264_generic_decode( name, h264type, decode, release ) \
531     h264type * name( const uint8_t *p_buf, size_t i_buf, bool b_escaped ) \
532     { \
533         h264type *p_h264type = calloc(1, sizeof(h264type)); \
534         if(likely(p_h264type)) \
535         { \
536             bs_t bs; \
537             bs_init( &bs, p_buf, i_buf ); \
538             unsigned i_bitflow = 0; \
539             if( b_escaped ) \
540             { \
541                 bs.p_fwpriv = &i_bitflow; \
542                 bs.pf_forward = hxxx_bsfw_ep3b_to_rbsp;  /* Does the emulated 3bytes conversion to rbsp */ \
543             } \
544             else (void) i_bitflow;\
545             bs_skip( &bs, 8 ); /* Skip nal_unit_header */ \
546             if( !decode( &bs, p_h264type ) ) \
547             { \
548                 release( p_h264type ); \
549                 p_h264type = NULL; \
550             } \
551         } \
552         return p_h264type; \
553     }
554
555 IMPL_h264_generic_decode( h264_decode_sps, h264_sequence_parameter_set_t,
556                           h264_parse_sequence_parameter_set_rbsp, h264_release_sps )
557
558 IMPL_h264_generic_decode( h264_decode_pps, h264_picture_parameter_set_t,
559                           h264_parse_picture_parameter_set_rbsp, h264_release_pps )
560
561 block_t *h264_AnnexB_NAL_to_avcC( uint8_t i_nal_length_size,
562                                            const uint8_t *p_sps_buf,
563                                            size_t i_sps_size,
564                                            const uint8_t *p_pps_buf,
565                                            size_t i_pps_size )
566 {
567     if( i_pps_size > UINT16_MAX || i_sps_size > UINT16_MAX )
568         return NULL;
569
570     if( !hxxx_strip_AnnexB_startcode( &p_sps_buf, &i_sps_size ) ||
571         !hxxx_strip_AnnexB_startcode( &p_pps_buf, &i_pps_size ) )
572         return NULL;
573
574     /* The length of the NAL size is encoded using 1, 2 or 4 bytes */
575     if( i_nal_length_size != 1 && i_nal_length_size != 2
576      && i_nal_length_size != 4 )
577         return NULL;
578
579     bo_t bo;
580     /* 6 * int(8), i_sps_size, 1 * int(8), i_pps_size */
581     if( bo_init( &bo, 7 + i_sps_size + i_pps_size ) != true )
582         return NULL;
583
584     bo_add_8( &bo, 1 ); /* configuration version */
585     bo_add_mem( &bo, 3, &p_sps_buf[1] ); /* i_profile/profile_compatibility/level */
586     bo_add_8( &bo, 0xfc | (i_nal_length_size - 1) ); /* 0b11111100 | lengthsize - 1*/
587
588     bo_add_8( &bo, 0xe0 | (i_sps_size > 0 ? 1 : 0) ); /* 0b11100000 | sps_count */
589     if( i_sps_size )
590     {
591         bo_add_16be( &bo, i_sps_size );
592         bo_add_mem( &bo, i_sps_size, p_sps_buf );
593     }
594
595     bo_add_8( &bo, (i_pps_size > 0 ? 1 : 0) ); /* pps_count */
596     if( i_pps_size )
597     {
598         bo_add_16be( &bo, i_pps_size );
599         bo_add_mem( &bo, i_pps_size, p_pps_buf );
600     }
601
602     return bo.b;
603 }
604
605 bool h264_get_picture_size( const h264_sequence_parameter_set_t *p_sps, unsigned *p_w, unsigned *p_h,
606                             unsigned *p_vw, unsigned *p_vh )
607 {
608     *p_w = 16 * p_sps->pic_width_in_mbs_minus1 + 16;
609     *p_h = 16 * p_sps->pic_height_in_map_units_minus1 + 16;
610     *p_h *= ( 2 - p_sps->frame_mbs_only_flag );
611
612     *p_vw = *p_w - p_sps->frame_crop.left_offset - p_sps->frame_crop.right_offset;
613     *p_vh = *p_h - p_sps->frame_crop.bottom_offset - p_sps->frame_crop.top_offset;
614
615     return true;
616 }
617
618 bool h264_get_chroma_luma( const h264_sequence_parameter_set_t *p_sps, uint8_t *pi_chroma_format,
619                            uint8_t *pi_depth_luma, uint8_t *pi_depth_chroma )
620 {
621     if( p_sps->i_bit_depth_luma == 0 )
622         return false;
623     *pi_chroma_format = p_sps->i_chroma_idc;
624     *pi_depth_luma = p_sps->i_bit_depth_luma;
625     *pi_depth_chroma = p_sps->i_bit_depth_chroma;
626     return true;
627 }
628
629 bool h264_get_profile_level(const es_format_t *p_fmt, size_t *p_profile,
630                             size_t *p_level, uint8_t *pi_nal_length_size)
631 {
632     uint8_t *p = (uint8_t*)p_fmt->p_extra;
633     if(!p || !p_fmt->p_extra) return false;
634
635     /* Check the profile / level */
636     if (p_fmt->i_original_fourcc == VLC_FOURCC('a','v','c','1') && p[0] == 1)
637     {
638         if (p_fmt->i_extra < 12) return false;
639         if (pi_nal_length_size) *pi_nal_length_size = 1 + (p[4]&0x03);
640         if (!(p[5]&0x1f)) return false;
641         p += 8;
642     }
643     else
644     {
645         if (p_fmt->i_extra < 8) return false;
646         if (!p[0] && !p[1] && !p[2] && p[3] == 1) p += 4;
647         else if (!p[0] && !p[1] && p[2] == 1) p += 3;
648         else return false;
649     }
650
651     if ( ((*p++)&0x1f) != 7) return false;
652
653     /* Get profile/level out of first SPS */
654     if (p_profile) *p_profile = p[0];
655     if (p_level) *p_level = p[2];
656     return true;
657 }