git.sesse.net Git - vlc/blob - 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     "Allows you to modify the default caching value for pvr streams. This " \
  49     "value should be set in millisecond units." )
  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_( "Defines the 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 autodetect)" )
  64
  65 #define HEIGHT_TEXT N_( "Height" )
  66 #define HEIGHT_LONGTEXT N_( "Height of the stream to capture " \
  67     "(-1 for autodetect)" )
  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 #define BITRATE_MODE_TEXT N_( "Bitrate mode (vbr or cbr)" )
  90 #define BITRATE_MODE_LONGTEXT N_( "Bitrate mode to use" )
  91
  92 #define BITMASK_TEXT N_( "Audio bitmask" )
  93 #define BITMASK_LONGTEXT N_("This option allows setting of bitmask that will "\
  94     "get used by the audio part of the card." )
  95
  96 #define VOLUME_TEXT N_( "Volume" )
  97 #define VOLUME_LONGTEXT N_("This option allows setting of the audio volume " \
  98     "(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( _("MPEG Encoding cards input (with ivtv drivers)") );
 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 }