RepoMirrors
/
mpv
mirror of https://github.com/mpv-player/mpv
1
0
Fork 0
Code Issues Releases Wiki Activity
mpv/libmpdemux/stream_pvr.c

1027 lines
27 KiB
C
Raw Blame History

/*
* Copyright (C) 2006 Benjamin Zores
* Stream layer for WinTV PVR-150/250/350 (a.k.a IVTV) PVR cards.
* See http://ivtvdriver.org/index.php/Main_Page for more details on the
* cards supported by the ivtv driver.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <sys/time.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <inttypes.h>
#include <sys/poll.h>
#include <linux/videodev2.h>
#include <linux/ivtv.h>
#include "mp_msg.h"
#include "help_mp.h"
#include "stream.h"
#include "tv.h"
#define PVR_DEFAULT_DEVICE "/dev/video0"
/* logging mechanisms */
#define LOG_LEVEL_PVR "[pvr]"
#define LOG_LEVEL_V4L2 "[v4l2]"
#define LOG_LEVEL_IVTV "[ivtv]"
/* IVTV driver settings (see http://ivtvdriver.org/index.php/Ivtvctl ) */
/* codec aspect ratio (1:1, 4:3, 16:9, 2.21:1) */
#define PVR_ASPECT_RATIO_1_1 1
#define PVR_ASPECT_RATIO_4_3 2
#define PVR_ASPECT_RATIO_16_9 3
#define PVR_ASPECT_RATIO_2_21_1 4
/* audio codec sample rate (32KHz, CD 44.1 KHz, AC97 48 KHz) */
#define PVR_AUDIO_SAMPLE_RATE_44_1_KHZ 0x0000
#define PVR_AUDIO_SAMPLE_RATE_48_KHZ 0x0001
#define PVR_AUDIO_SAMPLE_RATE_32_KHZ 0x0002
/* audio codec layer (1 or 2) */
#define PVR_AUDIO_LAYER_1 0x0004
#define PVR_AUDIO_LAYER_2 0x0008
/* audio codec bitrate */
#define PVR_AUDIO_BITRATE_32 0x0010
#define PVR_AUDIO_BITRATE_L1_64 0x0020
#define PVR_AUDIO_BITRATE_L1_96 0x0030
#define PVR_AUDIO_BITRATE_L1_128 0x0040
#define PVR_AUDIO_BITRATE_L1_160 0x0050
#define PVR_AUDIO_BITRATE_L1_192 0x0060
#define PVR_AUDIO_BITRATE_L1_224 0x0070
#define PVR_AUDIO_BITRATE_L1_256 0x0080
#define PVR_AUDIO_BITRATE_L1_288 0x0090
#define PVR_AUDIO_BITRATE_L1_320 0x00A0
#define PVR_AUDIO_BITRATE_L1_352 0x00B0
#define PVR_AUDIO_BITRATE_L1_384 0x00C0
#define PVR_AUDIO_BITRATE_L1_416 0x00D0
#define PVR_AUDIO_BITRATE_L1_448 0x00E0
#define PVR_AUDIO_BITRATE_L2_48 0x0020
#define PVR_AUDIO_BITRATE_L2_56 0x0030
#define PVR_AUDIO_BITRATE_L2_64 0x0040
#define PVR_AUDIO_BITRATE_L2_80 0x0050
#define PVR_AUDIO_BITRATE_L2_96 0x0060
#define PVR_AUDIO_BITRATE_L2_112 0x0070
#define PVR_AUDIO_BITRATE_L2_128 0x0080
#define PVR_AUDIO_BITRATE_L2_160 0x0090
#define PVR_AUDIO_BITRATE_L2_192 0x00A0
#define PVR_AUDIO_BITRATE_L2_224 0x00B0
#define PVR_AUDIO_BITRATE_L2_256 0x00C0
#define PVR_AUDIO_BITRATE_L2_320 0x00D0
#define PVR_AUDIO_BITRATE_L2_384 0x00E0
/* audio codec mode */
#define PVR_AUDIO_MODE_ARG_STEREO "stereo"
#define PVR_AUDIO_MODE_ARG_JOINT_STEREO "joint_stereo"
#define PVR_AUDIO_MODE_ARG_DUAL "dual"
#define PVR_AUDIO_MODE_ARG_MONO "mono"
#define PVR_AUDIO_MODE_STEREO 0x0000
#define PVR_AUDIO_MODE_JOINT_STEREO 0x0100
#define PVR_AUDIO_MODE_DUAL 0x0200
#define PVR_AUDIO_MODE_MONO 0x0300
/* video codec bitrate mode */
#define PVR_VIDEO_BITRATE_MODE_ARG_VBR "vbr"
#define PVR_VIDEO_BITRATE_MODE_ARG_CBR "cbr"
#define PVR_VIDEO_BITRATE_MODE_VBR 0
#define PVR_VIDEO_BITRATE_MODE_CBR 1
/* video codec stream type */
#define PVR_VIDEO_STREAM_TYPE_PS "ps"
#define PVR_VIDEO_STREAM_TYPE_TS "ts"
#define PVR_VIDEO_STREAM_TYPE_MPEG1 "mpeg1"
#define PVR_VIDEO_STREAM_TYPE_DVD "dvd"
#define PVR_VIDEO_STREAM_TYPE_VCD "vcd"
#define PVR_VIDEO_STREAM_TYPE_SVCD "svcd"
#define PVR_VIDEO_STREAM_TYPE_DVD_S1 "dvds1"
#define PVR_VIDEO_STREAM_TYPE_DVD_S2 "dvds2"
/* command line arguments */
int pvr_param_aspect_ratio = 0;
int pvr_param_sample_rate = 0;
int pvr_param_audio_layer = 0;
int pvr_param_audio_bitrate = 0;
char *pvr_param_audio_mode = NULL;
int pvr_param_bitrate = 0;
char *pvr_param_bitrate_mode = NULL;
int pvr_param_bitrate_peak = 0;
char *pvr_param_stream_type = NULL;
struct pvr_t {
int dev_fd;
char *video_dev;
/* v4l2 params */
int mute;
int input;
int normid;
int brightness;
int contrast;
int hue;
int saturation;
int width;
int height;
char *freq;
/* ivtv params */
int aspect;
int samplerate;
int layer;
int audio_rate;
int audio_mode;
int bitrate;
int bitrate_mode;
int bitrate_peak;
int stream_type;
};
static struct pvr_t *
pvr_init (void)
{
struct pvr_t *pvr = NULL;
pvr = malloc (sizeof (struct pvr_t));
pvr->dev_fd = -1;
pvr->video_dev = strdup (PVR_DEFAULT_DEVICE);
/* v4l2 params */
pvr->mute = 0;
pvr->input = 0;
pvr->normid = -1;
pvr->brightness = 0;
pvr->contrast = 0;
pvr->hue = 0;
pvr->saturation = 0;
pvr->width = -1;
pvr->height = -1;
pvr->freq = NULL;
/* ivtv params */
pvr->aspect = -1;
pvr->samplerate = -1;
pvr->layer = -1;
pvr->audio_rate = -1;
pvr->audio_mode = -1;
pvr->bitrate = -1;
pvr->bitrate_mode = -1;
pvr->bitrate_peak = -1;
pvr->stream_type = -1;
return pvr;
}
static void
pvr_uninit (struct pvr_t *pvr)
{
if (!pvr)
return;
/* close device */
if (pvr->dev_fd)
close (pvr->dev_fd);
if (pvr->video_dev)
free (pvr->video_dev);
if (pvr->freq)
free (pvr->freq);
free (pvr);
}
/* IVTV layer */
static void
parse_ivtv_options (struct pvr_t *pvr)
{
if (!pvr)
return;
/* -pvr aspect=digit */
if (pvr_param_aspect_ratio >= 1 && pvr_param_aspect_ratio <= 4)
pvr->aspect = pvr_param_aspect_ratio;
/* -pvr arate=x */
if (pvr_param_sample_rate != 0)
{
switch (pvr_param_sample_rate)
{
case 32000:
pvr->samplerate = PVR_AUDIO_SAMPLE_RATE_32_KHZ;
break;
case 44100:
pvr->samplerate = PVR_AUDIO_SAMPLE_RATE_44_1_KHZ;
break;
case 48000:
pvr->samplerate = PVR_AUDIO_SAMPLE_RATE_48_KHZ;
break;
default:
break;
}
}
/* -pvr alayer=x */
if (pvr_param_audio_layer == 1)
pvr->layer = PVR_AUDIO_LAYER_1;
else if (pvr_param_audio_layer == 2)
pvr->layer = PVR_AUDIO_LAYER_2;
/* -pvr abitrate=x */
if (pvr_param_audio_bitrate != 0)
{
/* set according to layer or use layer 1 by default if not specified */
switch (pvr_param_audio_bitrate)
{
case 32:
pvr->audio_rate = PVR_AUDIO_BITRATE_32;
break;
case 48:
pvr->audio_rate = PVR_AUDIO_BITRATE_L2_48;
break;
case 56:
pvr->audio_rate = PVR_AUDIO_BITRATE_L2_56;
break;
case 64:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_64 : PVR_AUDIO_BITRATE_L1_64;
break;
case 80:
pvr->audio_rate = PVR_AUDIO_BITRATE_L2_80;
break;
case 96:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_96 : PVR_AUDIO_BITRATE_L1_96;
break;
case 112:
pvr->audio_rate = PVR_AUDIO_BITRATE_L2_112;
break;
case 128:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_128 : PVR_AUDIO_BITRATE_L1_128;
break;
case 160:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_160 : PVR_AUDIO_BITRATE_L1_160;
break;
case 192:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_192 : PVR_AUDIO_BITRATE_L1_192;
break;
case 224:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_224 : PVR_AUDIO_BITRATE_L1_224;
break;
case 256:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_256 : PVR_AUDIO_BITRATE_L1_256;
break;
case 288:
pvr->audio_rate = PVR_AUDIO_BITRATE_L1_288;
break;
case 320:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_320 : PVR_AUDIO_BITRATE_L1_320;
break;
case 352:
pvr->audio_rate = PVR_AUDIO_BITRATE_L1_352;
break;
case 384:
pvr->audio_rate = (pvr_param_audio_layer == 2) ?
PVR_AUDIO_BITRATE_L2_384 : PVR_AUDIO_BITRATE_L1_384;
break;
case 416:
pvr->audio_rate = PVR_AUDIO_BITRATE_L1_416;
break;
case 448:
pvr->audio_rate = PVR_AUDIO_BITRATE_L1_448;
break;
default:
break;
}
}
/* -pvr amode=x */
if (pvr_param_audio_mode)
{
if (!strcmp (pvr_param_audio_mode, PVR_AUDIO_MODE_ARG_STEREO))
pvr->audio_mode = PVR_AUDIO_MODE_STEREO;
else if (!strcmp (pvr_param_audio_mode, PVR_AUDIO_MODE_ARG_JOINT_STEREO))
pvr->audio_mode = PVR_AUDIO_MODE_JOINT_STEREO;
else if (!strcmp (pvr_param_audio_mode, PVR_AUDIO_MODE_ARG_DUAL))
pvr->audio_mode = PVR_AUDIO_MODE_DUAL;
else if (!strcmp (pvr_param_audio_mode, PVR_AUDIO_MODE_ARG_MONO))
pvr->audio_mode = PVR_AUDIO_MODE_MONO;
else /* for anything else, set to stereo */
pvr->audio_mode = PVR_AUDIO_MODE_STEREO;
}
/* -pvr vbitrate=x */
if (pvr_param_bitrate)
pvr->bitrate = pvr_param_bitrate;
/* -pvr vmode=x */
if (pvr_param_bitrate_mode)
{
if (!strcmp (pvr_param_bitrate_mode, PVR_VIDEO_BITRATE_MODE_ARG_VBR))
pvr->bitrate_mode = PVR_VIDEO_BITRATE_MODE_VBR;
else if (!strcmp (pvr_param_bitrate_mode, PVR_VIDEO_BITRATE_MODE_ARG_CBR))
pvr->bitrate_mode = PVR_VIDEO_BITRATE_MODE_CBR;
else /* for anything else, set to VBR */
pvr->bitrate_mode = PVR_VIDEO_BITRATE_MODE_VBR;
}
/* -pvr vpeak=x */
if (pvr_param_bitrate_peak)
pvr->bitrate_peak = pvr_param_bitrate_peak;
/* -pvr fmt=x */
if (pvr_param_stream_type)
{
if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_PS))
pvr->stream_type = IVTV_STREAM_PS;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_TS))
pvr->stream_type = IVTV_STREAM_TS;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_MPEG1))
pvr->stream_type = IVTV_STREAM_MPEG1;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_DVD))
pvr->stream_type = IVTV_STREAM_DVD;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_VCD))
pvr->stream_type = IVTV_STREAM_VCD;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_SVCD))
pvr->stream_type = IVTV_STREAM_SVCD;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_DVD_S1))
pvr->stream_type = IVTV_STREAM_DVD_S1;
else if (!strcmp (pvr_param_stream_type, PVR_VIDEO_STREAM_TYPE_DVD_S2))
pvr->stream_type = IVTV_STREAM_DVD_S2;
else /* for anything else, set to MPEG PS */
pvr->stream_type = IVTV_STREAM_PS;
}
}
static int
set_ivtv_settings (struct pvr_t *pvr)
{
struct ivtv_ioctl_codec codec;
if (!pvr)
return -1;
if (pvr->dev_fd < 0)
return -1;
/* get current settings */
if (ioctl (pvr->dev_fd, IVTV_IOC_G_CODEC, &codec) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get codec (%s).\n", LOG_LEVEL_IVTV, strerror (errno));
return -1;
}
/* set default encoding settings
* may be overlapped by user parameters
* Use VBR MPEG_PS encoding at 6 Mbps (peak at 9.6 Mbps)
* with 48 KHz L2 384 kbps audio.
*/
codec.aspect = PVR_ASPECT_RATIO_4_3;
codec.bitrate_mode = PVR_VIDEO_BITRATE_MODE_VBR;
codec.bitrate = 6000000;
codec.bitrate_peak = 9600000;
codec.stream_type = IVTV_STREAM_PS;
codec.audio_bitmask = PVR_AUDIO_LAYER_2
| PVR_AUDIO_BITRATE_L2_384 | PVR_AUDIO_SAMPLE_RATE_48_KHZ;
/* set aspect ratio */
if (pvr->aspect != -1)
codec.aspect = pvr->aspect;
/* if user value is given, we need to reset audio bitmask */
if ((pvr->samplerate != -1) || (pvr->layer != -1)
|| (pvr->audio_rate != -1) || (pvr->audio_mode != -1))
codec.audio_bitmask = 0;
/* set audio samplerate */
if (pvr->samplerate != -1)
codec.audio_bitmask |= pvr->samplerate;
/* set audio layer */
if (pvr->layer != -1)
codec.audio_bitmask |= pvr->layer;
/* set audio bitrate */
if (pvr->audio_rate != -1)
codec.audio_bitmask |= pvr->audio_rate;
/* set audio mode */
if (pvr->audio_mode != -1)
codec.audio_bitmask |= pvr->audio_mode;
/* set video bitrate */
if (pvr->bitrate != -1)
codec.bitrate = pvr->bitrate;
/* set video bitrate mode */
if (pvr->bitrate_mode != -1)
codec.bitrate_mode = pvr->bitrate_mode;
/* set video bitrate peak */
if (pvr->bitrate != -1)
codec.bitrate_peak = pvr->bitrate_peak;
/* set video stream type */
if (pvr->stream_type != -1)
codec.stream_type = pvr->stream_type;
/* set new encoding settings */
if (ioctl (pvr->dev_fd, IVTV_IOC_S_CODEC, &codec) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set codec (%s).\n", LOG_LEVEL_IVTV, strerror (errno));
return -1;
}
return 0;
}
/* V4L2 layer */
static void
parse_v4l2_tv_options (struct pvr_t *pvr)
{
if (!pvr)
return;
if (tv_param_device)
{
if (pvr->video_dev)
free (pvr->video_dev);
pvr->video_dev = strdup (tv_param_device);
}
if (tv_param_noaudio)
pvr->mute = tv_param_noaudio;
if (tv_param_input)
pvr->input = tv_param_input;
if (tv_param_normid)
pvr->normid = tv_param_normid;
if (tv_param_brightness)
pvr->brightness = tv_param_brightness;
if (tv_param_contrast)
pvr->contrast = tv_param_contrast;
if (tv_param_hue)
pvr->hue = tv_param_hue;
if (tv_param_saturation)
pvr->saturation = tv_param_saturation;
if (tv_param_width)
pvr->width = tv_param_width;
if (tv_param_height)
pvr->height = tv_param_height;
if (tv_param_freq)
pvr->freq = strdup (tv_param_freq);
}
static int
set_v4l2_settings (struct pvr_t *pvr)
{
if (!pvr)
return -1;
if (pvr->dev_fd < 0)
return -1;
/* -tv noaudio */
if (pvr->mute)
{
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_AUDIO_MUTE;
ctrl.value = 1;
if (ioctl (pvr->dev_fd, VIDIOC_S_CTRL, &ctrl) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't mute (%s).\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
}
/* -tv input=x */
if (pvr->input != 0)
{
if (ioctl (pvr->dev_fd, VIDIOC_S_INPUT, &pvr->input) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set input (%s)\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
}
/* -tv normid=x */
if (pvr->normid != -1)
{
struct v4l2_standard std;
std.index = pvr->normid;
if (ioctl (pvr->dev_fd, VIDIOC_ENUMSTD, &std) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set norm (%s)\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
mp_msg (MSGT_OPEN, MSGL_V,
"%s set norm to %s\n", LOG_LEVEL_V4L2, std.name);
if (ioctl (pvr->dev_fd, VIDIOC_S_STD, &std.id) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set norm (%s)\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
}
/* -tv brightness=x */
if (pvr->brightness != 0)
{
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_BRIGHTNESS;
ctrl.value = pvr->brightness;
if (ctrl.value < 0)
ctrl.value = 0;
if (ctrl.value > 255)
ctrl.value = 255;
if (ioctl (pvr->dev_fd, VIDIOC_S_CTRL, &ctrl) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set brightness to %d (%s).\n",
LOG_LEVEL_V4L2, ctrl.value, strerror (errno));
return -1;
}
}
/* -tv contrast=x */
if (pvr->contrast != 0)
{
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_CONTRAST;
ctrl.value = pvr->contrast;
if (ctrl.value < 0)
ctrl.value = 0;
if (ctrl.value > 127)
ctrl.value = 127;
if (ioctl (pvr->dev_fd, VIDIOC_S_CTRL, &ctrl) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set contrast to %d (%s).\n",
LOG_LEVEL_V4L2, ctrl.value, strerror (errno));
return -1;
}
}
/* -tv hue=x */
if (pvr->hue != 0)
{
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_HUE;
ctrl.value = pvr->hue;
if (ctrl.value < -128)
ctrl.value = -128;
if (ctrl.value > 127)
ctrl.value = 127;
if (ioctl (pvr->dev_fd, VIDIOC_S_CTRL, &ctrl) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set hue to %d (%s).\n",
LOG_LEVEL_V4L2, ctrl.value, strerror (errno));
return -1;
}
}
/* -tv saturation=x */
if (pvr->saturation != 0)
{
struct v4l2_control ctrl;
ctrl.id = V4L2_CID_SATURATION;
ctrl.value = pvr->saturation;
if (ctrl.value < 0)
ctrl.value = 0;
if (ctrl.value > 127)
ctrl.value = 127;
if (ioctl (pvr->dev_fd, VIDIOC_S_CTRL, &ctrl) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set saturation to %d (%s).\n",
LOG_LEVEL_V4L2, ctrl.value, strerror (errno));
return -1;
}
}
/* -tv width=x:height=y */
if (pvr->width && pvr->height)
{
struct v4l2_format vfmt;
vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
vfmt.fmt.pix.width = pvr->width;
vfmt.fmt.pix.height = pvr->height;
if (ioctl (pvr->dev_fd, VIDIOC_S_FMT, &vfmt) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set resolution to %dx%d (%s).\n",
LOG_LEVEL_V4L2, pvr->width, pvr->height, strerror (errno));
return -1;
}
}
/* -tv freq=x */
if (pvr->freq)
{
struct v4l2_frequency vf;
vf.tuner = 0;
vf.type = 0;
vf.frequency = strtol (pvr->freq, 0L, 0);
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s setting frequency to %d\n", LOG_LEVEL_V4L2, vf.frequency);
if (ioctl (pvr->dev_fd, VIDIOC_S_FREQUENCY, &vf) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR, "%s can't set frequency (%s).\n",
LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
}
return 0;
}
static int
v4l2_list_capabilities (struct pvr_t *pvr)
{
struct v4l2_audio vaudio;
struct v4l2_standard vs;
struct v4l2_input vin;
int err = 0;
if (!pvr)
return -1;
if (pvr->dev_fd < 0)
return -1;
/* list available video inputs */
vin.index = 0;
err = 1;
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Available video inputs: ", LOG_LEVEL_V4L2);
while (ioctl (pvr->dev_fd, VIDIOC_ENUMINPUT, &vin) >= 0)
{
err = 0;
mp_msg (MSGT_OPEN, MSGL_INFO, "'#%d, %s' ", vin.index, vin.name);
vin.index++;
}
if (err)
{
mp_msg (MSGT_OPEN, MSGL_INFO, "none\n");
return -1;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO, "\n");
/* list available audio inputs */
vaudio.index = 0;
err = 1;
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Available audio inputs: ", LOG_LEVEL_V4L2);
while (ioctl (pvr->dev_fd, VIDIOC_ENUMAUDIO, &vaudio) >= 0)
{
err = 0;
mp_msg (MSGT_OPEN, MSGL_INFO, "'#%d, %s' ", vaudio.index, vaudio.name);
vaudio.index++;
}
if (err)
{
mp_msg (MSGT_OPEN, MSGL_INFO, "none\n");
return -1;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO, "\n");
/* list available norms */
vs.index = 0;
mp_msg (MSGT_OPEN, MSGL_INFO, "%s Available norms: ", LOG_LEVEL_V4L2);
while (ioctl (pvr->dev_fd, VIDIOC_ENUMSTD, &vs) >= 0)
{
err = 0;
mp_msg (MSGT_OPEN, MSGL_INFO, "'#%d, %s' ", vs.index, vs.name);
vs.index++;
}
if (err)
{
mp_msg (MSGT_OPEN, MSGL_INFO, "none\n");
return -1;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO, "\n");
return 0;
}
static int
v4l2_display_settings (struct pvr_t *pvr)
{
struct v4l2_audio vaudio;
struct v4l2_standard vs;
struct v4l2_input vin;
v4l2_std_id std;
int input;
if (!pvr)
return -1;
if (pvr->dev_fd < 0)
return -1;
/* get current video input */
if (ioctl (pvr->dev_fd, VIDIOC_G_INPUT, &input) == 0)
{
vin.index = input;
if (ioctl (pvr->dev_fd, VIDIOC_ENUMINPUT, &vin) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get input (%s).\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Video input: %s\n", LOG_LEVEL_V4L2, vin.name);
}
else
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get input (%s).\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
/* get current audio input */
if (ioctl (pvr->dev_fd, VIDIOC_G_AUDIO, &vaudio) == 0)
{
vaudio.index = input;
if (ioctl (pvr->dev_fd, VIDIOC_ENUMAUDIO, &vaudio) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get input (%s).\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Audio input: %s\n", LOG_LEVEL_V4L2, vaudio.name);
}
else
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get input (%s).\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
/* get current video format */
if (ioctl (pvr->dev_fd, VIDIOC_G_STD, &std) == 0)
{
vs.index = 0;
while (ioctl (pvr->dev_fd, VIDIOC_ENUMSTD, &vs) >= 0)
{
if (vs.id == std)
{
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Norm: %s.\n", LOG_LEVEL_V4L2, vs.name);
break;
}
vs.index++;
}
}
else
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get norm (%s)\n", LOG_LEVEL_V4L2, strerror (errno));
return -1;
}
return 0;
}
/* stream layer */
static void
pvr_stream_close (stream_t *stream)
{
struct pvr_t *pvr;
if (!stream)
return;
pvr = (struct pvr_t *) stream->priv;
pvr_uninit (pvr);
}
static int
pvr_stream_read (stream_t *stream, char *buffer, int size)
{
struct pollfd pfds[1];
struct pvr_t *pvr;
int rk, fd, pos;
if (!stream || !buffer)
return 0;
pvr = (struct pvr_t *) stream->priv;
fd = pvr->dev_fd;
pos = 0;
if (fd < 0)
return 0;
while (pos < size)
{
pfds[0].fd = fd;
pfds[0].events = POLLIN | POLLPRI;
rk = size - pos;
if (poll (pfds, 1, 500) <= 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s failed with errno %d when reading %d bytes\n",
LOG_LEVEL_PVR, errno, size-pos);
break;
}
rk = read (fd, &buffer[pos], rk);
if (rk > 0)
{
pos += rk;
mp_msg (MSGT_OPEN, MSGL_DBG3,
"%s read (%d) bytes\n", LOG_LEVEL_PVR, pos);
}
}
if (!pos)
mp_msg (MSGT_OPEN, MSGL_ERR, "%s read %d bytes\n", LOG_LEVEL_PVR, pos);
return pos;
}
static int
pvr_stream_open (stream_t *stream, int mode, void *opts, int *file_format)
{
struct ivtv_ioctl_codec codec;
struct ivtv_driver_info info;
struct v4l2_capability vcap;
struct pvr_t *pvr = NULL;
if (mode != STREAM_READ)
return STREAM_UNSUPORTED;
pvr = pvr_init ();
parse_v4l2_tv_options (pvr);
parse_ivtv_options (pvr);
/* open device */
pvr->dev_fd = open (pvr->video_dev, O_RDWR);
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Using device %s\n", LOG_LEVEL_PVR, pvr->video_dev);
if (pvr->dev_fd == -1)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s error opening device %s\n", LOG_LEVEL_PVR, pvr->video_dev);
pvr_uninit (pvr);
return STREAM_ERROR;
}
/* query capabilities (i.e test V4L2 support) */
if (ioctl (pvr->dev_fd, VIDIOC_QUERYCAP, &vcap) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s device is not V4L2 compliant (%s).\n",
LOG_LEVEL_PVR, strerror (errno));
pvr_uninit (pvr);
return STREAM_ERROR;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Detected %s\n", LOG_LEVEL_PVR, vcap.card);
/* get codec and initialize card (i.e test IVTV support) */
if (ioctl (pvr->dev_fd, IVTV_IOC_G_CODEC, &codec) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s device is not IVTV compliant (%s).\n",
LOG_LEVEL_PVR, strerror (errno));
pvr_uninit (pvr);
return STREAM_ERROR;
}
/* get ivtv driver info */
if (ioctl (pvr->dev_fd, IVTV_IOC_G_DRIVER_INFO, &info) < 0)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s device is not IVTV compliant (%s).\n",
LOG_LEVEL_PVR, strerror (errno));
pvr_uninit (pvr);
return STREAM_ERROR;
}
else
mp_msg (MSGT_OPEN, MSGL_INFO,
"%s Detected ivtv driver: %s\n", LOG_LEVEL_PVR, info.comment);
/* list V4L2 capabilities */
if (v4l2_list_capabilities (pvr) == -1)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get v4l2 capabilities\n", LOG_LEVEL_PVR);
pvr_uninit (pvr);
return STREAM_ERROR;
}
/* apply V4L2 settings */
if (set_v4l2_settings (pvr) == -1)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set v4l2 settings\n", LOG_LEVEL_PVR);
pvr_uninit (pvr);
return STREAM_ERROR;
}
/* apply IVTV settings */
if (set_ivtv_settings (pvr) == -1)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't set ivtv settings\n", LOG_LEVEL_PVR);
pvr_uninit (pvr);
return STREAM_ERROR;
}
/* display current V4L2 settings */
if (v4l2_display_settings (pvr) == -1)
{
mp_msg (MSGT_OPEN, MSGL_ERR,
"%s can't get v4l2 settings\n", LOG_LEVEL_PVR);
pvr_uninit (pvr);
return STREAM_ERROR;
}
stream->priv = pvr;
stream->type = STREAMTYPE_PVR;
stream->fill_buffer = pvr_stream_read;
stream->close = pvr_stream_close;
return STREAM_OK;
}
stream_info_t stream_info_pvr = {
"PVR (V4L2/IVTV) Input",
"pvr",
"Benjamin Zores",
"",
pvr_stream_open,
{ "pvr", NULL },
NULL,
1
};
Reference in New Issue View Git Blame Copy Permalink