]> git.sesse.net Git - vlc/blobdiff - modules/packetizer/h264.c
Removes trailing spaces. Removes tabs.
[vlc] / modules / packetizer / h264.c
index 641c4ea67543bf7cf63d7ac0fe9f4370dfa780f5..23e1720c656450a0d2cbdb5d432127a94b4476a6 100644 (file)
@@ -7,6 +7,7 @@
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *          Eric Petit <titer@videolan.org>
  *          Gildas Bazin <gbazin@videolan.org>
+ *          Derk-Jan Hartman <hartman at videolan dot org>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-#include <stdlib.h>                                      /* malloc(), free() */
 
 #include <vlc/vlc.h>
-#include <vlc/decoder.h>
-#include <vlc/sout.h>
+#include <vlc_sout.h>
+#include <vlc_codec.h>
+#include <vlc_block.h>
 
 #include "vlc_block_helper.h"
 #include "vlc_bits.h"
@@ -56,6 +57,27 @@ vlc_module_end();
 static block_t *Packetize( decoder_t *, block_t ** );
 static block_t *PacketizeAVC1( decoder_t *, block_t ** );
 
+typedef struct
+{
+    int i_nal_type;
+    int i_nal_ref_idc;
+
+    int i_frame_type;
+    int i_pic_parameter_set_id;
+    int i_frame_num;
+
+    int i_field_pic_flag;
+    int i_bottom_field_flag;
+
+    int i_idr_pic_id;
+
+    int i_pic_order_cnt_lsb;
+    int i_delta_pic_order_cnt_bottom;
+
+    int i_delta_pic_order_cnt0;
+    int i_delta_pic_order_cnt1;
+} slice_t;
+
 struct decoder_sys_t
 {
     block_bytestream_t bytestream;
@@ -69,6 +91,7 @@ struct decoder_sys_t
 
     vlc_bool_t   b_sps;
     vlc_bool_t   b_pps;
+    vlc_bool_t   b_header;
 
     /* avcC data */
     int i_avcC_length_size;
@@ -78,13 +101,15 @@ struct decoder_sys_t
     /* Useful values of the Sequence Parameter Set */
     int i_log2_max_frame_num;
     int b_frame_mbs_only;
+    int i_pic_order_cnt_type;
+    int i_delta_pic_order_always_zero_flag;
+    int i_log2_max_pic_order_cnt_lsb;
+
+    /* Value from Picture Parameter Set */
+    int i_pic_order_present_flag;
 
     /* Useful values of the Slice Header */
-    int i_nal_type;
-    int i_nal_ref_idc;
-    int i_idr_pic_id;
-    int i_frame_num;
-    int i_frame_type;
+    slice_t slice;
 };
 
 enum
@@ -134,6 +159,7 @@ static int Open( vlc_object_t *p_this )
         p_dec->fmt_in.i_codec != VLC_FOURCC( 'H', '2', '6', '4') &&
         p_dec->fmt_in.i_codec != VLC_FOURCC( 'V', 'S', 'S', 'H') &&
         p_dec->fmt_in.i_codec != VLC_FOURCC( 'v', 's', 's', 'h') &&
