git.sesse.net Git - vlc/blob - modules/access/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_access.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 <sys/poll.h>
  39 #include "videodev2.h"
  40
  41 /*****************************************************************************
  42  * Module descriptor
  43  *****************************************************************************/
  44 static int  Open ( vlc_object_t * );
  45 static void Close( vlc_object_t * );
  46
  47 #define CACHING_TEXT N_("Caching value in ms")
  48 #define CACHING_LONGTEXT N_( \
  49     "Default caching value for PVR streams. This " \
  50     "value should be set in milliseconds." )
  51
  52 #define DEVICE_TEXT N_( "Device" )
  53 #define DEVICE_LONGTEXT N_( "PVR video device" )
  54
  55 #define RADIO_DEVICE_TEXT N_( "Radio device" )
  56 #define RADIO_DEVICE_LONGTEXT N_( "PVR radio device" )
  57
  58 #define NORM_TEXT N_( "Norm" )
  59 #define NORM_LONGTEXT N_( "Norm of the stream " \
  60     "(Automatic, SECAM, PAL, or NTSC)." )
  61
  62 #define WIDTH_TEXT N_( "Width" )
  63 #define WIDTH_LONGTEXT N_( "Width of the stream to capture " \
  64     "(-1 for autodetection)." )
  65
  66 #define HEIGHT_TEXT N_( "Height" )
  67 #define HEIGHT_LONGTEXT N_( "Height of the stream to capture " \
  68     "(-1 for autodetection)." )
  69
  70 #define FREQUENCY_TEXT N_( "Frequency" )
  71 #define FREQUENCY_LONGTEXT N_( "Frequency to capture (in kHz), if applicable." )
  72
  73 #define FRAMERATE_TEXT N_( "Framerate" )
  74 #define FRAMERATE_LONGTEXT N_( "Framerate to capture, if applicable " \
  75     "(-1 for autodetect)." )
  76
  77 #define KEYINT_TEXT N_( "Key interval" )
  78 #define KEYINT_LONGTEXT N_( "Interval between keyframes (-1 for autodetect)." )
  79
  80 #define BFRAMES_TEXT N_( "B Frames" )
  81 #define BFRAMES_LONGTEXT N_("If this option is set, B-Frames will be used. " \
  82     "Use this option to set the number of B-Frames.")
  83
  84 #define BITRATE_TEXT N_( "Bitrate" )
  85 #define BITRATE_LONGTEXT N_( "Bitrate to use (-1 for default)." )
  86
  87 #define BITRATE_PEAK_TEXT N_( "Bitrate peak" )
  88 #define BITRATE_PEAK_LONGTEXT N_( "Peak bitrate in VBR mode." )
  89
  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_tuner vt;
 564         vt.index = 0; /* TODO: let the user choose the tuner */
 565         memset( &vt.reserved, 0, sizeof(vt.reserved) );
 566
 567         if ( p_sys->i_frequency >= pi_radio_range[0]
 568               && p_sys->i_frequency <= pi_radio_range[1] )
 569         {
 570             if( ( p_sys->i_radio_fd = open( psz_radio_device, O_RDWR ) ) < 0 )
 571             {
 572                 msg_Err( p_access, "cannot open radio device (%s)",
 573                          strerror( errno ) );
 574                 close( p_sys->i_fd );
 575                 free( p_sys );
 576                 return VLC_EGENERIC;
 577             }
 578             else
 579             {
 580                 msg_Dbg( p_access, "using radio device: %s", psz_radio_device );
 581             }
 582             i_fd = p_sys->i_radio_fd;
 583         }
 584         else
 585         {
 586             i_fd = p_sys->i_fd;
 587             p_sys->i_radio_fd = -1;
 588         }
 589
 590         if ( ioctl( i_fd, VIDIOC_G_TUNER, &vt ) < 0 )
 591         {
 592             msg_Warn( p_access, "VIDIOC_G_TUNER failed (%s)",
 593                       strerror( errno ) );
 594         }
 595         else
 596         {
 597             struct v4l2_frequency vf;
 598             vf.tuner = vt.index;
 599
 600             if ( ioctl( i_fd, VIDIOC_G_FREQUENCY, &vf ) < 0 )
 601             {
 602                 msg_Warn( p_access, "VIDIOC_G_FREQUENCY failed (%s)",
 603                           strerror( errno ) );
 604             }
 605             else
 606             {
 607                 if( vt.capability & V4L2_TUNER_CAP_LOW )
 608                     vf.frequency = p_sys->i_frequency * 16;
 609                 else
 610                     vf.frequency = (p_sys->i_frequency * 16 + 500) / 1000;
 611
 612                 if( ioctl( i_fd, VIDIOC_S_FREQUENCY, &vf ) < 0 )
 613                 {
 614                     msg_Warn( p_access, "VIDIOC_S_FREQUENCY failed (%s)",
 615                               strerror( errno ) );
 616                 }
 617                 else
 618                 {
 619                     msg_Dbg( p_access, "tuner frequency set to: %d",
 620                              p_sys->i_frequency );
 621                 }
 622             }
 623         }
 624     }
 625
 626     /* control parameters */
 627     if ( p_sys->i_volume != -1 )
 628     {
 629         struct v4l2_control ctrl;
 630
 631         ctrl.id = V4L2_CID_AUDIO_VOLUME;
 632         ctrl.value = p_sys->i_volume;
 633
 634         if ( ioctl( p_sys->i_fd, VIDIOC_S_CTRL, &ctrl ) < 0 )
 635         {
 636             msg_Warn( p_access, "VIDIOC_S_CTRL failed" );
 637         }
 638     }
 639
 640     /* codec parameters */
 641     if ( p_sys->i_framerate != -1
 642             || p_sys->i_bitrate_mode != -1
 643             || p_sys->i_bitrate_peak != -1
 644             || p_sys->i_keyint != -1
 645             || p_sys->i_bframes != -1
 646             || p_sys->i_bitrate != -1
 647             || p_sys->i_audio_bitmask != -1 )
 648     {
 649         struct ivtv_ioctl_codec codec;
 650
 651         if ( ioctl( p_sys->i_fd, IVTV_IOC_G_CODEC, &codec ) < 0 )
 652         {
 653             msg_Warn( p_access, "IVTV_IOC_G_CODEC failed" );
 654         }
 655         else
 656         {
 657             if ( p_sys->i_framerate != -1 )
 658             {
 659                 switch ( p_sys->i_framerate )
 660                 {
 661                     case 30:
 662                         codec.framerate = 0;
 663                         break;
 664
 665                     case 25:
 666                         codec.framerate = 1;
 667                         break;
 668
 669                     default:
 670                         msg_Warn( p_access, "invalid framerate, reverting to 25" );
 671                         codec.framerate = 1;
 672                         break;
 673                 }
 674             }
 675
 676             if ( p_sys->i_bitrate != -1 )
 677             {
 678                 codec.bitrate = p_sys->i_bitrate;
 679             }
 680
 681             if ( p_sys->i_bitrate_peak != -1 )
 682             {
 683                 codec.bitrate_peak = p_sys->i_bitrate_peak;
 684             }
 685
 686             if ( p_sys->i_bitrate_mode != -1 )
 687             {
 688                 codec.bitrate_mode = p_sys->i_bitrate_mode;
 689             }
 690
 691             if ( p_sys->i_audio_bitmask != -1 )
 692             {
 693                 codec.audio_bitmask = p_sys->i_audio_bitmask;
 694             }
 695             if ( p_sys->i_keyint != -1 )
 696             {
 697                 codec.framespergop = p_sys->i_keyint;
 698             }
 699
 700             if ( p_sys->i_bframes != -1 )
 701             {
 702                 codec.bframes = p_sys->i_bframes;
 703             }
 704             if( ioctl( p_sys->i_fd, IVTV_IOC_S_CODEC, &codec ) < 0 )
 705             {
 706                 msg_Warn( p_access, "IVTV_IOC_S_CODEC failed" );
 707             }
 708             else
 709             {
 710                 msg_Dbg( p_access, "Setting codec parameters to:  framerate: %d, bitrate: %d/%d/%d",
 711                codec.framerate, codec.bitrate, codec.bitrate_peak, codec.bitrate_mode );
 712             }
 713         }
 714     }
 715
 716     /* do a quick read */
 717 #if 0
 718     if ( p_sys->i_fd )
 719     {
 720         if ( read( p_sys->i_fd, psz_tmp, 1 ) )
 721         {
 722             msg_Dbg(p_input, "Could read byte from device");
 723         }
 724         else
 725         {
 726             msg_Warn(p_input, "Could not read byte from device");
 727         }
 728     }
 729 #endif
 730
 731     return VLC_SUCCESS;
 732 }
 733
 734 /*****************************************************************************
 735  * Close: close the device
 736  *****************************************************************************/
 737 static void Close( vlc_object_t * p_this )
 738 {
 739     access_t *p_access = (access_t*) p_this;
 740     access_sys_t * p_sys = p_access->p_sys;
 741
 742     close( p_sys->i_fd );
 743     if ( p_sys->i_radio_fd != -1 )
 744         close( p_sys->i_radio_fd );
 745     free( p_sys );
 746 }
 747
 748 /*****************************************************************************
 749  * Read
 750  *****************************************************************************/
 751 static int Read( access_t * p_access, uint8_t * p_buffer, int i_len )
 752 {
 753     access_sys_t * p_sys = p_access->p_sys;
 754
 755     int i_ret;
 756     struct pollfd ufd;
 757
 758     ufd.fd = p_sys->i_fd;
 759     ufd.events = POLLIN;
 760
 761     if( p_access->info.b_eof )
 762         return 0;
 763
 764     do
 765     {
 766         if( p_access->b_die )
 767             return 0;
 768
 769         ufd.revents = 0;
 770     }
 771     while( ( i_ret = poll( &ufd, 1, 500 ) ) == 0 );
 772
 773     if( i_ret < 0 )
 774     {
 775         msg_Err( p_access, "select error (%s)", strerror( errno ) );
 776         return -1;
 777     }
 778
 779     i_ret = read( p_sys->i_fd, p_buffer, i_len );
 780     if( i_ret == 0 )
 781     {
 782         p_access->info.b_eof = VLC_TRUE;
 783     }
 784     else if( i_ret > 0 )
 785     {
 786         p_access->info.i_pos += i_ret;
 787     }
 788
 789     return i_ret;
 790 }
 791
 792 /*****************************************************************************
 793  * Control
 794  *****************************************************************************/
 795 static int Control( access_t *p_access, int i_query, va_list args )
 796 {
 797     vlc_bool_t   *pb_bool;
 798     int          *pi_int;
 799     int64_t      *pi_64;
 800
 801     switch( i_query )
 802     {
 803         /* */
 804         case ACCESS_CAN_SEEK:
 805         case ACCESS_CAN_FASTSEEK:
 806             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 807             *pb_bool = VLC_FALSE;
 808             break;
 809         case ACCESS_CAN_PAUSE:
 810             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 811             *pb_bool = VLC_FALSE;
 812             break;
 813         case ACCESS_CAN_CONTROL_PACE:
 814             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
 815             *pb_bool = VLC_FALSE;
 816             break;
 817
 818         /* */
 819         case ACCESS_GET_MTU:
 820             pi_int = (int*)va_arg( args, int * );
 821             *pi_int = 0;
 822             break;
 823
 824         case ACCESS_GET_PTS_DELAY:
 825             pi_64 = (int64_t*)va_arg( args, int64_t * );
 826             *pi_64 = (int64_t)var_GetInteger( p_access, "pvr-caching" ) * 1000;
 827             break;
 828
 829         /* */
 830         case ACCESS_SET_PAUSE_STATE:
 831             /* Nothing to do */
 832             break;
 833
 834         case ACCESS_GET_TITLE_INFO:
 835         case ACCESS_SET_TITLE:
 836         case ACCESS_SET_SEEKPOINT:
 837         case ACCESS_SET_PRIVATE_ID_STATE:
 838             return VLC_EGENERIC;
 839
 840         default:
 841             msg_Warn( p_access, "unimplemented query in control" );
 842             return VLC_EGENERIC;
 843
 844     }
 845     return VLC_SUCCESS;
 846 }