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