+        p_dec->fmt_in.i_codec != VLC_FOURCC( 'D', 'A', 'V', 'C') &&
         ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') ||
           p_dec->fmt_in.i_extra < 7 ) )
     {
@@ -159,12 +185,18 @@ static int Open( vlc_object_t *p_this )
     p_sys->b_pps   = VLC_FALSE;
     p_sys->p_sps   = 0;
     p_sys->p_pps   = 0;
-
-    p_sys->i_nal_type = -1;
-    p_sys->i_nal_ref_idc = -1;
-    p_sys->i_idr_pic_id = -1;
-    p_sys->i_frame_num = -1;
-    p_sys->i_frame_type = 0;
+    p_sys->b_header= VLC_FALSE;
+
+    p_sys->slice.i_nal_type = -1;
+    p_sys->slice.i_nal_ref_idc = -1;
+    p_sys->slice.i_idr_pic_id = -1;
+    p_sys->slice.i_frame_num = -1;
+    p_sys->slice.i_frame_type = 0;
+    p_sys->slice.i_pic_parameter_set_id = -1;
+    p_sys->slice.i_field_pic_flag = 0;
+    p_sys->slice.i_bottom_field_flag = -1;
+    p_sys->slice.i_pic_order_cnt_lsb = -1;
+    p_sys->slice.i_delta_pic_order_cnt_bottom = -1;
 
     /* Setup properties */
     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
@@ -213,22 +245,23 @@ static int Open( vlc_object_t *p_this )
         /* FIXME: FFMPEG isn't happy at all if you leave this */
         if( p_dec->fmt_out.i_extra ) free( p_dec->fmt_out.p_extra );
         p_dec->fmt_out.i_extra = 0; p_dec->fmt_out.p_extra = NULL;
-        
         /* Set the new extradata */
         p_dec->fmt_out.i_extra = p_sys->p_pps->i_buffer + p_sys->p_sps->i_buffer;
         p_dec->fmt_out.p_extra = (uint8_t*)malloc( p_dec->fmt_out.i_extra );
-        memcpy( p_dec->fmt_out.p_extra, p_sys->p_sps->p_buffer, p_sys->p_sps->i_buffer);
-        memcpy( p_dec->fmt_out.p_extra+p_sys->p_sps->i_buffer, p_sys->p_pps->p_buffer, p_sys->p_pps->i_buffer);
+        memcpy( (uint8_t*)p_dec->fmt_out.p_extra, p_sys->p_sps->p_buffer, p_sys->p_sps->i_buffer);
+        memcpy( (uint8_t*)p_dec->fmt_out.p_extra+p_sys->p_sps->i_buffer, p_sys->p_pps->p_buffer, p_sys->p_pps->i_buffer);
+        p_sys->b_header = VLC_TRUE;
 
         /* Set callback */
         p_dec->pf_packetize = PacketizeAVC1;
     }
     else
     {
-        /* This type of stream contains data with 3 of 4 byte startcodes 
+        /* This type of stream contains data with 3 of 4 byte startcodes
          * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes
          * The fmt_out.p_extra should be the same */
-         
         /* Set callback */
         p_dec->pf_packetize = Packetize;
 
@@ -277,7 +310,25 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
     decoder_sys_t *p_sys = p_dec->p_sys;
     block_t       *p_pic;
 
-    if( !pp_block || !*pp_block ) return NULL;
+    if( !pp_block || !*pp_block )
+        return NULL;
+
+    if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
+    {
+        if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
+        {
+            p_sys->i_state = STATE_NOSYNC;
+            block_BytestreamFlush( &p_sys->bytestream );
+
+            if( p_sys->p_frame )
+                block_ChainRelease( p_sys->p_frame );
+            p_sys->p_frame = NULL;
+            p_sys->slice.i_frame_type = 0;
+            p_sys->b_slice = VLC_FALSE;
+        }
+        block_Release( *pp_block );
+        return NULL;
+    }
 
     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 
@@ -329,7 +380,8 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
                                 p_pic->i_buffer-1 );
 
                 /* Remove trailing 0 bytes */
-                while( p_pic->i_buffer && (!p_pic->p_buffer[p_pic->i_buffer-1] ) ) p_pic->i_buffer--;
+                while( p_pic->i_buffer && (!p_pic->p_buffer[p_pic->i_buffer-1] ) )
+                    p_pic->i_buffer--;
                 p_sys->i_offset = 0;
 
                 /* Parse the NAL */
@@ -365,7 +417,13 @@ static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
     block_t       *p_ret = NULL;
     uint8_t       *p;
 
-    if( !pp_block || !*pp_block ) return NULL;
+    if( !pp_block || !*pp_block )
+        return NULL;
+    if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
+    {
+        block_Release( *pp_block );
+        return NULL;
+    }
 
     p_block = *pp_block;
     *pp_block = NULL;
