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