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