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