X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fdemux%2Fnsv.c;h=017f511ce03623a20bc3988fae75ae5eb116dbc2;hb=05345249b06e297dcc136f0daa22f5f95f366118;hp=56a76a8807c5f294d8cd5e4ee5e90097f644e689;hpb=ba616997914720d09aeb690a74429506d68da3c2;p=vlc

diff --git a/modules/demux/nsv.c b/modules/demux/nsv.c
index 56a76a8807..017f511ce0 100644
--- a/modules/demux/nsv.c
+++ b/modules/demux/nsv.c
@@ -1,8 +1,8 @@
 /*****************************************************************************
  * nsv.c: NullSoft Video demuxer.
  *****************************************************************************
- * Copyright (C) 2004 VideoLAN
- * $Id: nsv.c,v 1.4 2004/01/07 15:31:31 fenrir Exp $
+ * Copyright (C) 2004-2007 the VideoLAN team
+ * $Id$
  *
  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  *
@@ -18,16 +18,20 @@
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  *****************************************************************************/
 
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
-#include <stdlib.h>                                      /* malloc(), free() */
 
-#include <vlc/vlc.h>
-#include <vlc/input.h>
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_demux.h>
 
 /* TODO:
  *  - implement NSVf parsing (to get meta data)
@@ -41,12 +45,14 @@
 static int  Open    ( vlc_object_t * );
 static void Close  ( vlc_object_t * );
 
-vlc_module_begin();
-    set_description( _("NullSoft demuxer" ) );
-    set_capability( "demux2", 10 );
-    set_callbacks( Open, Close );
-    add_shortcut( "nsv" );
-vlc_module_end();
+vlc_module_begin ()
+    set_description( N_("NullSoft demuxer" ) )
+    set_capability( "demux", 10 )
+    set_category( CAT_INPUT )
+    set_subcategory( SUBCAT_INPUT_DEMUX )
+    set_callbacks( Open, Close )
+    add_shortcut( "nsv" )
+vlc_module_end ()
 
 /*****************************************************************************
  * Local prototypes
@@ -60,9 +66,14 @@ struct demux_sys_t
     es_format_t  fmt_video;
     es_out_id_t *p_video;
 
+    es_format_t  fmt_sub;
+    es_out_id_t  *p_sub;
+
     int64_t     i_pcr;
     int64_t     i_time;
     int64_t     i_pcr_inc;
+
+    bool b_start_record;
 };
 
 static int Demux  ( demux_t *p_demux );
@@ -81,28 +92,26 @@ static int Open( vlc_object_t *p_this )
     demux_t     *p_demux = (demux_t*)p_this;
     demux_sys_t *p_sys;
 
-    uint8_t     *p_peek;
-    int         i;
+    const uint8_t *p_peek;
 
     if( stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
-    {
-        msg_Err( p_demux, "cannot peek" );
         return VLC_EGENERIC;
-    }
-    if( strncmp( p_peek, "NSVf", 4 ) && strncmp( p_peek, "NSVs", 4 ))
+
+    if( memcmp( p_peek, "NSVf", 4 ) && memcmp( p_peek, "NSVs", 4 ) )
     {
        /* In case we had force this demuxer we try to resynch */
-        if( strcmp( p_demux->psz_demux, "nsv" ) || ReSynch( p_demux ) )
-        {
-            msg_Warn( p_demux, "NSV module discarded" );
+        if( !p_demux->b_force || ReSynch( p_demux ) )
             return VLC_EGENERIC;
-        }
     }
 
+    p_sys = malloc( sizeof( demux_sys_t ) );
+    if( unlikely(p_sys == NULL) )
+        return VLC_ENOMEM;
+
     /* Fill p_demux field */
+    p_demux->p_sys = p_sys;
     p_demux->pf_demux = Demux;
     p_demux->pf_control = Control;
-    p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
 
     es_format_Init( &p_sys->fmt_audio, AUDIO_ES, 0 );
     p_sys->p_audio = NULL;
@@ -110,10 +119,15 @@ static int Open( vlc_object_t *p_this )
     es_format_Init( &p_sys->fmt_video, VIDEO_ES, 0 );
     p_sys->p_video = NULL;
 
-    p_sys->i_pcr   = 1;
+    es_format_Init( &p_sys->fmt_sub, SPU_ES, 0 );
+    p_sys->p_sub = NULL;
+
+    p_sys->i_pcr   = 0;
     p_sys->i_time  = 0;
     p_sys->i_pcr_inc = 0;
 
+    p_sys->b_start_record = false;
+
     return VLC_SUCCESS;
 }
 
@@ -137,7 +151,7 @@ static int Demux( demux_t *p_demux )
     demux_sys_t *p_sys = p_demux->p_sys;
 
     uint8_t     header[5];
