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  *          Paul Corke <paulc@datatote.co.uk>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <vlc/vlc.h>
  29 #include <vlc_access.h>
  30
  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 #ifdef HAVE_NEW_LINUX_VIDEODEV2_H
  40 #   ifdef VIDEODEV2_H_FILE
  41 #   include VIDEODEV2_H_FILE
  42 #   else
  43 #   include <linux/videodev2.h>
  44 #   endif
  45 #else
  46 #include "videodev2.h"
  47 #endif
  48
  49 /*****************************************************************************
  50  * Module descriptor
  51  *****************************************************************************/
  52 static int  Open ( vlc_object_t * );
  53 static void Close( vlc_object_t * );
  54
  55 #define CACHING_TEXT N_("Caching value in ms")
  56 #define CACHING_LONGTEXT N_( \
  57     "Default caching value for PVR streams. This " \
  58     "value should be set in milliseconds." )
  59
  60 #define DEVICE_TEXT N_( "Device" )
  61 #define DEVICE_LONGTEXT N_( "PVR video device" )
  62
  63 #define RADIO_DEVICE_TEXT N_( "Radio device" )
  64 #define RADIO_DEVICE_LONGTEXT N_( "PVR radio device" )
  65
  66 #define NORM_TEXT N_( "Norm" )
  67 #define NORM_LONGTEXT N_( "Norm of the stream " \
  68     "(Automatic, SECAM, PAL, or NTSC)." )
  69
  70 #define WIDTH_TEXT N_( "Width" )
  71 #define WIDTH_LONGTEXT N_( "Width of the stream to capture " \
  72     "(-1 for autodetection)." )
  73
  74 #define HEIGHT_TEXT N_( "Height" )
  75 #define HEIGHT_LONGTEXT N_( "Height of the stream to capture " \
  76     "(-1 for autodetection)." )
  77
  78 #define FREQUENCY_TEXT N_( "Frequency" )
  79 #define FREQUENCY_LONGTEXT N_( "Frequency to capture (in kHz), if applicable." )
  80
  81 #define FRAMERATE_TEXT N_( "Framerate" )
  82 #define FRAMERATE_LONGTEXT N_( "Framerate to capture, if applicable " \
  83     "(-1 for autodetect)." )
  84
  85 #define KEYINT_TEXT N_( "Key interval" )
  86 #define KEYINT_LONGTEXT N_( "Interval between keyframes (-1 for autodetect)." )
  87
  88 #define BFRAMES_TEXT N_( "B Frames" )
  89 #define BFRAMES_LONGTEXT N_("If this option is set, B-Frames will be used. " \
  90     "Use this option to set the number of B-Frames.")
  91
  92 #define BITRATE_TEXT N_( "Bitrate" )
  93 #define BITRATE_LONGTEXT N_( "Bitrate to use (-1 for default)." )
  94
  95 #define BITRATE_PEAK_TEXT N_( "Bitrate peak" )
  96 #define BITRATE_PEAK_LONGTEXT N_( "Peak bitrate in VBR mode." )
  97
  98 #define BITRATE_MODE_TEXT N_( "Bitrate mode" )
  99 #define BITRATE_MODE_LONGTEXT N_( "Bitrate mode to use (VBR or CBR)." )
 100
 101 #define BITMASK_TEXT N_( "Audio bitmask" )
 102 #define BITMASK_LONGTEXT N_("Bitmask that will "\
 103     "get used by the audio part of the card." )
 104
 105 #define VOLUME_TEXT N_( "Volume" )
 106 #define VOLUME_LONGTEXT N_("Audio volume (0-65535)." )
 107
 108 #define CHAN_TEXT N_( "Channel" )
 109 #define CHAN_LONGTEXT N_( "Channel of the card to use (Usually, 0 = tuner, " \
 110     "1 = composite, 2 = svideo)" )
 111
 112 static int i_norm_list[] =
 113     { V4L2_STD_UNKNOWN, V4L2_STD_SECAM, V4L2_STD_PAL, V4L2_STD_NTSC };
 114 static const char *psz_norm_list_text[] =
 115     { N_("Automatic"), N_("SECAM"), N_("PAL"),  N_("NTSC") };
 116
 117 static int i_bitrates[] = { 0, 1 };
 118 static const char *psz_bitrates_list_text[] = { N_("vbr"), N_("cbr") };
 119
 120 static int pi_radio_range[2] = { 65000, 108000 };
 121
 122 vlc_module_begin();
 123     set_shortname( _("PVR") );
 124     set_description( _("IVTV MPEG Encoding cards input") );
 125     set_category( CAT_INPUT );
 126     set_subcategory( SUBCAT_INPUT_ACCESS );
 127     set_capability( "access2", 0 );
 128     add_shortcut( "pvr" );
 129
 130     add_integer( "pvr-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT,
 131                  CACHING_LONGTEXT, VLC_TRUE );
 132         change_safe();
 133     add_string( "pvr-device", "/dev/video0", NULL, DEVICE_TEXT,
 134                  DEVICE_LONGTEXT, VLC_FALSE );
 135         change_safe();
 136     add_string( "pvr-radio-device", "/dev/radio0", NULL, RADIO_DEVICE_TEXT,
 137                  RADIO_DEVICE_LONGTEXT, VLC_FALSE );
 138         change_safe();
 139     add_integer( "pvr-norm", V4L2_STD_UNKNOWN , NULL, NORM_TEXT,
 140                  NORM_LONGTEXT, VLC_FALSE );
 141         change_safe();
 142         change_integer_list( i_norm_list, psz_norm_list_text, 0 );
 143     add_integer( "pvr-width", -1, NULL, WIDTH_TEXT, WIDTH_LONGTEXT, VLC_TRUE );
 144         change_safe();
 145     add_integer( "pvr-height", -1, NULL, HEIGHT_TEXT, HEIGHT_LONGTEXT,
 146                  VLC_TRUE );
 147         change_safe();
 148     add_integer( "pvr-frequency", -1, NULL, FREQUENCY_TEXT, FREQUENCY_LONGTEXT,
 149                  VLC_FALSE );
 150         change_safe();
 151     add_integer( "pvr-framerate", -1, NULL, FRAMERATE_TEXT, FRAMERATE_LONGTEXT,
 152                  VLC_TRUE );
 153         change_safe();
 154     add_integer( "pvr-keyint", -1, NULL, KEYINT_TEXT, KEYINT_LONGTEXT,
 155                  VLC_TRUE );
 156         change_safe();
 157     add_integer( "pvr-bframes", -1, NULL, FRAMERATE_TEXT, FRAMERATE_LONGTEXT,
 158                  VLC_TRUE );
 159         change_safe();
 160     add_integer( "pvr-bitrate", -1, NULL, BITRATE_TEXT, BITRATE_LONGTEXT,
 161                  VLC_FALSE );
 162         change_safe();
 163     add_integer( "pvr-bitrate-peak", -1, NULL, BITRATE_PEAK_TEXT,
 164                  BITRATE_PEAK_LONGTEXT, VLC_TRUE );
 165         change_safe();
 166     add_integer( "pvr-bitrate-mode", -1, NULL, BITRATE_MODE_TEXT,
 167                  BITRATE_MODE_LONGTEXT, VLC_TRUE );
 168         change_safe();
 169         change_integer_list( i_bitrates, psz_bitrates_list_text, 0 );
 170     add_integer( "pvr-audio-bitmask", -1, NULL, BITMASK_TEXT,
 171                  BITMASK_LONGTEXT, VLC_TRUE );
 172         change_safe();
 173     add_integer( "pvr-audio-volume", -1, NULL, VOLUME_TEXT,
 174                  VOLUME_LONGTEXT, VLC_TRUE );
 175         change_safe();
 176     add_integer( "pvr-channel", -1, NULL, CHAN_TEXT, CHAN_LONGTEXT, VLC_TRUE );
 177         change_safe();
 178
 179     set_callbacks( Open, Close );
 180 vlc_module_end();
 181
 182 /*****************************************************************************
 183  * Prototypes
 184  *****************************************************************************/
 185 static ssize_t Read   ( access_t *, uint8_t *, size_t );
 186 static int Control( access_t *, int, va_list );
 187
 188 /* ivtv specific ioctls */
 189 #define IVTV_IOC_G_CODEC    0xFFEE7703
 190 #define IVTV_IOC_S_CODEC    0xFFEE7704
 191
 192 /* for use with IVTV_IOC_G_CODEC and IVTV_IOC_S_CODEC */
 193
 194 struct ivtv_ioctl_codec {
 195     uint32_t aspect;
 196     uint32_t audio_bitmask;
 197     uint32_t bframes;
 198     uint32_t bitrate_mode;
 199     uint32_t bitrate;
 200     uint32_t bitrate_peak;
 201     uint32_t dnr_mode;
 202     uint32_t dnr_spatial;
 203     uint32_t dnr_temporal;
 204     uint32_t dnr_type;
 205     uint32_t framerate;
 206     uint32_t framespergop;
 207     uint32_t gop_closure;
 208     uint32_t pulldown;
 209     uint32_t stream_type;
 210 };
 211
 212 struct access_sys_t
 213 {
 214     /* file descriptor */
 215     int i_fd;
 216     int i_radio_fd;
 217
 218     char *psz_videodev;
 219     char *psz_radiodev;
 220
 221     /* options */
 222     int i_standard;
 223     int i_width;
 224     int i_height;
 225     int i_frequency;
 226     int i_framerate;
 227     int i_keyint;
 228     int i_bframes;
 229     int i_bitrate;
 230     int i_bitrate_peak;
 231     int i_bitrate_mode;
 232     int i_audio_bitmask;
 233     int i_input;
 234     int i_volume;
 235
 236     /* driver version */
 237     vlc_bool_t b_v4l2_api;
 238 };
 239
 240 /*****************************************************************************
 241  * ConfigureIVTV: set up codec parameters using the old ivtv api
 242  *****************************************************************************/
 243 static int ConfigureIVTV( access_t * p_access )
 244 {
 245     access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
 246     struct ivtv_ioctl_codec codec;
 247     int result;
 248
 249     memset( &codec, 0, sizeof(struct ivtv_ioctl_codec) );
 250
 251     result = ioctl( p_sys->i_fd, IVTV_IOC_G_CODEC, &codec );
 252     if( result < 0 )
 253     {
 254         msg_Err( p_access, "Failed to read current capture card settings." );
 255         return VLC_EGENERIC;
 256     }
 257
 258     if( p_sys->i_framerate != -1 )
 259     {
 260         switch( p_sys->i_framerate )
 261         {
 262             case 30:
 263                 codec.framerate = 0;
 264                 break;
 265
 266             case 25:
 267                 codec.framerate = 1;
 268                 break;
 269
 270             default:
 271                 msg_Warn( p_access, "Invalid framerate, reverting to 25." );
 272                 codec.framerate = 1;
 273                 break;
 274         }
 275     }
 276
 277     if( p_sys->i_bitrate != -1 )
 278     {
 279         codec.bitrate = p_sys->i_bitrate;
 280     }
 281
 282     if( p_sys->i_bitrate_peak != -1 )
 283     {
 284         codec.bitrate_peak = p_sys->i_bitrate_peak;
 285     }
 286
 287     if( p_sys->i_bitrate_mode != -1 )
 288     {
 289         codec.bitrate_mode = p_sys->i_bitrate_mode;
 290     }
 291
 292     if( p_sys->i_audio_bitmask != -1 )
 293     {
 294         codec.audio_bitmask = p_sys->i_audio_bitmask;
 295     }
 296
 297     if( p_sys->i_keyint != -1 )
 298     {
 299         codec.framespergop = p_sys->i_keyint;
 300     }
 301
 302     if( p_sys->i_bframes != -1 )
 303     {
 304         codec.bframes = p_sys->i_bframes;
 305     }
 306
 307     result = ioctl( p_sys->i_fd, IVTV_IOC_S_CODEC, &codec );
 308     if( result  < 0 )
 309     {
 310         msg_Err( p_access, "Failed to write new capture card settings." );
 311         return VLC_EGENERIC;
 312     }
 313
 314     msg_Dbg( p_access, "Setting codec parameters to:  framerate: "
 315                         "%d, bitrate: %d/%d/%d",
 316                         codec.framerate, codec.bitrate,
 317                         codec.bitrate_peak, codec.bitrate_mode );
 318     return VLC_SUCCESS;
 319 }
 320
 321 #ifdef HAVE_NEW_LINUX_VIDEODEV2_H
 322
 323 #define MAX_V4L2_CTRLS (6)
 324 /*****************************************************************************
 325  * AddV4L2Ctrl: adds a control to the v4l2 controls list
 326  *****************************************************************************/
 327 static void AddV4L2Ctrl( access_t * p_access,
 328                          struct v4l2_ext_controls * p_controls,
 329                          uint32_t i_id, uint32_t i_value )
 330 {
 331     if( p_controls->count >= MAX_V4L2_CTRLS )
 332     {
 333         msg_Err( p_access, "Tried to set too many v4l2 controls at once." );
 334         return;
 335     }
 336
 337     p_controls->controls[p_controls->count].id    = i_id;
 338     p_controls->controls[p_controls->count].value = i_value;
 339     p_controls->count++;
 340 }
 341
 342 /*****************************************************************************
 343  * V4L2SampleRate: calculate v4l2 sample rate from pvr-audio-bitmask
 344  *****************************************************************************/
 345 static uint32_t V4L2SampleRate( uint32_t i_bitmask )
 346 {
 347     switch( i_bitmask & 0x0003 )
 348     {
 349         case 0x0001: return V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000;
 350         case 0x0002: return V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000;
 351     }
 352     return V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100;
 353 }
 354
 355 /*****************************************************************************
 356  * V4L2AudioEncoding: calculate v4l2 audio encoding level from pvr-audio-bitmask
 357  *****************************************************************************/
 358 static uint32_t V4L2AudioEncoding( uint32_t i_bitmask )
 359 {
 360     switch( i_bitmask & 0x000c )
 361     {
 362         case 0x0004: return V4L2_MPEG_AUDIO_ENCODING_LAYER_1;
 363         case 0x0008: return V4L2_MPEG_AUDIO_ENCODING_LAYER_2;
 364     }
 365     return 0xffffffff;
 366 }
 367
 368 /*****************************************************************************
 369  * V4L2AudioL1Bitrate: calculate v4l2 audio bitrate for layer-1 audio from pvr-audio-bitmask
 370  *****************************************************************************/
 371 static uint32_t V4L2AudioL1Bitrate( uint32_t i_bitmask )
 372 {
 373     switch( i_bitmask & 0x00f0 )
 374     {
 375         case 0x0010: return V4L2_MPEG_AUDIO_L1_BITRATE_32K;
 376         case 0x0020: return V4L2_MPEG_AUDIO_L1_BITRATE_64K;
 377         case 0x0030: return V4L2_MPEG_AUDIO_L1_BITRATE_96K;
 378         case 0x0040: return V4L2_MPEG_AUDIO_L1_BITRATE_128K;
 379         case 0x0050: return V4L2_MPEG_AUDIO_L1_BITRATE_160K;
 380         case 0x0060: return V4L2_MPEG_AUDIO_L1_BITRATE_192K;
 381         case 0x0070: return V4L2_MPEG_AUDIO_L1_BITRATE_224K;
 382         case 0x0080: return V4L2_MPEG_AUDIO_L1_BITRATE_256K;
 383         case 0x0090: return V4L2_MPEG_AUDIO_L1_BITRATE_288K;
 384         case 0x00a0: return V4L2_MPEG_AUDIO_L1_BITRATE_320K;
 385         case 0x00b0: return V4L2_MPEG_AUDIO_L1_BITRATE_352K;
 386         case 0x00c0: return V4L2_MPEG_AUDIO_L1_BITRATE_384K;
 387         case 0x00d0: return V4L2_MPEG_AUDIO_L1_BITRATE_416K;
 388         case 0x00e0: return V4L2_MPEG_AUDIO_L1_BITRATE_448K;
 389     }
 390     return V4L2_MPEG_AUDIO_L1_BITRATE_320K;
 391 }
 392
 393 /*****************************************************************************
 394  * V4L2AudioL2Bitrate: calculate v4l2 audio bitrate for layer-1 audio from pvr-audio-bitmask
 395  *****************************************************************************/
 396 static uint32_t V4L2AudioL2Bitrate( uint32_t i_bitmask )
 397 {
 398     switch( i_bitmask & 0x00f0 )
 399     {
 400         case 0x0010: return V4L2_MPEG_AUDIO_L2_BITRATE_32K;
 401         case 0x0020: return V4L2_MPEG_AUDIO_L2_BITRATE_48K;
 402         case 0x0030: return V4L2_MPEG_AUDIO_L2_BITRATE_56K;
 403         case 0x0040: return V4L2_MPEG_AUDIO_L2_BITRATE_64K;
 404         case 0x0050: return V4L2_MPEG_AUDIO_L2_BITRATE_80K;
 405         case 0x0060: return V4L2_MPEG_AUDIO_L2_BITRATE_96K;
 406         case 0x0070: return V4L2_MPEG_AUDIO_L2_BITRATE_112K;
 407         case 0x0080: return V4L2_MPEG_AUDIO_L2_BITRATE_128K;
 408         case 0x0090: return V4L2_MPEG_AUDIO_L2_BITRATE_160K;
 409         case 0x00a0: return V4L2_MPEG_AUDIO_L2_BITRATE_192K;
 410         case 0x00b0: return V4L2_MPEG_AUDIO_L2_BITRATE_224K;
 411         case 0x00c0: return V4L2_MPEG_AUDIO_L2_BITRATE_256K;
 412         case 0x00d0: return V4L2_MPEG_AUDIO_L2_BITRATE_320K;
 413         case 0x00e0: return V4L2_MPEG_AUDIO_L2_BITRATE_384K;
 414     }
 415     return V4L2_MPEG_AUDIO_L2_BITRATE_192K;
 416 }
 417
 418 /*****************************************************************************
 419  * V4L2AudioMode: calculate v4l2 audio mode from pvr-audio-bitmask
 420  *****************************************************************************/
 421 static uint32_t V4L2AudioMode( uint32_t i_bitmask )
 422 {
 423     switch( i_bitmask & 0x0300 )
 424     {
 425         case 0x0100: return V4L2_MPEG_AUDIO_MODE_JOINT_STEREO;
 426         case 0x0200: return V4L2_MPEG_AUDIO_MODE_DUAL;
 427         case 0x0300: return V4L2_MPEG_AUDIO_MODE_MONO;
 428     }
 429     return V4L2_MPEG_AUDIO_MODE_STEREO;
 430 }
 431
 432 /*****************************************************************************
 433  * ConfigureV4L2: set up codec parameters using the new v4l2 api
 434  *****************************************************************************/
 435 static int ConfigureV4L2( access_t * p_access )
 436 {
 437     access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
 438     struct v4l2_ext_controls controls;
 439     int result;
 440
 441     memset( &controls, 0, sizeof(struct v4l2_ext_controls) );
 442     controls.ctrl_class  = V4L2_CTRL_CLASS_MPEG;
 443     controls.error_idx   = 0;
 444     controls.reserved[0] = 0;
 445     controls.reserved[1] = 0;
 446     controls.count       = 0;
 447     controls.controls    = calloc( sizeof( struct v4l2_ext_control ),
 448                                    MAX_V4L2_CTRLS );
 449
 450     if( controls.controls == NULL )
 451         return VLC_ENOMEM;
 452
 453     /* Note: Ignore frame rate.  Doesn't look like it can be changed. */
 454     if( p_sys->i_bitrate != -1 )
 455     {
 456         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_VIDEO_BITRATE,
 457                      p_sys->i_bitrate );
 458         msg_Dbg( p_access, "Setting [%u] bitrate = %u",
 459                  controls.count - 1, p_sys->i_bitrate );
 460     }
 461
 462     if( p_sys->i_bitrate_peak != -1 )
 463     {
 464         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
 465                      p_sys->i_bitrate_peak );
 466         msg_Dbg( p_access, "Setting [%u] bitrate_peak = %u",
 467                  controls.count - 1, p_sys->i_bitrate_peak );
 468     }
 469
 470     if( p_sys->i_bitrate_mode != -1 )
 471     {
 472         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
 473                      p_sys->i_bitrate_mode );
 474         msg_Dbg( p_access, "Setting [%u] bitrate_mode = %u",
 475                  controls.count - 1, p_sys->i_bitrate_mode );
 476     }
 477
 478     if( p_sys->i_audio_bitmask != -1 )
 479     {
 480         /* Sample rate */
 481         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
 482                     V4L2SampleRate( p_sys->i_audio_bitmask ) );
 483
 484         /* Encoding layer and bitrate */
 485         switch( V4L2AudioEncoding( p_sys->i_audio_bitmask ) )
 486         {
 487             case V4L2_MPEG_AUDIO_ENCODING_LAYER_1:
 488                  AddV4L2Ctrl( p_access, &controls,
 489                               V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
 490                               V4L2_MPEG_AUDIO_ENCODING_LAYER_1 );
 491                  AddV4L2Ctrl( p_access, &controls,
 492                               V4L2_CID_MPEG_AUDIO_L1_BITRATE,
 493                               V4L2AudioL1Bitrate( p_sys->i_audio_bitmask ) );
 494                  break;
 495
 496             case V4L2_MPEG_AUDIO_ENCODING_LAYER_2:
 497                  AddV4L2Ctrl( p_access, &controls,
 498                               V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ,
 499                               V4L2_MPEG_AUDIO_ENCODING_LAYER_2 );
 500                  AddV4L2Ctrl( p_access, &controls,
 501                               V4L2_CID_MPEG_AUDIO_L2_BITRATE,
 502                               V4L2AudioL2Bitrate( p_sys->i_audio_bitmask ) );
 503                  break;
 504         }
 505
 506         /* Audio mode - stereo or mono */
 507         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_AUDIO_MODE,
 508                      V4L2AudioMode( p_sys->i_audio_bitmask ) );
 509
 510         /* See if the user wants any other audio feature */
 511         if( ( p_sys->i_audio_bitmask & 0x1ff00 ) != 0 )
 512         {
 513             /* It would be possible to support the bits that represent:
 514              *   V4L2_CID_MPEG_AUDIO_MODE_EXTENSION
 515              *   V4L2_CID_MPEG_AUDIO_EMPHASIS
 516              *   V4L2_CID_MPEG_AUDIO_CRC
 517              * but they are not currently used.  Tell the user.
 518              */
 519             msg_Err( p_access, "There were bits in pvr-audio-bitmask that were not used.");
 520         }
 521         msg_Dbg( p_access, "Setting audio controls");
 522     }
 523
 524     if( p_sys->i_keyint != -1 )
 525     {
 526         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_VIDEO_GOP_SIZE,
 527                      p_sys->i_keyint );
 528         msg_Dbg( p_access, "Setting [%u] keyint = %u",
 529                  controls.count - 1, p_sys->i_keyint );
 530     }
 531
 532     if( p_sys->i_bframes != -1 )
 533     {
 534         AddV4L2Ctrl( p_access, &controls, V4L2_CID_MPEG_VIDEO_B_FRAMES,
 535                      p_sys->i_bframes );
 536         msg_Dbg( p_access, "Setting [%u] bframes = %u",
 537                  controls.count - 1, p_sys->i_bframes );
 538     }
 539
 540     result = ioctl( p_sys->i_fd, VIDIOC_S_EXT_CTRLS, &controls );
 541     if( result < 0 )
 542     {
 543         msg_Err( p_access, "Failed to write %u new capture card settings.",
 544                             controls.error_idx );
 545     }
 546     free( controls.controls );
 547     return VLC_SUCCESS;
 548 }
 549
 550 #endif /* HAVE_NEW_LINUX_VIDEODEV2_H */
 551
 552 /*****************************************************************************
 553  * Open: open the device
 554  *****************************************************************************/
 555 static int Open( vlc_object_t * p_this )
 556 {
 557     access_t *p_access = (access_t*) p_this;
 558     access_sys_t * p_sys;
 559     char * psz_tofree;
 560     char * psz_parser;
 561     char * psz_device = NULL;
 562     vlc_value_t val;
 563     struct v4l2_capability device_capability;
 564     int result;
 565
 566     memset( &device_capability, 0, sizeof(struct v4l2_capability) );
 567
 568     p_access->pf_read = Read;
 569     p_access->pf_block = NULL;
 570     p_access->pf_seek = NULL;
 571     p_access->pf_control = Control;
 572     p_access->info.i_update = 0;
 573     p_access->info.i_size = 0;
 574     p_access->info.i_pos = 0;
 575     p_access->info.b_eof = VLC_FALSE;
 576     p_access->info.i_title = 0;
 577     p_access->info.i_seekpoint = 0;
 578
 579     /* create private access data */
 580     p_sys = calloc( sizeof( access_sys_t ), 1 );
 581     if( !p_sys )
 582         return VLC_ENOMEM;
 583
 584     p_access->p_sys = p_sys;
 585
 586     /* defaults values */
 587     var_Create( p_access, "pvr-caching", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 588
 589     var_Create( p_access, "pvr-device", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
 590     var_Get( p_access, "pvr-device" , &val);
 591     p_sys->psz_videodev = val.psz_string;
 592
 593     var_Create( p_access, "pvr-radio-device", VLC_VAR_STRING |
 594                                               VLC_VAR_DOINHERIT );
 595     var_Get( p_access, "pvr-radio-device" , &val);
 596     p_sys->psz_radiodev = val.psz_string;
 597
 598     var_Create( p_access, "pvr-norm", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 599     var_Get( p_access, "pvr-norm" , &val);
 600     p_sys->i_standard = val.i_int;
 601
 602     var_Create( p_access, "pvr-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 603     var_Get( p_access, "pvr-width" , &val);
 604     p_sys->i_width = val.i_int;
 605
 606     var_Create( p_access, "pvr-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 607     var_Get( p_access, "pvr-height" , &val);
 608     p_sys->i_height = val.i_int;
 609
 610     var_Create( p_access, "pvr-frequency", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 611     var_Get( p_access, "pvr-frequency" , &val);
 612     p_sys->i_frequency = val.i_int;
 613
 614     var_Create( p_access, "pvr-framerate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 615     var_Get( p_access, "pvr-framerate" , &val);
 616     p_sys->i_framerate = val.i_int;
 617
 618     var_Create( p_access, "pvr-keyint", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 619     var_Get( p_access, "pvr-keyint" , &val);
 620     p_sys->i_keyint = val.i_int;
 621
 622     var_Create( p_access, "pvr-bframes", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 623     var_Get( p_access, "pvr-bframes" , &val);
 624     p_sys->i_bframes = val.b_bool;
 625
 626     var_Create( p_access, "pvr-bitrate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT );
 627     var_Get( p_access, "pvr-bitrate" , &val);
 628     p_sys->i_bitrate = val.i_int;
 629
 630     var_Create( p_access, "pvr-bitrate-peak", VLC_VAR_INTEGER |
 631                                               VLC_VAR_DOINHERIT );
 632     var_Get( p_access, "pvr-bitrate-peak" , &val);
 633     p_sys->i_bitrate_peak = val.i_int;
 634
 635     var_Create( p_access, "pvr-bitrate-mode", VLC_VAR_INTEGER |
 636                                               VLC_VAR_DOINHERIT );
 637     var_Get( p_access, "pvr-bitrate-mode" , &val);
 638     p_sys->i_bitrate_mode = val.i_int;
 639
 640     var_Create( p_access, "pvr-audio-bitmask", VLC_VAR_INTEGER |
 641                                               VLC_VAR_DOINHERIT );
 642     var_Get( p_access, "pvr-audio-bitmask" , &val);
 643     p_sys->i_audio_bitmask = val.i_int;
 644
 645     var_Create( p_access, "pvr-audio-volume", VLC_VAR_INTEGER |
 646                                               VLC_VAR_DOINHERIT );
 647     var_Get( p_access, "pvr-audio-volume" , &val);
 648     p_sys->i_volume = val.i_int;
 649
 650     var_Create( p_access, "pvr-channel", VLC_VAR_INTEGER |
 651                                               VLC_VAR_DOINHERIT );
 652     var_Get( p_access, "pvr-channel" , &val);
 653     p_sys->i_input = val.i_int;
 654
 655     /* parse command line options */
 656     psz_tofree = strdup( p_access->psz_path );
 657     if( !psz_tofree )
 658         return VLC_ENOMEM;
 659
 660     psz_parser = psz_tofree;
 661     if( *psz_parser )
 662     {
 663         for( ;; )
 664         {
 665             if ( !strncmp( psz_parser, "norm=", strlen( "norm=" ) ) )
 666             {
 667                 char *psz_parser_init;
 668                 psz_parser += strlen( "norm=" );
 669                 psz_parser_init = psz_parser;
 670                 while ( (*psz_parser != ':')
 671                         && (*psz_parser != ',')
 672                         && (*psz_parser != '\0') )
 673                 {
 674                     psz_parser++;
 675                 }
 676
 677                 if ( !strncmp( psz_parser_init, "secam" ,
 678                                psz_parser - psz_parser_init ) )
 679                 {
 680                     p_sys->i_standard = V4L2_STD_SECAM;
 681                 }
 682                 else if ( !strncmp( psz_parser_init, "pal" ,
 683                                     psz_parser - psz_parser_init ) )
 684                 {
 685                     p_sys->i_standard = V4L2_STD_PAL;
 686                 }
 687                 else if ( !strncmp( psz_parser_init, "ntsc" ,
 688                                     psz_parser - psz_parser_init ) )
 689                 {
 690                     p_sys->i_standard = V4L2_STD_NTSC;
 691                 }
 692                 else
 693                 {
 694                     p_sys->i_standard = strtol( psz_parser_init ,
 695                                                 &psz_parser, 0 );
 696                 }
 697             }
 698             else if( !strncmp( psz_parser, "channel=",
 699                                strlen( "channel=" ) ) )
 700             {
 701                 p_sys->i_input =
 702                     strtol( psz_parser + strlen( "channel=" ),
 703                             &psz_parser, 0 );
 704             }
 705             else if( !strncmp( psz_parser, "device=", strlen( "device=" ) ) )
 706             {
 707                 int i_len = strlen( "/dev/videox" );
 708                 psz_device = calloc( i_len  + 1, 1 );
 709                 if( !psz_device )
 710                     return VLC_ENOMEM;
 711
 712                 snprintf( psz_device, i_len, "/dev/video%ld",
 713                             strtol( psz_parser + strlen( "device=" ),
 714                             &psz_parser, 0 ) );
 715             }
 716             else if( !strncmp( psz_parser, "frequency=",
 717                                strlen( "frequency=" ) ) )
 718             {
 719                 p_sys->i_frequency =
 720                     strtol( psz_parser + strlen( "frequency=" ),
 721                             &psz_parser, 0 );
 722             }
 723             else if( !strncmp( psz_parser, "framerate=",
 724                                strlen( "framerate=" ) ) )
 725             {
 726                 p_sys->i_framerate =
 727                     strtol( psz_parser + strlen( "framerate=" ),
 728                             &psz_parser, 0 );
 729             }
 730             else if( !strncmp( psz_parser, "keyint=",
 731                                strlen( "keyint=" ) ) )
 732             {
 733                 p_sys->i_keyint =
 734                     strtol( psz_parser + strlen( "keyint=" ),
 735                             &psz_parser, 0 );
 736             }
 737             else if( !strncmp( psz_parser, "bframes=",
 738                                strlen( "bframes=" ) ) )
 739             {
 740                 p_sys->i_bframes =
 741                     strtol( psz_parser + strlen( "bframes=" ),
 742                             &psz_parser, 0 );
 743             }
 744
 745             else if( !strncmp( psz_parser, "width=",
 746                                strlen( "width=" ) ) )
 747             {
 748                 p_sys->i_width =
 749                     strtol( psz_parser + strlen( "width=" ),
 750                             &psz_parser, 0 );
 751             }
 752             else if( !strncmp( psz_parser, "height=",
 753                                strlen( "height=" ) ) )
 754             {
 755                 p_sys->i_height =
 756                     strtol( psz_parser + strlen( "height=" ),
 757                             &psz_parser, 0 );
 758             }
 759             else if( !strncmp( psz_parser, "audio=",
 760                                strlen( "audio=" ) ) )
 761             {
 762                 p_sys->i_audio_bitmask =
 763                     strtol( psz_parser + strlen( "audio=" ),
 764                             &psz_parser, 0 );
 765             }
 766             else if( !strncmp( psz_parser, "bitrate=",
 767                                strlen( "bitrate=" ) ) )
 768             {
 769                 p_sys->i_bitrate =
 770                     strtol( psz_parser + strlen( "bitrate=" ),
 771                             &psz_parser, 0 );
 772             }
 773             else if( !strncmp( psz_parser, "maxbitrate=",
 774                                strlen( "maxbitrate=" ) ) )
 775             {
 776                 p_sys->i_bitrate_peak =
 777                     strtol( psz_parser + strlen( "maxbitrate=" ),
 778                             &psz_parser, 0 );
 779             }
 780             else if( !strncmp( psz_parser, "bitratemode=",
 781                                strlen( "bitratemode=" ) ) )
 782             {
 783                 char *psz_parser_init;
 784                 psz_parser += strlen( "bitratemode=" );
 785                 psz_parser_init = psz_parser;
 786                 while ( (*psz_parser != ':')
 787                         && (*psz_parser != ',')
 788                         && (*psz_parser != '\0') )
 789                 {
 790                     psz_parser++;
 791                 }
 792
 793                 if ( !strncmp( psz_parser_init, "vbr" ,
 794                                psz_parser - psz_parser_init ) )
 795                 {
 796                      p_sys->i_bitrate_mode = 0;
 797                 }
 798                 else if ( !strncmp( psz_parser_init, "cbr" ,
 799                                     psz_parser - psz_parser_init ) )
 800                 {
 801                     p_sys->i_bitrate_mode = 1;
 802                 }
 803             }
 804             else if( !strncmp( psz_parser, "size=",
 805                                strlen( "size=" ) ) )
 806             {
 807                 p_sys->i_width =
 808                     strtol( psz_parser + strlen( "size=" ),
 809                             &psz_parser, 0 );
 810                 p_sys->i_height =
 811                     strtol( psz_parser + 1 ,
 812                             &psz_parser, 0 );
 813             }
 814             else
 815             {
 816                 char *psz_parser_init;
 817                 psz_parser_init = psz_parser;
 818                 while ( (*psz_parser != ':') &&
 819                         (*psz_parser != ',') &&
 820                         (*psz_parser != '\0') )
 821                 {
 822                     psz_parser++;
 823                 }
 824                 psz_device = calloc( psz_parser - psz_parser_init + 1, 1 );
 825                 if( !psz_device )
 826                     return VLC_ENOMEM;
 827
 828                 strncpy( psz_device, psz_parser_init,
 829                          psz_parser - psz_parser_init );
 830             }
 831             if( *psz_parser )
 832                 psz_parser++;
 833             else
 834                 break;
 835         }
 836     }
 837     free( psz_tofree );
 838
 839     if( psz_device )
 840     {
 841         if( p_sys->psz_videodev )
 842             free( p_sys->psz_videodev );
 843         p_sys->psz_videodev = psz_device;
 844     }
 845
 846     /* open the device */
 847     p_sys->i_fd = open( p_sys->psz_videodev, O_RDWR );
 848     if( p_sys->i_fd < 0 )
 849     {
 850         msg_Err( p_access, "Cannot open device (%m)." );
 851         Close( VLC_OBJECT(p_access) );
 852         return VLC_EGENERIC;
 853     }
 854     msg_Dbg( p_access, "Using video device: %s.", p_sys->psz_videodev);
 855
 856     /* See what version of ivtvdriver is running */
 857     result = ioctl( p_sys->i_fd, VIDIOC_QUERYCAP, &device_capability );
 858     if( result < 0 )
 859     {
 860         msg_Err( p_access, "unknown ivtv/pvr driver version in use" );
 861         Close( VLC_OBJECT(p_access) );
 862         return VLC_EGENERIC;
 863     }
 864
 865     msg_Dbg( p_access, "%s driver (%s on %s) version %02x.%02x.%02x",
 866               device_capability.driver,
 867               device_capability.card,
 868               device_capability.bus_info,
 869             ( device_capability.version >> 16 ) & 0xff,
 870             ( device_capability.version >>  8 ) & 0xff,
 871             ( device_capability.version       ) & 0xff);
 872
 873     if ( strncmp( (char *) device_capability.driver, "ivtv", 4 )
 874            || device_capability.version >= 0x000800 )
 875     {
 876         /* Drivers > 0.8.0 use v4l2 API instead of IVTV ioctls */
 877         msg_Dbg( p_access, "this driver uses the v4l2 API" );
 878         p_sys->b_v4l2_api = VLC_TRUE;
 879     }
 880     else
 881     {
 882         p_sys->b_v4l2_api = VLC_FALSE;
 883     }
 884
 885     /* set the input */
 886     if ( p_sys->i_input != -1 )
 887     {
 888         result = ioctl( p_sys->i_fd, VIDIOC_S_INPUT, &p_sys->i_input );
 889         if ( result < 0 )
 890             msg_Warn( p_access, "Failed to select the requested input pin." );
 891         else
 892             msg_Dbg( p_access, "input set to: %d", p_sys->i_input );
 893     }
 894
 895     /* set the video standard */
 896     if ( p_sys->i_standard != V4L2_STD_UNKNOWN )
 897     {
 898         result = ioctl( p_sys->i_fd, VIDIOC_S_STD, &p_sys->i_standard );
 899         if ( result  < 0 )
 900             msg_Warn( p_access, "Failed to set the requested video standard." );
 901         else
 902             msg_Dbg( p_access, "video standard set to: %x",
 903                      p_sys->i_standard);
 904     }
 905
 906     /* set the picture size */
 907     if ( (p_sys->i_width != -1) || (p_sys->i_height != -1) )
 908     {
 909         struct v4l2_format vfmt;
 910
 911         memset( &vfmt, 0, sizeof(struct v4l2_format) );
 912         vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 913
 914         result = ioctl( p_sys->i_fd, VIDIOC_G_FMT, &vfmt );
 915         if ( result < 0 )
 916         {
 917             msg_Warn( p_access, "Failed to read current picture size." );
 918         }
 919         else
 920         {
 921             if ( p_sys->i_width != -1 )
 922             {
 923                 vfmt.fmt.pix.width = p_sys->i_width;
 924             }
 925
 926             if ( p_sys->i_height != -1 )
 927             {
 928                 vfmt.fmt.pix.height = p_sys->i_height;
 929             }
 930
 931             result = ioctl( p_sys->i_fd, VIDIOC_S_FMT, &vfmt );
 932             if ( result < 0 )
 933             {
 934                 msg_Warn( p_access, "Failed to set requested picture size." );
 935             }
 936             else
 937             {
 938                 msg_Dbg( p_access, "picture size set to: %dx%d",
 939                          vfmt.fmt.pix.width, vfmt.fmt.pix.height );
 940             }
 941         }
 942     }
 943
 944     /* set the frequency */
 945     if ( p_sys->i_frequency != -1 )
 946     {
 947         int i_fd;
 948         struct v4l2_tuner vt;
 949
 950          /* TODO: let the user choose the tuner */
 951         memset( &vt, 0, sizeof(struct v4l2_tuner) );
 952
 953         if ( (p_sys->i_frequency >= pi_radio_range[0])
 954               && (p_sys->i_frequency <= pi_radio_range[1]) )
 955         {
 956             p_sys->i_radio_fd = open( p_sys->psz_radiodev, O_RDWR );
 957             if( p_sys->i_radio_fd < 0 )
 958             {
 959                 msg_Err( p_access, "Cannot open radio device (%m)." );
 960                 Close( VLC_OBJECT(p_access) );
 961                 return VLC_EGENERIC;
 962             }
 963             msg_Dbg( p_access, "using radio device: %s",
 964                      p_sys->psz_radiodev );
 965             i_fd = p_sys->i_radio_fd;
 966         }
 967         else
 968         {
 969             i_fd = p_sys->i_fd;
 970             p_sys->i_radio_fd = -1;
 971         }
 972
 973         result = ioctl( i_fd, VIDIOC_G_TUNER, &vt );
 974         if ( result < 0 )
 975         {
 976             msg_Warn( p_access, "Failed to read tuner information (%m)." );
 977         }
 978         else
 979         {
 980             struct v4l2_frequency vf;
 981
 982             memset( &vf, 0, sizeof(struct v4l2_frequency) );
 983             vf.tuner = vt.index;
 984
 985             result = ioctl( i_fd, VIDIOC_G_FREQUENCY, &vf );
 986             if ( result < 0 )
 987             {
 988                 msg_Warn( p_access, "Failed to read tuner frequency (%m)." );
 989             }
 990             else
 991             {
 992                 if( vt.capability & V4L2_TUNER_CAP_LOW )
 993                     vf.frequency = p_sys->i_frequency * 16;
 994                 else
 995                     vf.frequency = (p_sys->i_frequency * 16 + 500) / 1000;
 996
 997                 result = ioctl( i_fd, VIDIOC_S_FREQUENCY, &vf );
 998                 if( result < 0 )
 999                 {
1000                     msg_Warn( p_access, "Failed to set tuner frequency (%m)." );
1001                 }
1002                 else
1003                 {
1004                     msg_Dbg( p_access, "tuner frequency set to: %d",
1005                              p_sys->i_frequency );
1006                 }
1007             }
1008         }
1009     }
1010
1011     /* control parameters */
1012     if ( p_sys->i_volume != -1 )
1013     {
1014         struct v4l2_control ctrl;
1015
1016         memset( &ctrl, 0, sizeof(struct v4l2_control) );
1017         ctrl.id = V4L2_CID_AUDIO_VOLUME;
1018         ctrl.value = p_sys->i_volume;
1019
1020         result = ioctl( p_sys->i_fd, VIDIOC_S_CTRL, &ctrl );
1021         if ( result < 0 )
1022         {
1023             msg_Warn( p_access, "Failed to set the volume." );
1024         }
1025     }
1026
1027     /* codec parameters */
1028     if ( (p_sys->i_framerate != -1)
1029             || (p_sys->i_bitrate_mode != -1)
1030             || (p_sys->i_bitrate_peak != -1)
1031             || (p_sys->i_keyint != -1)
1032             || (p_sys->i_bframes != -1)
1033             || (p_sys->i_bitrate != -1)
1034             || (p_sys->i_audio_bitmask != -1) )
1035     {
1036         if( p_sys->b_v4l2_api )
1037         {
1038 #ifdef HAVE_NEW_LINUX_VIDEODEV2_H
1039             result = ConfigureV4L2( p_access );
1040             if( result != VLC_SUCCESS )
1041             {
1042                 Close( VLC_OBJECT(p_access) );
1043                 return result;
1044             }
1045 #else
1046             msg_Warn( p_access, "You have new ivtvdrivers, "
1047                       "but this vlc was built against an old v4l2 version." );
1048 #endif
1049         }
1050         else
1051         {
1052             result = ConfigureIVTV( p_access );
1053             if( result != VLC_SUCCESS )
1054             {
1055                 Close( VLC_OBJECT(p_access) );
1056                 return result;
1057             }
1058         }
1059     }
1060
1061     return VLC_SUCCESS;
1062 }
1063
1064 /*****************************************************************************
1065  * Close: close the device
1066  *****************************************************************************/
1067 static void Close( vlc_object_t * p_this )
1068 {
1069     access_t *p_access = (access_t*) p_this;
1070     access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
1071
1072     if ( p_sys->i_fd != -1 )
1073         close( p_sys->i_fd );
1074     if ( p_sys->i_radio_fd != -1 )
1075         close( p_sys->i_radio_fd );
1076     if ( p_sys->psz_videodev )
1077         free( p_sys->psz_videodev );
1078     if ( p_sys->psz_radiodev )
1079         free( p_sys->psz_radiodev );
1080     free( p_sys );
1081 }
1082
1083 /*****************************************************************************
1084  * Read
1085  *****************************************************************************/
1086 static ssize_t Read( access_t * p_access, uint8_t * p_buffer, size_t i_len )
1087 {
1088     access_sys_t *p_sys = (access_sys_t *) p_access->p_sys;
1089     struct pollfd ufd;
1090     int i_ret;
1091
1092     ufd.fd = p_sys->i_fd;
1093     ufd.events = POLLIN;
1094
1095     if( p_access->info.b_eof )
1096         return 0;
1097
1098     do
1099     {
1100         if( p_access->b_die )
1101             return 0;
1102
1103         ufd.revents = 0;
1104     }
1105     while( ( i_ret = poll( &ufd, 1, 500 ) ) == 0 );
1106
1107     if( i_ret < 0 )
1108     {
1109         msg_Err( p_access, "Polling error (%m)." );
1110         return -1;
1111     }
1112
1113     i_ret = read( p_sys->i_fd, p_buffer, i_len );
1114     if( i_ret == 0 )
1115     {
1116         p_access->info.b_eof = VLC_TRUE;
1117     }
1118     else if( i_ret > 0 )
1119     {
1120         p_access->info.i_pos += i_ret;
1121     }
1122
1123     return i_ret;
1124 }
1125
1126 /*****************************************************************************
1127  * Control
1128  *****************************************************************************/
1129 static int Control( access_t *p_access, int i_query, va_list args )
1130 {
1131     vlc_bool_t   *pb_bool;
1132     int          *pi_int;
1133     int64_t      *pi_64;
1134
1135     switch( i_query )
1136     {
1137         /* */
1138         case ACCESS_CAN_SEEK:
1139         case ACCESS_CAN_FASTSEEK:
1140             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
1141             *pb_bool = VLC_FALSE;
1142             break;
1143         case ACCESS_CAN_PAUSE:
1144             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
1145             *pb_bool = VLC_FALSE;
1146             break;
1147         case ACCESS_CAN_CONTROL_PACE:
1148             pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t* );
1149             *pb_bool = VLC_FALSE;
1150             break;
1151
1152         /* */
1153         case ACCESS_GET_MTU:
1154             pi_int = (int*)va_arg( args, int * );
1155             *pi_int = 0;
1156             break;
1157
1158         case ACCESS_GET_PTS_DELAY:
1159             pi_64 = (int64_t*)va_arg( args, int64_t * );
1160             *pi_64 = (int64_t)var_GetInteger( p_access, "pvr-caching" ) * 1000;
1161             break;
1162
1163         /* */
1164         case ACCESS_SET_PAUSE_STATE:
1165             /* Nothing to do */
1166             break;
1167
1168         case ACCESS_GET_TITLE_INFO:
1169         case ACCESS_SET_TITLE:
1170         case ACCESS_SET_SEEKPOINT:
1171         case ACCESS_SET_PRIVATE_ID_STATE:
1172         case ACCESS_GET_CONTENT_TYPE:
1173             return VLC_EGENERIC;
1174
1175         default:
1176             msg_Warn( p_access, "Unimplemented query in control." );
1177             return VLC_EGENERIC;
1178
1179     }
1180     return VLC_SUCCESS;
1181 }