git.sesse.net Git - vlc/blob - modules/access/dshow/dshow.cpp

   1 /*****************************************************************************
   2  * dshow.c : DirectShow access module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2002 VideoLAN
   5  * $Id: dshow.cpp,v 1.1 2003/08/24 11:17:39 gbazin Exp $
   6  *
   7  * Author: Gildas Bazin <gbazin@netcourrier.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include <vlc/vlc.h>
  32 #include <vlc/input.h>
  33 #include <vlc/vout.h>
  34
  35 #ifndef _MSC_VER
  36 #   include <wtypes.h>
  37 #   include <unknwn.h>
  38 #   include <ole2.h>
  39 #   include <limits.h>
  40 #   define _WINGDI_ 1
  41 #   define AM_NOVTABLE
  42 #   define _OBJBASE_H_
  43 #   undef _X86_
  44 #   define _I64_MAX LONG_LONG_MAX
  45 #   define LONGLONG long long
  46 #endif
  47
  48 #include <dshow.h>
  49
  50 #include "filter.h"
  51
  52 /*****************************************************************************
  53  * Local prototypes
  54  *****************************************************************************/
  55 static int  AccessOpen  ( vlc_object_t * );
  56 static void AccessClose ( vlc_object_t * );
  57 static int  Read        ( input_thread_t *, byte_t *, size_t );
  58
  59 static int  DemuxOpen  ( vlc_object_t * );
  60 static void DemuxClose ( vlc_object_t * );
  61 static int  Demux      ( input_thread_t * );
  62
  63 static int OpenDevice( input_thread_t *, string );
  64 static IBaseFilter *FindCaptureDevice( vlc_object_t *, string *,
  65                                        list<string> * );
  66 static bool ConnectFilters( IFilterGraph *p_graph, IBaseFilter *p_filter,
  67                             IPin *p_input_pin );
  68
  69 /*****************************************************************************
  70  * Module descriptior
  71  *****************************************************************************/
  72 #define CACHING_TEXT N_("Caching value in ms")
  73 #define CACHING_LONGTEXT N_( \
  74     "Allows you to modify the default caching value for directshow streams. " \
  75     "This value should be set in miliseconds units." )
  76
  77 vlc_module_begin();
  78     set_description( _("DirectShow input") );
  79     add_category_hint( N_("dshow"), NULL, VLC_TRUE );
  80     add_integer( "dshow-caching", DEFAULT_PTS_DELAY / 1000, NULL,
  81                  CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
  82     add_shortcut( "dshow" );
  83     set_capability( "access", 10 );
  84     set_callbacks( AccessOpen, AccessClose );
  85
  86     add_submodule();
  87     set_description( _("DirectShow demuxer") );
  88     add_shortcut( "dshow" );
  89     set_capability( "demux", 200 );
  90     set_callbacks( DemuxOpen, DemuxClose );
  91
  92 vlc_module_end();
  93
  94 /****************************************************************************
  95  * I. Access Part
  96  ****************************************************************************/
  97
  98 /*
  99  * header:
 100  *  fcc  ".dsh"
 101  *  u32    stream count
 102  *      fcc "auds"|"vids"       0
 103  *      fcc codec               4
 104  *      if vids
 105  *          u32 width           8
 106  *          u32 height          12
 107  *          u32 padding         16
 108  *      if auds
 109  *          u32 channels        12
 110  *          u32 samplerate      8
 111  *          u32 samplesize      16
 112  *
 113  * data:
 114  *  u32     stream number
 115  *  u32     data size
 116  *  u8      data
 117  */
 118
 119 static void SetDWBE( uint8_t *p, uint32_t dw )
 120 {
 121     p[0] = (dw >> 24)&0xff;
 122     p[1] = (dw >> 16)&0xff;
 123     p[2] = (dw >>  8)&0xff;
 124     p[3] = (dw      )&0xff;
 125 }
 126
 127 static void SetQWBE( uint8_t *p, uint64_t qw )
 128 {
 129     SetDWBE( p, (qw >> 32)&0xffffffff );
 130     SetDWBE( &p[4], qw&0xffffffff );
 131 }
 132
 133 /****************************************************************************
 134  * Access descriptor declaration
 135  ****************************************************************************/
 136 struct access_sys_t
 137 {
 138     IFilterGraph  *p_graph;
 139     IBaseFilter   *p_device_filter;
 140     CaptureFilter *p_capture_filter;
 141     IMediaControl *p_control;
 142
 143     AM_MEDIA_TYPE mt;
 144
 145     /* video */
 146     char *psz_video_device;
 147     int  i_fourcc;
 148     int  i_width;
 149     int  i_height;
 150     VIDEOINFOHEADER vid_header;
 151
 152     /* audio */
 153
 154     /* header */
 155     int     i_header_size;
 156     int     i_header_pos;
 157     uint8_t *p_header;      // at lest 8 bytes allocated
 158
 159     /* data */
 160     int     i_data_size;
 161     int     i_data_pos;
 162     uint8_t *p_data;
 163
 164     VLCMediaSample sample;
 165 };
 166
 167 /*****************************************************************************
 168  * Open: open direct show device
 169  *****************************************************************************/
 170 static int AccessOpen( vlc_object_t *p_this )
 171 {
 172     input_thread_t *p_input = (input_thread_t *)p_this;
 173     access_sys_t   *p_sys;
 174
 175 #if 0
 176     /* parse url and open device(s) */
 177     char *psz_dup, *psz_parser;
 178     psz_dup = strdup( p_input->psz_name );
 179     psz_parser = psz_dup;
 180
 181     while( *psz_parser && *psz_parser != ':' )
 182     {
 183         psz_parser++;
 184     }
 185 #endif
 186
 187     p_input->pf_read        = Read;
 188     p_input->pf_seek        = NULL;
 189     p_input->pf_set_area    = NULL;
 190     p_input->pf_set_program = NULL;
 191
 192     vlc_mutex_lock( &p_input->stream.stream_lock );
 193     p_input->stream.b_pace_control = 0;
 194     p_input->stream.b_seekable = 0;
 195     p_input->stream.p_selected_area->i_size = 0;
 196     p_input->stream.p_selected_area->i_tell = 0;
 197     p_input->stream.i_method = INPUT_METHOD_FILE;
 198     vlc_mutex_unlock( &p_input->stream.stream_lock );
 199
 200     /* Update default_pts to a suitable value for access */
 201     p_input->i_pts_delay = config_GetInt( p_input, "dshow-caching" ) * 1000;
 202
 203     /* Initialize OLE/COM */
 204     CoInitializeEx( 0, COINIT_APARTMENTTHREADED );
 205
 206     /* create access private data */
 207     p_input->p_access_data = p_sys =
 208         (access_sys_t *)malloc( sizeof( access_sys_t ) );
 209     memset( p_sys, 0, sizeof( access_sys_t ) );
 210
 211     /* Initialize some data */
 212     p_sys->psz_video_device = NULL;
 213     p_sys->sample.p_sample  = NULL;
 214     p_sys->i_data_size = 0;
 215     p_sys->i_data_pos = 0;
 216
 217     if( OpenDevice( p_input, p_input->psz_name ) != VLC_SUCCESS )
 218     {
 219         /* Uninitialize OLE/COM */
 220         CoUninitialize();
 221
 222         free( p_sys );
 223         return VLC_EGENERIC;
 224     }
 225
 226     return VLC_SUCCESS;
 227 }
 228
 229 /*****************************************************************************
 230  * AccessClose: close device
 231  *****************************************************************************/
 232 static void AccessClose( vlc_object_t *p_this )
 233 {
 234     input_thread_t *p_input = (input_thread_t *)p_this;
 235     access_sys_t    *p_sys  = p_input->p_access_data;
 236
 237     /* Stop capturing stuff */
 238     p_sys->p_control->Stop();
 239     p_sys->p_control->Release();
 240
 241     /* Remove filters from graph */
 242     //p_sys->p_graph->RemoveFilter( p_sys->p_capture_filter );
 243     //p_sys->p_graph->RemoveFilter( p_sys->p_device_filter );
 244
 245     /* Release objects */
 246     //p_sys->p_device_filter->Release();
 247     //p_sys->p_capture_filter->Release();
 248     //p_sys->p_graph->Release();
 249
 250     /* Uninitialize OLE/COM */
 251     CoUninitialize();
 252
 253     free( p_sys );
 254 }
 255
 256 /****************************************************************************
 257  * ConnectFilters
 258  ****************************************************************************/
 259 static bool ConnectFilters( IFilterGraph *p_graph, IBaseFilter *p_filter,
 260                             IPin *p_input_pin )
 261 {
 262     IEnumPins *p_enumpins;
 263     IPin *p_output_pin;
 264     ULONG i_fetched;
 265
 266     if( S_OK != p_filter->EnumPins( &p_enumpins ) ) return false;
 267
 268     while( S_OK == p_enumpins->Next( 1, &p_output_pin, &i_fetched ) )
 269     {
 270         if( S_OK == p_graph->ConnectDirect( p_output_pin, p_input_pin, 0 ) )
 271         {
 272             p_enumpins->Release();
 273             return true;
 274         }
 275     }
 276
 277     p_enumpins->Release();
 278     return false;
 279 }
 280
 281 static int OpenDevice( input_thread_t *p_input, string devicename )
 282 {
 283     access_sys_t *p_sys = p_input->p_access_data;
 284     list<string> list_devices;
 285
 286 #if 1
 287     // Enum devices and display their names
 288     FindCaptureDevice( (vlc_object_t *)p_input, NULL, &list_devices );
 289
 290     list<string>::iterator iter;
 291     for( iter = list_devices.begin(); iter != list_devices.end(); iter++ )
 292         msg_Err( p_input, "found device: %s", iter->c_str() );
 293 #endif
 294
 295     /* If no device name was specified, pick the 1st one */
 296     if( devicename.size() == 0 )
 297     {
 298         devicename = *list_devices.begin();
 299     }
 300
 301     // Use the system device enumerator and class enumerator to find
 302     // a video capture/preview device, such as a desktop USB video camera.
 303     p_sys->p_device_filter =
 304         FindCaptureDevice( (vlc_object_t *)p_input, &devicename, NULL );
 305
 306     if( p_sys->p_device_filter )
 307         msg_Dbg( p_input, "found device: %s", devicename.c_str() );
 308
 309     /* Build graph */
 310     CoCreateInstance( CLSID_FilterGraph, 0, CLSCTX_INPROC,
 311                       (REFIID)IID_IFilterGraph, (void **)&p_sys->p_graph );
 312
 313     p_sys->p_graph->QueryInterface( IID_IMediaControl,
 314                                     (void **)&p_sys->p_control );
 315
 316     /* Create and add our capture filter */
 317     p_sys->p_capture_filter = new CaptureFilter( p_input );
 318     p_sys->p_graph->AddFilter( p_sys->p_capture_filter, 0 );
 319
 320     /* Add the device filter to the graph (seems necessary with VfW before
 321      * accessing pin attributes). */
 322     p_sys->p_graph->AddFilter( p_sys->p_device_filter, 0 );
 323
 324     // Attempt to connect one of this device's capture output pins
 325     msg_Dbg( p_input, "connecting filters" );
 326     if( ConnectFilters( p_sys->p_graph, p_sys->p_device_filter,
 327                         p_sys->p_capture_filter->CustomGetPin() ) )
 328     {
 329         /* Success */
 330         int i_fourcc = VLC_FOURCC( ' ', ' ', ' ', ' ' );
 331         AM_MEDIA_TYPE *pmt = &p_sys->mt;
 332         p_sys->mt = p_sys->p_capture_filter->CustomGetPin()->
 333                         CustomGetMediaType();
 334
 335         if( pmt->majortype == MEDIATYPE_Video )
 336         {
 337             if( pmt->subtype == MEDIASUBTYPE_RGB8 )
 338               {
 339                 i_fourcc = VLC_FOURCC( 'G', 'R', 'E', 'Y' );
 340               }
 341             else if( pmt->subtype == MEDIASUBTYPE_RGB555 )
 342               {
 343                 i_fourcc = VLC_FOURCC( 'R', 'V', '1', '5' );
 344               }
 345             else if( pmt->subtype == MEDIASUBTYPE_RGB565 )
 346               {
 347                 i_fourcc = VLC_FOURCC( 'R', 'V', '1', '6' );
 348               }
 349             else if( pmt->subtype == MEDIASUBTYPE_RGB24 )
 350               {
 351                 i_fourcc = VLC_FOURCC( 'R', 'V', '2', '4' );
 352               }
 353             else if( pmt->subtype == MEDIASUBTYPE_RGB32 )
 354               {
 355                 i_fourcc = VLC_FOURCC( 'R', 'V', '3', '2' );
 356               }
 357             else if( pmt->subtype == MEDIASUBTYPE_ARGB32 )
 358               {
 359                 i_fourcc = VLC_FOURCC( 'R', 'G', 'B', 'A' );
 360               }
 361
 362             else if( pmt->subtype == MEDIASUBTYPE_YUYV )
 363               {
 364                 i_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', 'V' );
 365               }
 366             else if( pmt->subtype == MEDIASUBTYPE_Y411 )
 367               {
 368                 i_fourcc = VLC_FOURCC( 'I', '4', '1', 'N' );
 369               }
 370             else if( pmt->subtype == MEDIASUBTYPE_Y41P )
 371               {
 372                 i_fourcc = VLC_FOURCC( 'I', '4', '1', '1' );
 373               }
 374             else if( pmt->subtype == MEDIASUBTYPE_YUY2 )
 375               {
 376                 i_fourcc = VLC_FOURCC( 'Y', 'U', 'Y', '2' );
 377               }
 378             else if( pmt->subtype == MEDIASUBTYPE_YVYU )
 379               {
 380                 i_fourcc = VLC_FOURCC( 'Y', 'V', 'Y', 'U' );
 381               }
 382             else if( pmt->subtype == MEDIASUBTYPE_Y411 )
 383               {
 384                 i_fourcc = VLC_FOURCC( 'I', '4', '1', 'N' );
 385               }
 386             else if( pmt->subtype == MEDIASUBTYPE_YV12 )
 387               {
 388                 i_fourcc = VLC_FOURCC( 'Y', 'V', '1', '2' );
 389               }
 390
 391             p_sys->i_fourcc = i_fourcc;
 392             p_sys->vid_header = *(VIDEOINFOHEADER *)pmt->pbFormat;
 393         }
 394
 395         /* create header */
 396         p_sys->i_header_size = 8 + 20;
 397         p_sys->i_header_pos  = 0;
 398         p_sys->p_header      = (uint8_t *)malloc( p_sys->i_header_size );
 399
 400         memcpy(  &p_sys->p_header[0], ".dsh", 4 );
 401         SetDWBE( &p_sys->p_header[4], 1 );
 402         memcpy(  &p_sys->p_header[ 8], "vids", 4 );
 403         memcpy(  &p_sys->p_header[12], &i_fourcc, 4 );
 404         SetDWBE( &p_sys->p_header[16], p_sys->vid_header.bmiHeader.biWidth );
 405         SetDWBE( &p_sys->p_header[20], p_sys->vid_header.bmiHeader.biHeight );
 406         SetDWBE( &p_sys->p_header[24], 0 );
 407
 408         p_sys->p_control->Run();
 409
 410         // We're done
 411         return VLC_SUCCESS;
 412     }
 413
 414     /* Remove filters from graph */
 415     p_sys->p_graph->RemoveFilter( p_sys->p_device_filter );
 416     p_sys->p_graph->RemoveFilter( p_sys->p_capture_filter );
 417
 418     /* Release objects */
 419     p_sys->p_device_filter->Release();
 420     p_sys->p_capture_filter->Release();
 421     p_sys->p_control->Release();
 422     p_sys->p_graph->Release();
 423
 424     return VLC_EGENERIC;
 425 }
 426
 427 static IBaseFilter *
 428 FindCaptureDevice( vlc_object_t *p_this, string *p_devicename,
 429                    list<string> *p_listdevices )
 430 {
 431     IBaseFilter *pBaseFilter = NULL;
 432     IMoniker *pMoniker = NULL;
 433     ULONG lFetched;
 434     HRESULT hr;
 435
 436     /* Create the system device enumerator */
 437     ICreateDevEnum *pDevEnum = NULL;
 438
 439     hr = CoCreateInstance( CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC,
 440                            IID_ICreateDevEnum, (void **)&pDevEnum );
 441     if( FAILED(hr) )
 442     {
 443         msg_Err( p_this, "failed to create the device enumerator (0x%x)", hr);
 444         return NULL;
 445     }
 446
 447     /* Create an enumerator for the video capture devices */
 448     IEnumMoniker *pClassEnum = NULL;
 449     hr = pDevEnum->CreateClassEnumerator( CLSID_VideoInputDeviceCategory,
 450                                           &pClassEnum, 0 );
 451     if( FAILED(hr) )
 452     {
 453         msg_Err( p_this, "failed to create the class enumerator (0x%x)", hr );
 454         return NULL;
 455     }
 456
 457     /* If there are no enumerators for the requested type, then
 458      * CreateClassEnumerator will succeed, but pClassEnum will be NULL */
 459     if( pClassEnum == NULL )
 460     {
 461         msg_Err( p_this, "no video capture device was detected." );
 462         return NULL;
 463     }
 464
 465     /* Enumerate the devices */
 466
 467     /* Note that if the Next() call succeeds but there are no monikers,
 468      * it will return S_FALSE (which is not a failure). Therefore, we check
 469      * that the return code is S_OK instead of using SUCCEEDED() macro. */
 470
 471     while( pClassEnum->Next( 1, &pMoniker, &lFetched ) == S_OK )
 472     {
 473         /* Getting the property page to get the device name */
 474         IPropertyBag *pBag;
 475         hr = pMoniker->BindToStorage( 0, 0, IID_IPropertyBag,
 476                                       reinterpret_cast<PVOID *>( &pBag ) );
 477         if( SUCCEEDED(hr) )
 478         {
 479             VARIANT var;
 480             var.vt = VT_BSTR;
 481             hr = pBag->Read( L"FriendlyName", &var, NULL );
 482             pBag->Release();
 483             if( SUCCEEDED(hr) )
 484             {
 485                 int i_convert = ( lstrlenW( var.bstrVal ) + 1 ) * 2;
 486                 char *p_buf = (char *)alloca( i_convert ); p_buf[0] = 0;
 487                 WideCharToMultiByte( CP_ACP, 0, var.bstrVal, -1, p_buf,
 488                                      i_convert, NULL, NULL );
 489                 SysFreeString(var.bstrVal);
 490
 491                 if( p_listdevices ) p_listdevices->push_back( p_buf );
 492
 493                 if( p_devicename && *p_devicename == string(p_buf) )
 494                 {
 495                     /* Bind Moniker to a filter object */
 496                     hr = pMoniker->BindToObject( 0, 0, IID_IBaseFilter,
 497                              reinterpret_cast<LPVOID *>(&pBaseFilter) );
 498                     if( FAILED(hr) )
 499                     {
 500                         msg_Err( p_this, "couldn't bind moniker to filter "
 501                                  "object (0x%x)", hr );
 502                         return NULL;
 503                     }
 504                     return pBaseFilter;
 505                 }
 506             }
 507         }
 508     }
 509
 510     return NULL;
 511 }
 512
 513 /*****************************************************************************
 514  * Read: reads from the device into PES packets.
 515  *****************************************************************************
 516  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
 517  * bytes.
 518  *****************************************************************************/
 519 static int Read( input_thread_t * p_input, byte_t * p_buffer, size_t i_len )
 520 {
 521     access_sys_t *p_sys = p_input->p_access_data;
 522     int          i_data = 0;
 523
 524 #if 0
 525     msg_Info( p_input, "access read data_size %i, data_pos %i",
 526               p_sys->i_data_size, p_sys->i_data_pos );
 527 #endif
 528
 529     while( i_len > 0 )
 530     {
 531         /* First copy header if any */
 532         if( i_len > 0 && p_sys->i_header_pos < p_sys->i_header_size )
 533         {
 534             int i_copy;
 535
 536             i_copy = __MIN( p_sys->i_header_size -
 537                             p_sys->i_header_pos, (int)i_len );
 538             memcpy( p_buffer, &p_sys->p_header[p_sys->i_header_pos], i_copy );
 539             p_sys->i_header_pos += i_copy;
 540
 541             p_buffer += i_copy;
 542             i_len -= i_copy;
 543             i_data += i_copy;
 544         }
 545
 546         /* Then copy data */
 547         if( i_len > 0 && p_sys->i_data_pos < p_sys->i_data_size )
 548         {
 549             int i_copy;
 550
 551             i_copy = __MIN( p_sys->i_data_size -
 552                             p_sys->i_data_pos, (int)i_len );
 553
 554             memcpy( p_buffer, &p_sys->p_data[p_sys->i_data_pos], i_copy );
 555             p_sys->i_data_pos += i_copy;
 556
 557             p_buffer += i_copy;
 558             i_len -= i_copy;
 559             i_data += i_copy;
 560         }
 561
 562         /* The caller got what he wanted */
 563         if( i_len <= 0 )
 564         {
 565             return i_data;
 566         }
 567
 568         /* Read no more than one frame at a time, otherwise we kill latency */
 569         if( p_sys->i_data_size && i_data &&
 570             p_sys->i_data_pos == p_sys->i_data_size )
 571         {
 572             p_sys->i_data_pos = 0; p_sys->i_data_size = 0;
 573             return i_data;
 574         }
 575
 576         /* Start new audio/video frame */
 577         if( p_sys->sample.p_sample )
 578         {
 579           //p_sys->sample.p_sample->Release();
 580         }
 581
 582         if( p_sys->p_capture_filter->CustomGetPin()
 583                 ->CustomGetSample( &p_sys->sample ) == S_OK )
 584         {
 585             p_sys->i_data_pos = 0;
 586             p_sys->i_data_size = p_sys->sample.p_sample->GetActualDataLength();
 587             p_sys->sample.p_sample->GetPointer( &p_sys->p_data );
 588
 589             REFERENCE_TIME i_pts, i_end_date;
 590             HRESULT hr = p_sys->sample.p_sample
 591                              ->GetTime( &i_pts, &i_end_date );
 592             if( hr != VFW_S_NO_STOP_TIME && hr != S_OK ) i_pts = 0;
 593
 594             if( !i_pts )
 595             {
 596                 /* Use our data timestamp */
 597                 i_pts = p_sys->sample.i_timestamp;
 598             }
 599
 600 #if 0
 601             msg_Dbg( p_input, "Read() PTS: "I64Fd, i_pts );
 602 #endif
 603
 604             /* create pseudo header */
 605             p_sys->i_header_size = 16;
 606             p_sys->i_header_pos  = 0;
 607             SetDWBE( &p_sys->p_header[0], 0 /*i_stream*/ );
 608             SetDWBE( &p_sys->p_header[4], p_sys->i_data_size );
 609             SetQWBE( &p_sys->p_header[8], i_pts  * 9 / 1000 );
 610         }
 611         else msleep( 10000 );
 612     }
 613
 614     return i_data;
 615 }
 616
 617 /****************************************************************************
 618  * I. Demux Part
 619  ****************************************************************************/
 620 static int DemuxOpen( vlc_object_t *p_this )
 621 {
 622     input_thread_t *p_input = (input_thread_t *)p_this;
 623
 624     uint8_t        *p_peek;
 625     int            i_streams;
 626     int            i;
 627
 628     data_packet_t  *p_pk;
 629
 630     /* Initialize access plug-in structures. */
 631     if( p_input->i_mtu == 0 )
 632     {
 633         /* Improve speed. */
 634         p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE ;
 635     }
 636
 637     /* a little test to see if it's a v4l stream */
 638     if( input_Peek( p_input, &p_peek, 8 ) < 8 )
 639     {
 640         msg_Warn( p_input, "v4l plugin discarded (cannot peek)" );
 641         return( VLC_EGENERIC );
 642     }
 643
 644     if( strcmp( (const char *)p_peek, ".dsh" ) ||
 645         GetDWBE( &p_peek[4] ) <= 0 )
 646     {
 647         msg_Warn( p_input, "v4l plugin discarded (not a valid stream)" );
 648         return VLC_EGENERIC;
 649     }
 650
 651     /*  create one program */
 652     vlc_mutex_lock( &p_input->stream.stream_lock );
 653     if( input_InitStream( p_input, 0 ) == -1)
 654     {
 655         vlc_mutex_unlock( &p_input->stream.stream_lock );
 656         msg_Err( p_input, "cannot init stream" );
 657         return( VLC_EGENERIC );
 658     }
 659     if( input_AddProgram( p_input, 0, 0) == NULL )
 660     {
 661         vlc_mutex_unlock( &p_input->stream.stream_lock );
 662         msg_Err( p_input, "cannot add program" );
 663         return( VLC_EGENERIC );
 664     }
 665
 666     p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
 667     p_input->stream.i_mux_rate =  0;
 668
 669     i_streams = GetDWBE( &p_peek[4] );
 670     if( input_Peek( p_input, &p_peek, 8 + 20 * i_streams )
 671         < 8 + 20 * i_streams )
 672     {
 673         msg_Err( p_input, "v4l plugin discarded (cannot peek)" );
 674         return( VLC_EGENERIC );
 675     }
 676     p_peek += 8;
 677
 678     for( i = 0; i < i_streams; i++ )
 679     {
 680         es_descriptor_t *p_es;
 681
 682         if( !strncmp( (const char *)p_peek, "auds", 4 ) )
 683         {
 684 #define wf ((WAVEFORMATEX*)p_es->p_waveformatex)
 685             p_es = input_AddES( p_input, p_input->stream.pp_programs[0],
 686                                 i + 1, AUDIO_ES, NULL, 0 );
 687             p_es->i_stream_id   = i + 1;
 688             p_es->i_fourcc      =
 689                 VLC_FOURCC( p_peek[4], p_peek[5], p_peek[6], p_peek[7] );
 690
 691             p_es->p_waveformatex= malloc( sizeof( WAVEFORMATEX ) );
 692
 693             wf->wFormatTag      = 0;//WAVE_FORMAT_UNKNOWN;
 694             wf->nChannels       = GetDWBE( &p_peek[8] );
 695             wf->nSamplesPerSec  = GetDWBE( &p_peek[12] );
 696             wf->wBitsPerSample  = GetDWBE( &p_peek[16] );
 697             wf->nBlockAlign     = wf->wBitsPerSample * wf->nChannels / 8;
 698             wf->nAvgBytesPerSec = wf->nBlockAlign * wf->nSamplesPerSec;
 699             wf->cbSize          = 0;
 700
 701             msg_Dbg( p_input, "added new audio es %d channels %dHz",
 702                      wf->nChannels, wf->nSamplesPerSec );
 703
 704             input_SelectES( p_input, p_es );
 705 #undef wf
 706         }
 707         else if( !strncmp( (const char *)p_peek, "vids", 4 ) )
 708         {
 709 #define bih ((BITMAPINFOHEADER*)p_es->p_bitmapinfoheader)
 710             p_es = input_AddES( p_input, p_input->stream.pp_programs[0],
 711                                 i + 1, VIDEO_ES, NULL, 0 );
 712             p_es->i_stream_id   = i + 1;
 713             p_es->i_fourcc  =
 714                 VLC_FOURCC( p_peek[4], p_peek[5], p_peek[6], p_peek[7] );
 715
 716             p_es->p_bitmapinfoheader = malloc( sizeof( BITMAPINFOHEADER ) );
 717
 718             bih->biSize     = sizeof( BITMAPINFOHEADER );
 719             bih->biWidth    = GetDWBE( &p_peek[8] );
 720             bih->biHeight   = GetDWBE( &p_peek[12] );
 721             bih->biPlanes   = 0;
 722             bih->biBitCount = 0;
 723             bih->biCompression      = 0;
 724             bih->biSizeImage= 0;
 725             bih->biXPelsPerMeter    = 0;
 726             bih->biYPelsPerMeter    = 0;
 727             bih->biClrUsed  = 0;
 728             bih->biClrImportant     = 0;
 729
 730             msg_Dbg( p_input, "added new video es %4.4s %dx%d",
 731                      (char*)&p_es->i_fourcc, bih->biWidth, bih->biHeight );
 732
 733             input_SelectES( p_input, p_es );
 734 #undef bih
 735         }
 736
 737         p_peek += 20;
 738     }
 739
 740     p_input->stream.p_selected_program->b_is_ok = 1;
 741     vlc_mutex_unlock( &p_input->stream.stream_lock );
 742
 743     if( input_SplitBuffer( p_input, &p_pk, 8 + i_streams * 20 ) > 0 )
 744     {
 745         input_DeletePacket( p_input->p_method_data, p_pk );
 746     }
 747
 748     p_input->pf_demux = Demux;
 749     return VLC_SUCCESS;
 750 }
 751
 752 static void DemuxClose( vlc_object_t *p_this )
 753 {
 754     return;
 755 }
 756
 757 static int Demux( input_thread_t *p_input )
 758 {
 759     es_descriptor_t *p_es;
 760     pes_packet_t    *p_pes;
 761
 762     int i_stream;
 763     int i_size;
 764     uint8_t *p_peek;
 765     mtime_t i_pcr;
 766
 767     if( input_Peek( p_input, &p_peek, 16 ) < 16 )
 768     {
 769         msg_Warn( p_input, "cannot peek (EOF ?)" );
 770         return( 0 );
 771     }
 772
 773     i_stream = GetDWBE( &p_peek[0] );
 774     i_size   = GetDWBE( &p_peek[4] );
 775     i_pcr    = GetQWBE( &p_peek[8] );
 776
 777     //msg_Dbg( p_input, "stream=%d size=%d", i_stream, i_size );
 778     //p_es = input_FindES( p_input, i_stream );
 779
 780     p_es = p_input->stream.p_selected_program->pp_es[i_stream];
 781     if( !p_es )
 782     {
 783         msg_Err( p_input, "cannot find ES" );
 784     }
 785
 786     p_pes = input_NewPES( p_input->p_method_data );
 787     if( p_pes == NULL )
 788     {
 789         msg_Warn( p_input, "cannot allocate PES" );
 790         msleep( 1000 );
 791         return( 1 );
 792     }
 793     i_size += 16;
 794     while( i_size > 0 )
 795     {
 796         data_packet_t   *p_data;
 797         int i_read;
 798
 799         if( (i_read = input_SplitBuffer( p_input, &p_data,
 800                                          __MIN( i_size, 10000 ) ) ) <= 0 )
 801         {
 802             input_DeletePES( p_input->p_method_data, p_pes );
 803             return( 0 );
 804         }
 805         if( !p_pes->p_first )
 806         {
 807             p_pes->p_first = p_data;
 808             p_pes->i_nb_data = 1;
 809             p_pes->i_pes_size = i_read;
 810         }
 811         else
 812         {
 813             p_pes->p_last->p_next  = p_data;
 814             p_pes->i_nb_data++;
 815             p_pes->i_pes_size += i_read;
 816         }
 817         p_pes->p_last  = p_data;
 818         i_size -= i_read;
 819     }
 820
 821     p_pes->p_first->p_payload_start += 16;
 822     p_pes->i_pes_size               -= 16;
 823
 824     if( p_es && p_es->p_decoder_fifo )
 825     {
 826         /* Call the pace control. */
 827         input_ClockManageRef( p_input, p_input->stream.p_selected_program,
 828                               i_pcr );
 829
 830         p_pes->i_pts = p_pes->i_dts = i_pcr <= 0 ? 0 :
 831             input_ClockGetTS( p_input, p_input->stream.p_selected_program,
 832                               i_pcr );
 833
 834         input_DecodePES( p_es->p_decoder_fifo, p_pes );
 835     }
 836     else
 837     {
 838         input_DeletePES( p_input->p_method_data, p_pes );
 839     }
 840
 841     return 1;
 842 }