@@ -465,7 +523,7 @@ static inline int bs_read_se( bs_t *s )
 
 /*****************************************************************************
  * ParseNALBlock: parses annexB type NALs
- * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode 
+ * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
  *****************************************************************************/
 static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
 {
@@ -477,39 +535,42 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
 
 #define OUTPUT \
     do {                                                      \
-        p_pic = block_ChainGather( p_sys->p_frame );          \
-        p_pic->i_length = 0;    /* FIXME */                   \
-        p_pic->i_flags |= p_sys->i_frame_type;                \
-                                                              \
-        p_sys->i_frame_type = 0;                              \
-        p_sys->p_frame = NULL;                                \
-        p_sys->b_slice = VLC_FALSE;                           \
+        if( !p_sys->b_header && p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I) \
+            break;                                            \
                                                               \
-        if( ( p_pic->i_flags & BLOCK_FLAG_TYPE_I ) &&         \
-              p_sys->p_sps && p_sys->p_pps )                  \
-        {                                                     \
+        if( p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I && p_sys->p_sps && p_sys->p_pps && !p_sys->b_header ) \
+        { \
             block_t *p_sps = block_Duplicate( p_sys->p_sps ); \
             block_t *p_pps = block_Duplicate( p_sys->p_pps ); \
-            p_sps->i_dts = p_pps->i_dts = p_pic->i_dts;       \
-            p_sps->i_pts = p_pps->i_pts = p_pic->i_pts;       \
+            p_sps->i_dts = p_sys->p_frame->i_dts;           \
+            p_sps->i_pts = p_sys->p_frame->i_pts;           \
             block_ChainAppend( &p_sps, p_pps );               \
-            block_ChainAppend( &p_sps, p_pic );               \
+            block_ChainAppend( &p_sps, p_sys->p_frame );      \
+            p_sys->b_header = VLC_TRUE;                       \
             p_pic = block_ChainGather( p_sps );               \
-        }                                                     \
+        } else { \
+            p_pic = block_ChainGather( p_sys->p_frame ); \
+        } \
+        p_pic->i_length = 0;    /* FIXME */                   \
+        p_pic->i_flags |= p_sys->slice.i_frame_type;          \
+            \
+        p_sys->slice.i_frame_type = 0;                        \
+        p_sys->p_frame = NULL;                                \
+        p_sys->b_slice = VLC_FALSE;                           \
     } while(0)
 
-
-    if( p_sys->b_slice && !p_sys->b_sps )
+    if( p_sys->b_slice && ( !p_sys->b_sps || !p_sys->b_pps ) )
     {
         block_ChainRelease( p_sys->p_frame );
-        msg_Warn( p_dec, "waiting for SPS" );
+        msg_Warn( p_dec, "waiting for SPS/PPS" );
 
         /* Reset context */
+        p_sys->slice.i_frame_type = 0;
         p_sys->p_frame = NULL;
         p_sys->b_slice = VLC_FALSE;
     }
 
-    if( !p_sys->b_sps &&
+    if( ( !p_sys->b_sps || !p_sys->b_pps ) &&
         i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
     {
         p_sys->b_slice = VLC_TRUE;
@@ -518,8 +579,9 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
     else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
     {
         uint8_t *dec;
-        int i_dec, i_first_mb, i_slice_type, i_frame_num;
-        vlc_bool_t b_pic = VLC_FALSE;
+        int i_dec, i_first_mb, i_slice_type;
+        slice_t slice;
+        vlc_bool_t b_pic;
         bs_t s;
 
         /* do not convert the whole frame */
@@ -534,59 +596,90 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
         switch( (i_slice_type = bs_read_ue( &s )) )
         {
         case 0: case 5:
-            p_sys->i_frame_type = BLOCK_FLAG_TYPE_P;
+            slice.i_frame_type = BLOCK_FLAG_TYPE_P;
             break;
         case 1: case 6:
-            p_sys->i_frame_type = BLOCK_FLAG_TYPE_B;
+            slice.i_frame_type = BLOCK_FLAG_TYPE_B;
             break;
         case 2: case 7:
-            p_sys->i_frame_type = BLOCK_FLAG_TYPE_I;
+            slice.i_frame_type = BLOCK_FLAG_TYPE_I;
             break;
         case 3: case 8: /* SP */
-            p_sys->i_frame_type = BLOCK_FLAG_TYPE_P;
+            slice.i_frame_type = BLOCK_FLAG_TYPE_P;
             break;
         case 4: case 9:
-            p_sys->i_frame_type = BLOCK_FLAG_TYPE_I;
+            slice.i_frame_type = BLOCK_FLAG_TYPE_I;
+            break;
+        default:
+            slice.i_frame_type = 0;
             break;
         }
 
-        /* pic_parameter_set_id */
-        bs_read_ue( &s );
-        /* frame_num */
-        i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );
+        /* */
+        slice.i_nal_type = i_nal_type;
+        slice.i_nal_ref_idc = i_nal_ref_idc;
 
-        /* Detection of the first VCL NAL unit of a primary coded picture
-         * (cf. 7.4.1.2.4) */
-        if( i_frame_num != p_sys->i_frame_num ||
-            ( (i_nal_ref_idc != p_sys->i_nal_ref_idc) &&
-              (!i_nal_ref_idc || !p_sys->i_nal_ref_idc) ) )
-        {
-            b_pic = VLC_TRUE;
-        }
-        p_sys->i_frame_num = i_frame_num;
-        p_sys->i_nal_ref_idc = i_nal_ref_idc;
+        slice.i_pic_parameter_set_id = bs_read_ue( &s );
+        slice.i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );
 
+        slice.i_field_pic_flag = 0;
+        slice.i_bottom_field_flag = -1;
         if( !p_sys->b_frame_mbs_only )
         {
             /* field_pic_flag */
-            if( bs_read( &s, 1 ) )
-            {
-                /* bottom_field_flag */
-                bs_read( &s, 1 );
-            }
+            slice.i_field_pic_flag = bs_read( &s, 1 );
+            if( slice.i_field_pic_flag )
+                slice.i_bottom_field_flag = bs_read( &s, 1 );
         }
 
-        if( i_nal_type == NAL_SLICE_IDR )
+        slice.i_idr_pic_id = p_sys->slice.i_idr_pic_id;
+        if( slice.i_nal_type == NAL_SLICE_IDR )
+            slice.i_idr_pic_id = bs_read_ue( &s );
+
+        slice.i_pic_order_cnt_lsb = -1;
+        slice.i_delta_pic_order_cnt_bottom = -1;
+        slice.i_delta_pic_order_cnt0 = 0;
+        slice.i_delta_pic_order_cnt1 = 0;
+        if( p_sys->i_pic_order_cnt_type == 0 )
         {
-            /* id_pic_id */
-            int i_idr_pic_id = bs_read_ue( &s );
-            if( p_sys->i_nal_type != i_nal_type ) b_pic = VLC_TRUE;
-            if( p_sys->i_idr_pic_id != i_idr_pic_id ) b_pic = VLC_TRUE;
-            p_sys->i_idr_pic_id = i_idr_pic_id;
+            slice.i_pic_order_cnt_lsb = bs_read( &s, p_sys->i_log2_max_pic_order_cnt_lsb + 4 );
+            if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag )
+                slice.i_delta_pic_order_cnt_bottom = bs_read_se( &s );
         }
-        p_sys->i_nal_type = i_nal_type;
+        else if( p_sys->i_pic_order_cnt_type == 1 && !p_sys->i_delta_pic_order_always_zero_flag )
+        {
+            slice.i_delta_pic_order_cnt0 = bs_read_se( &s );
+            if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag )
+                slice.i_delta_pic_order_cnt1 = bs_read_se( &s );
+        }
+
+        /* Detection of the first VCL NAL unit of a primary coded picture
+         * (cf. 7.4.1.2.4) */
+        b_pic = VLC_FALSE;
+        if( slice.i_frame_num != p_sys->slice.i_frame_num ||
+            slice.i_pic_parameter_set_id != p_sys->slice.i_pic_parameter_set_id ||
+            slice.i_field_pic_flag != p_sys->slice.i_field_pic_flag ||
+            slice.i_nal_ref_idc != p_sys->slice.i_nal_ref_idc )
+            b_pic = VLC_TRUE;
+        if( slice.i_bottom_field_flag != -1 && p_sys->slice.i_bottom_field_flag != -1 && slice.i_bottom_field_flag != p_sys->slice.i_bottom_field_flag )
+            b_pic = VLC_TRUE;
+        if( p_sys->i_pic_order_cnt_type == 0 &&
+            ( slice.i_pic_order_cnt_lsb != p_sys->slice.i_pic_order_cnt_lsb ||
+              slice.i_delta_pic_order_cnt_bottom != p_sys->slice.i_delta_pic_order_cnt_bottom ) )
+            b_pic = VLC_TRUE;
+        else if( p_sys->i_pic_order_cnt_type == 1 &&
+                 ( slice.i_delta_pic_order_cnt0 != p_sys->slice.i_delta_pic_order_cnt0 ||
+                   slice.i_delta_pic_order_cnt1 != p_sys->slice.i_delta_pic_order_cnt1 ) )
+            b_pic = VLC_TRUE;
+        if( ( slice.i_nal_type == NAL_SLICE_IDR || p_sys->slice.i_nal_type == NAL_SLICE_IDR ) &&
+            ( slice.i_nal_type != p_sys->slice.i_nal_type || slice.i_idr_pic_id != p_sys->slice.i_idr_pic_id ) )
+                b_pic = VLC_TRUE;
+
+        /* */
+        p_sys->slice = slice;
 
-        if( b_pic && p_sys->b_slice ) OUTPUT;
+        if( b_pic && p_sys->b_slice )
+            OUTPUT;
 
         p_sys->b_slice = VLC_TRUE;
 
@@ -613,18 +706,22 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
         bs_read_ue( &s );
         /* Skip i_log2_max_frame_num */
         p_sys->i_log2_max_frame_num = bs_read_ue( &s );
+        if( p_sys->i_log2_max_frame_num > 12)
+            p_sys->i_log2_max_frame_num = 12;
         /* Read poc_type */
-        i_tmp = bs_read_ue( &s );
-        if( i_tmp == 0 )
+        p_sys->i_pic_order_cnt_type = bs_read_ue( &s );
+        if( p_sys->i_pic_order_cnt_type == 0 )
         {
             /* skip i_log2_max_poc_lsb */
-            bs_read_ue( &s );
+            p_sys->i_log2_max_pic_order_cnt_lsb = bs_read_ue( &s );
+            if( p_sys->i_log2_max_pic_order_cnt_lsb > 12 )
+                p_sys->i_log2_max_pic_order_cnt_lsb = 12;
         }
-        else if( i_tmp == 1 )
+        else if( p_sys->i_pic_order_cnt_type == 1 )
         {
             int i_cycle;
             /* skip b_delta_pic_order_always_zero */
-            bs_skip( &s, 1 );
+            p_sys->i_delta_pic_order_always_zero_flag = bs_read( &s, 1 );
             /* skip i_offset_for_non_ref_pic */
             bs_read_se( &s );
             /* skip i_offset_for_top_to_bottom_field */
@@ -721,7 +818,12 @@ static block_t *ParseNALBlock( decoder_t *p_dec, block_t *p_frag )
     else if( i_nal_type == NAL_PPS )
     {
         bs_t s;
+
         bs_init( &s, &p_frag->p_buffer[5], p_frag->i_buffer - 5 );
+        bs_read_ue( &s ); // pps id
+        bs_read_ue( &s ); // sps id
+        bs_skip( &s, 1 ); // entropy coding mode flag
+        p_sys->i_pic_order_present_flag = bs_read( &s, 1 );
 
         if( !p_sys->b_pps ) msg_Dbg( p_dec, "found NAL_PPS" );
         p_sys->b_pps = VLC_TRUE;