-    uint8_t     *p_peek;
+    const uint8_t *p_peek;
 
     int         i_size;
     block_t     *p_frame;
@@ -150,19 +164,22 @@ static int Demux( demux_t *p_demux )
             return 0;
         }
 
-        if( !strncmp( p_peek, "NSVf", 4 ) )
+        if( !memcmp( p_peek, "NSVf", 4 ) )
         {
             if( ReadNSVf( p_demux ) )
-            {
                 return -1;
-            }
         }
-        else if( !strncmp( p_peek, "NSVs", 4 ) )
+        else if( !memcmp( p_peek, "NSVs", 4 ) )
         {
-            if( ReadNSVs( p_demux ) )
+            if( p_sys->b_start_record )
             {
-                return -1;
+                /* Enable recording once synchronized */
+                stream_Control( p_demux->s, STREAM_SET_RECORD_STATE, true, "nsv" );
+                p_sys->b_start_record = false;
             }
+
+            if( ReadNSVs( p_demux ) )
+                return -1;
             break;
         }
         else if( GetWLE( p_peek ) == 0xbeef )
@@ -177,11 +194,9 @@ static int Demux( demux_t *p_demux )
         }
         else
         {
-            msg_Err( p_demux, "invalid signature 0x%x (%4.4s)", *(uint32_t*)p_peek, (char*)p_peek );
+            msg_Err( p_demux, "invalid signature 0x%x (%4.4s)", GetDWLE( p_peek ), (const char*)p_peek );
             if( ReSynch( p_demux ) )
-            {
                 return -1;
-            }
         }
     }
 
@@ -192,16 +207,76 @@ static int Demux( demux_t *p_demux )
     }
 
     /* Set PCR */
-    es_out_Control( p_demux->out, ES_OUT_SET_PCR, (int64_t)p_sys->i_pcr );
+    es_out_Control( p_demux->out, ES_OUT_SET_PCR, VLC_TS_0 + p_sys->i_pcr );
 
     /* Read video */
     i_size = ( header[0] >> 4 ) | ( header[1] << 4 ) | ( header[2] << 12 );
     if( i_size > 0 )
     {
+        /* extra data ? */
+        if( (header[0]&0x0f) != 0x0 )
+        {
+            uint8_t      aux[6];
+            int          i_aux;
+            vlc_fourcc_t fcc;
+            if( stream_Read( p_demux->s, aux, 6 ) < 6 )
+            {
+                msg_Warn( p_demux, "cannot read" );
+                return 0;
+            }
+            i_aux = GetWLE( aux );
+            fcc   = VLC_FOURCC( aux[2], aux[3], aux[4], aux[5] );
+
+            msg_Dbg( p_demux, "Belekas: %d - size=%d fcc=%4.4s",
+                     header[0]&0xf, i_aux, (char*)&fcc );
+
+            if( fcc == VLC_FOURCC( 'S', 'U', 'B', 'T' ) && i_aux > 2 )
+            {
+                if( p_sys->p_sub == NULL )
+                {
+                    p_sys->fmt_sub.i_codec = VLC_FOURCC( 's', 'u', 'b', 't' );
+                    p_sys->p_sub = es_out_Add( p_demux->out, &p_sys->fmt_sub );
+                    es_out_Control( p_demux->out, ES_OUT_SET_ES, p_sys->p_sub );
+                }
+                stream_Read( p_demux->s, NULL, 2 );
+
+                if( ( p_frame = stream_Block( p_demux->s, i_aux - 2 ) ) )
+                {
+                    uint8_t *p = p_frame->p_buffer;
+
+                    while( p < &p_frame->p_buffer[p_frame->i_buffer] && *p != 0 )
+                    {
+                        p++;
+                    }
+                    if( *p == 0 && p + 1 < &p_frame->p_buffer[p_frame->i_buffer] )
+                    {
+                        p_frame->i_buffer -= p + 1 - p_frame->p_buffer;
+                        p_frame->p_buffer = p + 1;
+                    }
+
+                    /* Skip the first part (it is the language name) */
+                    p_frame->i_pts = VLC_TS_0 + p_sys->i_pcr;
+                    p_frame->i_dts = VLC_TS_0 + p_sys->i_pcr + 4000000;    /* 4s */
+
+                    es_out_Send( p_demux->out, p_sys->p_sub, p_frame );
+                }
+            }
+            else
+            {
+                /* We skip this extra data */
+                if( stream_Read( p_demux->s, NULL, i_aux ) < i_aux )
+                {
+                    msg_Warn( p_demux, "cannot read" );
+                    return 0;
+                }
+            }
+            i_size -= 6 + i_aux;
+        }
+
         /* msg_Dbg( p_demux, "frame video size=%d", i_size ); */
-        if( ( p_frame = stream_Block( p_demux->s, i_size ) ) )
+        if( i_size > 0 && ( p_frame = stream_Block( p_demux->s, i_size ) ) )
         {
-            p_frame->i_dts = p_sys->i_pcr;
+            p_frame->i_dts = VLC_TS_0 + p_sys->i_pcr;
             es_out_Send( p_demux->out, p_sys->p_video, p_frame );
         }
     }
