DirectShow based tv:// driver for win32

Teletext is also supported (but 625 system parameters are hardcoded).
pthreads is required for teletext.

Code is still experimental.



git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@24772 b3059339-0415-0410-9bf9-f77b7e298cf2

6 files changed, 4062 insertions, 9 deletions

diff --git a/stream/Makefile b/stream/Makefile
index 623154359e..f69b5d350c 100644
--- a/stream/Makefile
+++ b/stream/Makefile
@@ -52,6 +52,7 @@ SRCS_COMMON-$(STREAM_CACHE)      += cache2.c
 SRCS_COMMON-$(STREAMING_LIVE555) += stream_livedotcom.c
 SRCS_COMMON-$(TV)                += stream_tv.c tv.c frequencies.c tvi_dummy.c
 SRCS_COMMON-$(TV_BSDBT848)       += tvi_bsdbt848.c
+SRCS_COMMON-$(TV_DSHOW)          += tvi_dshow.c
 SRCS_COMMON-$(TV_TELETEXT)       += tvi_vbi.c
 SRCS_COMMON-$(TV_V4L1)           += tvi_v4l.c  audio_in.c
 SRCS_COMMON-$(TV_V4L2)           += tvi_v4l2.c audio_in.c
diff --git a/stream/stream_tv.c b/stream/stream_tv.c
index 95ba0b97a7..4328e72df9 100644
--- a/stream/stream_tv.c
+++ b/stream/stream_tv.c
@@ -36,7 +36,7 @@ tv_param_t stream_tv_defaults = {
     "europe-east", //chanlist
     "pal",         //norm
     0,             //automute
-#ifdef HAVE_TV_V4L2
+#if defined(HAVE_TV_V4L2) || defined(HAVE_TV_DSHOW)
     -1,            //normid
 #endif
     NULL,          //device
@@ -51,15 +51,18 @@ tv_param_t stream_tv_defaults = {
     0,             //immediate;
     44100,         //audiorate;
     0,             //audio_id
-#if defined(HAVE_TV_V4L)
+#if defined(HAVE_TV_V4L) || defined(HAVE_TV_DSHOW)
     -1,            //amode
     -1,            //volume
+#if defined(HAVE_TV_V4L)
     -1,            //bass
     -1,            //treble
     -1,            //balance
     -1,            //forcechan
     0,             //force_audio
+#endif
     -1,            //buffer_size
+#if defined(HAVE_TV_V4L)
     0,             //mjpeg
     2,             //decimation
     90,            //quality
@@ -68,6 +71,7 @@ tv_param_t stream_tv_defaults = {
 #endif
 #endif
     NULL,          //adevice
+#endif
     0,             //brightness
     0,             //contrast
     0,             //hue
@@ -80,7 +84,13 @@ tv_param_t stream_tv_defaults = {
 
     0,             //scan_autostart
     50,            //scan_threshold
-    0.5            //scan_period
+    0.5,            //scan_period
+#ifdef HAVE_TV_DSHOW
+    0,             //hidden_video_renderer;
+    0,             //hidden_vp_renderer;
+    0,             //system_clock;
+    0              //normalize_audio_chunks;
+#endif
 };
 
 #define ST_OFF(f) M_ST_OFF(tv_param_t,f)
diff --git a/stream/tv.c b/stream/tv.c
index 3315905930..7443445e28 100644
--- a/stream/tv.c
+++ b/stream/tv.c
@@ -42,6 +42,9 @@ char *tv_channel_last_real;
 
 /* enumerating drivers (like in stream.c) */
 extern tvi_info_t tvi_info_dummy;
+#ifdef HAVE_TV_DSHOW
+extern tvi_info_dshow;
+#endif
 #ifdef HAVE_TV_V4L1
 extern tvi_info_t tvi_info_v4l;
 #endif
@@ -63,6 +66,9 @@ static const tvi_info_t* tvi_driver_list[]={
 #ifdef HAVE_TV_BSDBT848
     &tvi_info_bsdbt848,
 #endif
+#ifdef HAVE_TV_DSHOW
+    &tvi_info_dshow,
+#endif
     &tvi_info_dummy,
     NULL
 };
@@ -200,9 +206,14 @@ static int demux_tv_fill_buffer(demuxer_t *demux, demux_stream_t *ds)
 
 static int norm_from_string(tvi_handle_t *tvh, char* norm)
 {
+    if (1
 #ifdef HAVE_TV_V4L2
-    if (strcmp(tvh->tv_param->driver, "v4l2") != 0) {
+        && strcmp(tvh->tv_param->driver, "v4l2") != 0 &&
 #endif
+#ifdef HAVE_TV_DSHOW
+        && strcmp(tvh->tv_param->driver, "dshow") != 0
+#endif
+    ) {
     if (!strcasecmp(norm, "pal"))
 	return TV_NORM_PAL;
     else if (!strcasecmp(norm, "ntsc"))
@@ -221,7 +232,7 @@ static int norm_from_string(tvi_handle_t *tvh, char* norm)
 	mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_BogusNormParameter, norm, "PAL");
 	return TV_NORM_PAL;
     }
-#ifdef HAVE_TV_V4L2
+#if defined(HAVE_TV_V4L2) || defined(HAVE_TV_DSHOW)
     } else {
 	tvi_functions_t *funcs = tvh->functions;
 	char str[8];
@@ -361,8 +372,15 @@ static int open_tv(tvi_handle_t *tvh)
     /* set some params got from cmdline */
     funcs->control(tvh->priv, TVI_CONTROL_SPC_SET_INPUT, &tvh->tv_param->input);
 
+#if defined(HAVE_TV_V4L2) || defined(HAVE_TV_DSHOW)
+    if (0 
 #ifdef HAVE_TV_V4L2
-    if (!strcmp(tvh->tv_param->driver, "v4l2") && tvh->tv_param->normid >= 0) {
+    || (!strcmp(tvh->tv_param->driver, "v4l2") && tvh->tv_param->normid >= 0)
+#endif
+#ifdef HAVE_TV_DSHOW
+    || (!strcmp(tvh->tv_param->driver, "dshow") && tvh->tv_param->normid >= 0)
+#endif
+    ) {
 	mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_SelectedNormId, tvh->tv_param->normid);
 	if (funcs->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->tv_param->normid) != TVI_CONTROL_TRUE) {
 	    mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_CannotSetNorm);
@@ -376,7 +394,7 @@ static int open_tv(tvi_handle_t *tvh)
     if (funcs->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->norm) != TVI_CONTROL_TRUE) {
 	mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_CannotSetNorm);
     }
-#ifdef HAVE_TV_V4L2
+#if defined(HAVE_TV_V4L2) || defined(HAVE_TV_DSHOW)
     }
 #endif
 
diff --git a/stream/tv.h b/stream/tv.h
index ff04a901d3..acd78f108f 100644
--- a/stream/tv.h
+++ b/stream/tv.h
@@ -11,7 +11,7 @@ typedef struct tv_param_s {
     char *chanlist;
     char *norm;
     int automute;
-#ifdef HAVE_TV_V4L2
+#if defined(HAVE_TV_V4L2) || defined(HAVE_TV_DSHOW)
     int normid;
 #endif
     char *device;
@@ -26,15 +26,18 @@ typedef struct tv_param_s {
     int immediate;
     int audiorate;
     int audio_id;
-#if defined(HAVE_TV_V4L)
+#if defined(HAVE_TV_V4L) || defined(HAVE_TV_DSHOW)
     int amode;
     int volume;
+#if defined(HAVE_TV_V4L)
     int bass;
     int treble;
     int balance;
     int forcechan;
     int force_audio;
+#endif
     int buffer_size;
+#if defined(HAVE_TV_V4L)
     int mjpeg;
     int decimation;
     int quality;
@@ -43,6 +46,7 @@ typedef struct tv_param_s {
 #endif
 #endif
     char* adevice;
+#endif
     int brightness;
     int contrast;
     int hue;
@@ -56,6 +60,35 @@ typedef struct tv_param_s {
     int scan;
     int scan_threshold;
     float scan_period;
+
+#ifdef HAVE_TV_DSHOW
+    /**
+      Terminate stream with video renderer instead of Null renderer 
+      Will help if video freezes but audio does not.
+      May not work with -vo directx and -vf crop combination.
+    */
+    int hidden_video_renderer;
+    /**
+      For VIVO cards VP pin have to be rendered too.
+      This tweak will cause VidePort pin stream to be terminated with video renderer 
+      instead of removing it from graph.
+      Use if your card have vp pin and video is still choppy.
+      May not work with -vo directx and -vf crop combination.
+    */
+    int hidden_vp_renderer;
+    /**
+      Use system clock as sync source instead of default graph clock (usually the clock 
+      from one of live sources in graph.
+    */
+    int system_clock;
+    /**
+      Some audio cards creates audio chunks with about 0.5 sec size.
+      This can cause choppy video when using mplayer with immediatemode=0
+      Use followingtweak to decrease audio chunk sizes.
+      It will create audio chunks with time length equal to one video frame time.
+    */
+    int normalize_audio_chunks;
+#endif
 } tv_param_t;
   
 extern tv_param_t stream_tv_defaults;
diff --git a/stream/tvi_dshow.c b/stream/tvi_dshow.c
new file mode 100644
index 0000000000..43ab094c2f
--- /dev/null
+++ b/stream/tvi_dshow.c
@@ -0,0 +1,3298 @@
+/*
+ *     TV support under Win32
+ * 
+ *     (C) 2007 Vladimir Voroshilov <voroshil@gmail.com>.
+ *
+ *     Based on tvi_dummy.c with help of tv.c, tvi_v4l2.c code .
+ *
+ *     -------------------------------------------------------------------------------
+ *
+ *     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 St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ *
+ *     -------------------------------------------------------------------------------
+ *
+ *
+ *     WARNING: This is alpha code!
+ *
+ *     Abilities:
+ *     * Watching TV under Win32 using WDM Capture driver and DirectShow
+ *     * Grabbing synchronized audio/video with mencoder (synchronization is beeing done by DirectShow)
+ *     * If device driver provides IAMStreamConfig interface, user can choose width/height with "-tv height=<h>:width=<w>"
+ *     * Adjusting BRIGHTNESS,HUE,SATURATION,CONTRAST if supported by device
+ *     * Selecting Tuner,S-Video,... as media source
+ *     * User can select used video capture device, passing -tv device=<dev#>
+ *     * User can select used audio input, passing -tv audioid=<input#>
+ *
+ *     options which will not be implemented (probably sometime in future, if possible):
+ *     * alsa
+ *     * mjpeg
+ *     * decimation=<1|2|4>
+ *     * quality=<0\-100>
+ *     * forceaudio
+ *     * forcechan=<1\-2>
+ *     * [volume|bass|treble|balance]
+ *
+ *     Works with:
+ *       - LifeView FlyTV Prime 34FM (SAA7134 based) with driver from Ivan Uskov
+ *     Partially works with:
+ *       - ATI 9200 VIVO based card
+ *       - ATI AIW 7500
+ *       - nVidia Ti-4400
+ * 
+ *     Known bugs:
+ *     * stream goes with 24.93 FPS (NTSC), while reporting 25 FPS (PAL) ?!
+ *     * direct set frequency call does not work ('Insufficient Buffer' error)
+ *     * audio stream goes with about 1 sample/sec rate when capturing sound from audio card
+ *
+ *     TODO:
+ *     * check audio with small buffer on vivo !!!
+ *     * norm for IAMVideoDecoder and for IAMTVtuner - differs !!
+ *     * check how to change TVFormat on VIVO card without tuner
+ *     * Flip image upside-down for RGB formats.
+ *     *
+ *     * remove debug sleep()
+ *     * Add some notes to methods' parameters
+ *     * refactor console messages
+ *     * check using header files and keep only needed
+ *     * add additional comments to methods' bodies
+ *
+ */
+
+
+/// \ingroup tvi_dshow
+
+#include "config.h"
+
+#include <stdio.h>
+#include "libmpcodecs/img_format.h"
+#include "libaf/af_format.h"
+#include "help_mp.h"
+#include "osdep/timer.h"
+
+
+#include "tv.h"
+#include "mp_msg.h"
+#include "frequencies.h"
+
+
+#include "tvi_dshow.h"
+
+static tvi_handle_t *tvi_init_dshow(tv_param_t* tv_param);
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*   Data structures
+*
+*---------------------------------------------------------------------------------------
+*/
+/** 
+    information about this file
+*/
+tvi_info_t tvi_info_dshow = {
+    tvi_init_dshow,
+    "DirectShow TV",
+    "dshow",
+    "Vladimir Voroshilov",
+    "Very experimental!! Use with caution"
+};
+
+
+/**
+ringbuffer related info
+*/
+typedef struct {
+    CRITICAL_SECTION *pMutex;	///< pointer to critical section (mutex)
+    char **ringbuffer;		///< ringbuffer array
+    double*dpts;		///< samples' timestamps
+
+    int buffersize;		///< size of buffer in blocks
+    int blocksize;		///< size of individual block
+    int head;			///< index of first valid sample
+    int tail;			///< index of last valid sample
+    int count;			///< count of valid samples in ringbuffer
+    double tStart;              ///< pts of first sample (first sample should have pts 0)
+} grabber_ringbuffer_t;
+
+/**
+     CSampleGrabberCD definition
+*/
+typedef struct CSampleGrabberCB {
+    ISampleGrabberCBVtbl *lpVtbl;
+    int refcount;
+    GUID interfaces[2];
+    grabber_ringbuffer_t *pbuf;
+} CSampleGrabberCB;
+
+typedef struct {
+    int dev_index;              ///< capture device index in device list (defaul: 0, first available device)
+    int adev_index;             ///< audio capture device index in device list (default: -1, not used)
+    int immediate_mode;         ///< immediate mode (no sound capture)
+    int state;                  ///< state: 1-filter graph running, 0-filter graph stopped
+    int direct_setfreq_call;    ///< 0-find nearest channels from system channel list(workaround),1-direct call to set frequency
+    int direct_getfreq_call;    ///< 0-find frequncy from frequency table (workaround),1-direct call to get frequency
+
+    int fcc;                    ///< used video format code (FourCC)
+    int width;                  ///< picture width (default: auto) 
+    int height;                 ///< picture height (default: auto)
+
+    int channels;               ///< number of audio channels (default: auto)
+    int samplerate;             ///< audio samplerate (default: auto)
+
+    long *freq_table;           ///< frequency table (in Hz)
+    int freq_table_len;         ///< length of freq table
+    int first_channel;          ///< channel number of first entry in freq table
+    int input;                  ///< used input
+
+    // video related stuff
+    int nVideoFormatUsed;                   ///< index of used video format
+    AM_MEDIA_TYPE **arpmtVideo;             ///< available video formats
+    VIDEO_STREAM_CONFIG_CAPS **arVideoCaps; ///< capabilities of output video
+    AM_MEDIA_TYPE *pmtVideo;                ///< video stream properties
+    grabber_ringbuffer_t *v_buf;
+    IBaseFilter *pVideoFilter;              ///< interface for capture device
+    IAMStreamConfig *pVideoStreamConfig;    ///< for configuring video stream
+
+    // audio related stuff
+    int nAudioFormatUsed;                   ///< index of used audio format
+    AM_MEDIA_TYPE **arpmtAudio;             ///< available audio formats
+    AUDIO_STREAM_CONFIG_CAPS **arAudioCaps; ///< capabilities of output audio
+    AM_MEDIA_TYPE *pmtAudio;                ///< audio stream properties.
+    grabber_ringbuffer_t *a_buf;
+    IBaseFilter *pAudioFilter;              ///< interface for audio capture device (if adevice passed)
+    IAMStreamConfig *pAudioStreamConfig;    ///< for configuring audio stream
+
+    AM_MEDIA_TYPE *pmtVBI;                  ///< available audio formats
+    grabber_ringbuffer_t *vbi_buf;
+
+    IAMTVTuner *pTVTuner;                   ///< interface for tuner device
+    IGraphBuilder *pGraph;                  ///< filter graph
+    ICaptureGraphBuilder2 *pBuilder;        ///< graph builder
+    IMediaControl *pMediaControl;           ///< interface for controlling graph (start, stop,...)
+    IAMVideoProcAmp *pVideoProcAmp;         ///< for adjusting hue,saturation,etc
+    IAMCrossbar *pCrossbar;                 ///< for selecting input (Tuner,Composite,S-Video,...)
+    DWORD dwRegister;                       ///< allow graphedit to connect to our graph
+    CSampleGrabberCB* pCSGCB;               ///< callback object
+    void *priv_vbi;                         ///< private VBI data structure
+    tt_stream_props tsp;                    ///< data for VBI initialization
+
+    tv_param_t* tv_param;                   ///< TV parameters
+} priv_t;
+
+#include "tvi_def.h"
+
+/**
+ country table entry structure (for loading freq table stored in kstvtuner.ax
+
+ \note
+ structure have to be 2-byte aligned and have 10-byte length!!
+*/
+typedef struct __attribute__((__packed__)) {
+    WORD CountryCode;		///< Country code
+    WORD CableFreqTable;	///< index of resource with frequencies for cable channels
+    WORD BroadcastFreqTable;	///< index of resource with frequencies for broadcast channels
+    DWORD VideoStandard;	///< used video standard 
+} TRCCountryList;
+/**
+    information about image formats
+*/
+typedef struct {
+    uint32_t fmt;		///< FourCC
+    const GUID *subtype;	///< DirectShow's subtype
+    int nBits;			///< number of bits
+    int nCompression;		///< complression
+    int tail;			///< number of additional bytes followed VIDEOINFOHEADER structure
+} img_fmt;
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*   Methods forward declaration
+*
+*---------------------------------------------------------------------------------------
+*/
+static HRESULT init_ringbuffer(grabber_ringbuffer_t * rb, int buffersize,
+			       int blocksize);
+static HRESULT show_filter_info(IBaseFilter * pFilter);
+#if 0 
+//defined in current MinGW release
+HRESULT STDCALL GetRunningObjectTable(DWORD, IRunningObjectTable **);
+HRESULT STDCALL CreateItemMoniker(LPCOLESTR, LPCOLESTR, IMoniker **);
+#endif
+static CSampleGrabberCB *CSampleGrabberCB_Create(grabber_ringbuffer_t *
+						 pbuf);
+static int set_crossbar_input(priv_t * priv, int input);
+static int subtype2imgfmt(const GUID * subtype);
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*  Global constants and variables
+*
+*---------------------------------------------------------------------------------------
+*/
+/**
+    lookup tables for physical connector types
+ */
+static const struct {
+    long type;
+    char *name;
+} tv_physcon_types[]={
+    {PhysConn_Video_Tuner,           "Tuner"          },
+    {PhysConn_Video_Composite,       "Composite"      },
+    {PhysConn_Video_SVideo,          "S-Video"        },
+    {PhysConn_Video_RGB,             "RGB"            },
+    {PhysConn_Video_YRYBY,           "YRYBY"          },
+    {PhysConn_Video_SerialDigital,   "SerialDigital"  },
+    {PhysConn_Video_ParallelDigital, "ParallelDigital"},
+    {PhysConn_Video_VideoDecoder,    "VideoDecoder"   },
+    {PhysConn_Video_VideoEncoder,    "VideoEncoder"   },
+    {PhysConn_Video_SCART,           "SCART"          },
+    {PhysConn_Video_Black,           "Blaack"         },
+    {PhysConn_Audio_Tuner,           "Tuner"          },
+    {PhysConn_Audio_Line,            "Line"           },
+    {PhysConn_Audio_Mic,             "Mic"            },
+    {PhysConn_Audio_AESDigital,      "AESDiital"      },
+    {PhysConn_Audio_SPDIFDigital,    "SPDIFDigital"   },
+    {PhysConn_Audio_AudioDecoder,    "AudioDecoder"   },
+    {PhysConn_Audio_SCSI,            "SCSI"           },
+    {PhysConn_Video_SCSI,            "SCSI"           },
+    {PhysConn_Audio_AUX,             "AUX"            },
+    {PhysConn_Video_AUX,             "AUX"            },
+    {PhysConn_Audio_1394,            "1394"           },
+    {PhysConn_Video_1394,            "1394"           },
+    {PhysConn_Audio_USB,             "USB"            },
+    {PhysConn_Video_USB,             "USB"            },
+    {-1,                              NULL            }
+};
+
+static const struct {
+    char *chanlist_name;
+    int country_code;
+} tv_chanlist2country[]={
+    {"us-bcast",     1},
+    {"russia",       7},
+    {"argentina",   54},
+    {"japan-bcast", 81},
+    {"china-bcast", 86},
+    {"southafrica", 27},
+    {"australia",   61},
+    {"ireland",    353},
+    {"france",      33},
+    {"italy",       39},
+    {"newzealand",  64},
+    //directshow table uses eastern europe freq table for russia
+    {"europe-east",  7},
+    //directshow table uses western europe freq table for germany
+    {"europe-west", 49},
+    /* cable channels */
+    {"us-cable",     1},
+    {"us-cable-hrc", 1},
+    {"japan-cable", 81},
+    //default is USA
+    {NULL,           1} 
+};
+
+/**
+    array, contains information about various supported (i hope) image formats
+*/
+static const img_fmt img_fmt_list[] = {
+    {IMGFMT_YUY2, &MEDIASUBTYPE_YUY2, 0, IMGFMT_YUY2, 0},
+    {IMGFMT_YV12, &MEDIASUBTYPE_YV12, 0, IMGFMT_YV12, 0},
+    {IMGFMT_IYUV, &MEDIASUBTYPE_IYUV, 0, IMGFMT_IYUV, 0},
+    {IMGFMT_I420, &MEDIASUBTYPE_I420, 0, IMGFMT_I420, 0},
+    {IMGFMT_UYVY, &MEDIASUBTYPE_UYVY, 0, IMGFMT_UYVY, 0},
+    {IMGFMT_YVYU, &MEDIASUBTYPE_YVYU, 0, IMGFMT_YVYU, 0},
+    {IMGFMT_YVU9, &MEDIASUBTYPE_YVU9, 0, IMGFMT_YVU9, 0},
+    {IMGFMT_BGR32, &MEDIASUBTYPE_RGB32, 32, 0, 0},
+    {IMGFMT_BGR24, &MEDIASUBTYPE_RGB24, 24, 0, 0},
+    {IMGFMT_BGR16, &MEDIASUBTYPE_RGB565, 16, 3, 12},
+    {IMGFMT_BGR15, &MEDIASUBTYPE_RGB555, 16, 3, 12},
+    {0, &GUID_NULL, 0, 0, 0}
+};
+
+#define TV_NORMS_COUNT 19
+static const struct {
+    long index;
+    char *name;
+} tv_norms[TV_NORMS_COUNT] = {
+    {
+    AnalogVideo_NTSC_M, "ntsc-m"}, {
+    AnalogVideo_NTSC_M_J, "ntsc-mj"}, {
+    AnalogVideo_NTSC_433, "ntsc-433"}, {
+    AnalogVideo_PAL_B, "pal-b"}, {
+    AnalogVideo_PAL_D, "pal-d"}, {
+    AnalogVideo_PAL_G, "pal-g"}, {
+    AnalogVideo_PAL_H, "pal-h"}, {
+    AnalogVideo_PAL_I, "pal-i"}, {
+    AnalogVideo_PAL_M, "pal-m"}, {
+    AnalogVideo_PAL_N, "pal-n"}, {
+    AnalogVideo_PAL_60, "pal-60"}, {
+    AnalogVideo_SECAM_B, "secam-b"}, {
+    AnalogVideo_SECAM_D, "secam-d"}, {
+    AnalogVideo_SECAM_G, "secam-g"}, {
+    AnalogVideo_SECAM_H, "secam-h"}, {
+    AnalogVideo_SECAM_K, "secam-k"}, {
+    AnalogVideo_SECAM_K1, "secam-k1"}, {
+    AnalogVideo_SECAM_L, "secam-l"}, {
+    AnalogVideo_SECAM_L1, "secam-l1"}
+};
+static long tv_available_norms[TV_NORMS_COUNT];
+static int tv_available_norms_count = 0;
+
+
+static long *tv_available_inputs;
+static int tv_available_inputs_count = 0;
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*  Various GUID definitions
+*
+*---------------------------------------------------------------------------------------
+*/
+/// CLSID definitions (used for CoCreateInstance call)
+DEFINE_GUID(CLSID_SampleGrabber, 0xC1F400A0, 0x3F08, 0x11d3, 0x9F, 0x0B,
+	    0x00, 0x60, 0x08, 0x03, 0x9E, 0x37);
+DEFINE_GUID(CLSID_NullRenderer, 0xC1F400A4, 0x3F08, 0x11d3, 0x9F, 0x0B,
+	    0x00, 0x60, 0x08, 0x03, 0x9E, 0x37);
+DEFINE_GUID(CLSID_SystemDeviceEnum, 0x62BE5D10, 0x60EB, 0x11d0, 0xBD, 0x3B,
+	    0x00, 0xA0, 0xC9, 0x11, 0xCE, 0x86);
+DEFINE_GUID(CLSID_CaptureGraphBuilder2, 0xBF87B6E1, 0x8C27, 0x11d0, 0xB3,
+	    0xF0, 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
+DEFINE_GUID(CLSID_VideoInputDeviceCategory, 0x860BB310, 0x5D01, 0x11d0,
+	    0xBD, 0x3B, 0x00, 0xA0, 0xC9, 0x11, 0xCE, 0x86);
+DEFINE_GUID(CLSID_AudioInputDeviceCategory, 0x33d9a762, 0x90c8, 0x11d0,
+	    0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86);
+DEFINE_GUID(CLSID_FilterGraph, 0xe436ebb3, 0x524f, 0x11ce, 0x9f, 0x53,
+	    0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(CLSID_SystemClock, 0xe436ebb1, 0x524f, 0x11ce, 0x9f, 0x53,
+	    0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
+#ifdef NOT_USED
+DEFINE_GUID(CLSID_CaptureGraphBuilder, 0xBF87B6E0, 0x8C27, 0x11d0, 0xB3,
+	    0xF0, 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
+DEFINE_GUID(CLSID_VideoPortManager, 0x6f26a6cd, 0x967b, 0x47fd, 0x87, 0x4a,
+	    0x7a, 0xed, 0x2c, 0x9d, 0x25, 0xa2);
+DEFINE_GUID(IID_IPin, 0x56a86891, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20,
+	    0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(IID_ICaptureGraphBuilder, 0xbf87b6e0, 0x8c27, 0x11d0, 0xb3,
+	    0xf0, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5);
+DEFINE_GUID(IID_IFilterGraph, 0x56a8689f, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00,
+	    0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(PIN_CATEGORY_PREVIEW, 0xfb6c4282, 0x0353, 0x11d1, 0x90, 0x5f,
+	    0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
+#endif
+
+/// IID definitions (used for QueryInterface call)
+DEFINE_GUID(IID_IReferenceClock, 0x56a86897, 0x0ad4, 0x11ce, 0xb0, 0x3a,
+	    0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(IID_IAMBufferNegotiation, 0x56ED71A0, 0xAF5F, 0x11D0, 0xB3, 0xF0,
+            0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
+DEFINE_GUID(IID_IKsPropertySet, 0x31efac30, 0x515c, 0x11d0, 0xa9, 0xaa,
+	    0x00, 0xaa, 0x00, 0x61, 0xbe, 0x93);
+DEFINE_GUID(IID_ISampleGrabber, 0x6B652FFF, 0x11FE, 0x4fce, 0x92, 0xAD,
+	    0x02, 0x66, 0xB5, 0xD7, 0xC7, 0x8F);
+DEFINE_GUID(IID_ISampleGrabberCB, 0x0579154A, 0x2B53, 0x4994, 0xB0, 0xD0,
+	    0xE7, 0x73, 0x14, 0x8E, 0xFF, 0x85);
+DEFINE_GUID(IID_ICaptureGraphBuilder2, 0x93e5a4e0, 0x2d50, 0x11d2, 0xab,
+	    0xfa, 0x00, 0xa0, 0xc9, 0xc6, 0xe3, 0x8d);
+DEFINE_GUID(IID_ICreateDevEnum, 0x29840822, 0x5b84, 0x11d0, 0xbd, 0x3b,
+	    0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86);
+DEFINE_GUID(IID_IGraphBuilder, 0x56a868a9, 0x0ad4, 0x11ce, 0xb0, 0x3a,
+	    0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(IID_IAMVideoProcAmp, 0xC6E13360, 0x30AC, 0x11d0, 0xA1, 0x8C,
+	    0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56);
+DEFINE_GUID(IID_IVideoWindow, 0x56a868b4, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00,
+	    0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(IID_IMediaControl, 0x56a868b1, 0x0ad4, 0x11ce, 0xb0, 0x3a,
+	    0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
+DEFINE_GUID(IID_IAMTVTuner, 0x211A8766, 0x03AC, 0x11d1, 0x8D, 0x13, 0x00,
+	    0xAA, 0x00, 0xBD, 0x83, 0x39);
+DEFINE_GUID(IID_IAMCrossbar, 0xc6e13380, 0x30ac, 0x11d0, 0xa1, 0x8c, 0x00,
+	    0xa0, 0xc9, 0x11, 0x89, 0x56);
+DEFINE_GUID(IID_IAMStreamConfig, 0xc6e13340, 0x30ac, 0x11d0, 0xa1, 0x8c,
+	    0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56);
+DEFINE_GUID(IID_IAMAudioInputMixer, 0x54C39221, 0x8380, 0x11d0, 0xB3, 0xF0,
+	    0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
+DEFINE_GUID(IID_IAMTVAudio, 0x83EC1C30, 0x23D1, 0x11d1, 0x99, 0xE6, 0x00,
+	    0xA0, 0xC9, 0x56, 0x02, 0x66);
+DEFINE_GUID(IID_IAMAnalogVideoDecoder, 0xC6E13350, 0x30AC, 0x11d0, 0xA1,
+	    0x8C, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56);
+DEFINE_GUID(IID_IPropertyBag, 0x55272a00, 0x42cb, 0x11ce, 0x81, 0x35, 0x00,
+	    0xaa, 0x00, 0x4b, 0xb8, 0x51);
+DEFINE_GUID(PIN_CATEGORY_CAPTURE, 0xfb6c4281, 0x0353, 0x11d1, 0x90, 0x5f,
+	    0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
+DEFINE_GUID(PIN_CATEGORY_VIDEOPORT, 0xfb6c4285, 0x0353, 0x11d1, 0x90, 0x5f,
+	    0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
+DEFINE_GUID(PIN_CATEGORY_PREVIEW, 0xfb6c4282, 0x0353, 0x11d1, 0x90, 0x5f, 
+            0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
+DEFINE_GUID(PIN_CATEGORY_VBI, 0xfb6c4284, 0x0353, 0x11d1, 0x90, 0x5f,
+            0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
+DEFINE_GUID(PROPSETID_TUNER, 0x6a2e0605, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00,
+	    0xa0, 0xc9, 0x11, 0x89, 0x56);
+DEFINE_GUID(MEDIATYPE_VBI,   0xf72a76e1, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00,
+            0x00, 0xc0, 0xcc, 0x16, 0xba);
+
+#define INSTANCEDATA_OF_PROPERTY_PTR(x) (((KSPROPERTY*)(x)) + 1)
+#define INSTANCEDATA_OF_PROPERTY_SIZE(x) (sizeof((x)) - sizeof(KSPROPERTY))
+
+#define DEVICE_NAME_MAX_LEN 2000
+
+/*---------------------------------------------------------------------------------------
+*  Methods, called only from this file
+*---------------------------------------------------------------------------------------*/
+
+void set_buffer_preference(int nDiv,WAVEFORMATEX* pWF,IPin* pOutPin,IPin* pInPin){
+    ALLOCATOR_PROPERTIES prop;
+    IAMBufferNegotiation* pBN;
+    HRESULT hr;
+
+    prop.cbAlign = -1;
+    prop.cbBuffer = pWF->nAvgBytesPerSec/nDiv;
+    if (!prop.cbBuffer)
+        prop.cbBuffer = 1;
+    prop.cbBuffer += pWF->nBlockAlign - 1;
+    prop.cbBuffer -= prop.cbBuffer % pWF->nBlockAlign;
+    prop.cbPrefix = -1;
+    prop.cBuffers = -1;    
+
+    hr=OLE_QUERYINTERFACE(pOutPin,IID_IAMBufferNegotiation,pBN);
+    if(FAILED(hr))
+        mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pOutPin->QueryInterface(IID_IAMBufferNegotiation) Error: 0x%x\n",(unsigned int)hr);
+    else{
+        hr=OLE_CALL_ARGS(pBN,SuggestAllocatorProperties,&prop);
+        if(FAILED(hr))
+            mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow:pOutPin->SuggestAllocatorProperties Error:0x%x\n",(unsigned int)hr);
+        OLE_RELEASE_SAFE(pBN);
+    }
+    hr=OLE_QUERYINTERFACE(pInPin,IID_IAMBufferNegotiation,pBN);
+    if(FAILED(hr))
+        mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pInPin->QueryInterface(IID_IAMBufferNegotiation) Error: 0x%x",(unsigned int)hr);
+    else{
+        hr=OLE_CALL_ARGS(pBN,SuggestAllocatorProperties,&prop);
+        if(FAILED(hr))
+            mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pInPit->SuggestAllocatorProperties Error:0x%x\n",(unsigned int)hr);
+        OLE_RELEASE_SAFE(pBN);
+    }
+}
+/*
+*---------------------------------------------------------------------------------------
+*
+*  CSampleGrabberCD class. Used for receiving samples from DirectShow.
+*
+*---------------------------------------------------------------------------------------
+*/
+/// CSampleGrabberCD destructor
+static void CSampleGrabberCB_Destroy(CSampleGrabberCB * This)
+{
+    free(This->lpVtbl);
+    free(This);
+}
+
+/// CSampleGrabberCD IUnknown interface methods implementation
+static long STDCALL CSampleGrabberCB_QueryInterface(ISampleGrabberCB *
+						    This,
+						    const GUID * riid,
+						    void **ppvObject)
+{
+    CSampleGrabberCB *me = (CSampleGrabberCB *) This;
+    GUID *r;
+    unsigned int i = 0;
+    Debug printf("CSampleGrabberCB_QueryInterface(%p) called\n", This);
+    if (!ppvObject)
+	return E_POINTER;
+    for (r = me->interfaces;
+	 i < sizeof(me->interfaces) / sizeof(me->interfaces[0]); r++, i++)
+	if (!memcmp(r, riid, sizeof(*r))) {
+	    OLE_CALL(This, AddRef);
+	    *ppvObject = This;
+	    return 0;
+	}
+    Debug printf("Query failed! (GUID: 0x%x)\n", *(unsigned int *) riid);
+    return E_NOINTERFACE;
+}
+
+static long STDCALL CSampleGrabberCB_AddRef(ISampleGrabberCB * This)
+{
+    CSampleGrabberCB *me = (CSampleGrabberCB *) This;
+    Debug printf("CSampleGrabberCB_AddRef(%p) called (ref:%d)\n", This,
+        	 me->refcount);
+    return ++(me->refcount);
+}
+
+static long STDCALL CSampleGrabberCB_Release(ISampleGrabberCB * This)
+{
+    CSampleGrabberCB *me = (CSampleGrabberCB *) This;
+    Debug printf("CSampleGrabberCB_Release(%p) called (new ref:%d)\n",
+		 This, me->refcount - 1);
+    if (--(me->refcount) == 0)
+	CSampleGrabberCB_Destroy(me);
+    return 0;
+}
+
+
+HRESULT STDCALL CSampleGrabberCB_BufferCB(ISampleGrabberCB * This,
+					  double SampleTime,
+					  BYTE * pBuffer, long lBufferLen)
+{
+    CSampleGrabberCB *this = (CSampleGrabberCB *) This;
+    grabber_ringbuffer_t *rb = this->pbuf;
+
+    if (!lBufferLen)
+	return E_FAIL;
+
+    if (!rb->ringbuffer) {
+	rb->buffersize /= lBufferLen;
+	if (init_ringbuffer(rb, rb->buffersize, lBufferLen) != S_OK)
+	    return E_FAIL;
+    }
+    mp_msg(MSGT_TV, MSGL_DBG4,
+	   "tvi_dshow: BufferCB(%p): len=%ld ts=%f\n", This, lBufferLen, SampleTime);
+    EnterCriticalSection(rb->pMutex);
+    if (rb->count >= rb->buffersize) {
+	rb->head = (rb->head + 1) % rb->buffersize;
+	rb->count--;
+    }
+
+    memcpy(rb->ringbuffer[rb->tail], pBuffer,
+	   lBufferLen < rb->blocksize ? lBufferLen : rb->blocksize);
+    rb->dpts[rb->tail] =  SampleTime;
+    rb->tail = (rb->tail + 1) % rb->buffersize;
+    rb->count++;
+    LeaveCriticalSection(rb->pMutex);
+
+    return S_OK;
+}
+
+/// wrapper. directshow does the same when BufferCB callback is requested
+HRESULT STDCALL CSampleGrabberCB_SampleCB(ISampleGrabberCB * This,
+					  double SampleTime,
+					  LPMEDIASAMPLE pSample)
+{
+    char* buf;
+    long len;
+    long long tStart,tEnd;
+    HRESULT hr;
+    grabber_ringbuffer_t *rb = ((CSampleGrabberCB*)This)->pbuf;
+
+    len=OLE_CALL(pSample,GetSize);
+    tStart=tEnd=0;
+    hr=OLE_CALL_ARGS(pSample,GetTime,&tStart,&tEnd);
+    if(FAILED(hr)){
+        return hr;
+    }
+    mp_msg(MSGT_TV, MSGL_DBG4,"tvi_dshow: SampleCB(%p): %d/%d %f\n", This,rb->count,rb->buffersize,1e-7*tStart);
+    hr=OLE_CALL_ARGS(pSample,GetPointer,(void*)&buf);
+    if(FAILED(hr)){
+        return hr;
+    }
+    hr=CSampleGrabberCB_BufferCB(This,1e-7*tStart,buf,len);
+    return hr;
+
+}
+
+/// main grabbing routine
+static CSampleGrabberCB *CSampleGrabberCB_Create(grabber_ringbuffer_t *
+						 pbuf)
+{
+    CSampleGrabberCB *This = malloc(sizeof(CSampleGrabberCB));
+    if (!This)
+	return NULL;
+
+    This->lpVtbl = malloc(sizeof(ISampleGrabberVtbl));
+    if (!This->lpVtbl) {
+	CSampleGrabberCB_Destroy(This);
+	return NULL;
+    }
+    This->refcount = 1;
+    This->lpVtbl->QueryInterface = CSampleGrabberCB_QueryInterface;
+    This->lpVtbl->AddRef = CSampleGrabberCB_AddRef;
+    This->lpVtbl->Release = CSampleGrabberCB_Release;
+    This->lpVtbl->SampleCB = CSampleGrabberCB_SampleCB;
+    This->lpVtbl->BufferCB = CSampleGrabberCB_BufferCB;
+
+    This->interfaces[0] = IID_IUnknown;
+    This->interfaces[1] = IID_ISampleGrabberCB;
+
+    This->pbuf = pbuf;
+
+    return This;
+}
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*  ROT related methods (register, unregister)
+*
+*---------------------------------------------------------------------------------------
+*/
+/** 
+Registering graph in ROT. User will be able to connect to graph from GraphEdit.
+*/
+static HRESULT AddToRot(IUnknown * pUnkGraph, DWORD * pdwRegister)
+{
+    IMoniker *pMoniker;
+    IRunningObjectTable *pROT;
+    WCHAR wsz[256];
+    HRESULT hr;
+
+    if (FAILED(GetRunningObjectTable(0, &pROT))) {
+	return E_FAIL;
+    }
+    wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR) pUnkGraph,
+	      GetCurrentProcessId());
+    hr = CreateItemMoniker(L"!", wsz, &pMoniker);
+    if (SUCCEEDED(hr)) {
+	hr = OLE_CALL_ARGS(pROT, Register, ROTFLAGS_REGISTRATIONKEEPSALIVE,
+		       pUnkGraph, pMoniker, pdwRegister);
+	OLE_RELEASE_SAFE(pMoniker);
+    }
+    OLE_RELEASE_SAFE(pROT);
+    return hr;
+}
+
+/// Unregistering graph in ROT
+static void RemoveFromRot(DWORD dwRegister)
+{
+    IRunningObjectTable *pROT;
+    if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
+	OLE_CALL_ARGS(pROT, Revoke, dwRegister);
+	OLE_RELEASE_SAFE(pROT);
+    }
+}
+
+/*
+*---------------------------------------------------------------------------------------
+*
+*  ringbuffer related methods (init, destroy)
+*
+*---------------------------------------------------------------------------------------
+*/
+/**
+ * \brief ringbuffer destroying routine
+ *
+ * \param rb pointer to empty (just allocated) ringbuffer structure
+ *
+ * \note routine does not frees memory, allocated for grabber_rinbuffer_s structure
+ */
+static void destroy_ringbuffer(grabber_ringbu