git.sesse.net Git - vlc/blob - modules/access/pvr/pvr.c

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