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