@@ -229,7 +304,7 @@ static int Demux( demux_t *p_demux )
         if( ( p_frame = stream_Block( p_demux->s, i_size ) ) )
         {
             p_frame->i_dts =
-            p_frame->i_pts = p_sys->i_pcr;
+            p_frame->i_pts = VLC_TS_0 + p_sys->i_pcr;
             es_out_Send( p_demux->out, p_sys->p_audio, p_frame );
         }
     }
@@ -250,6 +325,7 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
 {
     demux_sys_t *p_sys = p_demux->p_sys;
     double f, *pf;
+    bool b_bool, *pb_bool;
     int64_t i64, *pi64;
 
     switch( i_query )
@@ -259,7 +335,8 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
             i64 = stream_Size( p_demux->s );
             if( i64 > 0 )
             {
-                *pf = (double)stream_Tell( p_demux->s ) / (double)i64;
+                double current = stream_Tell( p_demux->s );
+                *pf = current / (double)i64;
             }
             else
             {
@@ -271,11 +348,9 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
             f = (double) va_arg( args, double );
             i64 = stream_Size( p_demux->s );
 
-            es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
             if( stream_Seek( p_demux->s, (int64_t)(i64 * f) ) || ReSynch( p_demux ) )
-            {
                 return VLC_EGENERIC;
-            }
+
             p_sys->i_time = -1; /* Invalidate time display */
             return VLC_SUCCESS;
 
@@ -300,13 +375,27 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
             *pi64 = 0;
             return VLC_EGENERIC;
 
-        case DEMUX_SET_TIME:
 #endif
         case DEMUX_GET_FPS:
             pf = (double*)va_arg( args, double * );
             *pf = (double)1000000.0 / (double)p_sys->i_pcr_inc;
             return VLC_SUCCESS;
 
+        case DEMUX_CAN_RECORD:
+            pb_bool = (bool*)va_arg( args, bool * );
+            *pb_bool = true;
+            return VLC_SUCCESS;
+
+        case DEMUX_SET_RECORD_STATE:
+            b_bool = (bool)va_arg( args, int );
+
+            if( !b_bool )
+                stream_Control( p_demux->s, STREAM_SET_RECORD_STATE, false );
+            p_sys->b_start_record = b_bool;
+            return VLC_SUCCESS;
+
+
+        case DEMUX_SET_TIME:
         default:
             return VLC_EGENERIC;
     }
@@ -317,11 +406,11 @@ static int Control( demux_t *p_demux, int i_query, va_list args )
  *****************************************************************************/
 static int ReSynch( demux_t *p_demux )
 {
-    uint8_t *p_peek;
+    const uint8_t *p_peek;
     int      i_skip;
     int      i_peek;
 
-    while( !p_demux->b_die )
+    while( vlc_object_alive (p_demux) )
     {
         if( ( i_peek = stream_Peek( p_demux->s, &p_peek, 1024 ) ) < 8 )
         {
@@ -331,7 +420,8 @@ static int ReSynch( demux_t *p_demux )
 
         while( i_skip < i_peek - 4 )
         {
-            if( !strncmp( p_peek, "NSVf", 4 ) || !strncmp( p_peek, "NSVs", 4 ) )
+            if( !memcmp( p_peek, "NSVf", 4 )
+             || !memcmp( p_peek, "NSVs", 4 ) )
             {
                 if( i_skip > 0 )
                 {
@@ -353,11 +443,11 @@ static int ReSynch( demux_t *p_demux )
  *****************************************************************************/
 static int ReadNSVf( demux_t *p_demux )
 {
-    demux_sys_t *p_sys = p_demux->p_sys;
-    uint8_t     *p;
+    /* demux_sys_t *p_sys = p_demux->p_sys; */
+    const uint8_t     *p;
     int         i_size;
 
-    msg_Dbg( p_demux, "New NSVf chunk" );
+    msg_Dbg( p_demux, "new NSVf chunk" );
     if( stream_Peek( p_demux->s, &p, 8 ) < 8 )
     {
         return VLC_EGENERIC;
@@ -369,7 +459,7 @@ static int ReadNSVf( demux_t *p_demux )
     return stream_Read( p_demux->s, NULL, i_size ) == i_size ? VLC_SUCCESS : VLC_EGENERIC;
 }
 /*****************************************************************************
- * ReadNSVf:
+ * ReadNSVs:
  *****************************************************************************/
 static int ReadNSVs( demux_t *p_demux )
 {
@@ -383,18 +473,30 @@ static int ReadNSVs( demux_t *p_demux )
         return VLC_EGENERIC;
     }
 
-    msg_Dbg( p_demux, "New NSVs chunk" );
     /* Video */
     switch( ( fcc = VLC_FOURCC( header[4], header[5], header[6], header[7] ) ) )
     {
         case VLC_FOURCC( 'V', 'P', '3', ' ' ):
+        case VLC_FOURCC( 'V', 'P', '3', '0' ):
+            fcc = VLC_FOURCC( 'V', 'P', '3', '0' );
+            break;
+
         case VLC_FOURCC( 'V', 'P', '3', '1' ):
             fcc = VLC_FOURCC( 'V', 'P', '3', '1' );
             break;
+
+        case VLC_FOURCC( 'V', 'P', '5', ' ' ):
+        case VLC_FOURCC( 'V', 'P', '5', '0' ):
+            fcc = VLC_FOURCC( 'V', 'P', '5', '0' );
+            break;
+        case VLC_FOURCC( 'V', 'P', '6', '0' ):
+        case VLC_FOURCC( 'V', 'P', '6', '1' ):
+        case VLC_FOURCC( 'V', 'P', '6', '2' ):
+        case VLC_FOURCC( 'H', '2', '6', '4' ):
         case VLC_FOURCC( 'N', 'O', 'N', 'E' ):
             break;
         default:
-            msg_Warn( p_demux, "unknow codec" );
+            msg_Warn( p_demux, "unknown codec %4.4s", (char *)&fcc );
             break;
     }
     if( fcc != VLC_FOURCC( 'N', 'O', 'N', 'E' ) && fcc != p_sys->fmt_video.i_codec  )
@@ -423,10 +525,17 @@ static int ReadNSVs( demux_t *p_demux )
         case VLC_FOURCC( 'P', 'C', 'M', ' ' ):
             fcc = VLC_FOURCC( 'a', 'r', 'a', 'w' );
             break;
+        case VLC_FOURCC( 'A', 'A', 'C', ' ' ):
+        case VLC_FOURCC( 'A', 'A', 'C', 'P' ):
+            fcc = VLC_FOURCC( 'm', 'p', '4', 'a' );
+            break;
+        case VLC_FOURCC( 'S', 'P', 'X', ' ' ):
+            fcc = VLC_FOURCC( 's', 'p', 'x', ' ' );
+            break;
         case VLC_FOURCC( 'N', 'O', 'N', 'E' ):
             break;
         default:
-            msg_Warn( p_demux, "unknow codec" );
+            msg_Warn( p_demux, "unknown codec %4.4s", (char *)&fcc );
             break;
     }
 
@@ -444,25 +553,31 @@ static int ReadNSVs( demux_t *p_demux )
 
     if( header[16]&0x80 )
     {
-        switch( header[16]&0x7f )
+        /* Fractional frame rate */
+        switch( header[16]&0x03 )
         {
-            case 1: /* 29.97 fps */
-                p_sys->i_pcr_inc = 33367;
+            case 0: /* 30 fps */
+                p_sys->i_pcr_inc = 33333; /* 300000/9 */
                 break;
-            case 3: /* 23.976 fps */
-                p_sys->i_pcr_inc = 41708;
+            case 1: /* 29.97 fps */
+                p_sys->i_pcr_inc = 33367; /* 300300/9 */
                 break;
-            case 5: /* 14.98 fps */
-                p_sys->i_pcr_inc = 66755;
+            case 2: /* 25 fps */
+                p_sys->i_pcr_inc = 40000; /* 360000/9 */
                 break;
-            default:
-                msg_Dbg( p_demux, "unknow fps (0x%x)", header[16] );
-                p_sys->i_pcr_inc = 40000;
+            case 3: /* 23.98 fps */
+                p_sys->i_pcr_inc = 41700; /* 375300/9 */
                 break;
         }
+
+        if( header[16] < 0xc0 )
+            p_sys->i_pcr_inc = p_sys->i_pcr_inc * (((header[16] ^ 0x80) >> 2 ) +1 );
+        else
+            p_sys->i_pcr_inc = p_sys->i_pcr_inc / (((header[16] ^ 0xc0) >> 2 ) +1 );
     }
     else if( header[16] != 0 )
     {
+        /* Integer frame rate */
         p_sys->i_pcr_inc = 1000000 / header[16];
     }
     else
@@ -470,7 +585,7 @@ static int ReadNSVs( demux_t *p_demux )
         msg_Dbg( p_demux, "invalid fps (0x00)" );
         p_sys->i_pcr_inc = 40000;
     }
-    msg_Dbg( p_demux, "    - fps=%.3f", 1000000.0 / (double)p_sys->i_pcr_inc );
+    //msg_Dbg( p_demux, "    - fps=%.3f", 1000000.0 / (double)p_sys->i_pcr_inc );
 
     return VLC_SUCCESS;
 }