开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
h264.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：19k
源码类别：

多媒体

开发平台：

MultiPlatform

h264.c：源码内容
  1. /*****************************************************************************
  2.  * h264.c: h264/avc video packetizer
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 VideoLAN
  5.  * $Id: h264.c 9031 2004-10-22 11:11:27Z gbazin $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *          Eric Petit <titer@videolan.org>
  9.  *          Gildas Bazin <gbazin@videolan.org>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24.  *****************************************************************************/
  26. /*****************************************************************************
  27.  * Preamble
  28.  *****************************************************************************/
  29. #include <stdlib.h>                                      /* malloc(), free() */
  31. #include <vlc/vlc.h>
  32. #include <vlc/decoder.h>
  33. #include <vlc/sout.h>
  35. #include "vlc_block_helper.h"
  36. #include "vlc_bits.h"
  38. /*****************************************************************************
  39.  * Module descriptor
  40.  *****************************************************************************/
  41. static int  Open ( vlc_object_t * );
  42. static void Close( vlc_object_t * );
  44. vlc_module_begin();
  45.     set_description( _("H264 video packetizer") );
  46.     set_capability( "packetizer", 50 );
  47.     set_callbacks( Open, Close );
  48. vlc_module_end();
  51. /****************************************************************************
  52.  * Local prototypes
  53.  ****************************************************************************/
  54. static block_t *Packetize( decoder_t *, block_t ** );
  55. static block_t *PacketizeAVC1( decoder_t *, block_t ** );
  57. struct decoder_sys_t
  58. {
  59.     block_bytestream_t bytestream;
  61.     int     i_state;
  62.     int     i_offset;
  63.     uint8_t startcode[4];
  65.     vlc_bool_t b_slice;
  66.     block_t    *p_frame;
  68.     int64_t      i_dts;
  69.     int64_t      i_pts;
  70.     unsigned int i_flags;
  72.     vlc_bool_t   b_sps;
  74.     /* avcC data */
  75.     int i_avcC_length_size;
  77.     /* Useful values of the Sequence Parameter Set */
  78.     int i_log2_max_frame_num;
  79.     int b_frame_mbs_only;
  81.     /* Useful values of the Slice Header */
  82.     int i_nal_type;
  83.     int i_nal_ref_idc;
  84.     int i_idr_pic_id;
  85.     int i_frame_num;
  86. };
  88. enum
  89. {
  90.     STATE_NOSYNC,
  91.     STATE_NEXT_SYNC,
  92. };
  94. enum nal_unit_type_e
  95. {
  96.     NAL_UNKNOWN = 0,
  97.     NAL_SLICE   = 1,
  98.     NAL_SLICE_DPA   = 2,
  99.     NAL_SLICE_DPB   = 3,
  100.     NAL_SLICE_DPC   = 4,
  101.     NAL_SLICE_IDR   = 5,    /* ref_idc != 0 */
  102.     NAL_SEI         = 6,    /* ref_idc == 0 */
  103.     NAL_SPS         = 7,
  104.     NAL_PPS         = 8
  105.     /* ref_idc == 0 for 6,9,10,11,12 */
  106. };
  108. enum nal_priority_e
  109. {
  110.     NAL_PRIORITY_DISPOSABLE = 0,
  111.     NAL_PRIORITY_LOW        = 1,
  112.     NAL_PRIORITY_HIGH       = 2,
  113.     NAL_PRIORITY_HIGHEST    = 3,
  114. };
  116. static block_t *ParseNALBlock( decoder_t *, block_t * );
  118. static block_t *nal_get_annexeb( decoder_t *, uint8_t *p, int );
  120. /*****************************************************************************
  121.  * Open: probe the packetizer and return score
  122.  *****************************************************************************/
  123. static int Open( vlc_object_t *p_this )
  124. {
  125.     decoder_t     *p_dec = (decoder_t*)p_this;
  126.     decoder_sys_t *p_sys;
  128.     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'h', '2', '6', '4') &&
  129.         p_dec->fmt_in.i_codec != VLC_FOURCC( 'H', '2', '6', '4') &&
  130.         p_dec->fmt_in.i_codec != VLC_FOURCC( 'V', 'S', 'S', 'H') &&
  131.         p_dec->fmt_in.i_codec != VLC_FOURCC( 'v', 's', 's', 'h') &&
  132.         ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') ||
  133.           p_dec->fmt_in.i_extra < 7 ) )
  134.     {
  135.         return VLC_EGENERIC;
  136.     }
  138.     /* Allocate the memory needed to store the decoder's structure */
  139.     if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
  140.     {
  141.         msg_Err( p_dec, "out of memory" );
  142.         return VLC_EGENERIC;
  143.     }
  144.     p_sys->i_state = STATE_NOSYNC;
  145.     p_sys->i_offset = 0;
  146.     p_sys->startcode[0] = 0;
  147.     p_sys->startcode[1] = 0;
  148.     p_sys->startcode[2] = 0;
  149.     p_sys->startcode[3] = 1;
  150.     p_sys->bytestream = block_BytestreamInit( p_dec );
  151.     p_sys->b_slice = VLC_FALSE;
  152.     p_sys->p_frame = NULL;
  153.     p_sys->i_dts   = 0;
  154.     p_sys->i_pts   = 0;
  155.     p_sys->i_flags = 0;
  156.     p_sys->b_sps   = VLC_FALSE;
  158.     p_sys->i_nal_type = -1;
  159.     p_sys->i_nal_ref_idc = -1;
  160.     p_sys->i_idr_pic_id = -1;
  161.     p_sys->i_frame_num = -1;
  163.     /* Setup properties */
  164.     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
  165.     p_dec->fmt_out.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
  166.     /* FIXME: FFMPEG isn't happy at all if you leave this */
  167.     if( p_dec->fmt_out.i_extra ) free( p_dec->fmt_out.p_extra );
  168.     p_dec->fmt_out.i_extra = 0; p_dec->fmt_out.p_extra = 0;
  170.     if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'a', 'v', 'c', '1' ) )
  171.     {
  172.         uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4];
  173.         int i_sps, i_pps;
  174.         int i;
  176.         /* Parse avcC */
  177.         p_sys->i_avcC_length_size = 1 + ((*p++)&0x03);
  179.         /* Read SPS */
  180.         i_sps = (*p++)&0x1f;
  182.         for( i = 0; i < i_sps; i++ )
  183.         {
  184.             int i_length = GetWBE( p );
  185.             block_t *p_sps = nal_get_annexeb( p_dec, p + 2, i_length );
  187.             ParseNALBlock( p_dec, p_sps );
  188.             p += 2 + i_length;
  189.         }
  190.         /* Read PPS */
  191.         i_pps = *p++;
  192.         for( i = 0; i < i_pps; i++ )
  193.         {
  194.             int i_length = GetWBE( p );
  195.             block_t *p_pps = nal_get_annexeb( p_dec, p + 2, i_length );
  197.             ParseNALBlock( p_dec, p_pps );
  198.             p += 2 + i_length;
  199.         }
  200.         msg_Dbg( p_dec, "avcC length size=%d sps=%d pps=%d",
  201.                  p_sys->i_avcC_length_size, i_sps, i_pps );
  203.         /* Set callback */
  204.         p_dec->pf_packetize = PacketizeAVC1;
  205.     }
  206.     else
  207.     {
  208.         /* Set callback */
  209.         p_dec->pf_packetize = Packetize;
  210.     }
  212.     return VLC_SUCCESS;
  213. }
  215. /*****************************************************************************
  216.  * Close: clean up the packetizer
  217.  *****************************************************************************/
  218. static void Close( vlc_object_t *p_this )
  219. {
  220.     decoder_t *p_dec = (decoder_t*)p_this;
  221.     decoder_sys_t *p_sys = p_dec->p_sys;
  223.     block_BytestreamRelease( &p_sys->bytestream );
  224.     free( p_sys );
  225. }
  227. /****************************************************************************
  228.  * Packetize: the whole thing
  229.  ****************************************************************************/
  230. static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
  231. {
  232.     decoder_sys_t *p_sys = p_dec->p_sys;
  233.     block_t       *p_pic;
  235.     if( !pp_block || !*pp_block ) return NULL;
  237.     block_BytestreamPush( &p_sys->bytestream, *pp_block );
  239.     for( ;; )
  240.     {
  241.         switch( p_sys->i_state )
  242.         {
  243.             case STATE_NOSYNC:
  244.                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
  245.                       &p_sys->i_offset, p_sys->startcode+1, 3 ) == VLC_SUCCESS)
  246.                 {
  247.                     p_sys->i_state = STATE_NEXT_SYNC;
  248.                 }
  250.                 if( p_sys->i_offset )
  251.                 {
  252.                     block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
  253.                     p_sys->i_offset = 0;
  254.                     block_BytestreamFlush( &p_sys->bytestream );
  255.                 }
  257.                 if( p_sys->i_state != STATE_NEXT_SYNC )
  258.                 {
  259.                     /* Need more data */
  260.                     return NULL;
  261.                 }
  263.                 p_sys->i_offset = 1; /* To find next startcode */
  265.             case STATE_NEXT_SYNC:
  266.                 /* Find the next startcode */
  267.                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
  268.                       &p_sys->i_offset, p_sys->startcode, 3 ) != VLC_SUCCESS)
  269.                 {
  270.                     if( block_FindStartcodeFromOffset( &p_sys->bytestream,
  271.                           &p_sys->i_offset, p_sys->startcode+1, 3 ) !=
  272.                         VLC_SUCCESS )
  273.                     {
  274.                         /* Need more data */
  275.                         return NULL;
  276.                     }
  277.                 }
  279.                 /* Get the new fragment and set the pts/dts */
  280.                 p_pic = block_New( p_dec, p_sys->i_offset );
  281.                 p_pic->i_pts = p_sys->bytestream.p_block->i_pts;
  282.                 p_pic->i_dts = p_sys->bytestream.p_block->i_dts;
  284.                 block_GetBytes( &p_sys->bytestream, p_pic->p_buffer,
  285.                                 p_pic->i_buffer );
  287.                 p_sys->i_offset = 0;
  289.                 /* Parse the NAL */
  290.                 if( !( p_pic = ParseNALBlock( p_dec, p_pic ) ) )
  291.                 {
  292.                     p_sys->i_state = STATE_NOSYNC;
  293.                     break;
  294.                 }
  296.                 /* So p_block doesn't get re-added several times */
  297.                 *pp_block = block_BytestreamPop( &p_sys->bytestream );
  299.                 p_sys->i_state = STATE_NOSYNC;
  301.                 return p_pic;
  302.         }
  303.     }
  304. }
  306. /****************************************************************************
  307.  * PacketizeAVC1: the whole thing
  308.  ****************************************************************************/
  309. static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
  310. {
  311.     decoder_sys_t *p_sys = p_dec->p_sys;
  312.     block_t       *p_block;
  313.     block_t       *p_ret = NULL;
  314.     uint8_t       *p;
  316.     if( !pp_block || !*pp_block ) return NULL;
  318.     p_block = *pp_block;
  319.     *pp_block = NULL;
  321.     for( p = p_block->p_buffer; p < &p_block->p_buffer[p_block->i_buffer]; )
  322.     {
  323.         block_t *p_pic;
  324.         int i_size = 0;
  325.         int i;
  327.         for( i = 0; i < p_sys->i_avcC_length_size; i++ )
  328.         {
  329.             i_size = (i_size << 8) | (*p++);
  330.         }
  332.         if( i_size > 0 )
  333.         {
  334.             block_t *p_part = nal_get_annexeb( p_dec, p, i_size );
  336.             p_part->i_dts = p_block->i_dts;
  337.             p_part->i_pts = p_block->i_pts;
  339.             /* Parse the NAL */
  340.             if( ( p_pic = ParseNALBlock( p_dec, p_part ) ) )
  341.             {
  342.                 block_ChainAppend( &p_ret, p_pic );
  343.             }
  344.         }
  345.         p += i_size;
  346.     }
  348.     return p_ret;
  349. }
  351. static block_t *nal_get_annexeb( decoder_t *p_dec, uint8_t *p, int i_size )
  352. {
  353.     block_t *p_nal;
  355.     p_nal = block_New( p_dec, 3 + i_size );
  357.     /* Add start code */
  358.     p_nal->p_buffer[0] = 0x00;
  359.     p_nal->p_buffer[1] = 0x00;
  360.     p_nal->p_buffer[2] = 0x01;
  362.     /* Copy nalu */
  363.     memcpy( &p_nal->p_buffer[3], p, i_size );
  365.     return p_nal;
  366. }
  368. static void nal_get_decoded( uint8_t **pp_ret, int *pi_ret,
  369.                              uint8_t *src, int i_src )
  370. {
  371.     uint8_t *end = &src[i_src];
  372.     uint8_t *dst = malloc( i_src );
  374.     *pp_ret = dst;
  376.     while( src < end )
  377.     {
  378.         if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
  379.             src[2] == 0x03 )
  380.         {
  381.             *dst++ = 0x00;
  382.             *dst++ = 0x00;
  384.             src += 3;
  385.             continue;
  386.         }
  387.         *dst++ = *src++;
  388.     }
  390.     *pi_ret = dst - *pp_ret;
  391. }
  393. static inline int bs_read_ue( bs_t *s )
  394. {
  395.     int i = 0;
  397.     while( bs_read1( s ) == 0 && s->p < s->p_end && i < 32 )
  398.     {
  399.         i++;
  400.     }
  401.     return( ( 1 << i) - 1 + bs_read( s, i ) );
  402. }
  404. static inline int bs_read_se( bs_t *s )
  405. {
  406.     int val = bs_read_ue( s );
  408.     return val&0x01 ? (val+1)/2 : -(val/2);
  409. }
  412. static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
  413. {
  414.     decoder_sys_t *p_sys = p_dec->p_sys;
  415.     block_t *p_pic = NULL;
  417.     const int i_nal_ref_idc = (p_frag->p_buffer[3] >> 5)&0x03;
  418.     const int i_nal_type = p_frag->p_buffer[3]&0x1f;
  420.     if( p_sys->b_slice && !p_sys->b_sps )
  421.     {
  422.         block_ChainRelease( p_sys->p_frame );
  423.         msg_Warn( p_dec, "waiting for SPS" );
  425.         /* Reset context */
  426.         p_sys->p_frame = NULL;
  427.         p_sys->b_slice = VLC_FALSE;
  428.     }
  430.     if( !p_sys->b_sps &&
  431.         i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
  432.     {
  433.         p_sys->b_slice = VLC_TRUE;
  434.         /* Fragment will be discarded later on */
  435.     }
  436.     else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
  437.     {
  438.         uint8_t *dec;
  439.         int i_dec, i_first_mb, i_slice_type, i_frame_num, i_pic_flags = 0;
  440.         vlc_bool_t b_pic = VLC_FALSE;
  441.         bs_t s;
  443.         /* do not convert the whole frame */
  444.         nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[4],
  445.                          __MIN( p_frag->i_buffer - 4, 60 ) );
  446.         bs_init( &s, dec, i_dec );
  448.         /* first_mb_in_slice */
  449.         i_first_mb = bs_read_ue( &s );
  451.         /* slice_type */
  452.         switch( (i_slice_type = bs_read_ue( &s )) )
  453.         {
  454.             case 0: case 5:
  455.                 i_pic_flags = BLOCK_FLAG_TYPE_P;
  456.                 break;
  457.             case 1: case 6:
  458.                 i_pic_flags = BLOCK_FLAG_TYPE_B;
  459.                 break;
  460.             case 2: case 7:
  461.                 i_pic_flags = BLOCK_FLAG_TYPE_I;
  462.                 break;
  463.             case 3: case 8: /* SP */
  464.                 i_pic_flags = BLOCK_FLAG_TYPE_P;
  465.                 break;
  466.             case 4: case 9:
  467.                 i_pic_flags = BLOCK_FLAG_TYPE_I;
  468.                 break;
  469.         }
  471.         /* pic_parameter_set_id */
  472.         bs_read_ue( &s );
  473.         /* frame_num */
  474.         i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );
  476.         /* Detection of the first VCL NAL unit of a primary coded picture
  477.          * (cf. 7.4.1.2.4) */
  478.         if( i_frame_num != p_sys->i_frame_num ||
  479.             ( (i_nal_ref_idc != p_sys->i_nal_ref_idc) &&
  480.               (!i_nal_ref_idc || !p_sys->i_nal_ref_idc) ) )
  481.         {
  482.             b_pic = VLC_TRUE;
  483.         }
  484.         p_sys->i_frame_num = i_frame_num;
  485.         p_sys->i_nal_ref_idc = i_nal_ref_idc;
  487.         if( !p_sys->b_frame_mbs_only )
  488.         {
  489.             /* field_pic_flag */
  490.             if( bs_read( &s, 1 ) )
  491.             {
  492.                 /* bottom_field_flag */
  493.                 bs_read( &s, 1 );
  494.             }
  495.         }
  497.         if( i_nal_type == NAL_SLICE_IDR )
  498.         {
  499.             /* id_pic_id */
  500.             int i_idr_pic_id = bs_read_ue( &s );
  501.             if( p_sys->i_nal_type != i_nal_type ) b_pic = VLC_TRUE;
  502.             if( p_sys->i_idr_pic_id != i_idr_pic_id ) b_pic = VLC_TRUE;
  503.             p_sys->i_idr_pic_id = i_idr_pic_id;
  504.         }
  505.         p_sys->i_nal_type = i_nal_type;
  507.         if( b_pic && p_sys->b_slice )
  508.         {
  509.             p_pic = block_ChainGather( p_sys->p_frame );
  510.             p_pic->i_dts = p_sys->i_dts;
  511.             p_pic->i_pts = p_sys->i_pts;
  512.             p_pic->i_length = 0;    /* FIXME */
  513.             p_pic->i_flags = p_sys->i_flags;
  515.             /* Reset context */
  516.             p_sys->p_frame = NULL;
  517.             p_sys->b_slice = VLC_FALSE;
  518.         }
  520.         p_sys->b_slice = VLC_TRUE;
  521.         p_sys->i_flags = i_pic_flags;
  522.         p_sys->i_dts   = p_frag->i_dts;
  523.         p_sys->i_pts   = p_frag->i_pts;
  525.         free( dec );
  526.     }
  527.     else if( i_nal_type == NAL_SPS )
  528.     {
  529.         uint8_t *dec;
  530.         int     i_dec;
  531.         bs_t s;
  532.         int i_tmp;
  534.         msg_Dbg( p_dec, "found NAL_SPS" );
  536.         p_sys->b_sps = VLC_TRUE;
  538.         nal_get_decoded( &dec, &i_dec, &p_frag->p_buffer[4],
  539.                          p_frag->i_buffer - 4 );
  541.         bs_init( &s, dec, i_dec );
  542.         /* Skip profile(8), constraint_set012, reserver(5), level(8) */
  543.         bs_skip( &s, 8 + 1+1+1 + 5 + 8 );
  544.         /* sps id */
  545.         bs_read_ue( &s );
  546.         /* Skip i_log2_max_frame_num */
  547.         p_sys->i_log2_max_frame_num = bs_read_ue( &s );
  548.         /* Read poc_type */
  549.         i_tmp = bs_read_ue( &s );
  550.         if( i_tmp == 0 )
  551.         {
  552.             /* skip i_log2_max_poc_lsb */
  553.             bs_read_ue( &s );
  554.         }
  555.         else if( i_tmp == 1 )
  556.         {
  557.             int i_cycle;
  558.             /* skip b_delta_pic_order_always_zero */
  559.             bs_skip( &s, 1 );
  560.             /* skip i_offset_for_non_ref_pic */
  561.             bs_read_se( &s );
  562.             /* skip i_offset_for_top_to_bottom_field */
  563.             bs_read_se( &s );
  564.             /* read i_num_ref_frames_in_poc_cycle */
  565.             i_cycle = bs_read_ue( &s );
  566.             if( i_cycle > 256 ) i_cycle = 256;
  567.             while( i_cycle > 0 )
  568.             {
  569.                 /* skip i_offset_for_ref_frame */
  570.                 bs_read_se(&s );
  571.             }
  572.         }
  573.         /* i_num_ref_frames */
  574.         bs_read_ue( &s );
  575.         /* b_gaps_in_frame_num_value_allowed */
  576.         bs_skip( &s, 1 );
  578.         /* Read size */
  579.         p_dec->fmt_out.video.i_width  = 16 * ( bs_read_ue( &s ) + 1 );
  580.         p_dec->fmt_out.video.i_height = 16 * ( bs_read_ue( &s ) + 1 );
  582.         /* b_frame_mbs_only */
  583.         p_sys->b_frame_mbs_only = bs_read( &s, 1 );
  584.         if( p_sys->b_frame_mbs_only == 0 )
  585.         {
  586.             bs_skip( &s, 1 );
  587.         }
  588.         /* b_direct8x8_inference */
  589.         bs_skip( &s, 1 );
  591.         /* crop */
  592.         i_tmp = bs_read( &s, 1 );
  593.         if( i_tmp )
  594.         {
  595.             /* left */
  596.             bs_read_ue( &s );
  597.             /* right */
  598.             bs_read_ue( &s );
  599.             /* top */
  600.             bs_read_ue( &s );
  601.             /* bottom */
  602.             bs_read_ue( &s );
  603.         }
  605.         /* vui */
  606.         i_tmp = bs_read( &s, 1 );
  607.         if( i_tmp )
  608.         {
  609.             /* read the aspect ratio part if any FIXME check it */
  610.             i_tmp = bs_read( &s, 1 );
  611.             if( i_tmp )
  612.             {
  613.                 static const struct { int w, h; } sar[14] =
  614.                 {
  615.                     { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
  616.                     { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
  617.                     { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
  618.                     { 64, 33 }, { 160,99 },
  619.                 };
  620.                 int i_sar = bs_read( &s, 8 );
  621.                 int w, h;
  623.                 if( i_sar < 14 )
  624.                 {
  625.                     w = sar[i_sar].w;
  626.                     h = sar[i_sar].h;
  627.                 }
  628.                 else
  629.                 {
  630.                     w = bs_read( &s, 16 );
  631.                     h = bs_read( &s, 16 );
  632.                 }
  633.                 p_dec->fmt_out.video.i_aspect =
  634.                     VOUT_ASPECT_FACTOR * w / h * p_dec->fmt_out.video.i_width /
  635.                     p_dec->fmt_out.video.i_height;
  636.             }
  637.         }
  639.         free( dec );
  640.     }
  641.     else if( i_nal_type == NAL_PPS )
  642.     {
  643.         bs_t s;
  644.         bs_init( &s, &p_frag->p_buffer[4], p_frag->i_buffer - 4 );
  646.         /* TODO */
  647.         msg_Dbg( p_dec, "found NAL_PPS" );
  648.     }
  650.     /* Append the block */
  651.     block_ChainAppend( &p_sys->p_frame, p_frag );
  653.     return p_pic;
  654. }