* modules/access/v4l/v4l.c:
[vlc.git] / modules / access / v4l / v4l.c
1 /*****************************************************************************
2  * v4l.c : Video4Linux input module for vlc
3  *****************************************************************************
4  * Copyright (C) 2002 VideoLAN
5  * $Id: v4l.c,v 1.19 2003/07/24 22:05:16 sam Exp $
6  *
7  * Author: Laurent Aimar <fenrir@via.ecp.fr>
8  *         Paul Forgey <paulf at aphrodite dot com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <stdlib.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #include <vlc/vlc.h>
33 #include <vlc/input.h>
34 #include <vlc/vout.h>
35 #include <codecs.h>
36 #include "encoder.h"
37
38 #include <sys/types.h>
39 #include <sys/stat.h>
40 #include <sys/ioctl.h>
41 #include <unistd.h>
42 #include <sys/mman.h>
43 #include <errno.h>
44
45 #include <fcntl.h>
46 #include <linux/videodev.h>
47 #include "videodev_mjpeg.h"
48
49 #include <sys/soundcard.h>
50
51 /*****************************************************************************
52  * Local prototypes
53  *****************************************************************************/
54 static int  AccessOpen  ( vlc_object_t * );
55 static void AccessClose ( vlc_object_t * );
56 static int  Read        ( input_thread_t *, byte_t *, size_t );
57
58 static int  DemuxOpen  ( vlc_object_t * );
59 static void DemuxClose ( vlc_object_t * );
60 static int  Demux      ( input_thread_t * );
61
62
63 /*****************************************************************************
64  * Module descriptior
65  *****************************************************************************/
66 #define CACHING_TEXT N_("Caching value in ms")
67 #define CACHING_LONGTEXT N_( \
68     "Allows you to modify the default caching value for v4l streams. This " \
69     "value should be set in miliseconds units." )
70
71 vlc_module_begin();
72     set_description( _("Video4Linux input") );
73     add_category_hint( N_("v4l"), NULL, VLC_TRUE );
74     add_integer( "v4l-caching", DEFAULT_PTS_DELAY / 1000, NULL,
75                  CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
76     add_shortcut( "v4l" );
77     set_capability( "access", 10 );
78     set_callbacks( AccessOpen, AccessClose );
79
80     add_submodule();
81         set_description( _("Video4Linux demuxer") );
82         add_shortcut( "v4l" );
83         set_capability( "demux", 200 );
84         set_callbacks( DemuxOpen, DemuxClose );
85 vlc_module_end();
86
87
88 /****************************************************************************
89  * I. Access Part
90  ****************************************************************************/
91 #define MJPEG_BUFFER_SIZE (256*1024)
92
93 struct quicktime_mjpeg_app1
94 {
95     uint32_t    i_reserved;             /* set to 0 */
96     uint32_t    i_tag;                  /* 'mjpg' */
97     uint32_t    i_field_size;           /* offset following EOI */
98     uint32_t    i_padded_field_size;    /* offset following EOI+pad */
99     uint32_t    i_next_field;           /* offset to next field */
100     uint32_t    i_DQT_offset;
101     uint32_t    i_DHT_offset;
102     uint32_t    i_SOF_offset;
103     uint32_t    i_SOS_offset;
104     uint32_t    i_data_offset;          /* following SOS marker data */
105 };
106
107 struct access_sys_t
108 {
109     char    *psz_video_device;
110     int     fd;
111
112     vlc_fourcc_t    i_codec;   // if i_codec != i_chroma then we need a compressor
113     video_encoder_t *p_encoder;
114     picture_t       pic;
115
116     int i_channel;
117     int i_audio;
118     int i_norm;
119     int i_tuner;
120     int i_frequency;
121     int i_chroma;
122     int i_width;
123     int i_height;
124
125     vlc_bool_t b_mjpeg;
126     int i_decimation;
127     int i_quality;
128
129     struct video_capability vid_cap;
130     struct video_mbuf       vid_mbuf;
131     struct mjpeg_requestbuffers mjpeg_buffers;
132
133     uint8_t *p_video_mmap;
134     int     i_frame_pos;
135
136     struct video_mmap   vid_mmap;
137     struct video_picture vid_picture;
138
139     uint8_t *p_video_frame;
140     int     i_video_frame_size;
141     int     i_video_frame_size_allocated;
142
143     char         *psz_adev;
144     int          fd_audio;
145     vlc_fourcc_t i_acodec_raw;
146     int          i_sample_rate;
147     vlc_bool_t   b_stereo;
148
149     uint8_t *p_audio_frame;
150     int     i_audio_frame_size;
151     int     i_audio_frame_size_allocated;
152
153     /* header */
154     int     i_header_size;
155     int     i_header_pos;
156     uint8_t *p_header;      // at lest 8 bytes allocated
157
158     /* data */
159     int     i_data_size;
160     int     i_data_pos;
161     uint8_t *p_data;        // never allocated
162
163 };
164
165 /*
166  * header:
167  *  fcc  ".v4l"
168  *  u32    stream count
169  *      fcc "auds"|"vids"       0
170  *      fcc codec               4
171  *      if vids
172  *          u32 width           8
173  *          u32 height          12
174  *          u32 padding         16
175  *      if auds
176  *          u32 channels        12
177  *          u32 samplerate      8
178  *          u32 samplesize      16
179  *
180  * data:
181  *  u32     stream number
182  *  u32     data size
183  *  u8      data
184  */
185
186 static void    SetDWBE( uint8_t *p, uint32_t dw )
187 {
188     p[0] = (dw >> 24)&0xff;
189     p[1] = (dw >> 16)&0xff;
190     p[2] = (dw >>  8)&0xff;
191     p[3] = (dw      )&0xff;
192 }
193
194 static void    SetQWBE( uint8_t *p, uint64_t qw )
195 {
196     SetDWBE( p,     (qw >> 32)&0xffffffff );
197     SetDWBE( &p[4], qw&0xffffffff);
198 }
199
200 static uint32_t GetDWBE( uint8_t *p_buff )
201 {
202     return( ( p_buff[0] << 24 ) + ( p_buff[1] << 16 ) +
203             ( p_buff[2] <<  8 ) + p_buff[3] );
204 }
205 static uint64_t GetQWBE( uint8_t *p )
206 {
207     return( ( (uint64_t)GetDWBE( p ) << 32) | (uint64_t)GetDWBE( &p[4] ) );
208 }
209
210 /*****************************************************************************
211  * Open: open device:
212  *****************************************************************************
213  *
214  * url: <video device>::::
215  *
216  *****************************************************************************/
217 static int AccessOpen( vlc_object_t *p_this )
218 {
219     input_thread_t *p_input = (input_thread_t *)p_this;
220     access_sys_t   *p_sys;
221     char           *psz_dup, *psz_parser;
222     struct mjpeg_params mjpeg;
223     int i;
224
225     struct video_channel    vid_channel;
226
227     /* create access private data */
228     p_sys = malloc( sizeof( access_sys_t ) );
229     memset( p_sys, 0, sizeof( access_sys_t ) );
230
231     p_sys->psz_video_device = NULL;
232     p_sys->fd               = -1;
233     p_sys->i_channel        = -1;
234     p_sys->i_audio          = -1;
235     p_sys->i_norm           = VIDEO_MODE_AUTO;    // auto
236     p_sys->i_tuner          = -1;
237     p_sys->i_frequency      = -1;
238     p_sys->i_width          = 0;
239     p_sys->i_height         = 0;
240
241     p_sys->b_mjpeg     = VLC_FALSE;
242     p_sys->i_decimation = 1;
243     p_sys->i_quality = 100;
244
245     p_sys->i_frame_pos = 0;
246
247     p_sys->i_codec          = VLC_FOURCC( 0, 0, 0, 0 );
248     p_sys->i_video_frame_size_allocated = 0;
249     p_sys->psz_adev         = NULL;
250     p_sys->fd_audio         = -1;
251     p_sys->i_sample_rate    = 44100;
252     p_sys->b_stereo         = VLC_TRUE;
253
254     p_sys->i_data_size = 0;
255     p_sys->i_data_pos  = 0;
256     p_sys->p_data      = NULL;
257
258     /* parse url and open device(s) */
259     psz_dup = strdup( p_input->psz_name );
260     psz_parser = psz_dup;
261
262     while( *psz_parser && *psz_parser != ':' )
263     {
264         psz_parser++;
265     }
266
267     if( *psz_parser == ':' )
268     {
269         /* read options */
270         for( ;; )
271         {
272             *psz_parser++ = '\0';
273             if( !strncmp( psz_parser, "channel=", strlen( "channel=" ) ) )
274             {
275                 p_sys->i_channel = strtol( psz_parser + strlen( "channel=" ),
276                                            &psz_parser, 0 );
277             }
278             else if( !strncmp( psz_parser, "norm=", strlen( "norm=" ) ) )
279             {
280                 psz_parser += strlen( "norm=" );
281                 if( !strncmp( psz_parser, "pal", strlen( "pal" ) ) )
282                 {
283                     p_sys->i_norm = VIDEO_MODE_PAL;
284                     psz_parser += strlen( "pal" );
285                 }
286                 else if( !strncmp( psz_parser, "ntsc", strlen( "ntsc" ) ) )
287                 {
288                     p_sys->i_norm = VIDEO_MODE_NTSC;
289                     psz_parser += strlen( "ntsc" );
290                 }
291                 else if( !strncmp( psz_parser, "secam", strlen( "secam" ) ) )
292                 {
293                     p_sys->i_norm = VIDEO_MODE_SECAM;
294                     psz_parser += strlen( "secam" );
295                 }
296                 else if( !strncmp( psz_parser, "auto", strlen( "auto" ) ) )
297                 {
298                     p_sys->i_norm = VIDEO_MODE_AUTO;
299                     psz_parser += strlen( "auto" );
300                 }
301                 else
302                 {
303                     p_sys->i_norm = strtol( psz_parser, &psz_parser, 0 );
304                 }
305             }
306             else if( !strncmp( psz_parser, "frequency=",
307                                strlen( "frequency=" ) ) )
308             {
309                 p_sys->i_frequency =
310                     strtol( psz_parser + strlen( "frequency=" ),
311                             &psz_parser, 0 );
312                 if( p_sys->i_frequency < 30000 )
313                 {
314                 msg_Warn( p_input, "v4l syntax has changed : 'frequency' is now channel frequency in kHz");
315                 }
316             }
317             else if( !strncmp( psz_parser, "audio=", strlen( "audio=" ) ) )
318             {
319                 p_sys->i_audio = strtol( psz_parser + strlen( "audio=" ),
320                                          &psz_parser, 0 );
321             }
322             else if( !strncmp( psz_parser, "size=", strlen( "size=" ) ) )
323             {
324                 psz_parser += strlen( "size=" );
325                 if( !strncmp( psz_parser, "subqcif", strlen( "subqcif" ) ) )
326                 {
327                     p_sys->i_width  = 128;
328                     p_sys->i_height = 96;
329                 }
330                 else if( !strncmp( psz_parser, "qsif", strlen( "qsif" ) ) )
331                 {
332                     p_sys->i_width  = 160;
333                     p_sys->i_height = 120;
334                 }
335                 else if( !strncmp( psz_parser, "qcif", strlen( "qcif" ) ) )
336                 {
337                     p_sys->i_width  = 176;
338                     p_sys->i_height = 144;
339                 }
340                 else if( !strncmp( psz_parser, "sif", strlen( "sif" ) ) )
341                 {
342                     p_sys->i_width  = 320;
343                     p_sys->i_height = 244;
344                 }
345                 else if( !strncmp( psz_parser, "cif", strlen( "cif" ) ) )
346                 {
347                     p_sys->i_width  = 352;
348                     p_sys->i_height = 288;
349                 }
350                 else if( !strncmp( psz_parser, "vga", strlen( "vga" ) ) )
351                 {
352                     p_sys->i_width  = 640;
353                     p_sys->i_height = 480;
354                 }
355                 else
356                 {
357                     /* widthxheight */
358                     p_sys->i_width = strtol( psz_parser, &psz_parser, 0 );
359                     if( *psz_parser == 'x' || *psz_parser == 'X')
360                     {
361                         p_sys->i_height = strtol( psz_parser + 1,
362                                                   &psz_parser, 0 );
363                     }
364                     msg_Dbg( p_input, "WxH %dx%d", p_sys->i_width,
365                              p_sys->i_height );
366                 }
367             }
368             else if( !strncmp( psz_parser, "tuner=", strlen( "tuner=" ) ) )
369             {
370                 p_sys->i_tuner = strtol( psz_parser + strlen( "tuner=" ),
371                                          &psz_parser, 0 );
372             }
373             else if( !strncmp( psz_parser, "codec=", strlen( "codec=" ) ) )
374             {
375                 psz_parser += strlen( "codec=" );
376                 if( !strncmp( psz_parser, "mpeg4", strlen( "mpeg4" ) ) )
377                 {
378                     p_sys->i_codec = VLC_FOURCC( 'm', 'p', '4', 'v' );
379                 }
380                 else if( !strncmp( psz_parser, "mpeg1", strlen( "mpeg1" ) ) )
381                 {
382                     p_sys->i_codec = VLC_FOURCC( 'm', 'p', '1', 'v' );
383                 }
384                 else
385                 {
386                     msg_Warn( p_input, "unknow codec" );
387                 }
388             }
389             else if( !strncmp( psz_parser, "adev=", strlen( "adev=" ) ) )
390             {
391                 int  i_len;
392
393                 psz_parser += strlen( "adev=" );
394                 if( strchr( psz_parser, ':' ) )
395                 {
396                     i_len = strchr( psz_parser, ':' ) - psz_parser;
397                 }
398                 else
399                 {
400                     i_len = strlen( psz_parser );
401                 }
402
403                 p_sys->psz_adev = strndup( psz_parser, i_len );
404
405                 psz_parser += i_len;
406             }
407             else if( !strncmp( psz_parser, "samplerate=",
408                                strlen( "samplerate=" ) ) )
409             {
410                 p_sys->i_sample_rate =
411                     strtol( psz_parser + strlen( "samplerate=" ),
412                             &psz_parser, 0 );
413             }
414             else if( !strncmp( psz_parser, "stereo", strlen( "stereo" ) ) )
415             {
416                 psz_parser += strlen( "stereo" );
417
418                 p_sys->b_stereo = VLC_TRUE;
419             }
420             else if( !strncmp( psz_parser, "mono", strlen( "mono" ) ) )
421             {
422                 psz_parser += strlen( "mono" );
423
424                 p_sys->b_stereo = VLC_FALSE;
425             }
426             else if( !strncmp( psz_parser, "mjpeg", strlen( "mjpeg" ) ) )
427             {
428                 psz_parser += strlen( "mjpeg" );
429
430                 p_sys->b_mjpeg = VLC_TRUE;
431             }
432             else if( !strncmp( psz_parser, "decimation=", 
433                         strlen( "decimation=" ) ) )
434             {
435                 p_sys->i_decimation = 
436                     strtol( psz_parser + strlen( "decimation=" ),
437                             &psz_parser, 0 );
438             }
439             else if( !strncmp( psz_parser, "quality=",
440                         strlen( "quality=" ) ) )
441             {
442                 p_sys->i_quality =
443                     strtol( psz_parser + strlen( "quality=" ),
444                             &psz_parser, 0 );
445             }
446             else
447             {
448                 msg_Warn( p_input, "unknown option" );
449             }
450
451             while( *psz_parser && *psz_parser != ':' )
452             {
453                 psz_parser++;
454             }
455
456             if( *psz_parser == '\0' )
457             {
458                 break;
459             }
460         }
461     }
462
463     if( *psz_dup )
464     {
465         p_sys->psz_video_device = strdup( psz_dup );
466     }
467     else
468     {
469         p_sys->psz_video_device = strdup( "/dev/video" );
470     }
471     msg_Dbg( p_input, "video device=`%s'", p_sys->psz_video_device );
472
473     if( p_sys->psz_adev && *p_sys->psz_adev == '\0' )
474     {
475         p_sys->psz_adev = strdup( "/dev/dsp" );
476     }
477     msg_Dbg( p_input, "audio device=`%s'", p_sys->psz_adev );
478
479
480
481     if( ( p_sys->fd = open( p_sys->psz_video_device, O_RDWR ) ) < 0 )
482     {
483         msg_Err( p_input, "cannot open device (%s)", strerror( errno ) );
484         goto failed;
485     }
486
487     if( ioctl( p_sys->fd, VIDIOCGCAP, &p_sys->vid_cap ) < 0 )
488     {
489         msg_Err( p_input, "cannot get capabilities (%s)", strerror( errno ) );
490         goto failed;
491     }
492
493     msg_Dbg( p_input,
494              "V4L device %s %d channels %d audios %d < w < %d %d < h < %d",
495              p_sys->vid_cap.name,
496              p_sys->vid_cap.channels,
497              p_sys->vid_cap.audios,
498              p_sys->vid_cap.minwidth,  p_sys->vid_cap.maxwidth,
499              p_sys->vid_cap.minheight, p_sys->vid_cap.maxheight );
500
501     if( p_sys->i_channel < 0 || p_sys->i_channel >= p_sys->vid_cap.channels )
502     {
503         msg_Dbg( p_input, "invalid channel, falling back on channel 0" );
504         p_sys->i_channel = 0;
505     }
506     if( p_sys->i_audio >= p_sys->vid_cap.audios )
507     {
508         msg_Dbg( p_input, "invalid audio, falling back with no audio" );
509         p_sys->i_audio = -1;
510     }
511
512     if( p_sys->i_width < p_sys->vid_cap.minwidth ||
513         p_sys->i_width > p_sys->vid_cap.maxwidth )
514     {
515         msg_Dbg( p_input, "invalid width %i", p_sys->i_width );
516         p_sys->i_width = 0;
517     }
518     if( p_sys->i_height < p_sys->vid_cap.minheight ||
519         p_sys->i_height > p_sys->vid_cap.maxheight )
520     {
521         msg_Dbg( p_input, "invalid height %i", p_sys->i_height );
522         p_sys->i_height = 0;
523     }
524
525     if( !( p_sys->vid_cap.type & VID_TYPE_CAPTURE ) )
526     {
527         msg_Err( p_input, "cannot grab" );
528         goto failed;
529     }
530
531     vid_channel.channel = p_sys->i_channel;
532     if( ioctl( p_sys->fd, VIDIOCGCHAN, &vid_channel ) < 0 )
533     {
534         msg_Err( p_input, "cannot get channel infos (%s)",
535                           strerror( errno ) );
536         goto failed;
537     }
538     msg_Dbg( p_input,
539              "setting channel %s(%d) %d tuners flags=0x%x type=0x%x norm=0x%x",
540              vid_channel.name,
541              vid_channel.channel,
542              vid_channel.tuners,
543              vid_channel.flags,
544              vid_channel.type,
545              vid_channel.norm );
546
547     if( p_sys->i_tuner >= vid_channel.tuners )
548     {
549         msg_Dbg( p_input, "invalid tuner, falling back on tuner 0" );
550         p_sys->i_tuner = 0;
551     }
552
553     vid_channel.norm = p_sys->i_norm;
554     if( ioctl( p_sys->fd, VIDIOCSCHAN, &vid_channel ) < 0 )
555     {
556         msg_Err( p_input, "cannot set channel (%s)", strerror( errno ) );
557         goto failed;
558     }
559
560     if( vid_channel.flags & VIDEO_VC_TUNER )
561     {
562
563         /* set tuner */
564 #if 0
565         struct video_tuner vid_tuner;
566         if( p_sys->i_tuner >= 0 )
567         {
568             vid_tuner.tuner = p_sys->i_tuner;
569             if( ioctl( p_sys->fd, VIDIOCGTUNER, &vid_tuner ) < 0 )
570             {
571                 msg_Err( p_input, "cannot get tuner (%s)", strerror( errno ) );
572                 goto failed;
573             }
574             msg_Dbg( p_input, "tuner %s low=%d high=%d, flags=0x%x "
575                      "mode=0x%x signal=0x%x",
576                      vid_tuner.name, vid_tuner.rangelow, vid_tuner.rangehigh,
577                      vid_tuner.flags, vid_tuner.mode, vid_tuner.signal );
578
579             msg_Dbg( p_input, "setting tuner %s (%d)",
580                      vid_tuner.name, vid_tuner.tuner );
581
582             //vid_tuner.mode = p_sys->i_norm; /* FIXME FIXME to be checked FIXME FIXME */
583             if( ioctl( p_sys->fd, VIDIOCSTUNER, &vid_tuner ) < 0 )
584             {
585                 msg_Err( p_input, "cannot set tuner (%s)", strerror( errno ) );
586                 goto failed;
587             }
588         }
589 #endif
590
591         // show a warning if frequency is < than 30000. User is certainly usint old syntax.
592         
593
594         /* set frequency */
595         if( p_sys->i_frequency >= 0 )
596         {
597             int driver_frequency = p_sys->i_frequency * 16 /1000;
598             if( ioctl( p_sys->fd, VIDIOCSFREQ, &driver_frequency ) < 0 )
599             {
600                 msg_Err( p_input, "cannot set frequency (%s)",
601                                   strerror( errno ) );
602                 goto failed;
603             }
604             msg_Dbg( p_input, "frequency %d (%d)", p_sys->i_frequency,
605                                                    driver_frequency );
606         }
607     }
608
609     /* set audio */
610     if( vid_channel.flags & VIDEO_VC_AUDIO )
611     {
612         struct video_audio      vid_audio;
613
614         /* XXX TODO volume, balance, ... */
615         if( p_sys->i_audio >= 0 )
616         {
617             vid_audio.audio = p_sys->i_audio;
618             if( ioctl( p_sys->fd, VIDIOCGAUDIO, &vid_audio ) < 0 )
619             {
620                 msg_Err( p_input, "cannot get audio (%s)", strerror( errno ) );
621                 goto failed;
622             }
623
624             /* unmute audio */
625             vid_audio.flags &= ~VIDEO_AUDIO_MUTE;
626
627             if( ioctl( p_sys->fd, VIDIOCSAUDIO, &vid_audio ) < 0 )
628             {
629                 msg_Err( p_input, "cannot set audio (%s)", strerror( errno ) );
630                 goto failed;
631             }
632         }
633
634     }
635
636     if( p_sys->psz_adev )
637     {
638         int    i_format;
639         if( ( p_sys->fd_audio = open( p_sys->psz_adev, O_RDONLY|O_NONBLOCK ) ) < 0 )
640         {
641             msg_Err( p_input, "cannot open audio device (%s)",
642                               strerror( errno ) );
643             goto failed;
644         }
645
646         i_format = AFMT_S16_LE;
647         if( ioctl( p_sys->fd_audio, SNDCTL_DSP_SETFMT, &i_format ) < 0
648             || i_format != AFMT_S16_LE )
649         {
650             msg_Err( p_input, "cannot set audio format (16b little endian) "
651                               "(%s)", strerror( errno ) );
652             goto failed;
653         }
654
655         if( ioctl( p_sys->fd_audio, SNDCTL_DSP_STEREO,
656                    &p_sys->b_stereo ) < 0 )
657         {
658             msg_Err( p_input, "cannot set audio channels count (%s)",
659                               strerror( errno ) );
660             goto failed;
661         }
662
663         if( ioctl( p_sys->fd_audio, SNDCTL_DSP_SPEED,
664                    &p_sys->i_sample_rate ) < 0 )
665         {
666             msg_Err( p_input, "cannot set audio sample rate (%s)",
667                               strerror( errno ) );
668             goto failed;
669         }
670
671         msg_Dbg( p_input,
672                  "adev=`%s' %s %dHz",
673                  p_sys->psz_adev,
674                  p_sys->b_stereo ? "stereo" : "mono",
675                  p_sys->i_sample_rate );
676
677         p_sys->i_audio_frame_size = 0;
678         p_sys->i_audio_frame_size_allocated = 6*1024;
679         p_sys->p_audio_frame =
680             malloc( p_sys->i_audio_frame_size_allocated );
681     }
682
683     /* establish basic params with input and norm before feeling width
684      * or height */
685     if( p_sys->b_mjpeg )
686     {
687         struct quicktime_mjpeg_app1 *p_app1;
688         int32_t i_offset;
689
690         if( ioctl( p_sys->fd, MJPIOC_G_PARAMS, &mjpeg ) < 0 )
691         {
692             msg_Err( p_input, "cannot get mjpeg params (%s)",
693                               strerror( errno ) );
694             goto failed;
695         }
696         mjpeg.input = p_sys->i_channel;
697         mjpeg.norm  = p_sys->i_norm;
698         mjpeg.decimation = p_sys->i_decimation;
699
700         if( p_sys->i_width )
701             mjpeg.img_width = p_sys->i_width / p_sys->i_decimation;
702         if( p_sys->i_height )
703             mjpeg.img_height = p_sys->i_height / p_sys->i_decimation;
704
705         /* establish Quicktime APP1 marker while we are here */
706         mjpeg.APPn = 1;
707         mjpeg.APP_len = 40;
708
709         /* aligned */
710         p_app1 = (struct quicktime_mjpeg_app1 *)mjpeg.APP_data;
711         p_app1->i_reserved = 0;
712         p_app1->i_tag = VLC_FOURCC( 'm','j','p','g' );
713         p_app1->i_field_size = 0;
714         p_app1->i_padded_field_size = 0;
715         p_app1->i_next_field = 0;
716         /* XXX WARNING XXX */
717         /* these's nothing magic about these values.  We are dangerously
718          * assuming the encoder card is encoding mjpeg-a and is not throwing
719          * in marker tags we aren't expecting.  It's bad enough we have to
720          * search through the jpeg output for every frame we grab just to
721          * find the first field's end marker, so we take this risk to boost
722          * performance.
723          * This is really something the driver could do for us because this
724          * does conform to standards outside of Apple Quicktime.
725          */
726         i_offset = 0x2e;
727         p_app1->i_DQT_offset = hton32( i_offset );
728         i_offset = 0xb4;
729         p_app1->i_DHT_offset = hton32( i_offset );
730         i_offset = 0x258;
731         p_app1->i_SOF_offset = hton32( i_offset );
732         i_offset = 0x26b;
733         p_app1->i_SOS_offset = hton32( i_offset );
734         i_offset = 0x279;
735         p_app1->i_data_offset = hton32( i_offset );
736
737         /* SOF and SOS aren't specified by the mjpeg API because they aren't
738          * optional.  They will be present in the output. */
739         mjpeg.jpeg_markers = JPEG_MARKER_DHT | JPEG_MARKER_DQT;
740
741         if( ioctl( p_sys->fd, MJPIOC_S_PARAMS, &mjpeg ) < 0 )
742         {
743             msg_Err( p_input, "cannot set mjpeg params (%s)",
744                               strerror( errno ) );
745             goto failed;
746         }
747
748         p_sys->i_width = mjpeg.img_width * mjpeg.HorDcm;
749         p_sys->i_height = mjpeg.img_height * mjpeg.VerDcm *
750             mjpeg.field_per_buff;
751     }
752
753     /* fix width/height */
754     if( !p_sys->b_mjpeg && ( p_sys->i_width == 0 || p_sys->i_height == 0 ) )
755     {
756         struct video_window vid_win;
757
758         if( ioctl( p_sys->fd, VIDIOCGWIN, &vid_win ) < 0 )
759         {
760             msg_Err( p_input, "cannot get win (%s)", strerror( errno ) );
761             goto failed;
762         }
763         p_sys->i_width  = vid_win.width;
764         p_sys->i_height = vid_win.height;
765
766         msg_Dbg( p_input, "will use %dx%d", p_sys->i_width, p_sys->i_height );
767     }
768
769     p_sys->p_video_frame = NULL;
770
771     if( p_sys->b_mjpeg )
772     {
773         p_sys->i_chroma = VLC_FOURCC( 'I','4','2','0' );
774     }
775     else
776     {
777         /* Find out video format used by device */
778         if( ioctl( p_sys->fd, VIDIOCGPICT, &p_sys->vid_picture ) == 0 )
779         {
780             int i_chroma;
781             struct video_picture vid_picture = p_sys->vid_picture;
782
783             /* Try to set the format to something easy to encode */
784             vid_picture.palette = VIDEO_PALETTE_YUV420P;
785             if( ioctl( p_sys->fd, VIDIOCSPICT, &vid_picture ) == 0 )
786             {
787                 p_sys->vid_picture = vid_picture;
788             }
789             else
790             {
791                 vid_picture.palette = VIDEO_PALETTE_YUV422P;
792                 if( ioctl( p_sys->fd, VIDIOCSPICT, &vid_picture ) == 0 )
793                 {
794                     p_sys->vid_picture = vid_picture;
795                 }
796             }
797
798             /* Find out final format */
799             switch( p_sys->vid_picture.palette )
800             {
801             case VIDEO_PALETTE_GREY:
802                 i_chroma = VLC_FOURCC( 'G', 'R', 'E', 'Y' );
803                 break;
804             case VIDEO_PALETTE_HI240:
805                 i_chroma = VLC_FOURCC( 'I', '2', '4', '0' );
806                 break;
807             case VIDEO_PALETTE_RGB565:
808                 i_chroma = VLC_FOURCC( 'R', 'V', '1', '6' );
809                 break;
810             case VIDEO_PALETTE_RGB555:
811                 i_chroma = VLC_FOURCC( 'R', 'V', '1', '5' );
812                 break;
813             case VIDEO_PALETTE_RGB24:
814                 i_chroma = VLC_FOURCC( 'R', 'V', '2', '4' );
815                 break;
816             case VIDEO_PALETTE_RGB32:
817                 i_chroma = VLC_FOURCC( 'R', 'V', '3', '2' );
818                 break;
819             case VIDEO_PALETTE_YUV422:
820                 i_chroma = VLC_FOURCC( 'I', '4', '2', '2' );
821                 break;
822             case VIDEO_PALETTE_YUYV:
823                 i_chroma = VLC_FOURCC( 'Y', 'U', 'Y', 'V' );
824                 break;
825             case VIDEO_PALETTE_UYVY:
826                 i_chroma = VLC_FOURCC( 'U', 'Y', 'V', 'Y' );
827                 break;
828             case VIDEO_PALETTE_YUV420:
829                 i_chroma = VLC_FOURCC( 'I', '4', '2', 'N' );
830                 break;
831             case VIDEO_PALETTE_YUV411:
832                 i_chroma = VLC_FOURCC( 'I', '4', '1', 'N' );
833                 break;
834             case VIDEO_PALETTE_RAW:
835                 i_chroma = VLC_FOURCC( 'G', 'R', 'A', 'W' );
836                 break;
837             case VIDEO_PALETTE_YUV422P:
838                 i_chroma = VLC_FOURCC( 'I', '4', '2', '2' );
839                 break;
840             case VIDEO_PALETTE_YUV420P:
841                 i_chroma = VLC_FOURCC( 'I', '4', '2', '0' );
842                 break;
843             case VIDEO_PALETTE_YUV411P:
844                 i_chroma = VLC_FOURCC( 'I', '4', '1', '1' );
845                 break;
846             }
847             p_sys->i_chroma = i_chroma;
848         }
849         else
850         {
851             msg_Err( p_input, "ioctl VIDIOCGPICT failed" );
852             goto failed;
853         }
854     }
855
856
857     if( p_sys->b_mjpeg )
858     {
859         int i;
860
861         p_sys->mjpeg_buffers.count = 8;
862         p_sys->mjpeg_buffers.size = MJPEG_BUFFER_SIZE;
863
864         if( ioctl( p_sys->fd, MJPIOC_REQBUFS, &p_sys->mjpeg_buffers ) < 0 )
865         {
866             msg_Err( p_input, "mmap unsupported" );
867             goto failed;
868         }
869
870         p_sys->p_video_mmap = mmap( 0,
871                 p_sys->mjpeg_buffers.size * p_sys->mjpeg_buffers.count,
872                 PROT_READ | PROT_WRITE, MAP_SHARED, p_sys->fd, 0 );
873         if( p_sys->p_video_mmap == MAP_FAILED )
874         {
875             msg_Err( p_input, "mmap failed" );
876             goto failed;
877         }
878
879         p_sys->i_codec  = VLC_FOURCC( 'm','j','p','g' );
880         p_sys->p_encoder = NULL;
881         p_sys->i_frame_pos = -1;
882
883         /* queue up all the frames */
884         for( i = 0; i < (int)p_sys->mjpeg_buffers.count; i++ )
885         {
886             if( ioctl( p_sys->fd, MJPIOC_QBUF_CAPT, &i ) < 0 )
887             {
888                 msg_Err( p_input, "unable to queue frame" );
889                 goto failed;
890             }
891         }
892     }
893     else
894     {
895         /* Fill in picture_t fields */
896         vout_InitPicture( VLC_OBJECT(p_input), &p_sys->pic,
897                           p_sys->i_width, p_sys->i_height, p_sys->i_chroma );
898         if( !p_sys->pic.i_planes )
899         {
900             msg_Err( p_input, "unsupported chroma" );
901             goto failed;
902         }
903         p_sys->i_video_frame_size = 0;
904         for( i = 0; i < p_sys->pic.i_planes; i++ )
905         {
906             p_sys->i_video_frame_size += p_sys->pic.p[i].i_lines *
907               p_sys->pic.p[i].i_visible_pitch;
908         }
909
910         msg_Dbg( p_input, "v4l device uses frame size: %i",
911                  p_sys->i_video_frame_size );
912         msg_Dbg( p_input, "v4l device uses chroma: %4.4s",
913                 (char*)&p_sys->i_chroma );
914
915         /* Allocate mmap buffer */
916         if( ioctl( p_sys->fd, VIDIOCGMBUF, &p_sys->vid_mbuf ) < 0 )
917         {
918             msg_Err( p_input, "mmap unsupported" );
919             goto failed;
920         }
921
922         p_sys->p_video_mmap = mmap( 0, p_sys->vid_mbuf.size,
923                                     PROT_READ|PROT_WRITE, MAP_SHARED,
924                                     p_sys->fd, 0 );
925         if( p_sys->p_video_mmap == MAP_FAILED )
926         {
927             /* FIXME -> normal read */
928             msg_Err( p_input, "mmap failed" );
929             goto failed;
930         }
931
932         /* init grabbing */
933         p_sys->vid_mmap.frame  = 0;
934         p_sys->vid_mmap.width  = p_sys->i_width;
935         p_sys->vid_mmap.height = p_sys->i_height;
936         p_sys->vid_mmap.format = p_sys->vid_picture.palette;
937         if( ioctl( p_sys->fd, VIDIOCMCAPTURE, &p_sys->vid_mmap ) < 0 )
938         {
939             msg_Warn( p_input, "%4.4s refused", (char*)&p_sys->i_chroma );
940             msg_Err( p_input, "chroma selection failed" );
941             goto failed;
942         }
943
944         /* encoder part */
945         if( p_sys->i_codec != VLC_FOURCC( 0, 0, 0, 0 ) )
946         {
947             msg_Dbg( p_input,
948                      "need a rencoder from %4.4s to %4.4s",
949                      (char*)&p_sys->i_chroma,
950                      (char*)&p_sys->i_codec );
951 #define p_enc p_sys->p_encoder
952             p_enc = vlc_object_create( p_input, sizeof( video_encoder_t ) );
953             p_enc->i_codec = p_sys->i_codec;
954             p_enc->i_chroma= p_sys->i_chroma;
955             p_enc->i_width = p_sys->i_width;
956             p_enc->i_height= p_sys->i_height;
957             p_enc->i_aspect= 0;
958
959
960             p_enc->p_module = module_Need( p_enc, "video encoder",
961                                            "$video-encoder" );
962             if( !p_enc->p_module )
963             {
964                 msg_Warn( p_input, "no suitable encoder to %4.4s",
965                           (char*)&p_enc->i_codec );
966                 vlc_object_destroy( p_enc );
967                 goto failed;
968             }
969
970             /* *** init the codec *** */
971             if( p_enc->pf_init( p_enc ) )
972             {
973                 msg_Err( p_input, "failed to initialize video encoder plugin" );
974                 vlc_object_destroy( p_enc );
975                 goto failed;
976             }
977
978             /* *** alloacted buffer *** */
979             if( p_enc->i_buffer_size <= 0 )
980             {
981               p_enc->i_buffer_size = 1024 * 1024;// * p_enc->i_width * p_enc->i_height;
982             }
983             p_sys->i_video_frame_size = p_enc->i_buffer_size;
984             p_sys->i_video_frame_size_allocated = p_enc->i_buffer_size;
985             if( !( p_sys->p_video_frame = malloc( p_enc->i_buffer_size ) ) )
986             {
987                 msg_Err( p_input, "out of memory" );
988                 goto failed;
989             }
990 #undef p_enc
991         }
992         else
993         {
994             p_sys->i_codec  = p_sys->i_chroma;
995             p_sys->p_encoder = NULL;
996         }
997     }
998
999     p_input->pf_read        = Read;
1000     p_input->pf_seek        = NULL;
1001     p_input->pf_set_area    = NULL;
1002     p_input->pf_set_program = NULL;
1003
1004     p_input->p_access_data  = p_sys;
1005
1006     vlc_mutex_lock( &p_input->stream.stream_lock );
1007     p_input->stream.b_pace_control = 0;
1008     p_input->stream.b_seekable = 0;
1009     p_input->stream.p_selected_area->i_size = 0;
1010     p_input->stream.p_selected_area->i_tell = 0;
1011     p_input->stream.i_method = INPUT_METHOD_FILE;
1012     vlc_mutex_unlock( &p_input->stream.stream_lock );
1013
1014     /* Update default_pts to a suitable value for access */
1015     p_input->i_pts_delay = config_GetInt( p_input, "v4l-caching" ) * 1000;
1016
1017     msg_Info( p_input, "v4l grabbing started" );
1018
1019     /* create header */
1020     p_sys->i_header_size = 8 + 20;
1021     p_sys->i_header_pos  = 0;
1022     p_sys->p_header      = malloc( p_sys->i_header_size );
1023
1024     memcpy(  &p_sys->p_header[0], ".v4l", 4 );
1025     SetDWBE( &p_sys->p_header[4], 1 );
1026
1027     memcpy(  &p_sys->p_header[ 8], "vids", 4 );
1028     memcpy(  &p_sys->p_header[12], &p_sys->i_codec, 4 );
1029     SetDWBE( &p_sys->p_header[16], p_sys->i_width );
1030     SetDWBE( &p_sys->p_header[20], p_sys->i_height );
1031     SetDWBE( &p_sys->p_header[24], 0 );
1032
1033     if( p_sys->fd_audio > 0 )
1034     {
1035         p_sys->i_header_size += 20;
1036         p_sys->p_header = realloc( p_sys->p_header, p_sys->i_header_size );
1037
1038         SetDWBE( &p_sys->p_header[4], 2 );
1039
1040         memcpy(  &p_sys->p_header[28], "auds", 4 );
1041         memcpy(  &p_sys->p_header[32], "araw", 4 );
1042         SetDWBE( &p_sys->p_header[36], p_sys->b_stereo ? 2 : 1 );
1043         SetDWBE( &p_sys->p_header[40], p_sys->i_sample_rate );
1044         SetDWBE( &p_sys->p_header[44], 16 );
1045     }
1046     return VLC_SUCCESS;
1047
1048 failed:
1049     free( p_sys->psz_video_device );
1050     if( p_sys->fd >= 0 )
1051     {
1052         close( p_sys->fd );
1053     }
1054     free( p_sys );
1055     return VLC_EGENERIC;
1056 }
1057
1058 /*****************************************************************************
1059  * V4lClose: close device
1060  *****************************************************************************/
1061 static void AccessClose( vlc_object_t *p_this )
1062 {
1063     input_thread_t  *p_input = (input_thread_t *)p_this;
1064     access_sys_t    *p_sys   = p_input->p_access_data;
1065
1066     msg_Info( p_input, "v4l grabbing stoped" );
1067
1068     if( p_sys->b_mjpeg )
1069     {
1070         int i_noframe = -1;
1071         ioctl( p_sys->fd, MJPIOC_QBUF_CAPT, &i_noframe );
1072     }
1073
1074     free( p_sys->psz_video_device );
1075     close( p_sys->fd );
1076     if( p_sys->p_video_mmap && p_sys->p_video_mmap != MAP_FAILED )
1077     {
1078         if( p_sys->b_mjpeg )
1079             munmap( p_sys->p_video_mmap, p_sys->mjpeg_buffers.size *
1080                     p_sys->mjpeg_buffers.count );
1081         else
1082             munmap( p_sys->p_video_mmap, p_sys->vid_mbuf.size );
1083     }
1084     if( p_sys->fd_audio >= 0 )
1085     {
1086         close( p_sys->fd_audio );
1087     }
1088
1089     if( p_sys->p_encoder )
1090     {
1091         p_sys->p_encoder->pf_end( p_sys->p_encoder );
1092
1093         module_Unneed( p_sys->p_encoder,
1094                        p_sys->p_encoder->p_module );
1095         vlc_object_destroy( p_sys->p_encoder );
1096
1097         free( p_sys->p_video_frame );
1098     }
1099     free( p_sys );
1100 }
1101
1102 static int GrabAudio( input_thread_t * p_input,
1103                       uint8_t **pp_data,
1104                       int      *pi_data,
1105                       mtime_t  *pi_pts )
1106 {
1107     access_sys_t    *p_sys   = p_input->p_access_data;
1108     struct audio_buf_info buf_info;
1109     int i_read;
1110     int i_correct;
1111
1112     i_read = read( p_sys->fd_audio, p_sys->p_audio_frame,
1113                    p_sys->i_audio_frame_size_allocated );
1114
1115     if( i_read <= 0 )
1116     {
1117         return VLC_EGENERIC;
1118     }
1119
1120     p_sys->i_audio_frame_size = i_read;
1121
1122     /* from vls : correct the date because of kernel buffering */
1123     i_correct = i_read;
1124     if( ioctl( p_sys->fd_audio, SNDCTL_DSP_GETISPACE, &buf_info ) == 0 )
1125     {
1126         i_correct += buf_info.bytes;
1127     }
1128
1129
1130     *pp_data = p_sys->p_audio_frame;
1131     *pi_data = p_sys->i_audio_frame_size;
1132     *pi_pts  = mdate() - (mtime_t)1000000 * (mtime_t)i_correct /
1133                          2 / ( p_sys->b_stereo ? 2 : 1) / p_sys->i_sample_rate;
1134     return VLC_SUCCESS;
1135 }
1136
1137 static uint8_t *GrabCapture( input_thread_t *p_input )
1138 {
1139     access_sys_t *p_sys = p_input->p_access_data;
1140     p_sys->vid_mmap.frame = ( p_sys->i_frame_pos + 1 ) %
1141                             p_sys->vid_mbuf.frames;
1142     for( ;; )
1143     {
1144         if( ioctl( p_sys->fd, VIDIOCMCAPTURE, &p_sys->vid_mmap ) >= 0 )
1145         {
1146             break;
1147         }
1148
1149         if( errno != EAGAIN )
1150         {
1151             msg_Err( p_input, "failed while grabbing new frame" );
1152             return( NULL );
1153         }
1154         msg_Dbg( p_input, "another try ?" );
1155     }
1156
1157     //msg_Warn( p_input, "grab a new frame" );
1158
1159     while( ioctl(p_sys->fd, VIDIOCSYNC, &p_sys->i_frame_pos) < 0 &&
1160            ( errno == EAGAIN || errno == EINTR ) );
1161
1162     p_sys->i_frame_pos = p_sys->vid_mmap.frame;
1163     /* leave i_video_frame_size alone */
1164     return p_sys->p_video_mmap + p_sys->vid_mbuf.offsets[p_sys->i_frame_pos];
1165 }
1166
1167 static uint8_t *GrabMJPEG( input_thread_t *p_input )
1168 {
1169     access_sys_t *p_sys = p_input->p_access_data;
1170     struct mjpeg_sync sync;
1171     uint8_t *p_frame, *p_field, *p;
1172     uint16_t tag;
1173     uint32_t i_size;
1174     struct quicktime_mjpeg_app1 *p_app1 = NULL;
1175
1176     /* re-queue the last frame we sync'd */
1177     if( p_sys->i_frame_pos != -1 )
1178         while( ioctl( p_sys->fd, MJPIOC_QBUF_CAPT, &p_sys->i_frame_pos ) < 0 &&
1179                 ( errno == EAGAIN || errno == EINTR ) );
1180
1181     /* sync on the next frame */
1182     while( ioctl( p_sys->fd, MJPIOC_SYNC, &sync ) < 0 &&
1183             ( errno == EAGAIN || errno == EINTR ) );
1184
1185     p_sys->i_frame_pos = sync.frame;
1186     p_frame = p_sys->p_video_mmap + p_sys->mjpeg_buffers.size * sync.frame;
1187
1188     /* p_frame now points to the data.  fix up the Quicktime APP1 marker */
1189     tag = 0xffd9;
1190     tag = hton16( tag );
1191     p_field = p_frame;
1192
1193     /* look for EOI */
1194     p = memmem( p_field, sync.length, &tag, 2 );
1195
1196     if( p )
1197     {
1198         p += 2; /* data immediately following EOI */
1199         /* UNALIGNED! */
1200         p_app1 = (struct quicktime_mjpeg_app1 *)(p_field + 6);
1201
1202         i_size = ((uint32_t)(p - p_field));
1203         i_size = hton32( i_size );
1204         memcpy( &p_app1->i_field_size, &i_size, 4 );
1205
1206         while( *p == 0xff && *(p+1) == 0xff )
1207             p++;
1208
1209         i_size = ((uint32_t)(p - p_field));
1210         i_size = hton32( i_size );
1211         memcpy( &p_app1->i_padded_field_size, &i_size, 4 );
1212     }
1213
1214     tag = 0xffd8;
1215     tag = hton16( tag );
1216     p_field = memmem( p, sync.length - (size_t)(p - p_frame), &tag, 2 );
1217
1218     if( p_field )
1219     {
1220         i_size = (uint32_t)(p_field - p_frame);
1221         i_size = hton32( i_size );
1222         memcpy( &p_app1->i_next_field, &i_size, 4 );
1223
1224         /* UNALIGNED! */
1225         p_app1 = (struct quicktime_mjpeg_app1 *)(p_field + 6);
1226         tag = 0xffd9;
1227         tag = hton16( tag );
1228         p = memmem( p_field, sync.length - (size_t)(p_field - p_frame), 
1229                 &tag, 2 );
1230
1231         if( !p )
1232         {
1233             /* sometimes the second field doesn't have the EOI.  just put it
1234              * there
1235              */
1236             p = p_frame + sync.length;
1237             memcpy( p, &tag, 2 );
1238             sync.length += 2;
1239         }
1240
1241         p += 2;
1242         i_size = (uint32_t)(p - p_field);
1243         i_size = hton32( i_size );
1244         memcpy( &p_app1->i_field_size, &i_size, 4 );
1245         i_size = (uint32_t)(sync.length - (uint32_t)(p_field - p_frame));
1246         i_size = hton32( i_size );
1247         memcpy( &p_app1->i_padded_field_size, &i_size, 4 );
1248     }
1249
1250     p_sys->i_video_frame_size = sync.length;
1251     return p_frame;
1252 }
1253
1254 static int GrabVideo( input_thread_t * p_input,
1255                       uint8_t **pp_data,
1256                       int *pi_data,
1257                       mtime_t  *pi_pts )
1258 {
1259     access_sys_t *p_sys   = p_input->p_access_data;
1260     uint8_t *p_frame;
1261
1262     if( p_sys->b_mjpeg )
1263         p_frame = GrabMJPEG( p_input );
1264     else
1265         p_frame = GrabCapture( p_input );
1266
1267     if( !p_frame )
1268         return -1;
1269
1270     if( p_sys->p_encoder )
1271     {
1272         int i;
1273         /* notice we can't get here if we are using mjpeg */
1274
1275         p_sys->pic.p[0].p_pixels = p_frame;
1276
1277         for( i = 1; i < p_sys->pic.i_planes; i++ )
1278         {
1279             p_sys->pic.p[i].p_pixels = p_sys->pic.p[i-1].p_pixels +
1280                 p_sys->pic.p[i-1].i_pitch * p_sys->pic.p[i-1].i_lines;
1281         }
1282
1283         p_sys->i_video_frame_size = p_sys->i_video_frame_size_allocated;
1284         p_sys->p_encoder->pf_encode( p_sys->p_encoder, &p_sys->pic,
1285                                      p_sys->p_video_frame,
1286                                      &p_sys->i_video_frame_size );
1287     }
1288     else
1289     {
1290         p_sys->p_video_frame = p_frame;
1291     }
1292
1293     *pp_data = p_sys->p_video_frame;
1294     *pi_data = p_sys->i_video_frame_size;
1295     *pi_pts  = mdate();
1296     return VLC_SUCCESS;
1297 }
1298
1299 /*****************************************************************************
1300  * Read: reads from the device into PES packets.
1301  *****************************************************************************
1302  * Returns -1 in case of error, 0 in case of EOF, otherwise the number of
1303  * bytes.
1304  *****************************************************************************/
1305 static int Read( input_thread_t * p_input, byte_t * p_buffer, size_t i_len )
1306 {
1307     access_sys_t *p_sys = p_input->p_access_data;
1308     int          i_data = 0;
1309     int          i_stream;
1310     mtime_t      i_pts;
1311
1312     //msg_Info( p_input, "access read data_size %i, data_pos %i",
1313                 //p_sys->i_data_size, p_sys->i_data_pos );
1314     while( i_len > 0 )
1315     {
1316         /* First copy header if any */
1317         if( i_len > 0 && p_sys->i_header_pos < p_sys->i_header_size )
1318         {
1319             int i_copy;
1320
1321             i_copy = __MIN( p_sys->i_header_size - p_sys->i_header_pos,
1322                             (int)i_len );
1323             memcpy( p_buffer, &p_sys->p_header[p_sys->i_header_pos], i_copy );
1324             p_sys->i_header_pos += i_copy;
1325
1326             p_buffer += i_copy;
1327             i_len -= i_copy;
1328             i_data += i_copy;
1329         }
1330
1331         /* then data */
1332         if( i_len > 0 && p_sys->i_data_pos < p_sys->i_data_size )
1333         {
1334             int i_copy;
1335
1336             i_copy = __MIN( p_sys->i_data_size - p_sys->i_data_pos,
1337                             (int)i_len );
1338
1339             memcpy( p_buffer, &p_sys->p_data[p_sys->i_data_pos], i_copy );
1340             p_sys->i_data_pos += i_copy;
1341
1342             p_buffer += i_copy;
1343             i_len -= i_copy;
1344             i_data += i_copy;
1345         }
1346
1347         /* The caller got what he wanted */
1348         if( i_len <= 0 )
1349         {
1350             return( i_data );
1351         }
1352
1353         /* Read no more than one frame at a time.
1354          * That kills latency, especially for encoded v4l streams */
1355         if( p_sys->i_data_size && p_sys->i_data_pos == p_sys->i_data_size )
1356         {
1357             p_sys->i_data_pos = 0; p_sys->i_data_size = 0;
1358             return( i_data );
1359         }
1360
1361         /* re fill data by grabbing audio/video */
1362         p_sys->i_data_pos = 0;
1363
1364         /* try grabbing audio frames */
1365         i_stream = 1;
1366         if( p_sys->fd_audio < 0 ||
1367             GrabAudio( p_input, &p_sys->p_data, &p_sys->i_data_size, &i_pts ) )
1368         {
1369             /* and then get video frame if no audio */
1370             i_stream = 0;
1371             if( GrabVideo( p_input, &p_sys->p_data, &p_sys->i_data_size, &i_pts ) )
1372             {
1373                 return -1;
1374             }
1375         }
1376
1377         /* create pseudo header */
1378         p_sys->i_header_size = 16;
1379         p_sys->i_header_pos  = 0;
1380         SetDWBE( &p_sys->p_header[0], i_stream );
1381         SetDWBE( &p_sys->p_header[4], p_sys->i_data_size );
1382         SetQWBE( &p_sys->p_header[8], i_pts );
1383     }
1384
1385     return i_data;
1386 }
1387
1388 /****************************************************************************
1389  * I. Demux Part
1390  ****************************************************************************/
1391 #define MAX_PACKETS_IN_FIFO 3
1392
1393 static int DemuxOpen( vlc_object_t *p_this )
1394 {
1395     input_thread_t *p_input = (input_thread_t *)p_this;
1396     //demux_sys_t    *p_sys;
1397
1398     uint8_t        *p_peek;
1399     int            i_streams;
1400     int            i;
1401
1402     data_packet_t  *p_pk;
1403
1404     /* Initialize access plug-in structures. */
1405     if( p_input->i_mtu == 0 )
1406     {
1407         /* Improve speed. */
1408         p_input->i_bufsize = INPUT_DEFAULT_BUFSIZE ;
1409     }
1410
1411     /* a little test to see if it's a v4l stream */
1412     if( input_Peek( p_input, &p_peek, 8 ) < 8 )
1413     {
1414         msg_Warn( p_input, "v4l plugin discarded (cannot peek)" );
1415         return( VLC_EGENERIC );
1416     }
1417
1418     if( strncmp( p_peek, ".v4l", 4 ) || GetDWBE( &p_peek[4] ) <= 0 )
1419     {
1420         msg_Warn( p_input, "v4l plugin discarded (not a valid stream)" );
1421         return VLC_EGENERIC;
1422     }
1423
1424     /*  create one program */
1425     vlc_mutex_lock( &p_input->stream.stream_lock );
1426     if( input_InitStream( p_input, 0 ) == -1)
1427     {
1428         vlc_mutex_unlock( &p_input->stream.stream_lock );
1429         msg_Err( p_input, "cannot init stream" );
1430         return( VLC_EGENERIC );
1431     }
1432     if( input_AddProgram( p_input, 0, 0) == NULL )
1433     {
1434         vlc_mutex_unlock( &p_input->stream.stream_lock );
1435         msg_Err( p_input, "cannot add program" );
1436         return( VLC_EGENERIC );
1437     }
1438
1439     p_input->stream.p_selected_program = p_input->stream.pp_programs[0];
1440     p_input->stream.i_mux_rate =  0;
1441
1442     i_streams = GetDWBE( &p_peek[4] );
1443     if( input_Peek( p_input, &p_peek, 8 + 20 * i_streams )
1444         < 8 + 20 * i_streams )
1445     {
1446         msg_Err( p_input, "v4l plugin discarded (cannot peek)" );
1447         return( VLC_EGENERIC );
1448     }
1449     p_peek += 8;
1450
1451     for( i = 0; i < i_streams; i++ )
1452     {
1453         es_descriptor_t *p_es;
1454
1455         if( !strncmp( p_peek, "auds", 4 ) )
1456         {
1457 #define wf ((WAVEFORMATEX*)p_es->p_waveformatex)
1458             p_es = input_AddES( p_input, p_input->stream.pp_programs[0],
1459                                 i + 1, AUDIO_ES, NULL, 0 );
1460             p_es->i_stream_id   = i + 1;
1461             p_es->i_fourcc      =
1462                 VLC_FOURCC( p_peek[4], p_peek[5], p_peek[6], p_peek[7] );
1463
1464             p_es->p_waveformatex= malloc( sizeof( WAVEFORMATEX ) );
1465
1466             wf->wFormatTag      = WAVE_FORMAT_UNKNOWN;
1467             wf->nChannels       = GetDWBE( &p_peek[8] );
1468             wf->nSamplesPerSec  = GetDWBE( &p_peek[12] );
1469             wf->wBitsPerSample  = GetDWBE( &p_peek[16] );
1470             wf->nBlockAlign     = wf->wBitsPerSample * wf->nChannels / 8;
1471             wf->nAvgBytesPerSec = wf->nBlockAlign * wf->nSamplesPerSec;
1472             wf->cbSize          = 0;
1473
1474             msg_Dbg( p_input, "added new audio es %d channels %dHz",
1475                      wf->nChannels, wf->nSamplesPerSec );
1476
1477             input_SelectES( p_input, p_es );
1478 #undef wf
1479         }
1480         else if( !strncmp( p_peek, "vids", 4 ) )
1481         {
1482 #define bih ((BITMAPINFOHEADER*)p_es->p_bitmapinfoheader)
1483             p_es = input_AddES( p_input, p_input->stream.pp_programs[0],
1484                                 i + 1, VIDEO_ES, NULL, 0 );
1485             p_es->i_stream_id   = i + 1;
1486             p_es->i_fourcc  =
1487                 VLC_FOURCC( p_peek[4], p_peek[5], p_peek[6], p_peek[7] );
1488
1489             p_es->p_bitmapinfoheader = malloc( sizeof( BITMAPINFOHEADER ) );
1490
1491             bih->biSize     = sizeof( BITMAPINFOHEADER );
1492             bih->biWidth    = GetDWBE( &p_peek[8] );
1493             bih->biHeight   = GetDWBE( &p_peek[12] );
1494             bih->biPlanes   = 0;
1495             bih->biBitCount = 0;
1496             bih->biCompression      = 0;
1497             bih->biSizeImage= 0;
1498             bih->biXPelsPerMeter    = 0;
1499             bih->biYPelsPerMeter    = 0;
1500             bih->biClrUsed  = 0;
1501             bih->biClrImportant     = 0;
1502
1503             msg_Dbg( p_input, "added new video es %4.4s %dx%d",
1504                      (char*)&p_es->i_fourcc, bih->biWidth, bih->biHeight );
1505
1506             input_SelectES( p_input, p_es );
1507 #undef bih
1508         }
1509
1510         p_peek += 20;
1511     }
1512
1513     p_input->stream.p_selected_program->b_is_ok = 1;
1514     vlc_mutex_unlock( &p_input->stream.stream_lock );
1515
1516     if( input_SplitBuffer( p_input, &p_pk, 8 + i_streams * 20 ) > 0 )
1517     {
1518         input_DeletePacket( p_input->p_method_data, p_pk );
1519     }
1520
1521     p_input->pf_demux = Demux;
1522     return VLC_SUCCESS;
1523 }
1524
1525 static void DemuxClose( vlc_object_t *p_this )
1526 {
1527     return;
1528 }
1529
1530 static int Demux( input_thread_t *p_input )
1531 {
1532     es_descriptor_t *p_es;
1533     pes_packet_t    *p_pes;
1534
1535     int i_stream;
1536     int i_size;
1537     uint8_t *p_peek;
1538     mtime_t        i_pts;
1539
1540     if( input_Peek( p_input, &p_peek, 16 ) < 16 )
1541     {
1542         msg_Warn( p_input, "cannot peek (EOF ?)" );
1543         return( 0 );
1544     }
1545
1546     i_stream = GetDWBE( &p_peek[0] );
1547     i_size   = GetDWBE( &p_peek[4] );
1548     i_pts    = GetQWBE( &p_peek[8] );
1549
1550     //msg_Dbg( p_input, "stream=%d size=%d", i_stream, i_size );
1551 //    p_es = input_FindES( p_input, i_stream );
1552     p_es = p_input->stream.p_selected_program->pp_es[i_stream];
1553     if( !p_es )
1554     {
1555         msg_Err( p_input, "cannot find ES" );
1556     }
1557
1558     p_pes = input_NewPES( p_input->p_method_data );
1559     if( p_pes == NULL )
1560     {
1561         msg_Warn( p_input, "cannot allocate PES" );
1562         msleep( 1000 );
1563         return( 1 );
1564     }
1565     i_size += 16;
1566     while( i_size > 0 )
1567     {
1568         data_packet_t   *p_data;
1569         int i_read;
1570
1571         if( (i_read = input_SplitBuffer( p_input, &p_data,
1572                                          __MIN( i_size, 10000 ) ) ) <= 0 )
1573         {
1574             input_DeletePES( p_input->p_method_data, p_pes );
1575             return( 0 );
1576         }
1577         if( !p_pes->p_first )
1578         {
1579             p_pes->p_first = p_data;
1580             p_pes->i_nb_data = 1;
1581             p_pes->i_pes_size = i_read;
1582         }
1583         else
1584         {
1585             p_pes->p_last->p_next  = p_data;
1586             p_pes->i_nb_data++;
1587             p_pes->i_pes_size += i_read;
1588         }
1589         p_pes->p_last  = p_data;
1590         i_size -= i_read;
1591     }
1592 //    input_SplitBuffer( p_input, &p_pk, i_size + 8 );
1593     p_pes->p_first->p_payload_start += 16;
1594     p_pes->i_pes_size               -= 16;
1595     if( p_es && p_es->p_decoder_fifo )
1596     {
1597         vlc_mutex_lock( &p_es->p_decoder_fifo->data_lock );
1598         if( p_es->p_decoder_fifo->i_depth >= MAX_PACKETS_IN_FIFO )
1599         {
1600             /* Wait for the decoder. */
1601             vlc_cond_wait( &p_es->p_decoder_fifo->data_wait,
1602                            &p_es->p_decoder_fifo->data_lock );
1603         }
1604         vlc_mutex_unlock( &p_es->p_decoder_fifo->data_lock );
1605         //p_pes->i_pts = mdate() + p_input->i_pts_delay;
1606         p_pes->i_pts = p_pes->i_dts = i_pts + p_input->i_pts_delay;
1607         input_DecodePES( p_es->p_decoder_fifo, p_pes );
1608     }
1609     else
1610     {
1611         input_DeletePES( p_input->p_method_data, p_pes );
1612     }
1613
1614     return 1;
1615 }