String fixes
[vlc.git] / modules / access / pvr / pvr.c
1 /*****************************************************************************
2  * pvr.c
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Eric Petit <titer@videolan.org>
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <vlc/vlc.h>
28 #include <vlc/input.h>
29
30 #include <stdlib.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <fcntl.h>
34 #include <unistd.h>
35 #include <errno.h>
36 #include <linux/types.h>
37 #include <sys/ioctl.h>
38 #include "videodev2.h"
39
40 /*****************************************************************************
41  * Module descriptor
42  *****************************************************************************/
43 static int  Open ( vlc_object_t * );
44 static void Close( vlc_object_t * );
45
46 #define CACHING_TEXT N_("Caching value in ms")
47 #define CACHING_LONGTEXT N_( \
48     "Default caching value for PVR streams. This " \
49     "value should be set in milliseconds." )
50
51 #define DEVICE_TEXT N_( "Device" )
52 #define DEVICE_LONGTEXT N_( "PVR video device" )
53
54 #define RADIO_DEVICE_TEXT N_( "Radio device" )
55 #define RADIO_DEVICE_LONGTEXT N_( "PVR radio device" )
56
57 #define NORM_TEXT N_( "Norm" )
58 #define NORM_LONGTEXT N_( "Norm of the stream " \
59     "(Automatic, SECAM, PAL, or NTSC)." )
60
61 #define WIDTH_TEXT N_( "Width" )
62 #define WIDTH_LONGTEXT N_( "Width of the stream to capture " \
63     "(-1 for autodetection)." )
64
65 #define HEIGHT_TEXT N_( "Height" )
66 #define HEIGHT_LONGTEXT N_( "Height of the stream to capture " \
67     "(-1 for autodetection)." )
68
69 #define FREQUENCY_TEXT N_( "Frequency" )
70 #define FREQUENCY_LONGTEXT N_( "Frequency to capture (in kHz), if applicable." )
71
72 #define FRAMERATE_TEXT N_( "Framerate" )
73 #define FRAMERATE_LONGTEXT N_( "Framerate to capture, if applicable " \
74     "(-1 for autodetect)." )
75
76 #define KEYINT_TEXT N_( "Key interval" )
77 #define KEYINT_LONGTEXT N_( "Interval between keyframes (-1 for autodetect)." )
78
79 #define BFRAMES_TEXT N_( "B Frames" )
80 #define BFRAMES_LONGTEXT N_("If this option is set, B-Frames will be used. " \
81     "Use this option to set the number of B-Frames.")
82
83 #define BITRATE_TEXT N_( "Bitrate" )
84 #define BITRATE_LONGTEXT N_( "Bitrate to use (-1 for default)." )
85
86 #define BITRATE_PEAK_TEXT N_( "Bitrate peak" )
87 #define BITRATE_PEAK_LONGTEXT N_( "Peak bitrate in VBR mode." )
88
89 /// \bug extra parenthesis
90 #define BITRATE_MODE_TEXT N_( "Bitrate mode)" )
91 #define BITRATE_MODE_LONGTEXT N_( "Bitrate mode to use (VBR or CBR)." )
92
93 #define BITMASK_TEXT N_( "Audio bitmask" )
94 #define BITMASK_LONGTEXT N_("Bitmask that will "\
95     "get used by the audio part of the card." )
96
97 #define VOLUME_TEXT N_( "Volume" )
98 #define VOLUME_LONGTEXT N_("Audio volume (0-65535)." )
99
100 #define CHAN_TEXT N_( "Channel" )
101 #define CHAN_LONGTEXT N_( "Channel of the card to use (Usually, 0 = tuner, " \
102     "1 = composite, 2 = svideo)" )
103
104 static int i_norm_list[] =
105     { V4L2_STD_UNKNOWN, V4L2_STD_SECAM, V4L2_STD_PAL, V4L2_STD_NTSC };
106 static char *psz_norm_list_text[] =
107     { N_("Automatic"), N_("SECAM"), N_("PAL"),  N_("NTSC") };
108
109 static int i_bitrates[] = { 0, 1 };
110 static char *psz_bitrates_list_text[] = { N_("vbr"), N_("cbr") };
111
112 static int pi_radio_range[2] = { 65000, 108000 };
113
114 vlc_module_begin();
115     set_shortname( _("PVR") );
116     set_description( _("IVTV MPEG Encoding cards input") );
117     set_category( CAT_INPUT );
118     set_subcategory( SUBCAT_INPUT_ACCESS );
119     set_capability( "access2", 0 );
120     add_shortcut( "pvr" );
121
122     add_integer( "pvr-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, VLC_TRUE );
123     add_string( "pvr-device", "/dev/video0", NULL, DEVICE_TEXT,
124                  DEVICE_LONGTEXT, VLC_FALSE );
125     add_string( "pvr-radio-device", "/dev/radio0", NULL, RADIO_DEVICE_TEXT,
126                  RADIO_DEVICE_LONGTEXT, VLC_FALSE );
127     add_integer( "pvr-norm", V4L2_STD_UNKNOWN , NULL, NORM_TEXT,
128                  NORM_LONGTEXT, VLC_FALSE );
129        change_integer_list( i_norm_list, psz_norm_list_text, 0 );
130     add_integer( "pvr-width", -1, NULL, WIDTH_TEXT, WIDTH_LONGTEXT, VLC_TRUE );
131     add_integer( "pvr-height", -1, NULL, HEIGHT_TEXT, HEIGHT_LONGTEXT,
132                  VLC_TRUE );
133     add_integer( "pvr-frequency", -1, NULL, FREQUENCY_TEXT, FREQUENCY_LONGTEXT,
134                  VLC_FALSE );
135     add_integer( "pvr-framerate", -1, NULL, FRAMERATE_TEXT, FRAMERATE_LONGTEXT,
136                  VLC_TRUE );
137     add_integer( "pvr-keyint", -1, NULL, KEYINT_TEXT, KEYINT_LONGTEXT,
138                  VLC_TRUE );
139     add_integer( "pvr-bframes", -1, NULL, FRAMERATE_TEXT, FRAMERATE_LONGTEXT,
140                  VLC_TRUE );
141     add_integer( "pvr-bitrate", -1, NULL, BITRATE_TEXT, BITRATE_LONGTEXT,
142                  VLC_FALSE );
143     add_integer( "pvr-bitrate-peak", -1, NULL, BITRATE_PEAK_TEXT,
144                  BITRATE_PEAK_LONGTEXT, VLC_TRUE );
145     add_integer( "pvr-bitrate-mode", -1, NULL, BITRATE_MODE_TEXT,
146                  BITRATE_MODE_LONGTEXT, VLC_TRUE );
147         change_integer_list( i_bitrates, psz_bitrates_list_text, 0 );
148     add_integer( "pvr-audio-bitmask", -1, NULL, BITMASK_TEXT,
149                  BITMASK_LONGTEXT, VLC_TRUE );
150     add_integer( "pvr-audio-volume", -1, NULL, VOLUME_TEXT,
151                  VOLUME_LONGTEXT, VLC_TRUE );
152     add_integer( "pvr-channel", -1, NULL, CHAN_TEXT, CHAN_LONGTEXT, VLC_TRUE );
153
154     set_callbacks( Open, Close );
155 vlc_module_end();
156
157 /*****************************************************************************
158  * Prototypes
159  *****************************************************************************/
160 static int Read   ( access_t *, uint8_t *, int );
161 static int Control( access_t *, int, va_list );
162
163 /* ivtv specific ioctls */
164 #define IVTV_IOC_G_CODEC    0xFFEE7703
165 #define IVTV_IOC_S_CODEC    0xFFEE7704
166
167 /* for use with IVTV_IOC_G_CODEC and IVTV_IOC_S_CODEC */
168
169 struct ivtv_ioctl_codec {
170         uint32_t aspect;
171         uint32_t audio_bitmask;
172         uint32_t bframes;
173         uint32_t bitrate_mode;
174         uint32_t bitrate;
175         uint32_t bitrate_peak;
176         uint32_t dnr_mode;
177         uint32_t dnr_spatial;
178         uint32_t dnr_temporal;
179         uint32_t dnr_type;
180         uint32_t framerate;
181         uint32_t framespergop;
182         uint32_t gop_closure;
183         uint32_t pulldown;
184         uint32_t stream_type;
185 };
186
187 struct access_sys_t
188 {
189     /* file descriptor */
190     int i_fd;
191     int i_radio_fd;
192
193     /* options */
194     int i_standard;
195     int i_width;
196     int i_height;
197     int i_frequency;
198     int i_framerate;
199     int i_keyint;
200     int i_bframes;
201     int i_bitrate;
202     int i_bitrate_peak;
203     int i_bitrate_mode;
204     int i_audio_bitmask;
205     int i_input;
206     int i_volume;
207 };
208
209 /*****************************************************************************
210  * Open: open the device
211  *****************************************************************************/
212 static int Open( vlc_object_t * p_this )
213 {
214     access_t *p_access = (access_t*) p_this;
215     access_sys_t * p_sys;
216     char * psz_tofree, * psz_parser, * psz_device, * psz_radio_device;
217     vlc_value_t val;
218
219     //psz_device = calloc( strlen( "/dev/videox" ) + 1, 1 );
220
221     p_access->pf_read = Read;
222     p_access->pf_block = NULL;
223     p_access->pf_seek = NULL;
224     p_access->pf_control = Control;
225     p_access->info.i_update = 0;
226     p_access->info.i_size = 0;
227     p_access->info.i_pos = 0;
228     p_access->info.b_eof = VLC_FALSE;
229     p_access->info.i_title = 0;
230     p_access->info.i_seekpoint = 0;
231
232     /* create private access data */
233     p_sys = calloc( sizeof( access_sys_t ), 1 );
234     p_access->p_sys = p_sys;
235
236     /* defaults values */
237     var_Create( p_access, "pvr-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
238
239     var_Create( p_access, "pvr-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
240     var_Get( p_access, "pvr-device" , &val);
241     psz_device = val.psz_string;
242
243     var_Create( p_access, "pvr-radio-device", VLC_VAR_STRING |
244                                               VLC_VAR_DOINHERIT );
245     var_Get( p_access, "pvr-radio-device" , &val);
246     psz_radio_device = val.psz_string;
247
248     var_Create( p_access, "pvr-norm", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
249     var_Get( p_access, "pvr-norm" , &val);
250     p_sys->i_standard = val.i_int;
251
252     var_Create( p_access, "pvr-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
253     var_Get( p_access, "pvr-width" , &val);
254     p_sys->i_width = val.i_int;
255
256     var_Create( p_access, "pvr-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
257     var_Get( p_access, "pvr-height" , &val);
258     p_sys->i_height = val.i_int;
259
260     var_Create( p_access, "pvr-frequency", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
261     var_Get( p_access, "pvr-frequency" , &val);
262     p_sys->i_frequency = val.i_int;
263
264     var_Create( p_access, "pvr-framerate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
265     var_Get( p_access, "pvr-framerate" , &val);
266     p_sys->i_framerate = val.i_int;
267
268     var_Create( p_access, "pvr-keyint", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
269     var_Get( p_access, "pvr-keyint" , &val);
270     p_sys->i_keyint = val.i_int;
271
272     var_Create( p_access, "pvr-bframes", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
273     var_Get( p_access, "pvr-bframes" , &val);
274     p_sys->i_bframes = val.b_bool;
275
276     var_Create( p_access, "pvr-bitrate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
277     var_Get( p_access, "pvr-bitrate" , &val);
278     p_sys->i_bitrate = val.i_int;
279
280     var_Create( p_access, "pvr-bitrate-peak", VLC_VAR_INTEGER |
281                                               VLC_VAR_DOINHERIT );
282     var_Get( p_access, "pvr-bitrate-peak" , &val);
283     p_sys->i_bitrate_peak = val.i_int;
284
285     var_Create( p_access, "pvr-bitrate-mode", VLC_VAR_INTEGER |
286                                               VLC_VAR_DOINHERIT );
287     var_Get( p_access, "pvr-bitrate-mode" , &val);
288     p_sys->i_bitrate_mode = val.i_int;
289
290     var_Create( p_access, "pvr-audio-bitmask", VLC_VAR_INTEGER |
291                                               VLC_VAR_DOINHERIT );
292     var_Get( p_access, "pvr-audio-bitmask" , &val);
293     p_sys->i_audio_bitmask = val.i_int;
294
295     var_Create( p_access, "pvr-audio-volume", VLC_VAR_INTEGER |
296                                               VLC_VAR_DOINHERIT );
297     var_Get( p_access, "pvr-audio-volume" , &val);
298     p_sys->i_volume = val.i_int;
299
300     var_Create( p_access, "pvr-channel", VLC_VAR_INTEGER |
301                                               VLC_VAR_DOINHERIT );
302     var_Get( p_access, "pvr-channel" , &val);
303     p_sys->i_input = val.i_int;
304
305     /* parse command line options */
306     psz_tofree = strdup( p_access->psz_path );
307     psz_parser = psz_tofree;
308
309     if( *psz_parser )
310     {
311         for( ;; )
312         {
313             if ( !strncmp( psz_parser, "norm=", strlen( "norm=" ) ) )
314             {
315                 char *psz_parser_init;
316                 psz_parser += strlen( "norm=" );
317                 psz_parser_init = psz_parser;
318                 while ( *psz_parser != ':' && *psz_parser != ','
319                                                     && *psz_parser != '\0' )
320                 {
321                     psz_parser++;
322                 }
323
324                 if ( !strncmp( psz_parser_init, "secam" ,
325                                psz_parser - psz_parser_init ) )
326                 {
327                     p_sys->i_standard = V4L2_STD_SECAM;
328                 }
329                 else if ( !strncmp( psz_parser_init, "pal" ,
330                                     psz_parser - psz_parser_init ) )
331                 {
332                     p_sys->i_standard = V4L2_STD_PAL;
333                 }
334                 else if ( !strncmp( psz_parser_init, "ntsc" ,
335                                     psz_parser - psz_parser_init ) )
336                 {
337                     p_sys->i_standard = V4L2_STD_NTSC;
338                 }
339                 else
340                 {
341                     p_sys->i_standard = strtol( psz_parser_init ,
342                                                 &psz_parser, 0 );
343                 }
344             }
345             else if( !strncmp( psz_parser, "channel=",
346                                strlen( "channel=" ) ) )
347             {
348                 p_sys->i_input =
349                     strtol( psz_parser + strlen( "channel=" ),
350                             &psz_parser, 0 );
351             }
352             else if( !strncmp( psz_parser, "device=", strlen( "device=" ) ) )
353             {
354                 psz_device = calloc( strlen( "/dev/videox" ) + 1, 1 );
355                 sprintf( psz_device, "/dev/video%ld",
356                             strtol( psz_parser + strlen( "device=" ),
357                             &psz_parser, 0 ) );
358             }
359             else if( !strncmp( psz_parser, "frequency=",
360                                strlen( "frequency=" ) ) )
361             {
362                 p_sys->i_frequency =
363                     strtol( psz_parser + strlen( "frequency=" ),
364                             &psz_parser, 0 );
365             }
366             else if( !strncmp( psz_parser, "framerate=",
367                                strlen( "framerate=" ) ) )
368             {
369                 p_sys->i_framerate =
370                     strtol( psz_parser + strlen( "framerate=" ),
371                             &psz_parser, 0 );
372             }
373             else if( !strncmp( psz_parser, "keyint=",
374                                strlen( "keyint=" ) ) )
375             {
376                 p_sys->i_keyint =
377                     strtol( psz_parser + strlen( "keyint=" ),
378                             &psz_parser, 0 );
379             }
380             else if( !strncmp( psz_parser, "bframes=",
381                                strlen( "bframes=" ) ) )
382             {
383                 p_sys->i_bframes =
384                     strtol( psz_parser + strlen( "bframes=" ),
385                             &psz_parser, 0 );
386             }
387
388             else if( !strncmp( psz_parser, "width=",
389                                strlen( "width=" ) ) )
390             {
391                 p_sys->i_width =
392                     strtol( psz_parser + strlen( "width=" ),
393                             &psz_parser, 0 );
394             }
395             else if( !strncmp( psz_parser, "height=",
396                                strlen( "height=" ) ) )
397             {
398                 p_sys->i_height =
399                     strtol( psz_parser + strlen( "height=" ),
400                             &psz_parser, 0 );
401             }
402             else if( !strncmp( psz_parser, "audio=",
403                                strlen( "audio=" ) ) )
404             {
405                 p_sys->i_audio_bitmask =
406                     strtol( psz_parser + strlen( "audio=" ),
407                             &psz_parser, 0 );
408             }
409             else if( !strncmp( psz_parser, "bitrate=",
410                                strlen( "bitrate=" ) ) )
411             {
412                 p_sys->i_bitrate =
413                     strtol( psz_parser + strlen( "bitrate=" ),
414                             &psz_parser, 0 );
415             }
416             else if( !strncmp( psz_parser, "maxbitrate=",
417                                strlen( "maxbitrate=" ) ) )
418             {
419                 p_sys->i_bitrate_peak =
420                     strtol( psz_parser + strlen( "maxbitrate=" ),
421                             &psz_parser, 0 );
422             }
423             else if( !strncmp( psz_parser, "bitratemode=",
424                                strlen( "bitratemode=" ) ) )
425             {
426                 char *psz_parser_init;
427                 psz_parser += strlen( "bitratemode=" );
428                 psz_parser_init = psz_parser;
429                 while ( *psz_parser != ':' && *psz_parser != ','
430                          && *psz_parser != '\0' )
431                 {
432                     psz_parser++;
433                 }
434
435                 if ( !strncmp( psz_parser_init, "vbr" ,
436                                psz_parser - psz_parser_init ) )
437                 {
438                      p_sys->i_bitrate_mode = 0;
439                 }
440                 else if ( !strncmp( psz_parser_init, "cbr" ,
441                                     psz_parser - psz_parser_init ) )
442                 {
443                     p_sys->i_bitrate_mode = 1;
444                 }
445             }
446             else if( !strncmp( psz_parser, "size=",
447                                strlen( "size=" ) ) )
448             {
449                 p_sys->i_width =
450                     strtol( psz_parser + strlen( "size=" ),
451                             &psz_parser, 0 );
452                 p_sys->i_height =
453                     strtol( psz_parser + 1 ,
454                             &psz_parser, 0 );
455             }
456             else
457             {
458                 char *psz_parser_init;
459                 psz_parser_init = psz_parser;
460                 while ( *psz_parser != ':' && *psz_parser != ',' && *psz_parser != '\0' )
461                 {
462                     psz_parser++;
463                 }
464                 psz_device = calloc( psz_parser - psz_parser_init + 1, 1 );
465                 strncpy( psz_device, psz_parser_init,
466                          psz_parser - psz_parser_init );
467             }
468             if( *psz_parser )
469                 psz_parser++;
470             else
471                 break;
472         }
473     }
474
475     //give a default value to psz_device if none has been specified
476
477     if ( psz_device == NULL )
478     {
479         psz_device = calloc( strlen( "/dev/videox" ) + 1, 1 );
480         strcpy( psz_device, "/dev/video0" );
481     }
482
483     free( psz_tofree );
484
485     /* open the device */
486     if( ( p_sys->i_fd = open( psz_device, O_RDWR ) ) < 0 )
487     {
488         msg_Err( p_access, "cannot open device (%s)", strerror( errno ) );
489         free( p_sys );
490         return VLC_EGENERIC;
491     }
492     else
493     {
494         msg_Dbg( p_access, "using video device: %s",psz_device);
495     }
496
497     free( psz_device );
498
499     /* set the input */
500     if ( p_sys->i_input != -1 )
501     {
502         if ( ioctl( p_sys->i_fd, VIDIOC_S_INPUT, &p_sys->i_input ) < 0 )
503         {
504             msg_Warn( p_access, "VIDIOC_S_INPUT failed" );
505         }
506         else
507         {
508             msg_Dbg( p_access, "input set to :%d", p_sys->i_input);
509         }
510     }
511
512     /* set the video standard */
513     if ( p_sys->i_standard != V4L2_STD_UNKNOWN )
514     {
515         if ( ioctl( p_sys->i_fd, VIDIOC_S_STD, &p_sys->i_standard ) < 0 )
516         {
517             msg_Warn( p_access, "VIDIOC_S_STD failed" );
518         }
519         else
520         {
521             msg_Dbg( p_access, "video standard set to :%x", p_sys->i_standard);
522         }
523     }
524
525     /* set the picture size */
526     if ( p_sys->i_width != -1 || p_sys->i_height != -1 )
527     {
528         struct v4l2_format vfmt;
529
530         vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
531         if ( ioctl( p_sys->i_fd, VIDIOC_G_FMT, &vfmt ) < 0 )
532         {
533             msg_Warn( p_access, "VIDIOC_G_FMT failed" );
534         }
535         else
536         {
537             if ( p_sys->i_width != -1 )
538             {
539                 vfmt.fmt.pix.width = p_sys->i_width;
540             }
541
542             if ( p_sys->i_height != -1 )
543             {
544                 vfmt.fmt.pix.height = p_sys->i_height;
545             }
546
547             if ( ioctl( p_sys->i_fd, VIDIOC_S_FMT, &vfmt ) < 0 )
548             {
549                 msg_Warn( p_access, "VIDIOC_S_FMT failed" );
550             }
551             else
552             {
553                 msg_Dbg( p_access, "picture size set to :%dx%d",
554                          vfmt.fmt.pix.width, vfmt.fmt.pix.height );
555             }
556         }
557     }
558
559     /* set the frequency */
560     if ( p_sys->i_frequency != -1 )
561     {
562         int i_fd;
563         struct v4l2_frequency vf;
564         vf.tuner = 0; /* TODO: let the user choose the tuner */
565
566         if ( p_sys->i_frequency >= pi_radio_range[0]
567               && p_sys->i_frequency <= pi_radio_range[1] )
568         {
569             if( ( p_sys->i_radio_fd = open( psz_radio_device, O_RDWR ) ) < 0 )
570             {
571                 msg_Err( p_access, "cannot open radio device (%s)",
572                          strerror( errno ) );
573                 close( p_sys->i_fd );
574                 free( p_sys );
575                 return VLC_EGENERIC;
576             }
577             else
578             {
579                 msg_Dbg( p_access, "using radio device: %s", psz_radio_device );
580             }
581             i_fd = p_sys->i_radio_fd;
582         }
583         else
584         {
585             i_fd = p_sys->i_fd;
586             p_sys->i_radio_fd = -1;
587         }
588
589         if ( ioctl( i_fd, VIDIOC_G_FREQUENCY, &vf ) < 0 )
590         {
591             msg_Warn( p_access, "VIDIOC_G_FREQUENCY failed (%s)",
592                       strerror( errno ) );
593         }
594         else
595         {
596             vf.frequency = (p_sys->i_frequency * 16 + 500) / 1000;
597             if( ioctl( i_fd, VIDIOC_S_FREQUENCY, &vf ) < 0 )
598             {
599                 msg_Warn( p_access, "VIDIOC_S_FREQUENCY failed (%s)",
600                           strerror( errno ) );
601             }
602             else
603             {
604                 msg_Dbg( p_access, "tuner frequency set to :%d",
605                          p_sys->i_frequency );
606             }
607         }
608     }
609
610     /* control parameters */
611     if ( p_sys->i_volume != -1 )
612     {
613         struct v4l2_control ctrl;
614
615         ctrl.id = V4L2_CID_AUDIO_VOLUME;
616         ctrl.value = p_sys->i_volume;
617
618         if ( ioctl( p_sys->i_fd, VIDIOC_S_CTRL, &ctrl ) < 0 )
619         {
620             msg_Warn( p_access, "VIDIOC_S_CTRL failed" );
621         }
622     }
623
624     /* codec parameters */
625     if ( p_sys->i_framerate != -1
626             || p_sys->i_bitrate_mode != -1
627             || p_sys->i_bitrate_peak != -1
628             || p_sys->i_keyint != -1
629             || p_sys->i_bframes != -1
630             || p_sys->i_bitrate != -1
631             || p_sys->i_audio_bitmask != -1 )
632     {
633         struct ivtv_ioctl_codec codec;
634
635         if ( ioctl( p_sys->i_fd, IVTV_IOC_G_CODEC, &codec ) < 0 )
636         {
637             msg_Warn( p_access, "IVTV_IOC_G_CODEC failed" );
638         }
639         else
640         {
641             if ( p_sys->i_framerate != -1 )
642             {
643                 switch ( p_sys->i_framerate )
644                 {
645                     case 30:
646                         codec.framerate = 0;
647                         break;
648
649                     case 25:
650                         codec.framerate = 1;
651                         break;
652
653                     default:
654                         msg_Warn( p_access, "invalid framerate, reverting to 25" );
655                         codec.framerate = 1;
656                         break;
657                 }
658             }
659
660             if ( p_sys->i_bitrate != -1 )
661             {
662                 codec.bitrate = p_sys->i_bitrate;
663             }
664
665             if ( p_sys->i_bitrate_peak != -1 )
666             {
667                 codec.bitrate_peak = p_sys->i_bitrate_peak;
668             }
669
670             if ( p_sys->i_bitrate_mode != -1 )
671             {
672                 codec.bitrate_mode = p_sys->i_bitrate_mode;
673             }
674
675             if ( p_sys->i_audio_bitmask != -1 )
676             {
677                 codec.audio_bitmask = p_sys->i_audio_bitmask;
678             }
679             if ( p_sys->i_keyint != -1 )
680             {
681                 codec.framespergop = p_sys->i_keyint;
682             }
683
684             if ( p_sys->i_bframes != -1 )
685             {
686                 codec.bframes = p_sys->i_bframes;
687             }
688             if( ioctl( p_sys->i_fd, IVTV_IOC_S_CODEC, &codec ) < 0 )
689             {
690                 msg_Warn( p_access, "IVTV_IOC_S_CODEC failed" );
691             }
692             else
693             {
694                 msg_Dbg( p_access, "Setting codec parameters to:  framerate: %d, bitrate: %d/%d/%d",
695                codec.framerate, codec.bitrate, codec.bitrate_peak, codec.bitrate_mode );
696             }
697         }
698     }
699
700     /* do a quick read */
701 #if 0
702     if ( p_sys->i_fd )
703     {
704         if ( read( p_sys->i_fd, psz_tmp, 1 ) )
705         {
706             msg_Dbg(p_input, "Could read byte from device");
707         }
708         else
709         {
710             msg_Warn(p_input, "Could not read byte from device");
711         }
712     }
713 #endif
714
715     return VLC_SUCCESS;
716 }
717
718 /*****************************************************************************
719  * Close: close the device
720  *****************************************************************************/
721 static void Close( vlc_object_t * p_this )
722 {
723     access_t *p_access = (access_t*) p_this;
724     access_sys_t * p_sys = p_access->p_sys;
725
726     close( p_sys->i_fd );
727     if ( p_sys->i_radio_fd != -1 )
728         close( p_sys->i_radio_fd );
729     free( p_sys );
730 }
731
732 /*****************************************************************************
733  * Read
734  *****************************************************************************/
735 static int Read( access_t * p_access, uint8_t * p_buffer, int i_len )
736 {
737     access_sys_t * p_sys = p_access->p_sys;
738
739     int i_ret;
740
741     struct timeval timeout;
742     fd_set fds;
743
744     FD_ZERO( &fds );
745     FD_SET( p_sys->i_fd, &fds );
746     timeout.tv_sec = 0;
747     timeout.tv_usec = 500000;
748
749     if( p_access->info.b_eof )
750         return 0;
751
752     while( !( i_ret = select( p_sys->i_fd + 1, &fds, NULL, NULL, &timeout) ) )
753     {
754         FD_ZERO( &fds );
755         FD_SET( p_sys->i_fd, &fds );
756         timeout.tv_sec = 0;
757         timeout.tv_usec = 500000;
758
759         if( p_access->b_die )
760             return 0;
761     }
762
763     if( i_ret < 0 )
764     {
765         msg_Err( p_access, "select error (%s)", strerror( errno ) );
766         return -1;
767     }
768
769     i_ret = read( p_sys->i_fd, p_buffer, i_len );
770     if( i_ret == 0 )
771     {
772         p_access->info.b_eof = VLC_TRUE;
773     }
774     else if( i_ret > 0 )
775     {
776         p_access->info.i_pos += i_ret;
777     }
778
779     return i_ret;
780 }
781
782 /*****************************************************************************
783  * Control
784  *****************************************************************************/
785 static int Control( access_t *p_access, int i_query, va_list args )
786 {
787     vlc_bool_t   *pb_bool;
788     int          *pi_int;
789     int64_t      *pi_64;
790
791     switch( i_query )
792     {
793         /* */
794         case ACCESS_CAN_SEEK:
795         case ACCESS_CAN_FASTSEEK:
796             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
797             *pb_bool = VLC_FALSE;
798             break;
799         case ACCESS_CAN_PAUSE:
800             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
801             *pb_bool = VLC_FALSE;
802             break;
803         case ACCESS_CAN_CONTROL_PACE:
804             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
805             *pb_bool = VLC_FALSE;
806             break;
807
808         /* */
809         case ACCESS_GET_MTU:
810             pi_int = (int*)va_arg( args, int * );
811             *pi_int = 0;
812             break;
813
814         case ACCESS_GET_PTS_DELAY:
815             pi_64 = (int64_t*)va_arg( args, int64_t * );
816             *pi_64 = (int64_t)var_GetInteger( p_access, "pvr-caching" ) * 1000;
817             break;
818
819         /* */
820         case ACCESS_SET_PAUSE_STATE:
821             /* Nothing to do */
822             break;
823
824         case ACCESS_GET_TITLE_INFO:
825         case ACCESS_SET_TITLE:
826         case ACCESS_SET_SEEKPOINT:
827         case ACCESS_SET_PRIVATE_ID_STATE:
828             return VLC_EGENERIC;
829
830         default:
831             msg_Warn( p_access, "unimplemented query in control" );
832             return VLC_EGENERIC;
833
834     }
835     return VLC_SUCCESS;
836 }