?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cleanup: Silence compilation warnings on MinGW-w64
[mplayer.git] / stream / tvi_dshow.c
blob3e17d9cb99648ec122ca90c4c9d366492e0f14c2
1 /*
2 * TV support under Win32
3 *
4 * (C) 2007 Vladimir Voroshilov <voroshil@gmail.com>
5 *
6 * Based on tvi_dummy.c with help of tv.c, tvi_v4l2.c code.
7 *
8 * This file is part of MPlayer.
9 *
10 * MPlayer 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 * MPlayer 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 along
21 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23 */
24
25 /*
26 * WARNING: This is alpha code!
27 *
28 * Abilities:
29 * * Watching TV under Win32 using WDM Capture driver and DirectShow
30 * * Grabbing synchronized audio/video with mencoder (synchronization is beeing done by DirectShow)
31 * * If device driver provides IAMStreamConfig interface, user can choose width/height with "-tv height=<h>:width=<w>"
32 * * Adjusting BRIGHTNESS,HUE,SATURATION,CONTRAST if supported by device
33 * * Selecting Tuner,S-Video,... as media source
34 * * User can select used video capture device, passing -tv device=<dev#>
35 * * User can select used audio input, passing -tv audioid=<input#>
36 *
37 * options which will not be implemented (probably sometime in future, if possible):
38 * * alsa
39 * * mjpeg
40 * * decimation=<1|2|4>
41 * * quality=<0\-100>
42 * * forceaudio
43 * * forcechan=<1\-2>
44 * * [volume|bass|treble|balance]
45 *
46 * Works with:
47 * - LifeView FlyTV Prime 34FM (SAA7134 based) with driver from Ivan Uskov
48 * Partially works with:
49 * - ATI 9200 VIVO based card
50 * - ATI AIW 7500
51 * - nVidia Ti-4400
52 *
53 * Known bugs:
54 * * stream goes with 24.93 FPS (NTSC), while reporting 25 FPS (PAL) ?!
55 * * direct set frequency call does not work ('Insufficient Buffer' error)
56 * * audio stream goes with about 1 sample/sec rate when capturing sound from audio card
57 *
58 * TODO:
59 * * check audio with small buffer on vivo !!!
60 * * norm for IAMVideoDecoder and for IAMTVtuner - differs !!
61 * * check how to change TVFormat on VIVO card without tuner
62 * * Flip image upside-down for RGB formats.
63 * *
64 * * remove debug sleep()
65 * * Add some notes to methods' parameters
66 * * refactor console messages
67 * * check using header files and keep only needed
68 * * add additional comments to methods' bodies
69 *
70 */
71
72
73 /// \ingroup tvi_dshow
74
75 #include "config.h"
76
77 #include <stdio.h>
78 #include "libmpcodecs/img_format.h"
79 #include "libmpcodecs/dec_teletext.h"
80 #include "libaf/af_format.h"
81 #include "osdep/timer.h"
82
83
84 #include "tv.h"
85 #include "mp_msg.h"
86 #include "frequencies.h"
87
88
89 #include "tvi_dshow.h"
90
91 #ifndef STDCALL
92 // mingw64 needs this
93 #define STDCALL __stdcall
94 #endif
95
96 static tvi_handle_t *tvi_init_dshow(tv_param_t* tv_param);
97
98 /*
99 *---------------------------------------------------------------------------------------
100 *
101 * Data structures
102 *
103 *---------------------------------------------------------------------------------------
104 */
105 /**
106 information about this file
107 */
108 const tvi_info_t tvi_info_dshow = {
109 tvi_init_dshow,
110 "DirectShow TV",
111 "dshow",
112 "Vladimir Voroshilov",
113 "Very experimental!! Use with caution"
114 };
115
116
117 /**
118 ringbuffer related info
119 */
120 typedef struct {
121 CRITICAL_SECTION *pMutex; ///< pointer to critical section (mutex)
122 char **ringbuffer; ///< ringbuffer array
123 double*dpts; ///< samples' timestamps
124
125 int buffersize; ///< size of buffer in blocks
126 int blocksize; ///< size of individual block
127 int head; ///< index of first valid sample
128 int tail; ///< index of last valid sample
129 int count; ///< count of valid samples in ringbuffer
130 double tStart; ///< pts of first sample (first sample should have pts 0)
131 } grabber_ringbuffer_t;
132
133 typedef enum { unknown, video, audio, vbi } stream_type;
134
135 /**
136 CSampleGrabberCD definition
137 */
138 typedef struct CSampleGrabberCB {
139 ISampleGrabberCBVtbl *lpVtbl;
140 int refcount;
141 GUID interfaces[2];
142 grabber_ringbuffer_t *pbuf;
143 } CSampleGrabberCB;
144
145 /**
146 Chain related structure
147 */
148 typedef struct {
149 stream_type type; ///< stream type
150 const GUID* majortype; ///< GUID of major mediatype (video/audio/vbi)
151 const GUID* pin_category; ///< pin category (pointer to one of PIN_CATEGORY_*)
152
153 IBaseFilter *pCaptureFilter; ///< capture device filter
154 IAMStreamConfig *pStreamConfig; ///< for configuring stream
155 ISampleGrabber *pSG; ///< ISampleGrabber interface of SampleGrabber filter
156 IBaseFilter *pSGF; ///< IBaseFilter interface of SampleGrabber filter
157 IPin *pCapturePin; ///< output capture pin
158 IPin *pSGIn; ///< input pin of SampleGrabber filter
159
160 grabber_ringbuffer_t *rbuf; ///< sample frabber data
161 CSampleGrabberCB* pCSGCB; ///< callback object
162
163 AM_MEDIA_TYPE *pmt; ///< stream properties.
164 int nFormatUsed; ///< index of used format
165 AM_MEDIA_TYPE **arpmt; ///< available formats
166 void** arStreamCaps; ///< VIDEO_STREAM_CONFIG_CAPS or AUDIO_STREAM_CONFIG_CAPS
167 } chain_t;
168
169 typedef struct priv {
170 int dev_index; ///< capture device index in device list (defaul: 0, first available device)
171 int adev_index; ///< audio capture device index in device list (default: -1, not used)
172 int immediate_mode; ///< immediate mode (no sound capture)
173 int state; ///< state: 1-filter graph running, 0-filter graph stopped
174 int direct_setfreq_call; ///< 0-find nearest channels from system channel list(workaround),1-direct call to set frequency
175 int direct_getfreq_call; ///< 0-find frequncy from frequency table (workaround),1-direct call to get frequency
176
177 int fcc; ///< used video format code (FourCC)
178 int width; ///< picture width (default: auto)
179 int height; ///< picture height (default: auto)
180
181 int channels; ///< number of audio channels (default: auto)
182 int samplerate; ///< audio samplerate (default: auto)
183
184 long *freq_table; ///< frequency table (in Hz)
185 int freq_table_len; ///< length of freq table
186 int first_channel; ///< channel number of first entry in freq table
187 int input; ///< used input
188
189 chain_t* chains[3]; ///< chains' data (0-video, 1-audio, 2-vbi)
190
191 IAMTVTuner *pTVTuner; ///< interface for tuner device
192 IGraphBuilder *pGraph; ///< filter graph
193 ICaptureGraphBuilder2 *pBuilder; ///< graph builder
194 IMediaControl *pMediaControl; ///< interface for controlling graph (start, stop,...)
195 IAMVideoProcAmp *pVideoProcAmp; ///< for adjusting hue,saturation,etc
196 IAMCrossbar *pCrossbar; ///< for selecting input (Tuner,Composite,S-Video,...)
197 DWORD dwRegister; ///< allow graphedit to connect to our graph
198 void *priv_vbi; ///< private VBI data structure
199 tt_stream_props tsp; ///< data for VBI initialization
200
201 tv_param_t* tv_param; ///< TV parameters
202 } priv_t;
203
204 #include "tvi_def.h"
205
206 /**
207 country table entry structure (for loading freq table stored in kstvtuner.ax
208
209 \note
210 structure have to be 2-byte aligned and have 10-byte length!!
211 */
212 typedef struct __attribute__((__packed__)) {
213 WORD CountryCode; ///< Country code
214 WORD CableFreqTable; ///< index of resource with frequencies for cable channels
215 WORD BroadcastFreqTable; ///< index of resource with frequencies for broadcast channels
216 DWORD VideoStandard; ///< used video standard
217 } TRCCountryList;
218 /**
219 information about image formats
220 */
221 typedef struct {
222 uint32_t fmt; ///< FourCC
223 const GUID *subtype; ///< DirectShow's subtype
224 int nBits; ///< number of bits
225 int nCompression; ///< complression
226 int tail; ///< number of additional bytes followed VIDEOINFOHEADER structure
227 } img_fmt;
228
229 /*
230 *---------------------------------------------------------------------------------------
231 *
232 * Methods forward declaration
233 *
234 *---------------------------------------------------------------------------------------
235 */
236 static HRESULT init_ringbuffer(grabber_ringbuffer_t * rb, int buffersize,
237 int blocksize);
238 static HRESULT show_filter_info(IBaseFilter * pFilter);
239 #if 0
240 //defined in current MinGW release
241 HRESULT STDCALL GetRunningObjectTable(DWORD, IRunningObjectTable **);
242 HRESULT STDCALL CreateItemMoniker(LPCOLESTR, LPCOLESTR, IMoniker **);
243 #endif
244 static CSampleGrabberCB *CSampleGrabberCB_Create(grabber_ringbuffer_t *
245 pbuf);
246 static int set_crossbar_input(priv_t * priv, int input);
247 static int subtype2imgfmt(const GUID * subtype);
248
249 /*
250 *---------------------------------------------------------------------------------------
251 *
252 * Global constants and variables
253 *
254 *---------------------------------------------------------------------------------------
255 */
256 /**
257 lookup tables for physical connector types
258 */
259 static const struct {
260 long type;
261 char *name;
262 } tv_physcon_types[]={
263 {PhysConn_Video_Tuner, "Tuner" },
264 {PhysConn_Video_Composite, "Composite" },
265 {PhysConn_Video_SVideo, "S-Video" },
266 {PhysConn_Video_RGB, "RGB" },
267 {PhysConn_Video_YRYBY, "YRYBY" },
268 {PhysConn_Video_SerialDigital, "SerialDigital" },
269 {PhysConn_Video_ParallelDigital, "ParallelDigital"},
270 {PhysConn_Video_VideoDecoder, "VideoDecoder" },
271 {PhysConn_Video_VideoEncoder, "VideoEncoder" },
272 {PhysConn_Video_SCART, "SCART" },
273 {PhysConn_Video_Black, "Blaack" },
274 {PhysConn_Audio_Tuner, "Tuner" },
275 {PhysConn_Audio_Line, "Line" },
276 {PhysConn_Audio_Mic, "Mic" },
277 {PhysConn_Audio_AESDigital, "AESDiital" },
278 {PhysConn_Audio_SPDIFDigital, "SPDIFDigital" },
279 {PhysConn_Audio_AudioDecoder, "AudioDecoder" },
280 {PhysConn_Audio_SCSI, "SCSI" },
281 {PhysConn_Video_SCSI, "SCSI" },
282 {PhysConn_Audio_AUX, "AUX" },
283 {PhysConn_Video_AUX, "AUX" },
284 {PhysConn_Audio_1394, "1394" },
285 {PhysConn_Video_1394, "1394" },
286 {PhysConn_Audio_USB, "USB" },
287 {PhysConn_Video_USB, "USB" },
288 {-1, NULL }
289 };
290
291 static const struct {
292 char *chanlist_name;
293 int country_code;
294 } tv_chanlist2country[]={
295 {"us-bcast", 1},
296 {"russia", 7},
297 {"argentina", 54},
298 {"japan-bcast", 81},
299 {"china-bcast", 86},
300 {"southafrica", 27},
301 {"australia", 61},
302 {"ireland", 353},
303 {"france", 33},
304 {"italy", 39},
305 {"newzealand", 64},
306 //directshow table uses eastern europe freq table for russia
307 {"europe-east", 7},
308 //directshow table uses western europe freq table for germany
309 {"europe-west", 49},
310 /* cable channels */
311 {"us-cable", 1},
312 {"us-cable-hrc", 1},
313 {"japan-cable", 81},
314 //default is USA
315 {NULL, 1}
316 };
317
318 /**
319 array, contains information about various supported (i hope) image formats
320 */
321 static const img_fmt img_fmt_list[] = {
322 {IMGFMT_YUY2, &MEDIASUBTYPE_YUY2, 16, IMGFMT_YUY2, 0},
323 {IMGFMT_YV12, &MEDIASUBTYPE_YV12, 12, IMGFMT_YV12, 0},
324 {IMGFMT_IYUV, &MEDIASUBTYPE_IYUV, 12, IMGFMT_IYUV, 0},
325 {IMGFMT_I420, &MEDIASUBTYPE_I420, 12, IMGFMT_I420, 0},
326 {IMGFMT_UYVY, &MEDIASUBTYPE_UYVY, 16, IMGFMT_UYVY, 0},
327 {IMGFMT_YVYU, &MEDIASUBTYPE_YVYU, 16, IMGFMT_YVYU, 0},
328 {IMGFMT_YVU9, &MEDIASUBTYPE_YVU9, 9, IMGFMT_YVU9, 0},
329 {IMGFMT_BGR32, &MEDIASUBTYPE_RGB32, 32, 0, 0},
330 {IMGFMT_BGR24, &MEDIASUBTYPE_RGB24, 24, 0, 0},
331 {IMGFMT_BGR16, &MEDIASUBTYPE_RGB565, 16, 3, 12},
332 {IMGFMT_BGR15, &MEDIASUBTYPE_RGB555, 16, 3, 12},
333 {0, &GUID_NULL, 0, 0, 0}
334 };
335
336 #define TV_NORMS_COUNT 19
337 static const struct {
338 long index;
339 char *name;
340 } tv_norms[TV_NORMS_COUNT] = {
341 {
342 AnalogVideo_NTSC_M, "ntsc-m"}, {
343 AnalogVideo_NTSC_M_J, "ntsc-mj"}, {
344 AnalogVideo_NTSC_433, "ntsc-433"}, {
345 AnalogVideo_PAL_B, "pal-b"}, {
346 AnalogVideo_PAL_D, "pal-d"}, {
347 AnalogVideo_PAL_G, "pal-g"}, {
348 AnalogVideo_PAL_H, "pal-h"}, {
349 AnalogVideo_PAL_I, "pal-i"}, {
350 AnalogVideo_PAL_M, "pal-m"}, {
351 AnalogVideo_PAL_N, "pal-n"}, {
352 AnalogVideo_PAL_60, "pal-60"}, {
353 AnalogVideo_SECAM_B, "secam-b"}, {
354 AnalogVideo_SECAM_D, "secam-d"}, {
355 AnalogVideo_SECAM_G, "secam-g"}, {
356 AnalogVideo_SECAM_H, "secam-h"}, {
357 AnalogVideo_SECAM_K, "secam-k"}, {
358 AnalogVideo_SECAM_K1, "secam-k1"}, {
359 AnalogVideo_SECAM_L, "secam-l"}, {
360 AnalogVideo_SECAM_L1, "secam-l1"}
361 };
362 static long tv_available_norms[TV_NORMS_COUNT];
363 static int tv_available_norms_count = 0;
364
365
366 static long *tv_available_inputs;
367 static int tv_available_inputs_count = 0;
368
369 /*
370 *---------------------------------------------------------------------------------------
371 *
372 * Various GUID definitions
373 *
374 *---------------------------------------------------------------------------------------
375 */
376 // selectany can not be used with "static", fixes compilation with mingw-w64
377 #undef DECLSPEC_SELECTANY
378 #define DECLSPEC_SELECTANY
379 /// CLSID definitions (used for CoCreateInstance call)
380 #define CLSID_SampleGrabber MP_CLSID_SampleGrabber
381 static DEFINE_GUID(CLSID_SampleGrabber, 0xC1F400A0, 0x3F08, 0x11d3, 0x9F, 0x0B,
382 0x00, 0x60, 0x08, 0x03, 0x9E, 0x37);
383 #define CLSID_NullRenderer MP_CLSID_NullRenderer
384 static DEFINE_GUID(CLSID_NullRenderer, 0xC1F400A4, 0x3F08, 0x11d3, 0x9F, 0x0B,
385 0x00, 0x60, 0x08, 0x03, 0x9E, 0x37);
386 #define CLSID_SystemDeviceEnum MP_CLSID_SystemDeviceEnum
387 static DEFINE_GUID(CLSID_SystemDeviceEnum, 0x62BE5D10, 0x60EB, 0x11d0, 0xBD, 0x3B,
388 0x00, 0xA0, 0xC9, 0x11, 0xCE, 0x86);
389 #define CLSID_CaptureGraphBuilder2 MP_CLSID_CaptureGraphBuilder2
390 static DEFINE_GUID(CLSID_CaptureGraphBuilder2, 0xBF87B6E1, 0x8C27, 0x11d0, 0xB3,
391 0xF0, 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
392 #define CLSID_VideoInputDeviceCategory MP_CLSID_VideoInputDeviceCategory
393 static DEFINE_GUID(CLSID_VideoInputDeviceCategory, 0x860BB310, 0x5D01, 0x11d0,
394 0xBD, 0x3B, 0x00, 0xA0, 0xC9, 0x11, 0xCE, 0x86);
395 #define CLSID_AudioInputDeviceCategory MP_CLSID_AudioInputDeviceCategory
396 static DEFINE_GUID(CLSID_AudioInputDeviceCategory, 0x33d9a762, 0x90c8, 0x11d0,
397 0xbd, 0x43, 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86);
398 #define CLSID_FilterGraph MP_CLSID_FilterGraph
399 static DEFINE_GUID(CLSID_FilterGraph, 0xe436ebb3, 0x524f, 0x11ce, 0x9f, 0x53,
400 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
401 #define CLSID_SystemClock MP_CLSID_SystemClock
402 static DEFINE_GUID(CLSID_SystemClock, 0xe436ebb1, 0x524f, 0x11ce, 0x9f, 0x53,
403 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
404 #ifdef NOT_USED
405 #define CLSID_CaptureGraphBuilder MP_CLSID_CaptureGraphBuilder
406 static DEFINE_GUID(CLSID_CaptureGraphBuilder, 0xBF87B6E0, 0x8C27, 0x11d0, 0xB3,
407 0xF0, 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
408 #define CLSID_VideoPortManager MP_CLSID_VideoPortManager
409 static DEFINE_GUID(CLSID_VideoPortManager, 0x6f26a6cd, 0x967b, 0x47fd, 0x87, 0x4a,
410 0x7a, 0xed, 0x2c, 0x9d, 0x25, 0xa2);
411 #define IID_IPin MP_IID_IPin
412 static DEFINE_GUID(IID_IPin, 0x56a86891, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00, 0x20,
413 0xaf, 0x0b, 0xa7, 0x70);
414 #define IID_ICaptureGraphBuilder MP_IID_ICaptureGraphBuilder
415 static DEFINE_GUID(IID_ICaptureGraphBuilder, 0xbf87b6e0, 0x8c27, 0x11d0, 0xb3,
416 0xf0, 0x00, 0xaa, 0x00, 0x37, 0x61, 0xc5);
417 #define IID_IFilterGraph MP_IID_IFilterGraph
418 static DEFINE_GUID(IID_IFilterGraph, 0x56a8689f, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00,
419 0x20, 0xaf, 0x0b, 0xa7, 0x70);
420 #define PIN_CATEGORY_PREVIEW MP_PIN_CATEGORY_PREVIEW
421 static DEFINE_GUID(PIN_CATEGORY_PREVIEW, 0xfb6c4282, 0x0353, 0x11d1, 0x90, 0x5f,
422 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
423 #endif
424
425 /// IID definitions (used for QueryInterface call)
426 #define IID_IReferenceClock MP_IID_IReferenceClock
427 static DEFINE_GUID(IID_IReferenceClock, 0x56a86897, 0x0ad4, 0x11ce, 0xb0, 0x3a,
428 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
429 #define IID_IAMBufferNegotiation MP_IID_IAMBufferNegotiation
430 static DEFINE_GUID(IID_IAMBufferNegotiation, 0x56ED71A0, 0xAF5F, 0x11D0, 0xB3, 0xF0,
431 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
432 #define IID_IKsPropertySet MP_IID_IKsPropertySet
433 static DEFINE_GUID(IID_IKsPropertySet, 0x31efac30, 0x515c, 0x11d0, 0xa9, 0xaa,
434 0x00, 0xaa, 0x00, 0x61, 0xbe, 0x93);
435 #define IID_ISampleGrabber MP_IID_ISampleGrabber
436 static DEFINE_GUID(IID_ISampleGrabber, 0x6B652FFF, 0x11FE, 0x4fce, 0x92, 0xAD,
437 0x02, 0x66, 0xB5, 0xD7, 0xC7, 0x8F);
438 #define IID_ISampleGrabberCB MP_IID_ISampleGrabberCB
439 static DEFINE_GUID(IID_ISampleGrabberCB, 0x0579154A, 0x2B53, 0x4994, 0xB0, 0xD0,
440 0xE7, 0x73, 0x14, 0x8E, 0xFF, 0x85);
441 #define IID_ICaptureGraphBuilder2 MP_IID_ICaptureGraphBuilder2
442 static DEFINE_GUID(IID_ICaptureGraphBuilder2, 0x93e5a4e0, 0x2d50, 0x11d2, 0xab,
443 0xfa, 0x00, 0xa0, 0xc9, 0xc6, 0xe3, 0x8d);
444 #define IID_ICreateDevEnum MP_IID_ICreateDevEnum
445 static DEFINE_GUID(IID_ICreateDevEnum, 0x29840822, 0x5b84, 0x11d0, 0xbd, 0x3b,
446 0x00, 0xa0, 0xc9, 0x11, 0xce, 0x86);
447 #define IID_IGraphBuilder MP_IID_IGraphBuilder
448 static DEFINE_GUID(IID_IGraphBuilder, 0x56a868a9, 0x0ad4, 0x11ce, 0xb0, 0x3a,
449 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
450 #define IID_IAMVideoProcAmp MP_IID_IAMVideoProcAmp
451 static DEFINE_GUID(IID_IAMVideoProcAmp, 0xC6E13360, 0x30AC, 0x11d0, 0xA1, 0x8C,
452 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56);
453 #define IID_IVideoWindow MP_IID_IVideoWindow
454 static DEFINE_GUID(IID_IVideoWindow, 0x56a868b4, 0x0ad4, 0x11ce, 0xb0, 0x3a, 0x00,
455 0x20, 0xaf, 0x0b, 0xa7, 0x70);
456 #define IID_IMediaControl MP_IID_IMediaControl
457 static DEFINE_GUID(IID_IMediaControl, 0x56a868b1, 0x0ad4, 0x11ce, 0xb0, 0x3a,
458 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
459 #define IID_IAMTVTuner MP_IID_IAMTVTuner
460 static DEFINE_GUID(IID_IAMTVTuner, 0x211A8766, 0x03AC, 0x11d1, 0x8D, 0x13, 0x00,
461 0xAA, 0x00, 0xBD, 0x83, 0x39);
462 #define IID_IAMCrossbar MP_IID_IAMCrossbar
463 static DEFINE_GUID(IID_IAMCrossbar, 0xc6e13380, 0x30ac, 0x11d0, 0xa1, 0x8c, 0x00,
464 0xa0, 0xc9, 0x11, 0x89, 0x56);
465 #define IID_IAMStreamConfig MP_IID_IAMStreamConfig
466 static DEFINE_GUID(IID_IAMStreamConfig, 0xc6e13340, 0x30ac, 0x11d0, 0xa1, 0x8c,
467 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56);
468 #define IID_IAMAudioInputMixer MP_IID_IAMAudioInputMixer
469 static DEFINE_GUID(IID_IAMAudioInputMixer, 0x54C39221, 0x8380, 0x11d0, 0xB3, 0xF0,
470 0x00, 0xAA, 0x00, 0x37, 0x61, 0xC5);
471 #define IID_IAMTVAudio MP_IID_IAMTVAudio
472 static DEFINE_GUID(IID_IAMTVAudio, 0x83EC1C30, 0x23D1, 0x11d1, 0x99, 0xE6, 0x00,
473 0xA0, 0xC9, 0x56, 0x02, 0x66);
474 #define IID_IAMAnalogVideoDecoder MP_IID_IAMAnalogVideoDecoder
475 static DEFINE_GUID(IID_IAMAnalogVideoDecoder, 0xC6E13350, 0x30AC, 0x11d0, 0xA1,
476 0x8C, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56);
477 #define IID_IPropertyBag MP_IID_IPropertyBag
478 static DEFINE_GUID(IID_IPropertyBag, 0x55272a00, 0x42cb, 0x11ce, 0x81, 0x35, 0x00,
479 0xaa, 0x00, 0x4b, 0xb8, 0x51);
480 #define PIN_CATEGORY_CAPTURE MP_PIN_CATEGORY_CAPTURE
481 static DEFINE_GUID(PIN_CATEGORY_CAPTURE, 0xfb6c4281, 0x0353, 0x11d1, 0x90, 0x5f,
482 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
483 #define PIN_CATEGORY_VIDEOPORT MP_PIN_CATEGORY_VIDEOPORT
484 static DEFINE_GUID(PIN_CATEGORY_VIDEOPORT, 0xfb6c4285, 0x0353, 0x11d1, 0x90, 0x5f,
485 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
486 #define PIN_CATEGORY_PREVIEW MP_PIN_CATEGORY_PREVIEW
487 static DEFINE_GUID(PIN_CATEGORY_PREVIEW, 0xfb6c4282, 0x0353, 0x11d1, 0x90, 0x5f,
488 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
489 #define PIN_CATEGORY_VBI MP_PIN_CATEGORY_VBI
490 static DEFINE_GUID(PIN_CATEGORY_VBI, 0xfb6c4284, 0x0353, 0x11d1, 0x90, 0x5f,
491 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba);
492 #define PROPSETID_TUNER MP_PROPSETID_TUNER
493 static DEFINE_GUID(PROPSETID_TUNER, 0x6a2e0605, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00,
494 0xa0, 0xc9, 0x11, 0x89, 0x56);
495 #define MEDIATYPE_VBI MP_MEDIATYPE_VBI
496 static DEFINE_GUID(MEDIATYPE_VBI, 0xf72a76e1, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00,
497 0x00, 0xc0, 0xcc, 0x16, 0xba);
498
499 #define INSTANCEDATA_OF_PROPERTY_PTR(x) (((KSPROPERTY*)(x)) + 1)
500 #define INSTANCEDATA_OF_PROPERTY_SIZE(x) (sizeof((x)) - sizeof(KSPROPERTY))
501
502 #define DEVICE_NAME_MAX_LEN 2000
503
504 /*---------------------------------------------------------------------------------------
505 * Methods, called only from this file
506 *---------------------------------------------------------------------------------------*/
507
508 static void set_buffer_preference(int nDiv, WAVEFORMATEX *pWF,
509 IPin *pOutPin, IPin *pInPin)
510 {
511 ALLOCATOR_PROPERTIES prop;
512 IAMBufferNegotiation* pBN;
513 HRESULT hr;
514
515 prop.cbAlign = -1;
516 prop.cbBuffer = pWF->nAvgBytesPerSec/nDiv;
517 if (!prop.cbBuffer)
518 prop.cbBuffer = 1;
519 prop.cbBuffer += pWF->nBlockAlign - 1;
520 prop.cbBuffer -= prop.cbBuffer % pWF->nBlockAlign;
521 prop.cbPrefix = -1;
522 prop.cBuffers = -1;
523
524 hr=OLE_QUERYINTERFACE(pOutPin,IID_IAMBufferNegotiation,pBN);
525 if(FAILED(hr))
526 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pOutPin->QueryInterface(IID_IAMBufferNegotiation) Error: 0x%x\n",(unsigned int)hr);
527 else{
528 hr=OLE_CALL_ARGS(pBN,SuggestAllocatorProperties,&prop);
529 if(FAILED(hr))
530 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow:pOutPin->SuggestAllocatorProperties Error:0x%x\n",(unsigned int)hr);
531 OLE_RELEASE_SAFE(pBN);
532 }
533 hr=OLE_QUERYINTERFACE(pInPin,IID_IAMBufferNegotiation,pBN);
534 if(FAILED(hr))
535 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pInPin->QueryInterface(IID_IAMBufferNegotiation) Error: 0x%x",(unsigned int)hr);
536 else{
537 hr=OLE_CALL_ARGS(pBN,SuggestAllocatorProperties,&prop);
538 if(FAILED(hr))
539 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: pInPit->SuggestAllocatorProperties Error:0x%x\n",(unsigned int)hr);
540 OLE_RELEASE_SAFE(pBN);
541 }
542 }
543 /*
544 *---------------------------------------------------------------------------------------
545 *
546 * CSampleGrabberCD class. Used for receiving samples from DirectShow.
547 *
548 *---------------------------------------------------------------------------------------
549 */
550 /// CSampleGrabberCD destructor
551 static void CSampleGrabberCB_Destroy(CSampleGrabberCB * This)
552 {
553 free(This->lpVtbl);
554 free(This);
555 }
556
557 /// CSampleGrabberCD IUnknown interface methods implementation
558 static long STDCALL CSampleGrabberCB_QueryInterface(ISampleGrabberCB *
559 This,
560 const GUID * riid,
561 void **ppvObject)
562 {
563 CSampleGrabberCB *me = (CSampleGrabberCB *) This;
564 GUID *r;
565 unsigned int i = 0;
566 Debug printf("CSampleGrabberCB_QueryInterface(%p) called\n", This);
567 if (!ppvObject)
568 return E_POINTER;
569 for (r = me->interfaces;
570 i < sizeof(me->interfaces) / sizeof(me->interfaces[0]); r++, i++)
571 if (!memcmp(r, riid, sizeof(*r))) {
572 OLE_CALL(This, AddRef);
573 *ppvObject = This;
574 return 0;
575 }
576 Debug printf("Query failed! (GUID: 0x%x)\n", *(unsigned int *) riid);
577 return E_NOINTERFACE;
578 }
579
580 static long STDCALL CSampleGrabberCB_AddRef(ISampleGrabberCB * This)
581 {
582 CSampleGrabberCB *me = (CSampleGrabberCB *) This;
583 Debug printf("CSampleGrabberCB_AddRef(%p) called (ref:%d)\n", This,
584 me->refcount);
585 return ++(me->refcount);
586 }
587
588 static long STDCALL CSampleGrabberCB_Release(ISampleGrabberCB * This)
589 {
590 CSampleGrabberCB *me = (CSampleGrabberCB *) This;
591 Debug printf("CSampleGrabberCB_Release(%p) called (new ref:%d)\n",
592 This, me->refcount - 1);
593 if (--(me->refcount) == 0)
594 CSampleGrabberCB_Destroy(me);
595 return 0;
596 }
597
598
599 static HRESULT STDCALL CSampleGrabberCB_BufferCB(ISampleGrabberCB *This,
600 double SampleTime,
601 BYTE *pBuffer,
602 long lBufferLen)
603 {
604 CSampleGrabberCB *this = (CSampleGrabberCB *) This;
605 grabber_ringbuffer_t *rb = this->pbuf;
606
607 if (!lBufferLen)
608 return E_FAIL;
609
610 if (!rb->ringbuffer) {
611 rb->buffersize /= lBufferLen;
612 if (init_ringbuffer(rb, rb->buffersize, lBufferLen) != S_OK)
613 return E_FAIL;
614 }
615 mp_msg(MSGT_TV, MSGL_DBG4,
616 "tvi_dshow: BufferCB(%p): len=%ld ts=%f\n", This, lBufferLen, SampleTime);
617 EnterCriticalSection(rb->pMutex);
618 if (rb->count >= rb->buffersize) {
619 rb->head = (rb->head + 1) % rb->buffersize;
620 rb->count--;
621 }
622
623 memcpy(rb->ringbuffer[rb->tail], pBuffer,
624 lBufferLen < rb->blocksize ? lBufferLen : rb->blocksize);
625 rb->dpts[rb->tail] = SampleTime;
626 rb->tail = (rb->tail + 1) % rb->buffersize;
627 rb->count++;
628 LeaveCriticalSection(rb->pMutex);
629
630 return S_OK;
631 }
632
633 /// wrapper. directshow does the same when BufferCB callback is requested
634 static HRESULT STDCALL CSampleGrabberCB_SampleCB(ISampleGrabberCB *This,
635 double SampleTime,
636 LPMEDIASAMPLE pSample)
637 {
638 char* buf;
639 long len;
640 long long tStart,tEnd;
641 HRESULT hr;
642 grabber_ringbuffer_t *rb = ((CSampleGrabberCB*)This)->pbuf;
643
644 len=OLE_CALL(pSample,GetSize);
645 tStart=tEnd=0;
646 hr=OLE_CALL_ARGS(pSample,GetTime,&tStart,&tEnd);
647 if(FAILED(hr)){
648 return hr;
649 }
650 mp_msg(MSGT_TV, MSGL_DBG4,"tvi_dshow: SampleCB(%p): %d/%d %f\n", This,rb->count,rb->buffersize,1e-7*tStart);
651 hr=OLE_CALL_ARGS(pSample,GetPointer,(void*)&buf);
652 if(FAILED(hr)){
653 return hr;
654 }
655 hr=CSampleGrabberCB_BufferCB(This,1e-7*tStart,buf,len);
656 return hr;
657
658 }
659
660 /// main grabbing routine
661 static CSampleGrabberCB *CSampleGrabberCB_Create(grabber_ringbuffer_t *
662 pbuf)
663 {
664 CSampleGrabberCB *This = malloc(sizeof(CSampleGrabberCB));
665 if (!This)
666 return NULL;
667
668 This->lpVtbl = malloc(sizeof(ISampleGrabberVtbl));
669 if (!This->lpVtbl) {
670 CSampleGrabberCB_Destroy(This);
671 return NULL;
672 }
673 This->refcount = 1;
674 This->lpVtbl->QueryInterface = CSampleGrabberCB_QueryInterface;
675 This->lpVtbl->AddRef = CSampleGrabberCB_AddRef;
676 This->lpVtbl->Release = CSampleGrabberCB_Release;
677 This->lpVtbl->SampleCB = CSampleGrabberCB_SampleCB;
678 This->lpVtbl->BufferCB = CSampleGrabberCB_BufferCB;
679
680 This->interfaces[0] = IID_IUnknown;
681 This->interfaces[1] = IID_ISampleGrabberCB;
682
683 This->pbuf = pbuf;
684
685 return This;
686 }
687
688 /*
689 *---------------------------------------------------------------------------------------
690 *
691 * ROT related methods (register, unregister)
692 *
693 *---------------------------------------------------------------------------------------
694 */
695 /**
696 Registering graph in ROT. User will be able to connect to graph from GraphEdit.
697 */
698 static HRESULT AddToRot(IUnknown * pUnkGraph, DWORD * pdwRegister)
699 {
700 IMoniker *pMoniker;
701 IRunningObjectTable *pROT;
702 WCHAR wsz[256];
703 HRESULT hr;
704
705 if (FAILED(GetRunningObjectTable(0, &pROT))) {
706 return E_FAIL;
707 }
708 wsprintfW(wsz, L"FilterGraph %08x pid %08x", (DWORD_PTR) pUnkGraph,
709 GetCurrentProcessId());
710 hr = CreateItemMoniker(L"!", wsz, &pMoniker);
711 if (SUCCEEDED(hr)) {
712 hr = OLE_CALL_ARGS(pROT, Register, ROTFLAGS_REGISTRATIONKEEPSALIVE,
713 pUnkGraph, pMoniker, pdwRegister);
714 OLE_RELEASE_SAFE(pMoniker);
715 }
716 OLE_RELEASE_SAFE(pROT);
717 return hr;
718 }
719
720 /// Unregistering graph in ROT
721 static void RemoveFromRot(DWORD dwRegister)
722 {
723 IRunningObjectTable *pROT;
724 if (SUCCEEDED(GetRunningObjectTable(0, &pROT))) {
725 OLE_CALL_ARGS(pROT, Revoke, dwRegister);
726 OLE_RELEASE_SAFE(pROT);
727 }
728 }
729
730 /*
731 *---------------------------------------------------------------------------------------
732 *
733 * ringbuffer related methods (init, destroy)
734 *
735 *---------------------------------------------------------------------------------------
736 */
737 /**
738 * \brief ringbuffer destroying routine
739 *
740 * \param rb pointer to empty (just allocated) ringbuffer structure
741 *
742 * \note routine does not frees memory, allocated for grabber_rinbuffer_s structure
743 */
744 static void destroy_ringbuffer(grabber_ringbuffer_t * rb)
745 {
746 int i;
747
748 if (!rb)
749 return;
750
751 if (rb->ringbuffer) {
752 for (i = 0; i < rb->buffersize; i++)
753 free(rb->ringbuffer[i]);
754 free(rb->ringbuffer);
755 rb->ringbuffer = NULL;
756 }
757 free(rb->dpts);
758 rb->dpts = NULL;
759 if (rb->pMutex) {
760 DeleteCriticalSection(rb->pMutex);
761 free(rb->pMutex);
762 rb->pMutex = NULL;
763 }
764
765 rb->blocksize = 0;
766 rb->buffersize = 0;
767 rb->head = 0;
768 rb->tail = 0;
769 rb->count = 0;
770 }
771
772 /**
773 * \brief ringbuffer initialization
774 *
775 * \param rb pointer to empty (just allocated) ringbuffer structure
776 * \param buffersize size of buffer in blocks
777 * \param blocksize size of buffer's block
778 *
779 * \return S_OK if success
780 * \return E_OUTOFMEMORY not enough memory
781 *
782 * \note routine does not allocates memory for grabber_rinbuffer_s structure
783 */
784 static HRESULT init_ringbuffer(grabber_ringbuffer_t * rb, int buffersize,
785 int blocksize)
786 {
787 int i;
788
789 if (!rb)
790 return E_OUTOFMEMORY;
791
792 rb->buffersize = buffersize < 2 ? 2 : buffersize;
793 rb->blocksize = blocksize;
794
795 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Capture buffer: %d blocks of %d bytes.\n",
796 rb->buffersize, rb->blocksize);
797
798 rb->ringbuffer = malloc(rb->buffersize * sizeof(char *));
799 if (!rb)
800 return E_POINTER;
801 memset(rb->ringbuffer, 0, rb->buffersize * sizeof(char *));
802
803 for (i = 0; i < rb->buffersize; i++) {
804 rb->ringbuffer[i] = malloc(rb->blocksize * sizeof(char));
805 if (!rb->ringbuffer[i]) {
806 destroy_ringbuffer(rb);
807 return E_OUTOFMEMORY;
808 }
809 }
810 rb->dpts = malloc(rb->buffersize * sizeof(double));
811 if (!rb->dpts) {
812 destroy_ringbuffer(rb);
813 return E_OUTOFMEMORY;
814 }
815 rb->head = 0;
816 rb->tail = 0;
817 rb->count = 0;
818 rb->tStart = -1;
819 rb->pMutex = malloc(sizeof(CRITICAL_SECTION));
820 if (!rb->pMutex) {
821 destroy_ringbuffer(rb);
822 return E_OUTOFMEMORY;
823 }
824 InitializeCriticalSection(rb->pMutex);
825 return S_OK;
826 }
827
828 /*
829 *---------------------------------------------------------------------------------------
830 *
831 * Tuner related methods (frequency, capabilities, etc
832 *
833 *---------------------------------------------------------------------------------------
834 */
835 /**
836 * \brief returns string with name for givend PsysCon_* constant
837 *
838 * \param lPhysicalType constant from PhysicalConnectorType enumeration
839 *
840 * \return pointer to string with apropriate name
841 *
842 * \note
843 * Caller should not free returned pointer
844 */
845 static char *physcon2str(const long lPhysicalType)
846 {
847 int i;
848 for(i=0; tv_physcon_types[i].name; i++)
849 if(tv_physcon_types[i].type==lPhysicalType)
850 return tv_physcon_types[i].name;
851 return "Unknown";
852 };
853
854 /**
855 * \brief converts MPlayer's chanlist to system country code.
856 *
857 * \param chanlist MPlayer's chanlist name
858 *
859 * \return system country code
860 *
861 * \remarks
862 * After call to IAMTVTuner::put_CountryCode with returned value tuner switches to frequency table used in specified
863 * country (which is usually larger then MPlayer's one, so workaround will work fine).
864 *
865 * \todo
866 * Resolve trouble with cable channels (DirectShow's tuners must be switched between broadcast and cable channels modes.
867 */
868 static int chanlist2country(char *chanlist)
869 {
870 int i;
871 for(i=0; tv_chanlist2country[i].chanlist_name; i++)
872 if (!strcmp(chanlist, tv_chanlist2country[i].chanlist_name))
873 break;
874 return tv_chanlist2country[i].country_code;
875 }
876
877 /**
878 * \brief loads specified resource from module and return pointer to it
879 *
880 * \param hDLL valid module desriptor
881 * \param index index of resource. resource with name "#<index>" will be loaded
882 *
883 * \return pointer to loader resource or NULL if error occured
884 */
885 static void *GetRC(HMODULE hDLL, int index)
886 {
887 char szRCDATA[10];
888 char szName[10];
889 HRSRC hRes;
890 HGLOBAL hTable;
891
892 snprintf(szRCDATA, 10, "#%d", (int)RT_RCDATA);
893 snprintf(szName, 10, "#%d", index);
894
895 hRes = FindResource(hDLL, szName, szRCDATA);
896 if (!hRes) {
897 return NULL;
898 }
899 hTable = LoadResource(hDLL, hRes);
900 if (!hTable) {
901 return NULL;
902 }
903 return LockResource(hTable);
904 }
905
906 /**
907 * \brief loads frequency table for given country from kstvtune.ax
908 *
909 * \param[in] nCountry - country code
910 * \param[in] nInputType (TunerInputCable or TunerInputAntenna)
911 * \param[out] pplFreqTable - address of variable that receives pointer to array, containing frequencies
912 * \param[out] pnLen length of array
913 * \param[out] pnFirst - channel number of first entry in array (nChannelMax)
914 *
915 * \return S_OK if success
916 * \return E_POINTER pplFreqTable==NULL || plFirst==NULL || pnLen==NULL
917 * \return E_FAIL error occured during load
918 *
919 * \remarks
920 * - array must be freed by caller
921 * - MSDN says that it is not neccessery to unlock or free resource. It will be done after unloading DLL
922 */
923 static HRESULT load_freq_table(int nCountry, int nInputType,
924 long **pplFreqTable, int *pnLen,
925 int *pnFirst)
926 {
927 HMODULE hDLL;
928 long *plFreqTable;
929 TRCCountryList *pCountryList;
930 int i, index;
931
932 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: load_freq_table called %d (%s)\n",nCountry,nInputType == TunerInputAntenna ? "broadcast" : "cable");
933 /* ASSERT(sizeof(TRCCountryList)==10); // need properly aligned structure */
934
935 if (!pplFreqTable || !pnFirst || !pnLen)
936 return E_POINTER;
937 if (!nCountry)
938 return E_FAIL;
939
940 hDLL = LoadLibrary("kstvtune.ax");
941 if (!hDLL) {
942 return E_FAIL;
943 }
944 pCountryList = GetRC(hDLL, 9999);
945 if (!pCountryList) {
946 FreeLibrary(hDLL);
947 return E_FAIL;
948 }
949 for (i = 0; pCountryList[i].CountryCode != 0; i++)
950 if (pCountryList[i].CountryCode == nCountry)
951 break;
952 if (pCountryList[i].CountryCode == 0) {
953 FreeLibrary(hDLL);
954 return E_FAIL;
955 }
956 if (nInputType == TunerInputCable)
957 index = pCountryList[i].CableFreqTable;
958 else
959 index = pCountryList[i].BroadcastFreqTable;
960
961 plFreqTable = GetRC(hDLL, index); //First element is number of first channel, second - number of last channel
962 if (!plFreqTable) {
963 FreeLibrary(hDLL);
964 return E_FAIL;
965 }
966 *pnFirst = plFreqTable[0];
967 *pnLen = (int) (plFreqTable[1] - plFreqTable[0] + 1);
968 *pplFreqTable = malloc((*pnLen) * sizeof(long));
969 if (!*pplFreqTable) {
970 FreeLibrary(hDLL);
971 return E_FAIL;
972 }
973 for (i = 0; i < *pnLen; i++) {
974 (*pplFreqTable)[i] = plFreqTable[i + 2];
975 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: load_freq_table #%d => (%ld)\n",i+*pnFirst,(*pplFreqTable)[i]);
976 }
977 FreeLibrary(hDLL);
978 return S_OK;
979 }
980
981 /**
982 * \brief tunes to given frequency through IKsPropertySet call
983 *
984 * \param pTVTuner IAMTVTuner interface of capture device
985 * \param lFreq frequency to tune (in Hz)
986 *
987 * \return S_OK success
988 * \return apropriate error code otherwise
989 *
990 * \note
991 * Due to either bug in driver or error in following code calll to IKsProperty::Set
992 * in this methods always fail with error 0x8007007a.
993 *
994 * \todo test code on other machines and an error
995 */
996 static HRESULT set_frequency_direct(IAMTVTuner * pTVTuner, long lFreq)
997 {
998 HRESULT hr;
999 DWORD dwSupported = 0;
1000 DWORD cbBytes = 0;
1001 KSPROPERTY_TUNER_MODE_CAPS_S mode_caps;
1002 KSPROPERTY_TUNER_FREQUENCY_S frequency;
1003 IKsPropertySet *pKSProp;
1004
1005 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: set_frequency_direct called\n");
1006
1007 memset(&mode_caps, 0, sizeof(mode_caps));
1008 memset(&frequency, 0, sizeof(frequency));
1009
1010 hr = OLE_QUERYINTERFACE(pTVTuner, IID_IKsPropertySet, pKSProp);
1011 if (FAILED(hr))
1012 return hr; //no IKsPropertySet interface
1013
1014 mode_caps.Mode = AMTUNER_MODE_TV;
1015 hr = OLE_CALL_ARGS(pKSProp, QuerySupported, &PROPSETID_TUNER,
1016 KSPROPERTY_TUNER_MODE_CAPS, &dwSupported);
1017 if (FAILED(hr)) {
1018 OLE_RELEASE_SAFE(pKSProp);
1019 return hr;
1020 }
1021
1022 if (!dwSupported & KSPROPERTY_SUPPORT_GET) {
1023 OLE_RELEASE_SAFE(pKSProp);
1024 return E_FAIL; //PROPSETID_TINER not supported
1025 }
1026
1027 hr = OLE_CALL_ARGS(pKSProp, Get, &PROPSETID_TUNER,
1028 KSPROPERTY_TUNER_MODE_CAPS,
1029 INSTANCEDATA_OF_PROPERTY_PTR(&mode_caps),
1030 INSTANCEDATA_OF_PROPERTY_SIZE(mode_caps),
1031 &mode_caps, sizeof(mode_caps), &cbBytes);
1032
1033 frequency.Frequency = lFreq;
1034
1035 if (mode_caps.Strategy == KS_TUNER_STRATEGY_DRIVER_TUNES)
1036 frequency.TuningFlags = KS_TUNER_TUNING_FINE;
1037 else
1038 frequency.TuningFlags = KS_TUNER_TUNING_EXACT;
1039
1040 if (lFreq < mode_caps.MinFrequency || lFreq > mode_caps.MaxFrequency) {
1041 OLE_RELEASE_SAFE(pKSProp);
1042 return E_FAIL;
1043 }
1044
1045 hr = OLE_CALL_ARGS(pKSProp, Set, &PROPSETID_TUNER,
1046 KSPROPERTY_TUNER_FREQUENCY,
1047 INSTANCEDATA_OF_PROPERTY_PTR(&frequency),
1048 INSTANCEDATA_OF_PROPERTY_SIZE(frequency),
1049 &frequency, sizeof(frequency));
1050 if (FAILED(hr)) {
1051 OLE_RELEASE_SAFE(pKSProp);
1052 return hr;
1053 }
1054
1055 OLE_RELEASE_SAFE(pKSProp);
1056
1057 return S_OK;
1058 }
1059
1060 /**
1061 * \brief find channel with nearest frequency and set it
1062 *
1063 * \param priv driver's private data
1064 * \param lFreq frequency in Hz
1065 *
1066 * \return S_OK if success
1067 * \return E_FAIL if error occured
1068 */
1069 static HRESULT set_nearest_freq(priv_t * priv, long lFreq)
1070 {
1071 HRESULT hr;
1072 int i;
1073 long lFreqDiff=-1;
1074 int nChannel;
1075 TunerInputType tunerInput;
1076 long lInput;
1077
1078 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: set_nearest_freq called: %ld\n", lFreq);
1079 if(priv->freq_table_len == -1 && !priv->freq_table) {
1080
1081 hr = OLE_CALL_ARGS(priv->pTVTuner, get_ConnectInput, &lInput);
1082 if(FAILED(hr)){ //Falling back to 0
1083 lInput=0;
1084 }
1085
1086 hr = OLE_CALL_ARGS(priv->pTVTuner, get_InputType, lInput, &tunerInput);
1087
1088 if (load_freq_table(chanlist2country(priv->tv_param->chanlist), tunerInput, &(priv->freq_table), &(priv->freq_table_len), &(priv->first_channel)) != S_OK) {//FIXME
1089 priv->freq_table_len=0;
1090 priv->freq_table=NULL;
1091 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to load frequency table from kstvtune.ax\n");
1092 return E_FAIL;
1093 };
1094 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: loaded system (%s) frequency table for country id=%d (channels:%d).\n", tunerInput == TunerInputAntenna ? "broadcast" : "cable",
1095 chanlist2country(priv->tv_param->chanlist), priv->freq_table_len);
1096 }
1097
1098 if (priv->freq_table_len <= 0)
1099 return E_FAIL;
1100
1101 //FIXME: rewrite search algo
1102 nChannel = -1;
1103 for (i = 0; i < priv->freq_table_len; i++) {
1104 if (nChannel == -1 || labs(lFreq - priv->freq_table[i]) < lFreqDiff) {
1105 nChannel = priv->first_channel + i;
1106 lFreqDiff = labs(lFreq - priv->freq_table[i]);
1107 }
1108 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: set_nearest_freq #%d (%ld) => %d (%ld)\n",i+priv->first_channel,priv->freq_table[i], nChannel,lFreqDiff);
1109 }
1110 if (nChannel == -1) {
1111 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Unable to find nearest channel in system frequency table\n");
1112 return E_FAIL;
1113 }
1114 mp_msg(MSGT_TV, MSGL_V, "tvi_dshow: set_nearest_freq #%d (%ld)\n",nChannel,priv->freq_table[nChannel - priv->first_channel]);
1115 hr = OLE_CALL_ARGS(priv->pTVTuner, put_Channel, nChannel,
1116 AMTUNER_SUBCHAN_DEFAULT, AMTUNER_SUBCHAN_DEFAULT);
1117 if (FAILED(hr)) {
1118 mp_tmsg(MSGT_TV,MSGL_ERR,"tvi_dshow: Unable to switch to nearest channel from system frequency table. Error:0x%x\n", (unsigned int)hr);
1119 return E_FAIL;
1120 }
1121 return S_OK;
1122 }
1123
1124 /**
1125 * \brief setting frequency. decides whether use direct call/workaround
1126 *
1127 * \param priv driver's private data
1128 * \param lFreq frequency in Hz
1129 *
1130 * \return TVI_CONTROL_TRUE if success
1131 * \return TVI_CONTROL_FALSE if error occured
1132 *
1133 * \todo check for freq boundary
1134 */
1135 static int set_frequency(priv_t * priv, long lFreq)
1136 {
1137 HRESULT hr;
1138
1139 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: set_frequency called: %ld\n", lFreq);
1140 if (!priv->pTVTuner)
1141 return TVI_CONTROL_FALSE;
1142 if (priv->direct_setfreq_call) { //using direct call to set frequency
1143 hr = set_frequency_direct(priv->pTVTuner, lFreq);
1144 if (FAILED(hr)) {
1145 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: Unable to set frequency directly. OS built-in channels table will be used.\n");
1146 priv->direct_setfreq_call = 0;
1147 }
1148 }
1149 if (!priv->direct_setfreq_call) {
1150 hr = set_nearest_freq(priv, lFreq);
1151 }
1152 if (FAILED(hr))
1153 return TVI_CONTROL_FALSE;
1154 #ifdef DEPRECATED
1155 priv->pGrabber->ClearBuffer(priv->pGrabber);
1156 #endif
1157 return TVI_CONTROL_TRUE;
1158 }
1159
1160 /**
1161 * \brief return current frequency from tuner (in Hz)
1162 *
1163 * \param pTVTuner IAMTVTuner interface of tuner
1164 * \param plFreq address of variable that receives current frequency
1165 *
1166 * \return S_OK success
1167 * \return E_POINTER pTVTuner==NULL || plFreq==NULL
1168 * \return apropriate error code otherwise
1169 */
1170 static HRESULT get_frequency_direct(IAMTVTuner * pTVTuner, long *plFreq)
1171 {
1172 HRESULT hr;
1173 KSPROPERTY_TUNER_STATUS_S TunerStatus;
1174 DWORD cbBytes;
1175 IKsPropertySet *pKSProp;
1176 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: get_frequency_direct called\n");
1177
1178 if (!plFreq)
1179 return E_POINTER;
1180
1181 hr = OLE_QUERYINTERFACE(pTVTuner, IID_IKsPropertySet, pKSProp);
1182 if (FAILED(hr)) {
1183 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Get freq QueryInterface failed\n");
1184 return hr;
1185 }
1186
1187 hr = OLE_CALL_ARGS(pKSProp, Get, &PROPSETID_TUNER,
1188 KSPROPERTY_TUNER_STATUS,
1189 INSTANCEDATA_OF_PROPERTY_PTR(&TunerStatus),
1190 INSTANCEDATA_OF_PROPERTY_SIZE(TunerStatus),
1191 &TunerStatus, sizeof(TunerStatus), &cbBytes);
1192 if (FAILED(hr)) {
1193 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Get freq Get failure\n");
1194 return hr;
1195 }
1196 *plFreq = TunerStatus.CurrentFrequency;
1197 return S_OK;
1198 }
1199
1200 /**
1201 * \brief gets current frequency
1202 *
1203 * \param priv driver's private data structure
1204 * \param plFreq - pointer to long int to store frequency to (in Hz)
1205 *
1206 * \return TVI_CONTROL_TRUE if success, TVI_CONTROL_FALSE otherwise
1207 */
1208 static int get_frequency(priv_t * priv, long *plFreq)
1209 {
1210 HRESULT hr;
1211
1212 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: get_frequency called\n");
1213
1214 if (!plFreq || !priv->pTVTuner)
1215 return TVI_CONTROL_FALSE;
1216
1217 if (priv->direct_getfreq_call) { //using direct call to get frequency
1218 hr = get_frequency_direct(priv->pTVTuner, plFreq);
1219 if (FAILED(hr)) {
1220 mp_tmsg(MSGT_TV, MSGL_INFO, "tvi_dshow: Unable to get frequency directly. OS built-in channels table will be used.\n");
1221 priv->direct_getfreq_call = 0;
1222 }
1223 }
1224 if (!priv->direct_getfreq_call) {
1225 hr=OLE_CALL_ARGS(priv->pTVTuner, get_VideoFrequency, plFreq);
1226 if (FAILED(hr))
1227 return TVI_CONTROL_FALSE;
1228
1229 }
1230 return TVI_CONTROL_TRUE;
1231 }
1232
1233 /**
1234 * \brief get tuner capabilities
1235 *
1236 * \param priv driver's private data
1237 */
1238 static void get_capabilities(priv_t * priv)
1239 {
1240 long lAvailableFormats;
1241 HRESULT hr;
1242 int i;
1243 long lInputPins, lOutputPins, lRelated, lPhysicalType;
1244 IEnumPins *pEnum;
1245 char tmp[200];
1246 IPin *pPin = 0;
1247 PIN_DIRECTION ThisPinDir;
1248 PIN_INFO pi;
1249 IAMAudioInputMixer *pIAMixer;
1250
1251 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: get_capabilities called\n");
1252 if (priv->pTVTuner) {
1253
1254 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: supported norms:");
1255 hr = OLE_CALL_ARGS(priv->pTVTuner, get_AvailableTVFormats,
1256 &lAvailableFormats);
1257 if (FAILED(hr))
1258 tv_available_norms_count = 0;
1259 else {
1260 for (i = 0; i < TV_NORMS_COUNT; i++) {
1261 if (lAvailableFormats & tv_norms[i].index) {
1262 tv_available_norms[tv_available_norms_count] = i;
1263 mp_msg(MSGT_TV, MSGL_V, " %d=%s;",
1264 tv_available_norms_count + 1, tv_norms[i].name);
1265 tv_available_norms_count++;
1266 }
1267 }
1268 }
1269 mp_msg(MSGT_TV, MSGL_INFO, "\n");
1270 }
1271 if (priv->pCrossbar) {
1272 OLE_CALL_ARGS(priv->pCrossbar, get_PinCounts, &lOutputPins,
1273 &lInputPins);
1274
1275 tv_available_inputs = malloc(sizeof(long) * lInputPins);
1276 tv_available_inputs_count = 0;
1277
1278 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: available video inputs:");
1279 for (i = 0; i < lInputPins; i++) {
1280 OLE_CALL_ARGS(priv->pCrossbar, get_CrossbarPinInfo, 1, i,
1281 &lRelated, &lPhysicalType);
1282
1283 if (lPhysicalType < 0x1000) {
1284 tv_available_inputs[tv_available_inputs_count++] = i;
1285 mp_msg(MSGT_TV, MSGL_V, " %d=%s;",
1286 tv_available_inputs_count - 1,
1287 physcon2str(lPhysicalType));
1288 }
1289 }
1290 mp_msg(MSGT_TV, MSGL_INFO, "\n");
1291
1292 set_crossbar_input(priv, 0);
1293 }
1294
1295 if (priv->adev_index != -1) {
1296 hr = OLE_CALL_ARGS(priv->chains[1]->pCaptureFilter, EnumPins, &pEnum);
1297 if (FAILED(hr))
1298 return;
1299 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: available audio inputs:");
1300 i = 0;
1301 while (OLE_CALL_ARGS(pEnum, Next, 1, &pPin, NULL) == S_OK) {
1302 memset(&pi, 0, sizeof(pi));
1303 memset(tmp, 0, 200);
1304 OLE_CALL_ARGS(pPin, QueryDirection, &ThisPinDir);
1305 if (ThisPinDir == PINDIR_INPUT) {
1306 OLE_CALL_ARGS(pPin, QueryPinInfo, &pi);
1307 wtoa(pi.achName, tmp, 200);
1308 OLE_RELEASE_SAFE(pi.pFilter);
1309 mp_msg(MSGT_TV, MSGL_V, " %d=%s", i, tmp);
1310 mp_msg(MSGT_TV, MSGL_DBG3, " (%p)", pPin);
1311 hr = OLE_QUERYINTERFACE(pPin, IID_IAMAudioInputMixer,pIAMixer);
1312 if (SUCCEEDED(hr)) {
1313 if (i == priv->tv_param->audio_id) {
1314 OLE_CALL_ARGS(pIAMixer, put_Enable, TRUE);
1315 if(priv->tv_param->volume>0)
1316 OLE_CALL_ARGS(pIAMixer, put_MixLevel, 0.01 * priv->tv_param->volume);
1317 #if 0
1318 else
1319 OLE_CALL_ARGS(pIAMixer, put_MixLevel, 1.0);
1320 #endif
1321 mp_tmsg(MSGT_TV, MSGL_V, "(selected)");
1322 } else {
1323 OLE_CALL_ARGS(pIAMixer, put_Enable, FALSE);
1324 #if 0
1325 OLE_CALL_ARGS(pIAMixer, put_MixLevel, 0.0);
1326 #endif
1327 }
1328 OLE_RELEASE_SAFE(pIAMixer);
1329 }
1330 mp_msg(MSGT_TV, MSGL_V, ";");
1331 OLE_RELEASE_SAFE(pPin);
1332 i++;
1333 }
1334 }
1335 mp_msg(MSGT_TV, MSGL_INFO, "\n");
1336 OLE_RELEASE_SAFE(pEnum);
1337 }
1338 }
1339
1340 /*
1341 *---------------------------------------------------------------------------------------
1342 *
1343 * Filter related methods
1344 *
1345 *---------------------------------------------------------------------------------------
1346 */
1347 /**
1348 * \brief building in graph audio/video capture chain
1349 *
1350 * \param priv driver's private data
1351 * \param pCaptureFilter pointer to capture device's IBaseFilter interface
1352 * \param pbuf ringbuffer data structure
1353 * \param pmt media type for chain (AM_MEDIA_TYPE)
1354 *
1355 * \note routine does not frees memory, allocated for grabber_rinbuffer_s structure
1356 */
1357 static HRESULT build_sub_graph(priv_t * priv, chain_t * chain, const GUID* ppin_category)
1358 {
1359 HRESULT hr;
1360 int nFormatProbed = 0;
1361
1362 IPin *pSGOut;
1363 IPin *pNRIn=NULL;
1364
1365 IBaseFilter *pNR = NULL;
1366
1367 hr=S_OK;
1368
1369 //No supported formats
1370 if(!chain->arpmt[0])
1371 return E_FAIL;
1372
1373 do{
1374 hr = OLE_CALL_ARGS(priv->pBuilder, FindPin,
1375 (IUnknown *) chain->pCaptureFilter,
1376 PINDIR_OUTPUT, ppin_category,
1377 chain->majortype, FALSE, 0, &chain->pCapturePin);
1378 if(FAILED(hr)){
1379 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: FindPin(pCapturePin) call failed. Error:0x%x\n", (unsigned int)hr);
1380 break;
1381 }
1382 /* Addinf SampleGrabber filter for video stream */
1383 hr = CoCreateInstance((GUID *) & CLSID_SampleGrabber, NULL,CLSCTX_INPROC_SERVER, &IID_IBaseFilter,(void *) &chain->pSGF);
1384 if(FAILED(hr)){
1385 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: CoCreateInstance(SampleGrabber) call failed. Error:0x%x\n", (unsigned int)hr);
1386 break;
1387 }
1388 hr = OLE_CALL_ARGS(priv->pGraph, AddFilter, chain->pSGF, L"Sample Grabber");
1389 if(FAILED(hr)){
1390 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: AddFilter(SampleGrabber) call failed. Error:0x%x\n", (unsigned int)hr);
1391 break;
1392 }
1393 hr = OLE_CALL_ARGS(priv->pBuilder, FindPin, (IUnknown *) chain->pSGF,PINDIR_INPUT, NULL, NULL, FALSE, 0, &chain->pSGIn);
1394 if(FAILED(hr)){
1395 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: FindPin(pSGIn) call failed. Error:0x%x\n", (unsigned int)hr);
1396 break;
1397 }
1398 hr = OLE_CALL_ARGS(priv->pBuilder, FindPin, (IUnknown *) chain->pSGF,PINDIR_OUTPUT, NULL, NULL, FALSE, 0, &pSGOut);
1399 if(FAILED(hr)){
1400 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: FindPin(pSGOut) call failed. Error:0x%x\n", (unsigned int)hr);
1401 break;
1402 }
1403
1404 /* creating ringbuffer for video samples */
1405 chain->pCSGCB = CSampleGrabberCB_Create(chain->rbuf);
1406 if(!chain->pCSGCB){
1407 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: CSampleGrabberCB_Create(pbuf) call failed. Error:0x%x\n", (unsigned int)E_OUTOFMEMORY);
1408 break;
1409 }
1410
1411 /* initializing SampleGrabber filter */
1412 hr = OLE_QUERYINTERFACE(chain->pSGF, IID_ISampleGrabber, chain->pSG);
1413 if(FAILED(hr)){
1414 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: QueryInterface(IID_ISampleGrabber) call failed. Error:0x%x\n", (unsigned int)hr);
1415 break;
1416 }
1417 // hr = OLE_CALL_ARGS(pSG, SetCallback, (ISampleGrabberCB *) pCSGCB, 1); //we want to receive copy of sample's data
1418 hr = OLE_CALL_ARGS(chain->pSG, SetCallback, (ISampleGrabberCB *) chain->pCSGCB, 0); //we want to receive sample
1419
1420 if(FAILED(hr)){
1421 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: SetCallback(pSG) call failed. Error:0x%x\n", (unsigned int)hr);
1422 break;
1423 }
1424 hr = OLE_CALL_ARGS(chain->pSG, SetOneShot, FALSE); //... for all frames
1425 if(FAILED(hr)){
1426 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: SetOneShot(pSG) call failed. Error:0x%x\n", (unsigned int)hr);
1427 break;
1428 }
1429 hr = OLE_CALL_ARGS(chain->pSG, SetBufferSamples, FALSE); //... do not buffer samples in sample grabber
1430 if(FAILED(hr)){
1431 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: SetBufferSamples(pSG) call failed. Error:0x%x\n", (unsigned int)hr);
1432 break;
1433 }
1434
1435 if(priv->tv_param->normalize_audio_chunks && chain->type==audio){
1436 set_buffer_preference(20,(WAVEFORMATEX*)(chain->arpmt[nFormatProbed]->pbFormat),chain->pCapturePin,chain->pSGIn);
1437 }
1438
1439 for(nFormatProbed=0; chain->arpmt[nFormatProbed]; nFormatProbed++)
1440 {
1441 DisplayMediaType("Probing format", chain->arpmt[nFormatProbed]);
1442 hr = OLE_CALL_ARGS(chain->pSG, SetMediaType, chain->arpmt[nFormatProbed]); //set desired mediatype
1443 if(FAILED(hr)){
1444 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: SetMediaType(pSG) call failed. Error:0x%x\n", (unsigned int)hr);
1445 continue;
1446 }
1447 /* connecting filters together: VideoCapture --> SampleGrabber */
1448 hr = OLE_CALL_ARGS(priv->pGraph, Connect, chain->pCapturePin, chain->pSGIn);
1449 if(FAILED(hr)){
1450 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: Unable to create pCapturePin<->pSGIn connection. Error:0x%x\n", (unsigned int)hr);
1451 continue;
1452 }
1453 break;
1454 }
1455
1456 if(!chain->arpmt[nFormatProbed])
1457 {
1458 mp_msg(MSGT_TV, MSGL_WARN, "tvi_dshow: Unable to negotiate media format\n");
1459 hr = E_FAIL;
1460 break;
1461 }
1462
1463 hr = OLE_CALL_ARGS(chain->pCapturePin, ConnectionMediaType, chain->pmt);
1464 if(FAILED(hr))
1465 {
1466 mp_tmsg(MSGT_TV, MSGL_WARN, "tvi_dshow: Unable to get actual mediatype (Error:0x%x). Assuming equal to requested.\n", (unsigned int)hr);
1467 }
1468
1469 if(priv->tv_param->hidden_video_renderer){
1470 IEnumFilters* pEnum;
1471 IBaseFilter* pFilter;
1472
1473 hr=OLE_CALL_ARGS(priv->pBuilder,RenderStream,NULL,NULL,(IUnknown*)chain->pCapturePin,NULL,NULL);
1474
1475 OLE_CALL_ARGS(priv->pGraph, EnumFilters, &pEnum);
1476 while (OLE_CALL_ARGS(pEnum, Next, 1, &pFilter, NULL) == S_OK) {
1477 LPVIDEOWINDOW pVideoWindow;
1478 hr = OLE_QUERYINTERFACE(pFilter, IID_IVideoWindow, pVideoWindow);
1479 if (SUCCEEDED(hr))
1480 {
1481 OLE_CALL_ARGS(pVideoWindow,put_Visible,/* OAFALSE*/ 0);
1482 OLE_CALL_ARGS(pVideoWindow,put_AutoShow,/* OAFALSE*/ 0);
1483 OLE_RELEASE_SAFE(pVideoWindow);
1484 }
1485 OLE_RELEASE_SAFE(pFilter);
1486 }
1487 OLE_RELEASE_SAFE(pEnum);
1488 }else
1489 {
1490 #if 0
1491 /*
1492 Code below is disabled, because terminating chain with NullRenderer leads to jerky video.
1493 Perhaps, this happens because NullRenderer filter discards each received
1494 frame while discarded frames causes live source filter to dramatically reduce frame rate.
1495 */
1496 /* adding sink for video stream */
1497 hr = CoCreateInstance((GUID *) & CLSID_NullRenderer, NULL,CLSCTX_INPROC_SERVER, &IID_IBaseFilter,(void *) &pNR);
1498 if(FAILED(hr)){
1499 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: CoCreateInstance(NullRenderer) call failed. Error:0x%x\n", (unsigned int)hr);
1500 break;
1501 }
1502 hr = OLE_CALL_ARGS(priv->pGraph, AddFilter, pNR, L"Null Renderer");
1503 if(FAILED(hr)){
1504 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: AddFilter(NullRenderer) call failed. Error:0x%x\n", (unsigned int)hr);
1505 break;
1506 }
1507 hr = OLE_CALL_ARGS(priv->pBuilder, FindPin, (IUnknown *) pNR,PINDIR_INPUT, NULL, NULL, FALSE, 0, &pNRIn);
1508 if(FAILED(hr)){
1509 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: FindPin(pNRIn) call failed. Error:0x%x\n", (unsigned int)hr);
1510 break;
1511 }
1512 /*
1513 Prevent ending VBI chain with NullRenderer filter, because this causes VBI pin disconnection
1514 */
1515 if(memcmp(&(arpmt[nFormatProbed]->majortype),&MEDIATYPE_VBI,16)){
1516 /* connecting filters together: SampleGrabber --> NullRenderer */
1517 hr = OLE_CALL_ARGS(priv->pGraph, Connect, pSGOut, pNRIn);
1518 if(FAILED(hr)){
1519 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: Unable to create pSGOut<->pNRIn connection. Error:0x%x\n", (unsigned int)hr);
1520 break;
1521 }
1522 }
1523 #endif
1524 }
1525
1526 hr = S_OK;
1527 } while(0);
1528
1529 OLE_RELEASE_SAFE(pSGOut);
1530 OLE_RELEASE_SAFE(pNR);
1531 OLE_RELEASE_SAFE(pNRIn);
1532
1533 return hr;
1534 }
1535
1536 /**
1537 * \brief configures crossbar for grabbing video stream from given input
1538 *
1539 * \param priv driver's private data
1540 * \param input index of available video input to get data from
1541 *
1542 * \return TVI_CONTROL_TRUE success
1543 * \return TVI_CONTROL_FALSE error
1544 */
1545 static int set_crossbar_input(priv_t * priv, int input)
1546 {
1547 HRESULT hr;
1548 int i, nVideoDecoder, nAudioDecoder;
1549 long lInput, lInputRelated, lRelated, lPhysicalType, lOutputPins,
1550 lInputPins;
1551
1552 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: Configuring crossbar\n");
1553 if (!priv->pCrossbar || input < 0
1554 || input >= tv_available_inputs_count)
1555 return TVI_CONTROL_FALSE;
1556
1557 OLE_CALL_ARGS(priv->pCrossbar, get_PinCounts, &lOutputPins, &lInputPins);
1558
1559 lInput = tv_available_inputs[input];
1560
1561 if (lInput < 0 || lInput >= lInputPins)
1562 return TVI_CONTROL_FALSE;
1563
1564 OLE_CALL_ARGS(priv->pCrossbar, get_CrossbarPinInfo, 1 /* input */ , lInput,
1565 &lInputRelated, &lPhysicalType);
1566
1567 nVideoDecoder = nAudioDecoder = -1;
1568 for (i = 0; i < lOutputPins; i++) {
1569 OLE_CALL_ARGS(priv->pCrossbar, get_CrossbarPinInfo, 0 /*output */ , i,
1570 &lRelated, &lPhysicalType);
1571 if (lPhysicalType == PhysConn_Video_VideoDecoder)
1572 nVideoDecoder = i;
1573 if (lPhysicalType == PhysConn_Audio_AudioDecoder)
1574 nAudioDecoder = i;
1575 }
1576 if (nVideoDecoder >= 0) {
1577 //connecting given input with video decoder
1578 hr = OLE_CALL_ARGS(priv->pCrossbar, Route, nVideoDecoder, lInput);
1579 if (hr != S_OK) {
1580 mp_tmsg(MSGT_TV,MSGL_ERR,"Unable to connect given input to video decoder. Error:0x%x\n", (unsigned int)hr);
1581 return TVI_CONTROL_FALSE;
1582 }
1583 }
1584 if (nAudioDecoder >= 0 && lInputRelated >= 0) {
1585 hr = OLE_CALL_ARGS(priv->pCrossbar, Route, nAudioDecoder,
1586 lInputRelated);
1587 if (hr != S_OK) {
1588 mp_tmsg(MSGT_TV,MSGL_ERR,"Unable to connect given input to audio decoder. Error:0x%x\n", (unsigned int)hr);
1589 return TVI_CONTROL_FALSE;
1590 }
1591 }
1592 return TVI_CONTROL_TRUE;
1593 }
1594
1595 /**
1596 * \brief adjusts video control (hue,saturation,contrast,brightess)
1597 *
1598 * \param priv driver's private data
1599 * \param control which control to adjust
1600 * \param value new value for control (0-100)
1601 *
1602 * \return TVI_CONTROL_TRUE success
1603 * \return TVI_CONTROL_FALSE error
1604 */
1605 static int set_control(priv_t * priv, int control, int value)
1606 {
1607 long lMin, lMax, lStepping, lDefault, lFlags, lValue;
1608 HRESULT hr;
1609
1610 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: set_control called\n");
1611 if (value < -100 || value > 100 || !priv->pVideoProcAmp)
1612 return TVI_CONTROL_FALSE;
1613
1614 hr = OLE_CALL_ARGS(priv->pVideoProcAmp, GetRange, control,
1615 &lMin, &lMax, &lStepping, &lDefault, &lFlags);
1616 if (FAILED(hr) || lFlags != VideoProcAmp_Flags_Manual)
1617 return TVI_CONTROL_FALSE;
1618
1619 lValue = lMin + (value + 100) * (lMax - lMin) / 200;
1620 /*
1621 Workaround for ATI AIW 7500. The driver reports: max=255, stepping=256
1622 */
1623 if (lStepping > lMax) {
1624 mp_msg(MSGT_TV, MSGL_DBG3,
1625 "tvi_dshow: Stepping (%ld) is bigger than max value (%ld) for control %d. Assuming 1\n",
1626 lStepping, lMax,control);
1627 lStepping = 1;
1628 }
1629 lValue -= lValue % lStepping;
1630 hr = OLE_CALL_ARGS(priv->pVideoProcAmp, Set, control, lValue,
1631 VideoProcAmp_Flags_Manual);
1632 if (FAILED(hr))
1633 return TVI_CONTROL_FALSE;
1634
1635 return TVI_CONTROL_TRUE;
1636 }
1637
1638 /**
1639 * \brief get current value of video control (hue,saturation,contrast,brightess)
1640 *
1641 * \param priv driver's private data
1642 * \param control which control to adjust
1643 * \param pvalue address of variable thar receives current value
1644 *
1645 * \return TVI_CONTROL_TRUE success
1646 * \return TVI_CONTROL_FALSE error
1647 */
1648 static int get_control(priv_t * priv, int control, int *pvalue)
1649 {
1650 long lMin, lMax, lStepping, lDefault, lFlags, lValue;
1651 HRESULT hr;
1652
1653 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: get_control called\n");
1654 if (!pvalue || !priv->pVideoProcAmp)
1655 return TVI_CONTROL_FALSE;
1656
1657 hr = OLE_CALL_ARGS(priv->pVideoProcAmp, GetRange, control,
1658 &lMin, &lMax, &lStepping, &lDefault, &lFlags);
1659 if (FAILED(hr))
1660 return TVI_CONTROL_FALSE;
1661 if (lMin == lMax) {
1662 *pvalue = lMin;
1663 return TVI_CONTROL_TRUE;
1664 }
1665
1666 hr = OLE_CALL_ARGS(priv->pVideoProcAmp, Get, control, &lValue, &lFlags);
1667 if (FAILED(hr))
1668 return TVI_CONTROL_FALSE;
1669
1670 *pvalue = 200 * (lValue - lMin) / (lMax - lMin) - 100;
1671
1672 return TVI_CONTROL_TRUE;
1673 }
1674
1675 /**
1676 * \brief create AM_MEDIA_TYPE structure, corresponding to given FourCC code and width/height/fps
1677 * \param fcc FourCC code for video format
1678 * \param width picture width
1679 * \param height pciture height
1680 * \param fps frames per second (required for bitrate calculation)
1681 *
1682 * \return pointer to AM_MEDIA_TYPE structure if success, NULL - otherwise
1683 */
1684 static AM_MEDIA_TYPE* create_video_format(int fcc, int width, int height, int fps)
1685 {
1686 int i;
1687 AM_MEDIA_TYPE mt;
1688 VIDEOINFOHEADER vHdr;
1689
1690 /* Check given fcc in lookup table*/
1691 for(i=0; img_fmt_list[i].fmt && img_fmt_list[i].fmt!=fcc; i++) /* NOTHING */;
1692 if(!img_fmt_list[i].fmt)
1693 return NULL;
1694
1695 memset(&mt, 0, sizeof(AM_MEDIA_TYPE));
1696 memset(&vHdr, 0, sizeof(VIDEOINFOHEADER));
1697
1698 vHdr.bmiHeader.biSize = sizeof(vHdr.bmiHeader);
1699 vHdr.bmiHeader.biWidth = width;
1700 vHdr.bmiHeader.biHeight = height;
1701 //FIXME: is biPlanes required too?
1702 //vHdr.bmiHeader.biPlanes = img_fmt_list[i].nPlanes;
1703 vHdr.bmiHeader.biBitCount = img_fmt_list[i].nBits;
1704 vHdr.bmiHeader.biCompression = img_fmt_list[i].nCompression;
1705 vHdr.bmiHeader.biSizeImage = width * height * img_fmt_list[i].nBits / 8;
1706 vHdr.dwBitRate = vHdr.bmiHeader.biSizeImage * 8 * fps;
1707
1708 mt.pbFormat = (char*)&vHdr;
1709 mt.cbFormat = sizeof(vHdr);
1710
1711 mt.majortype = MEDIATYPE_Video;
1712 mt.subtype = *img_fmt_list[i].subtype;
1713 mt.formattype = FORMAT_VideoInfo;
1714
1715 mt.bFixedSizeSamples = 1;
1716 mt.bTemporalCompression = 0;
1717 mt.lSampleSize = vHdr.bmiHeader.biSizeImage;
1718
1719 return CreateMediaType(&mt);
1720 }
1721
1722 /**
1723 * \brief extracts fcc,width,height from AM_MEDIA_TYPE
1724 *
1725 * \param pmt pointer to AM_MEDIA_TYPE to extract data from
1726 * \param pfcc address of variable that receives FourCC
1727 * \param pwidth address of variable that receives width
1728 * \param pheight address of variable that recevies height
1729 *
1730 * \return 1 if data extracted successfully, 0 - otherwise
1731 */
1732 static int extract_video_format(AM_MEDIA_TYPE * pmt, int *pfcc,
1733 int *pwidth, int *pheight)
1734 {
1735 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: extract_video_format called\n");
1736 if (!pmt)
1737 return 0;
1738 if (!pmt->pbFormat)
1739 return 0;
1740 if (memcmp(&(pmt->formattype), &FORMAT_VideoInfo, 16) != 0)
1741 return 0;
1742 if (pfcc)
1743 *pfcc = subtype2imgfmt(&(pmt->subtype));
1744 if (pwidth)
1745 *pwidth = ((VIDEOINFOHEADER *) pmt->pbFormat)->bmiHeader.biWidth;
1746 if (pheight)
1747 *pheight = ((VIDEOINFOHEADER *) pmt->pbFormat)->bmiHeader.biHeight;
1748 return 1;
1749 }
1750
1751 /**
1752 * \brief extracts samplerate,bits,channels from AM_MEDIA_TYPE
1753 *
1754 * \param pmt pointer to AM_MEDIA_TYPE to extract data from
1755 * \param pfcc address of variable that receives samplerate
1756 * \param pwidth address of variable that receives number of bits per sample
1757 * \param pheight address of variable that recevies number of channels
1758 *
1759 * \return 1 if data extracted successfully, 0 - otherwise
1760 */
1761 static int extract_audio_format(AM_MEDIA_TYPE * pmt, int *psamplerate,
1762 int *pbits, int *pchannels)
1763 {
1764 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: extract_audio_format called\n");
1765 if (!pmt)
1766 return 0;
1767 if (!pmt->pbFormat)
1768 return 0;
1769 if (memcmp(&(pmt->formattype), &FORMAT_WaveFormatEx, 16) != 0)
1770 return 0;
1771 if (psamplerate)
1772 *psamplerate = ((WAVEFORMATEX *) pmt->pbFormat)->nSamplesPerSec;
1773 if (pbits)
1774 *pbits = ((WAVEFORMATEX *) pmt->pbFormat)->wBitsPerSample;
1775 if (pchannels)
1776 *pchannels = ((WAVEFORMATEX *) pmt->pbFormat)->nChannels;
1777 return 1;
1778 }
1779
1780 /**
1781 * \brief checks if AM_MEDIA_TYPE compatible with given samplerate,bits,channels
1782 *
1783 * \param pmt pointer to AM_MEDIA_TYPE for check
1784 * \param samplerate audio samplerate
1785 * \param bits bits per sample
1786 * \param channels number of audio channels
1787 *
1788 * \return 1 if AM_MEDIA_TYPE compatible
1789 * \return 0 if not
1790 */
1791 static int check_audio_format(AM_MEDIA_TYPE * pmt, int samplerate,
1792 int bits, int channels)
1793 {
1794 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: check_audio_format called\n");
1795 if (!pmt)
1796 return 0;
1797 if (memcmp(&(pmt->majortype), &MEDIATYPE_Audio, 16) != 0)
1798 return 0;
1799 if (memcmp(&(pmt->subtype), &MEDIASUBTYPE_PCM, 16) != 0)
1800 return 0;
1801 if (memcmp(&(pmt->formattype), &FORMAT_WaveFormatEx, 16) != 0)
1802 return 0;
1803 if (!pmt->pbFormat)
1804 return 0;
1805 if (((WAVEFORMATEX *) pmt->pbFormat)->nSamplesPerSec != samplerate)
1806 return 0;
1807 if (((WAVEFORMATEX *) pmt->pbFormat)->wBitsPerSample != bits)
1808 return 0;
1809 if (channels > 0
1810 && ((WAVEFORMATEX *) pmt->pbFormat)->nChannels != channels)
1811 return 0;
1812
1813 return 1;
1814 }
1815
1816 /**
1817 * \brief checks if AM_MEDIA_TYPE compatible with given fcc,width,height
1818 *
1819 * \param pmt pointer to AM_MEDIA_TYPE for check
1820 * \param fcc FourCC (compression)
1821 * \param width width of picture
1822 * \param height height of picture
1823 *
1824 * \return 1 if AM_MEDIA_TYPE compatible
1825 & \return 0 if not
1826 *
1827 * \note
1828 * width and height are currently not used
1829 *
1830 * \todo
1831 * add width/height check
1832 */
1833 static int check_video_format(AM_MEDIA_TYPE * pmt, int fcc, int width,
1834 int height)
1835 {
1836 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: check_video_format called\n");
1837 if (!pmt)
1838 return 0;
1839 if (memcmp(&(pmt->majortype), &MEDIATYPE_Video, 16) != 0)
1840 return 0;
1841 if (subtype2imgfmt(&(pmt->subtype)) != fcc)
1842 return 0;
1843 return 1;
1844 }
1845
1846 /**
1847 * \brief converts DirectShow subtype to MPlayer's IMGFMT
1848 *
1849 * \param subtype DirectShow subtype for video format
1850 *
1851 * \return MPlayer's IMGFMT or 0 if error occured
1852 */
1853 static int subtype2imgfmt(const GUID * subtype)
1854 {
1855 int i;
1856 for (i = 0; img_fmt_list[i].fmt; i++) {
1857 if (memcmp(subtype, img_fmt_list[i].subtype, 16) == 0)
1858 return img_fmt_list[i].fmt;
1859 }
1860 return 0;
1861 }
1862
1863 /**
1864 * \brief prints filter name and it pins
1865 *
1866 * \param pFilter - IBaseFilter to get data from
1867 *
1868 * \return S_OK if success, error code otherwise
1869 */
1870 static HRESULT show_filter_info(IBaseFilter * pFilter)
1871 {
1872 char tmp[200];
1873 FILTER_INFO fi;
1874 LPENUMPINS pEnum = 0;
1875 IPin *pPin = 0;
1876 PIN_DIRECTION ThisPinDir;
1877 PIN_INFO pi;
1878 HRESULT hr;
1879 int i;
1880
1881 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: show_filter_info called\n");
1882 memset(&fi, 0, sizeof(fi));
1883 memset(tmp, 0, 200);
1884
1885 OLE_CALL_ARGS(pFilter, QueryFilterInfo, &fi);
1886 OLE_RELEASE_SAFE(fi.pGraph);
1887 wtoa(fi.achName, tmp, 200);
1888 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: BaseFilter (%p): Name=%s, Graph=%p output pins:",
1889 pFilter, tmp, fi.pGraph);
1890 hr = OLE_CALL_ARGS(pFilter, EnumPins, &pEnum);
1891 if (FAILED(hr))
1892 return hr;
1893 i = 0;
1894 while (OLE_CALL_ARGS(pEnum, Next, 1, &pPin, NULL) == S_OK) {
1895 memset(&pi, 0, sizeof(pi));
1896 memset(tmp, 0, 200);
1897 OLE_CALL_ARGS(pPin, QueryDirection, &ThisPinDir);
1898 if (ThisPinDir == PINDIR_OUTPUT) {
1899 OLE_CALL_ARGS(pPin, QueryPinInfo, &pi);
1900 wtoa(pi.achName, tmp, 200);
1901 OLE_RELEASE_SAFE(pi.pFilter);
1902 mp_msg(MSGT_TV, MSGL_DBG2, " %d=%s", i, tmp);
1903 mp_msg(MSGT_TV, MSGL_DBG3, " (%p)", pPin);
1904 mp_msg(MSGT_TV, MSGL_DBG2, ";");
1905 OLE_RELEASE_SAFE(pPin);
1906 i++;
1907 }
1908 }
1909 mp_msg(MSGT_TV, MSGL_DBG2, "\n");
1910 OLE_RELEASE_SAFE(pEnum);
1911 return S_OK;
1912 }
1913
1914 /**
1915 * \brief gets device's frendly in ANSI encoding
1916 *
1917 * \param pM IMoniker interface, got in enumeration process
1918 * \param category device category
1919 *
1920 * \return TVI_CONTROL_TRUE if operation succeded, TVI_CONTROL_FALSE - otherwise
1921 */
1922 static int get_device_name(IMoniker * pM, char *pBuf, int nLen)
1923 {
1924 HRESULT hr;
1925 VARIANT var;
1926 IPropertyBag *pPropBag;
1927 hr = OLE_CALL_ARGS(pM, BindToStorage, 0, 0, &IID_IPropertyBag,(void *) &pPropBag);
1928 if (FAILED(hr)) {
1929 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Call to BindToStorage failed\n");
1930 return TVI_CONTROL_FALSE;
1931 }
1932 var.vt = VT_BSTR;
1933 hr = OLE_CALL_ARGS(pPropBag, Read, L"Description", (LPVARIANT) & var,
1934 NULL);
1935 if (FAILED(hr)) {
1936 hr = OLE_CALL_ARGS(pPropBag, Read, L"FriendlyName", (LPVARIANT) & var,
1937 NULL);
1938 }
1939 OLE_RELEASE_SAFE(pPropBag);
1940 if (SUCCEEDED(hr)) {
1941 wtoa(var.bstrVal, pBuf, nLen);
1942 return TVI_CONTROL_TRUE;
1943 }
1944 return TVI_CONTROL_FALSE;
1945 }
1946
1947 /**
1948 * \brief find capture device at given index
1949 *
1950 * \param index device index to search for (-1 mean only print available)
1951 * \param category device category
1952 *
1953 * \return IBaseFilter interface for capture device with given index
1954 *
1955 * Sample values for category:
1956 * CLSID_VideoInputDeviceCategory - Video Capture Sources
1957 * CLSID_AudioInputDeviceCategory - Audio Capture Sources
1958 * See DirectShow SDK documentation for other possible values
1959 */
1960 static IBaseFilter *find_capture_device(int index, REFCLSID category)
1961 {
1962 IBaseFilter *pFilter = NULL;
1963 ICreateDevEnum *pDevEnum = NULL;
1964 IEnumMoniker *pClassEnum = NULL;
1965 IMoniker *pM;
1966 HRESULT hr;
1967 ULONG cFetched;
1968 int i;
1969 char tmp[DEVICE_NAME_MAX_LEN + 1];
1970 hr = CoCreateInstance((GUID *) & CLSID_SystemDeviceEnum, NULL,
1971 CLSCTX_INPROC_SERVER, &IID_ICreateDevEnum,
1972 (void *) &pDevEnum);
1973 if (FAILED(hr)) {
1974 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Unable to create device enumerator\n");
1975 return NULL;
1976 }
1977
1978 hr = OLE_CALL_ARGS(pDevEnum, CreateClassEnumerator, category, &pClassEnum, 0);
1979 OLE_RELEASE_SAFE(pDevEnum);
1980 if (FAILED(hr)) {
1981 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Unable to create class enumerator\n");
1982 return NULL;
1983 }
1984 if (hr == S_FALSE) {
1985 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: No capture devices found\n");
1986 return NULL;
1987 }
1988
1989 OLE_CALL(pClassEnum,Reset);
1990 for (i = 0; OLE_CALL_ARGS(pClassEnum, Next, 1, &pM, &cFetched) == S_OK; i++) {
1991 if(get_device_name(pM, tmp, DEVICE_NAME_MAX_LEN)!=TVI_CONTROL_TRUE)
1992 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to get name for device #%d\n", i);
1993 else
1994 mp_tmsg(MSGT_TV, MSGL_V, "tvi_dshow: Device #%d: %s\n", i, tmp);
1995 if (index != -1 && i == index) {
1996 mp_tmsg(MSGT_TV, MSGL_INFO, "tvi_dshow: Using device #%d: %s\n", index, tmp);
1997 hr = OLE_CALL_ARGS(pM, BindToObject, 0, 0, &IID_IBaseFilter,(void *) &pFilter);
1998 if (FAILED(hr))
1999 pFilter = NULL;
2000 }
2001 OLE_RELEASE_SAFE(pM);
2002 }
2003 if (index != -1 && !pFilter) {
2004 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Device #%d not found\n",
2005 index);
2006 }
2007 OLE_RELEASE_SAFE(pClassEnum);
2008
2009 return pFilter;
2010 }
2011
2012 /**
2013 * \brief get array of available formats through call to IAMStreamConfig::GetStreamCaps
2014 *
2015 * \praram[in] chain chain data structure
2016 *
2017 * \return S_OK success
2018 * \return E_POINTER one of parameters is NULL
2019 * \return E_FAIL required size of buffer is unknown for given media type
2020 * \return E_OUTOFMEMORY not enough memory
2021 * \return other error code from called methods
2022 *
2023 * \remarks
2024 * last items of chain->arpmt and chain->arStreamCaps will be NULL
2025 */
2026 static HRESULT get_available_formats_stream(chain_t *chain)
2027 {
2028 AM_MEDIA_TYPE **arpmt;
2029 void **pBuf=NULL;
2030
2031 HRESULT hr;
2032 int i, count, size;
2033 int done;
2034
2035 mp_msg(MSGT_TV, MSGL_DBG4,
2036 "tvi_dshow: get_available_formats_stream called\n");
2037
2038 if (!chain->pStreamConfig)
2039 return E_POINTER;
2040
2041 hr=OLE_CALL_ARGS(chain->pStreamConfig, GetNumberOfCapabilities, &count, &size);
2042 if (FAILED(hr)) {
2043 mp_msg(MSGT_TV, MSGL_DBG4,
2044 "tvi_dshow: Call to GetNumberOfCapabilities failed (get_available_formats_stream)\n");
2045 return hr;
2046 }
2047 if (chain->type == video){
2048 if (size != sizeof(VIDEO_STREAM_CONFIG_CAPS)) {
2049 mp_msg(MSGT_TV, MSGL_DBG4,
2050 "tvi_dshow: Wrong video structure size for GetNumberOfCapabilities (get_available_formats_stream)\n");
2051 return E_FAIL;
2052 }
2053 } else if (chain->type == audio){
2054 if (size != sizeof(AUDIO_STREAM_CONFIG_CAPS)) {
2055 mp_msg(MSGT_TV, MSGL_DBG4,
2056 "tvi_dshow: Wrong audio structure size for GetNumberOfCapabilities (get_available_formats_stream)\n");
2057 return E_FAIL;
2058 }
2059 } else {
2060 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unsupported media type passed to %s\n","get_available_formats_stream");
2061 return E_FAIL;
2062 }
2063 done = 0;
2064
2065 arpmt = malloc((count + 1) * sizeof(AM_MEDIA_TYPE *));
2066 if (arpmt) {
2067 memset(arpmt, 0, (count + 1) * sizeof(AM_MEDIA_TYPE *));
2068
2069 pBuf = malloc((count + 1) * sizeof(void *));
2070 if (pBuf) {
2071 memset(pBuf, 0, (count + 1) * sizeof(void *));
2072
2073 for (i = 0; i < count; i++) {
2074 pBuf[i] = malloc(size);
2075
2076 if (!pBuf[i])
2077 break;
2078
2079 hr = OLE_CALL_ARGS(chain->pStreamConfig, GetStreamCaps, i,
2080 &(arpmt[i]), pBuf[i]);
2081 if (FAILED(hr))
2082 break;
2083 }
2084 if (i == count) {
2085 chain->arpmt = arpmt;
2086 chain->arStreamCaps = pBuf;
2087 done = 1;
2088 }
2089 }
2090 }
2091 if (!done) {
2092 for (i = 0; i < count; i++) {
2093 if (pBuf)
2094 free(pBuf[i]);
2095 if (arpmt && arpmt[i])
2096 DeleteMediaType(arpmt[i]);
2097 }
2098 free(pBuf);
2099 free(arpmt);
2100 if (hr != S_OK) {
2101 mp_msg(MSGT_TV, MSGL_DBG4, "tvi_dshow: Call to GetStreamCaps failed (get_available_formats_stream)\n");
2102 return hr;
2103 } else
2104 return E_OUTOFMEMORY;
2105 }
2106 return S_OK;
2107 }
2108
2109 /**
2110 * \brief returns allocates an array and store available media formats for given pin type to it
2111 *
2112 * \param pBuilder ICaptureGraphBuilder2 interface of graph builder
2113 * \param chain chain data structure
2114 *
2115 * \return S_OK success
2116 * \return E_POINTER one of given pointers is null
2117 * \return apropriate error code otherwise
2118 */
2119 static HRESULT get_available_formats_pin(ICaptureGraphBuilder2 * pBuilder,
2120 chain_t *chain)
2121 {
2122 IEnumMediaTypes *pEnum;
2123 int i, count, size;
2124 ULONG cFetched;
2125 AM_MEDIA_TYPE *pmt;
2126 HRESULT hr;
2127 void **pBuf;
2128 AM_MEDIA_TYPE **arpmt; //This will be real array
2129 VIDEO_STREAM_CONFIG_CAPS *pVideoCaps;
2130 AUDIO_STREAM_CONFIG_CAPS *pAudioCaps;
2131 int p1, p2, p3;
2132
2133 mp_msg(MSGT_TV, MSGL_DBG4,
2134 "tvi_dshow: get_available_formats_pin called\n");
2135 if (!pBuilder || !chain->pCaptureFilter)
2136 return E_POINTER;
2137
2138 if (!chain->pCapturePin)
2139 {
2140 hr = OLE_CALL_ARGS(pBuilder, FindPin,
2141 (IUnknown *) chain->pCaptureFilter,
2142 PINDIR_OUTPUT, &PIN_CATEGORY_CAPTURE,
2143 chain->majortype, FALSE, 0, &chain->pCapturePin);
2144
2145 if (!chain->pCapturePin)
2146 return E_POINTER;
2147 }
2148 if (chain->type == video) {
2149 size = sizeof(VIDEO_STREAM_CONFIG_CAPS);
2150 } else if (chain->type == audio) {
2151 size = sizeof(AUDIO_STREAM_CONFIG_CAPS);
2152 } else {
2153 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unsupported media type passed to %s\n","get_available_formats_pin");
2154 return E_FAIL;
2155 }
2156
2157 hr = OLE_CALL_ARGS(chain->pCapturePin, EnumMediaTypes, &pEnum);
2158 if (FAILED(hr)) {
2159 mp_msg(MSGT_TV, MSGL_DBG4,
2160 "tvi_dshow: Call to EnumMediaTypes failed (get_available_formats_pin)\n");
2161 return hr;
2162 }
2163 for (i = 0; OLE_CALL_ARGS(pEnum, Next, 1, &pmt, &cFetched) == S_OK; i++) {
2164 if (!pmt)
2165 break;
2166 }
2167 OLE_CALL(pEnum,Reset);
2168
2169 count = i;
2170 arpmt = malloc((count + 1) * sizeof(AM_MEDIA_TYPE *));
2171 if (!arpmt)
2172 return E_OUTOFMEMORY;
2173 memset(arpmt, 0, (count + 1) * sizeof(AM_MEDIA_TYPE *));
2174
2175 for (i = 0;
2176 i < count
2177 && OLE_CALL_ARGS(pEnum, Next, 1, &(arpmt[i]), &cFetched) == S_OK;
2178 i++);
2179
2180 OLE_RELEASE_SAFE(pEnum);
2181
2182
2183 pBuf = malloc((count + 1) * sizeof(void *));
2184 if (!pBuf) {
2185 for (i = 0; i < count; i++)
2186 if (arpmt[i])
2187 DeleteMediaType(arpmt[i]);
2188 free(arpmt);
2189 return E_OUTOFMEMORY;
2190 }
2191 memset(pBuf, 0, (count + 1) * sizeof(void *));
2192
2193 for (i = 0; i < count; i++) {
2194 pBuf[i] = malloc(size);
2195 if (!pBuf[i])
2196 break;
2197 memset(pBuf[i], 0, size);
2198
2199 if (chain->type == video) {
2200 pVideoCaps = (VIDEO_STREAM_CONFIG_CAPS *) pBuf[i];
2201 extract_video_format(arpmt[i], NULL, &p1, &p2);
2202 pVideoCaps->MaxOutputSize.cx = pVideoCaps->MinOutputSize.cx =
2203 p1;
2204 pVideoCaps->MaxOutputSize.cy = pVideoCaps->MinOutputSize.cy =
2205 p2;
2206 } else {
2207 pAudioCaps = (AUDIO_STREAM_CONFIG_CAPS *) pBuf[i];
2208 extract_audio_format(arpmt[i], &p1, &p2, &p3);
2209 pAudioCaps->MaximumSampleFrequency =
2210 pAudioCaps->MinimumSampleFrequency = p1;
2211 pAudioCaps->MaximumBitsPerSample =
2212 pAudioCaps->MinimumBitsPerSample = p2;
2213 pAudioCaps->MaximumChannels = pAudioCaps->MinimumChannels = p3;
2214 }
2215
2216 }
2217 if (i != count) {
2218 for (i = 0; i < count; i++) {
2219 if (arpmt[i])
2220 DeleteMediaType(arpmt[i]);
2221 free(pBuf[i]);
2222 }
2223 free(arpmt);
2224 free(pBuf);
2225 return E_OUTOFMEMORY;
2226 }
2227 chain->arpmt = arpmt;
2228 chain->arStreamCaps = pBuf;
2229
2230 return S_OK;
2231 }
2232
2233 /*
2234 *---------------------------------------------------------------------------------------
2235 *
2236 * Public methods
2237 *
2238 *---------------------------------------------------------------------------------------
2239 */
2240 /**
2241 * \brief fills given buffer with audio data (usually one block)
2242 *
2243 * \param priv driver's private data structure
2244 * \param buffer buffer to store data to
2245 * \param len buffer's size in bytes (usually one block size)
2246 *
2247 * \return audio pts if audio present, 1 - otherwise
2248 */
2249 static double grab_audio_frame(priv_t * priv, char *buffer, int len)
2250 {
2251 int bytes = 0;
2252 int i;
2253 double pts;
2254 grabber_ringbuffer_t *rb = priv->chains[1]->rbuf;
2255 grabber_ringbuffer_t *vrb = priv->chains[0]->rbuf;
2256
2257 if (!rb || !rb->ringbuffer)
2258 return 1;
2259
2260 if(vrb && vrb->tStart<0){
2261 memset(buffer,0,len);
2262 return 0;
2263 }
2264 if(vrb && rb->tStart<0)
2265 rb->tStart=vrb->tStart;
2266
2267 if (len < rb->blocksize)
2268 bytes = len;
2269 else
2270 bytes = rb->blocksize;
2271
2272 mp_msg(MSGT_TV, MSGL_DBG3,"tvi_dshow: FillBuffer (audio) called. %d blocks in buffer, %d bytes requested\n",
2273 rb->count, len);
2274 if(!rb->count){
2275 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: waiting for frame\n");
2276 for(i=0;i<1000 && !rb->count;i++) usec_sleep(1000);
2277 if(!rb->count){
2278 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: waiting timeout\n");
2279 return 0;
2280 }
2281 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: got frame!\n");
2282 }
2283
2284 EnterCriticalSection(rb->pMutex);
2285 pts=rb->dpts[rb->head]-rb->tStart;
2286 memcpy(buffer, rb->ringbuffer[rb->head], bytes);
2287 rb->head = (rb->head + 1) % rb->buffersize;
2288 rb->count--;
2289 LeaveCriticalSection(rb->pMutex);
2290 return pts;
2291 }
2292
2293 /**
2294 * \brief returns audio frame size
2295 *
2296 * \param priv driver's private data structure
2297 *
2298 * \return audio block size if audio enabled and 1 - otherwise
2299 */
2300 static int get_audio_framesize(priv_t * priv)
2301 {
2302 if (!priv->chains[1]->rbuf)
2303 return 1; //no audio
2304 mp_msg(MSGT_TV,MSGL_DBG3,"get_audio_framesize: %d\n",priv->chains[1]->rbuf->blocksize);
2305 return priv->chains[1]->rbuf->blocksize;
2306 }
2307
2308 static int vbi_get_props(priv_t* priv,tt_stream_props* ptsp)
2309 {
2310 if(!priv || !ptsp)
2311 return TVI_CONTROL_FALSE;
2312
2313 //STUBS!!!
2314 ptsp->interlaced=0;
2315 ptsp->offset=256;
2316
2317 ptsp->sampling_rate=27e6;
2318 ptsp->samples_per_line=720;
2319
2320 ptsp->count[0]=16;
2321 ptsp->count[1]=16;
2322 //END STUBS!!!
2323 ptsp->bufsize = ptsp->samples_per_line * (ptsp->count[0] + ptsp->count[1]);
2324
2325 mp_msg(MSGT_TV,MSGL_V,"vbi_get_props: sampling_rate=%d,offset:%d,samples_per_line: %d\n interlaced:%s, count=[%d,%d]\n",
2326 ptsp->sampling_rate,
2327 ptsp->offset,
2328 ptsp->samples_per_line,
2329 ptsp->interlaced?"Yes":"No",
2330 ptsp->count[0],
2331 ptsp->count[1]);
2332
2333 return TVI_CONTROL_TRUE;
2334 }
2335
2336 static void vbi_grabber(priv_t* priv)
2337 {
2338 grabber_ringbuffer_t *rb = priv->chains[2]->rbuf;
2339 int i;
2340 unsigned char* buf;
2341 if (!rb || !rb->ringbuffer)
2342 return;
2343
2344 buf=calloc(1,rb->blocksize);
2345 for(i=0; i<23 && rb->count; i++){
2346 memcpy(buf,rb->ringbuffer[rb->head],rb->blocksize);
2347 teletext_control(priv->priv_vbi,TV_VBI_CONTROL_DECODE_PAGE,&buf);
2348 rb->head = (rb->head + 1) % rb->buffersize;
2349 rb->count--;
2350 }
2351 free(buf);
2352 }
2353
2354 /**
2355 * \brief fills given buffer with video data (usually one frame)
2356 *
2357 * \param priv driver's private data structure
2358 * \param buffer buffer to store data to
2359 * \param len buffer's size in bytes (usually one frame size)
2360 *
2361 * \return frame size if video present, 0 - otherwise
2362 */
2363 static double grab_video_frame(priv_t * priv, char *buffer, int len)
2364 {
2365 int bytes = 0;
2366 int i;
2367 double pts;
2368 grabber_ringbuffer_t *rb = priv->chains[0]->rbuf;
2369
2370 if (!rb || !rb->ringbuffer)
2371 return 1;
2372 if (len < rb->blocksize)
2373 bytes = len;
2374 else
2375 bytes = rb->blocksize;
2376
2377 mp_msg(MSGT_TV, MSGL_DBG3,"tvi_dshow: FillBuffer (video) called. %d blocks in buffer, %d bytes requested\n",
2378 rb->count, len);
2379 if(!rb->count){
2380 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: waiting for frame\n");
2381 for(i=0;i<1000 && !rb->count;i++) usec_sleep(1000);
2382 if(!rb->count){
2383 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: waiting timeout\n");
2384 return 0;
2385 }
2386 mp_msg(MSGT_TV,MSGL_DBG4,"tvi_dshow: got frame!\n");
2387 }
2388 EnterCriticalSection(rb->pMutex);
2389 if(rb->tStart<0)
2390 rb->tStart=rb->dpts[rb->head];
2391 pts=rb->dpts[rb->head]-rb->tStart;
2392 memcpy(buffer, rb->ringbuffer[rb->head], bytes);
2393 rb->head = (rb->head + 1) % rb->buffersize;
2394 rb->count--;
2395 LeaveCriticalSection(rb->pMutex);
2396
2397 vbi_grabber(priv);
2398 return pts;
2399 }
2400
2401 /**
2402 * \brief returns frame size
2403 *
2404 * \param priv driver's private data structure
2405 *
2406 * \return frame size if video present, 0 - otherwise
2407 */
2408 static int get_video_framesize(priv_t * priv)
2409 {
2410 // if(!priv->pmtVideo) return 1; //no video
2411 // return priv->pmtVideo->lSampleSize;
2412 if (!priv->chains[0]->rbuf)
2413 return 1; //no video
2414 mp_msg(MSGT_TV,MSGL_DBG3,"geT_video_framesize: %d\n",priv->chains[0]->rbuf->blocksize);
2415 return priv->chains[0]->rbuf->blocksize;
2416 }
2417
2418 /**
2419 * \brief calculate audio buffer size
2420 * \param video_buf_size size of video buffer in bytes
2421 * \param video_bitrate video bit rate
2422 * \param audio_bitrate audio bit rate
2423 * \return audio buffer isze in bytes
2424 *
2425 * \remarks length of video buffer and resulted audio buffer calculated in
2426 * seconds will be the same.
2427 */
2428 static inline int audio_buf_size_from_video(int video_buf_size, int video_bitrate, int audio_bitrate)
2429 {
2430 int audio_buf_size = audio_bitrate * (video_buf_size / video_bitrate);
2431 mp_msg(MSGT_TV,MSGL_DBG2,"tvi_dshow: Audio capture buffer: %d * %d / %d = %d\n",
2432 audio_bitrate,video_buf_size,video_bitrate,audio_buf_size);
2433 return audio_buf_size;
2434 }
2435
2436 /**
2437 * \brief common chain initialization routine
2438 * \param chain chain data structure
2439 *
2440 * \note pCaptureFilter member should be initialized before call to this routine
2441 */
2442 static HRESULT init_chain_common(ICaptureGraphBuilder2 *pBuilder, chain_t *chain)
2443 {
2444 HRESULT hr;
2445 int i;
2446
2447 if(!chain->pCaptureFilter)
2448 return E_POINTER;
2449
2450 show_filter_info(chain->pCaptureFilter);
2451
2452 hr = OLE_CALL_ARGS(pBuilder, FindPin,
2453 (IUnknown *) chain->pCaptureFilter,
2454 PINDIR_OUTPUT, chain->pin_category,
2455 chain->majortype, FALSE, 0, &chain->pCapturePin);
2456
2457 if (FAILED(hr)) {
2458 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: FindPin(pCapturePin) call failed. Error:0x%x\n", (unsigned int)hr);
2459 return hr;
2460 }
2461
2462 hr = OLE_CALL_ARGS(pBuilder, FindInterface,
2463 chain->pin_category,
2464 chain->majortype,
2465 chain->pCaptureFilter,
2466 &IID_IAMStreamConfig,
2467 (void **) &(chain->pStreamConfig));
2468 if (FAILED(hr))
2469 chain->pStreamConfig = NULL;
2470
2471 /*
2472 Getting available video formats (last pointer in array will be NULL)
2473 First tryin to call IAMStreamConfig::GetStreamCaos. this will give us additional information such as
2474 min/max picture dimensions, etc. If this call fails trying IPIn::EnumMediaTypes with default
2475 min/max values.
2476 */
2477 hr = get_available_formats_stream(chain);
2478 if (FAILED(hr)) {
2479 mp_msg(MSGT_TV, MSGL_DBG2, "Unable to use IAMStreamConfig for retriving available formats (Error:0x%x). Using EnumMediaTypes instead\n", (unsigned int)hr);
2480 hr = get_available_formats_pin(pBuilder, chain);
2481 if(FAILED(hr)){
2482 return hr;
2483 }
2484 }
2485 chain->nFormatUsed = 0;
2486
2487 //If argument to CreateMediaType is NULL then result will be NULL too.
2488 chain->pmt = CreateMediaType(chain->arpmt[0]);
2489
2490 for (i = 0; chain->arpmt[i]; i++)
2491 DisplayMediaType("Available format", chain->arpmt[i]);
2492
2493 return S_OK;
2494 }
2495 /**
2496 * \brief build video stream chain in graph
2497 * \param priv private data structure
2498 *
2499 * \return S_OK if chain was built successfully, apropriate error code otherwise
2500 */
2501 static HRESULT build_video_chain(priv_t *priv)
2502 {
2503 HRESULT hr;
2504
2505 if(priv->chains[0]->rbuf)
2506 return S_OK;
2507
2508 if (priv->chains[0]->pStreamConfig) {
2509 hr = OLE_CALL_ARGS(priv->chains[0]->pStreamConfig, SetFormat, priv->chains[0]->pmt);
2510 if (FAILED(hr)) {
2511 mp_tmsg(MSGT_TV,MSGL_ERR,"tvi_dshow: Unable to select video format. Error:0x%x\n", (unsigned int)hr);
2512 }
2513 }
2514
2515 priv->chains[0]->rbuf=calloc(1,sizeof(grabber_ringbuffer_t));
2516 if(!priv->chains[0]->rbuf)
2517 return E_OUTOFMEMORY;
2518
2519 if (priv->tv_param->buffer_size >= 0) {
2520 priv->chains[0]->rbuf->buffersize = priv->tv_param->buffer_size;
2521 } else {
2522 priv->chains[0]->rbuf->buffersize = 16;
2523 }
2524
2525 priv->chains[0]->rbuf->buffersize *= 1024 * 1024;
2526 hr=build_sub_graph(priv, priv->chains[0], &PIN_CATEGORY_CAPTURE);
2527 if(FAILED(hr)){
2528 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to build video chain of capture graph. Error:0x%x\n",(unsigned int)hr);
2529 return hr;
2530 }
2531 return S_OK;
2532 }
2533
2534 /**
2535 * \brief build audio stream chain in graph
2536 * \param priv private data structure
2537 *
2538 * \return S_OK if chain was built successfully, apropriate error code otherwise
2539 */
2540 static HRESULT build_audio_chain(priv_t *priv)
2541 {
2542 HRESULT hr;
2543
2544 if(priv->chains[1]->rbuf)
2545 return S_OK;
2546
2547 if(priv->immediate_mode)
2548 return S_OK;
2549
2550 if (priv->chains[1]->pStreamConfig) {
2551 hr = OLE_CALL_ARGS(priv->chains[1]->pStreamConfig, SetFormat,
2552 priv->chains[1]->pmt);
2553 if (FAILED(hr)) {
2554 mp_tmsg(MSGT_TV,MSGL_ERR,"tvi_dshow: Unable to select audio format. Error:0x%x\n", (unsigned int)hr);
2555 }
2556 }
2557
2558 if(priv->chains[1]->pmt){
2559 priv->chains[1]->rbuf=calloc(1,sizeof(grabber_ringbuffer_t));
2560 if(!priv->chains[1]->rbuf)
2561 return E_OUTOFMEMORY;
2562
2563 /* let the audio buffer be the same size (in seconds) than video one */
2564 priv->chains[1]->rbuf->buffersize=audio_buf_size_from_video(
2565 priv->chains[0]->rbuf->buffersize,
2566 (((VIDEOINFOHEADER *) priv->chains[0]->pmt->pbFormat)->dwBitRate),
2567 (((WAVEFORMATEX *) (priv->chains[1]->pmt->pbFormat))->nAvgBytesPerSec));
2568
2569 hr=build_sub_graph(priv, priv->chains[1],&PIN_CATEGORY_CAPTURE);
2570 if(FAILED(hr)){
2571 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to build audio chain of capture graph. Error:0x%x\n",(unsigned int)hr);
2572 return 0;
2573 }
2574 }
2575 return S_OK;
2576 }
2577
2578 /**
2579 * \brief build VBI stream chain in graph
2580 * \param priv private data structure
2581 *
2582 * \return S_OK if chain was built successfully, apropriate error code otherwise
2583 */
2584 static HRESULT build_vbi_chain(priv_t *priv)
2585 {
2586 HRESULT hr;
2587
2588 if(priv->chains[2]->rbuf)
2589 return S_OK;
2590
2591 if(priv->tv_param->teletext.device)
2592 {
2593 priv->chains[2]->rbuf=calloc(1,sizeof(grabber_ringbuffer_t));
2594 if(!priv->chains[2]->rbuf)
2595 return E_OUTOFMEMORY;
2596
2597 init_ringbuffer(priv->chains[2]->rbuf,24,priv->tsp.bufsize);
2598
2599 hr=build_sub_graph(priv, priv->chains[2],&PIN_CATEGORY_VBI);
2600 if(FAILED(hr)){
2601 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to build VBI chain of capture graph. Error:0x%x\n",(unsigned int)hr);
2602 return 0;
2603 }
2604 }
2605 return S_OK;
2606 }
2607
2608 /**
2609 * \brief playback/capture real start
2610 *
2611 * \param priv driver's private data structure
2612 *
2613 * \return 1 if success, 0 - otherwise
2614 *
2615 * TODO: move some code from init() here
2616 */
2617 static int start(priv_t * priv)
2618 {
2619 HRESULT hr;
2620
2621 hr = build_video_chain(priv);
2622 if(FAILED(hr))
2623 return 0;
2624
2625 hr = build_audio_chain(priv);
2626 if(FAILED(hr))
2627 return 0;
2628
2629 hr = build_vbi_chain(priv);
2630 if(FAILED(hr))
2631 return 0;
2632
2633 /*
2634 Graph is ready to capture. Starting graph.
2635 */
2636 if (mp_msg_test(MSGT_TV, MSGL_DBG2)) {
2637 mp_msg(MSGT_TV, MSGL_DBG2, "Debug pause 10sec\n");
2638 usec_sleep(10000000);
2639 mp_msg(MSGT_TV, MSGL_DBG2, "Debug pause end\n");
2640 }
2641 if (!priv->pMediaControl) {
2642 mp_tmsg(MSGT_TV,MSGL_ERR,"tvi_dshow: Unable to get IMediaControl interface. Error:0x%x\n",(unsigned int)E_POINTER);
2643 return 0;
2644 }
2645 hr = OLE_CALL(priv->pMediaControl, Run);
2646 if (FAILED(hr)) {
2647 mp_tmsg(MSGT_TV,MSGL_ERR,"tvi_dshow: Unable to start graph! Error:0x%x\n", (unsigned int)hr);
2648 return 0;
2649 }
2650 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Graph is started.\n");
2651 priv->state = 1;
2652
2653 return 1;
2654 }
2655
2656 /**
2657 * \brief driver initialization
2658 *
2659 * \param priv driver's private data structure
2660 *
2661 * \return 1 if success, 0 - otherwise
2662 */
2663 static int init(priv_t * priv)
2664 {
2665 HRESULT hr;
2666 int result = 0;
2667 long lInput, lTunerInput;
2668 IEnumFilters *pEnum;
2669 IBaseFilter *pFilter;
2670 IPin *pVPOutPin;
2671 int i;
2672
2673 priv->state=0;
2674
2675 CoInitialize(NULL);
2676
2677 for(i=0; i<3;i++)
2678 priv->chains[i] = calloc(1, sizeof(chain_t));
2679
2680 priv->chains[0]->type=video;
2681 priv->chains[0]->majortype=&MEDIATYPE_Video;
2682 priv->chains[0]->pin_category=&PIN_CATEGORY_CAPTURE;
2683 priv->chains[1]->type=audio;
2684 priv->chains[1]->majortype=&MEDIATYPE_Audio;
2685 priv->chains[1]->pin_category=&PIN_CATEGORY_CAPTURE;
2686 priv->chains[2]->type=vbi;
2687 priv->chains[2]->majortype=&MEDIATYPE_VBI;
2688 priv->chains[2]->pin_category=&PIN_CATEGORY_VBI;
2689
2690 do{
2691 hr = CoCreateInstance((GUID *) & CLSID_FilterGraph, NULL,
2692 CLSCTX_INPROC_SERVER, &IID_IGraphBuilder,
2693 (void **) &priv->pGraph);
2694 if(FAILED(hr)){
2695 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: CoCreateInstance(FilterGraph) call failed. Error:0x%x\n", (unsigned int)hr);
2696 break;
2697 }
2698 //Debug
2699 if (mp_msg_test(MSGT_TV, MSGL_DBG2)) {
2700 AddToRot((IUnknown *) priv->pGraph, &(priv->dwRegister));
2701 }
2702
2703 hr = CoCreateInstance((GUID *) & CLSID_CaptureGraphBuilder2, NULL,
2704 CLSCTX_INPROC_SERVER, &IID_ICaptureGraphBuilder2,
2705 (void **) &priv->pBuilder);
2706 if(FAILED(hr)){
2707 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: CoCreateInstance(CaptureGraphBuilder) call failed. Error:0x%x\n", (unsigned int)hr);
2708 break;
2709 }
2710
2711 hr = OLE_CALL_ARGS(priv->pBuilder, SetFiltergraph, priv->pGraph);
2712 if(FAILED(hr)){
2713 mp_msg(MSGT_TV,MSGL_ERR, "tvi_dshow: SetFiltergraph call failed. Error:0x%x\n",(unsigned int)hr);
2714 break;
2715 }
2716
2717 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Searching for available video capture devices\n");
2718 priv->chains[0]->pCaptureFilter = find_capture_device(priv->dev_index, &CLSID_VideoInputDeviceCategory);
2719 if(!priv->chains[0]->pCaptureFilter){
2720 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Unable to find video capture device\n");
2721 break;
2722 }
2723 hr = OLE_CALL_ARGS(priv->pGraph, AddFilter, priv->chains[0]->pCaptureFilter, NULL);
2724 if(FAILED(hr)){
2725 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Unable to add video capture device to Directshow graph. Error:0x%x\n", (unsigned int)hr);
2726 break;
2727 }
2728 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Searching for available audio capture devices\n");
2729 if (priv->adev_index != -1) {
2730 priv->chains[1]->pCaptureFilter = find_capture_device(priv->adev_index, &CLSID_AudioInputDeviceCategory); //output available audio edevices
2731 if(!priv->chains[1]->pCaptureFilter){
2732 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Unable to find audio capture device\n");
2733 break;
2734 }
2735
2736 hr = OLE_CALL_ARGS(priv->pGraph, AddFilter, priv->chains[1]->pCaptureFilter, NULL);
2737 if(FAILED(hr)){
2738 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: Unable to add audio capture device to Directshow graph. Error:0x%x\n", (unsigned int)hr);
2739 break;
2740 }
2741 } else
2742 hr = OLE_QUERYINTERFACE(priv->chains[0]->pCaptureFilter, IID_IBaseFilter, priv->chains[1]->pCaptureFilter);
2743
2744 /* increase refrence counter for capture filter ad store pointer into vbi chain structure too */
2745 hr = OLE_QUERYINTERFACE(priv->chains[0]->pCaptureFilter, IID_IBaseFilter, priv->chains[2]->pCaptureFilter);
2746
2747 hr = OLE_QUERYINTERFACE(priv->chains[0]->pCaptureFilter, IID_IAMVideoProcAmp,priv->pVideoProcAmp);
2748 if (FAILED(hr) && hr != E_NOINTERFACE)
2749 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Get IID_IAMVideoProcAmp failed (0x%x).\n", (unsigned int)hr);
2750
2751 if (hr != S_OK) {
2752 mp_tmsg(MSGT_TV, MSGL_INFO, "tvi_dshow: Adjusting of brightness/hue/saturation/contrast is not supported by device\n");
2753 priv->pVideoProcAmp = NULL;
2754 }
2755
2756 hr = OLE_CALL_ARGS(priv->pBuilder, FindInterface,
2757 &PIN_CATEGORY_CAPTURE,
2758 priv->chains[0]->majortype,
2759 priv->chains[0]->pCaptureFilter,
2760 &IID_IAMCrossbar, (void **) &(priv->pCrossbar));
2761 if (FAILED(hr)) {
2762 mp_tmsg(MSGT_TV, MSGL_INFO, "tvi_dshow: Selection of capture source is not supported by device\n");
2763 priv->pCrossbar = NULL;
2764 }
2765
2766 if (priv->tv_param->amode >= 0) {
2767 IAMTVAudio *pTVAudio;
2768 hr = OLE_CALL_ARGS(priv->pBuilder, FindInterface, NULL, NULL,priv->chains[0]->pCaptureFilter,&IID_IAMTVAudio, (void *) &pTVAudio);
2769 if (hr == S_OK) {
2770 switch (priv->tv_param->amode) {
2771 case 0:
2772 hr = OLE_CALL_ARGS(pTVAudio, put_TVAudioMode, AMTVAUDIO_MODE_MONO);
2773 break;
2774 case 1:
2775 hr = OLE_CALL_ARGS(pTVAudio, put_TVAudioMode, AMTVAUDIO_MODE_STEREO);
2776 break;
2777 case 2:
2778 hr = OLE_CALL_ARGS(pTVAudio, put_TVAudioMode,
2779 AMTVAUDIO_MODE_LANG_A);
2780 break;
2781 case 3:
2782 hr = OLE_CALL_ARGS(pTVAudio, put_TVAudioMode,
2783 AMTVAUDIO_MODE_LANG_B);
2784 break;
2785 }
2786 OLE_RELEASE_SAFE(pTVAudio);
2787 if (FAILED(hr))
2788 mp_tmsg(MSGT_TV, MSGL_WARN, "tvi_dshow: Unable to set audio mode %d. Error:0x%x\n", priv->tv_param->amode,(unsigned int)hr);
2789 }
2790 }
2791
2792 // Video chain initialization
2793 hr = init_chain_common(priv->pBuilder, priv->chains[0]);
2794 if(FAILED(hr))
2795 break;
2796
2797 /*
2798 Audio chain initialization
2799 Since absent audio stream is not fatal,
2800 at least one NULL pointer should be kept in format arrays
2801 (to avoid another additional check everywhere for array presence).
2802 */
2803 hr = init_chain_common(priv->pBuilder, priv->chains[1]);
2804 if(FAILED(hr))
2805 {
2806 mp_msg(MSGT_TV, MSGL_V,
2807 "tvi_dshow: Unable to initialize audio chain (Error:0x%lx). Audio disabled\n",
2808 (unsigned long)hr);
2809 priv->chains[1]->arpmt=calloc(1, sizeof(AM_MEDIA_TYPE*));
2810 priv->chains[1]->arStreamCaps=calloc(1, sizeof(void*));
2811 }
2812
2813 /*
2814 VBI chain initialization
2815 Since absent VBI stream is not fatal,
2816 at least one NULL pointer should be kept in format arrays
2817 (to avoid another additional check everywhere for array presence).
2818 */
2819 hr = init_chain_common(priv->pBuilder, priv->chains[2]);
2820 if(FAILED(hr))
2821 {
2822 mp_msg(MSGT_TV, MSGL_V,
2823 "tvi_dshow: Unable to initialize VBI chain (Error:0x%lx). Teletext disabled\n",
2824 (unsigned long)hr);
2825 priv->chains[2]->arpmt=calloc(1, sizeof(AM_MEDIA_TYPE*));
2826 priv->chains[2]->arStreamCaps=calloc(1, sizeof(void*));
2827 }
2828
2829 if (!priv->chains[0]->pStreamConfig)
2830 mp_tmsg(MSGT_TV, MSGL_INFO, "tvi_dshow: Changing video width/height is not supported by device.\n");
2831
2832 if (!priv->chains[0]->arpmt[priv->chains[0]->nFormatUsed]
2833 || !extract_video_format(priv->chains[0]->arpmt[priv->chains[0]->nFormatUsed],
2834 &(priv->fcc), &(priv->width),
2835 &(priv->height))) {
2836 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to parse video format structure.\n");
2837 break;
2838 }
2839
2840 if (priv->chains[1]->arpmt[priv->chains[1]->nFormatUsed]) {
2841 if (!extract_audio_format(priv->chains[1]->pmt, &(priv->samplerate), NULL, NULL)) {
2842 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Unable to parse audio format structure.\n");
2843 DisplayMediaType("audio format failed",priv->chains[1]->arpmt[priv->chains[1]->nFormatUsed]);
2844 break;
2845 }
2846 }
2847
2848 hr = OLE_QUERYINTERFACE(priv->pGraph, IID_IMediaControl,priv->pMediaControl);
2849 if(FAILED(hr)){
2850 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Unable to get IMediaControl interface. Error:0x%x\n",(unsigned int)hr);
2851 break;
2852 }
2853 hr = OLE_CALL_ARGS(priv->pBuilder, FindInterface,
2854 &PIN_CATEGORY_CAPTURE, NULL,
2855 priv->chains[0]->pCaptureFilter,
2856 &IID_IAMTVTuner, (void **) &(priv->pTVTuner));
2857
2858 if (!priv->pTVTuner) {
2859 mp_msg(MSGT_TV, MSGL_DBG2, "tvi_dshow: Unable to access IAMTVTuner (0x%x)\n", (unsigned int)hr);
2860 }
2861
2862 // shows Tuner capabilities
2863 get_capabilities(priv);
2864
2865 if (priv->pTVTuner) {
2866 hr = OLE_CALL_ARGS(priv->pTVTuner, put_CountryCode,
2867 chanlist2country(priv->tv_param->chanlist));
2868 if(FAILED(hr)){
2869 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: Call to put_CountryCode failed. Error:0x%x\n",(unsigned int)hr);
2870 }
2871
2872 hr = OLE_CALL_ARGS(priv->pTVTuner, put_Mode, AMTUNER_MODE_TV);
2873 if(FAILED(hr)){
2874 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: Call to put_Mode failed. Error:0x%x\n",(unsigned int)hr);
2875 break;
2876 }
2877
2878 hr = OLE_CALL_ARGS(priv->pTVTuner, get_ConnectInput, &lInput);
2879 if(FAILED(hr)){
2880 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: Call to get_ConnectInput failed. Error:0x%x\n",(unsigned int)hr);
2881 break;
2882 }
2883
2884 /* small hack */
2885 lTunerInput = strstr(priv->tv_param->chanlist, "cable") ? TunerInputCable : TunerInputAntenna;
2886
2887 hr = OLE_CALL_ARGS(priv->pTVTuner, put_InputType, lInput, lTunerInput);
2888 if(FAILED(hr)){
2889 mp_msg(MSGT_TV,MSGL_DBG2, "tvi_dshow: Call to put_InputType failed. Error:0x%x\n",(unsigned int)hr);
2890 break;
2891 }
2892
2893 }
2894
2895 /**
2896 for VIVO cards we should check if preview pin is available on video capture device.
2897 If it is not, we have to connect Video Port Manager filter to VP pin of capture device filter.
2898 Otherwise we will get 0x8007001f (Device is not functioning properly) when attempting to start graph
2899 */
2900 hr = OLE_CALL_ARGS(priv->pBuilder, FindPin,
2901 (IUnknown *) priv->chains[0]->pCaptureFilter,
2902 PINDIR_OUTPUT,
2903 &PIN_CATEGORY_VIDEOPORT, NULL, FALSE,
2904 0, (IPin **) & pVPOutPin);
2905 if (SUCCEEDED(hr)) {
2906 hr = OLE_CALL_ARGS(priv->pGraph, Render, pVPOutPin);
2907 OLE_RELEASE_SAFE(pVPOutPin);
2908
2909 if (FAILED(hr)) {
2910 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Unable to terminate VideoPort pin with any filter in graph. Error:0x%x\n", (unsigned int)hr);
2911 break;
2912 }
2913 }
2914
2915 OLE_CALL_ARGS(priv->pGraph, EnumFilters, &pEnum);
2916 while (OLE_CALL_ARGS(pEnum, Next, 1, &pFilter, NULL) == S_OK) {
2917 LPVIDEOWINDOW pVideoWindow;
2918 hr = OLE_QUERYINTERFACE(pFilter, IID_IVideoWindow, pVideoWindow);
2919 if (SUCCEEDED(hr))
2920 {
2921 if(priv->tv_param->hidden_vp_renderer){
2922 OLE_CALL_ARGS(pVideoWindow,put_Visible,/* OAFALSE*/ 0);
2923 OLE_CALL_ARGS(pVideoWindow,put_AutoShow,/* OAFALSE*/ 0);
2924 }else
2925 {
2926 OLE_CALL_ARGS(priv->pGraph, RemoveFilter, pFilter);
2927 }
2928 OLE_RELEASE_SAFE(pVideoWindow);
2929 }
2930 OLE_RELEASE_SAFE(pFilter);
2931 }
2932 OLE_RELEASE_SAFE(pEnum);
2933 if(priv->tv_param->system_clock)
2934 {
2935 LPREFERENCECLOCK rc;
2936 IBaseFilter* pBF;
2937 hr = CoCreateInstance((GUID *) & CLSID_SystemClock, NULL,
2938 CLSCTX_INPROC_SERVER, &IID_IReferenceClock,
2939 (void *) &rc);
2940
2941 OLE_QUERYINTERFACE(priv->pBuilder,IID_IBaseFilter,pBF);
2942 OLE_CALL_ARGS(pBF,SetSyncSource,rc);
2943 }
2944 if(vbi_get_props(priv,&(priv->tsp))!=TVI_CONTROL_TRUE)
2945 break;
2946 result = 1;
2947 } while(0);
2948
2949 if (!result){
2950 mp_tmsg(MSGT_TV,MSGL_ERR, "tvi_dshow: Directshow graph initialization failure.\n");
2951 uninit(priv);
2952 }
2953 return result;
2954 }
2955
2956 /**
2957 * \brief chain uninitialization
2958 * \param chain chain data structure
2959 */
2960 static void destroy_chain(chain_t *chain)
2961 {
2962 int i;
2963
2964 if(!chain)
2965 return;
2966
2967 OLE_RELEASE_SAFE(chain->pStreamConfig);
2968 OLE_RELEASE_SAFE(chain->pCaptureFilter);
2969 OLE_RELEASE_SAFE(chain->pCSGCB);
2970 OLE_RELEASE_SAFE(chain->pCapturePin);
2971 OLE_RELEASE_SAFE(chain->pSGIn);
2972 OLE_RELEASE_SAFE(chain->pSG);
2973 OLE_RELEASE_SAFE(chain->pSGF);
2974
2975 if (chain->pmt)
2976 DeleteMediaType(chain->pmt);
2977
2978 if (chain->arpmt) {
2979 for (i = 0; chain->arpmt[i]; i++) {
2980 DeleteMediaType(chain->arpmt[i]);
2981 }
2982 free(chain->arpmt);
2983 }
2984
2985 if (chain->arStreamCaps) {
2986 for (i = 0; chain->arStreamCaps[i]; i++) {
2987 free(chain->arStreamCaps[i]);
2988 }
2989 free(chain->arStreamCaps);
2990 }
2991
2992 if (chain->rbuf) {
2993 destroy_ringbuffer(chain->rbuf);
2994 free(chain->rbuf);
2995 chain->rbuf = NULL;
2996 }
2997 free(chain);
2998 }
2999 /**
3000 * \brief driver uninitialization
3001 *
3002 * \param priv driver's private data structure
3003 *
3004 * \return always 1
3005 */
3006 static int uninit(priv_t * priv)
3007 {
3008 int i;
3009 if (!priv)
3010 return 1;
3011 //Debug
3012 if (priv->dwRegister) {
3013 RemoveFromRot(priv->dwRegister);
3014 }
3015 teletext_control(priv->priv_vbi,TV_VBI_CONTROL_STOP,(void*)1);
3016 //stop audio grabber thread
3017
3018 if (priv->state && priv->pMediaControl) {
3019 OLE_CALL(priv->pMediaControl, Stop);
3020 }
3021 OLE_RELEASE_SAFE(priv->pMediaControl);
3022 priv->state = 0;
3023
3024 if (priv->pGraph) {
3025 if (priv->chains[0]->pCaptureFilter)
3026 OLE_CALL_ARGS(priv->pGraph, RemoveFilter, priv->chains[0]->pCaptureFilter);
3027 if (priv->chains[1]->pCaptureFilter)
3028 OLE_CALL_ARGS(priv->pGraph, RemoveFilter, priv->chains[1]->pCaptureFilter);
3029 }
3030 OLE_RELEASE_SAFE(priv->pCrossbar);
3031 OLE_RELEASE_SAFE(priv->pVideoProcAmp);
3032 OLE_RELEASE_SAFE(priv->pGraph);
3033 OLE_RELEASE_SAFE(priv->pBuilder);
3034 if(priv->freq_table){
3035 priv->freq_table_len=-1;
3036 free(priv->freq_table);
3037 priv->freq_table=NULL;
3038 }
3039
3040 for(i=0; i<3;i++)
3041 {
3042 destroy_chain(priv->chains[i]);
3043 priv->chains[i] = NULL;
3044 }
3045 CoUninitialize();
3046 return 1;
3047 }
3048
3049 /**
3050 * \brief driver pre-initialization
3051 *
3052 * \param device string, containing device name in form "x[.y]", where x is video capture device
3053 * (default: 0, first available); y (if given) sets audio capture device
3054 *
3055 * \return 1 if success,0 - otherwise
3056 */
3057 static tvi_handle_t *tvi_init_dshow(tv_param_t* tv_param)
3058 {
3059 tvi_handle_t *h;
3060 priv_t *priv;
3061 int a;
3062
3063 h = tv_new_handle(sizeof(priv_t), &functions);
3064 if (!h)
3065 return NULL;
3066
3067 priv = h->priv;
3068
3069 memset(priv, 0, sizeof(priv_t));
3070 priv->direct_setfreq_call = 1; //first using direct call. if it fails, workaround will be enabled
3071 priv->direct_getfreq_call = 1; //first using direct call. if it fails, workaround will be enabled
3072 priv->adev_index = -1;
3073 priv->freq_table_len=-1;
3074 priv->tv_param=tv_param;
3075
3076 if (tv_param->device) {
3077 if (sscanf(tv_param->device, "%d", &a) == 1) {
3078 priv->dev_index = a;
3079 } else {
3080 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Wrong device parameter: %s\n", tv_param->device);
3081 tv_free_handle(h);
3082 return NULL;
3083 }
3084 if (priv->dev_index < 0) {
3085 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Wrong device index: %d\n", a);
3086 tv_free_handle(h);
3087 return NULL;
3088 }
3089 }
3090 if (tv_param->adevice) {
3091 if (sscanf(tv_param->adevice, "%d", &a) == 1) {
3092 priv->adev_index = a;
3093 } else {
3094 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Wrong adevice parameter: %s\n", tv_param->adevice);
3095 tv_free_handle(h);
3096 return NULL;
3097 }
3098 if (priv->dev_index < 0) {
3099 mp_tmsg(MSGT_TV, MSGL_ERR, "tvi_dshow: Wrong adevice index: %d\n", a);
3100 tv_free_handle(h);
3101 return NULL;
3102 }
3103 }
3104 return h;
3105 }
3106
3107 /**
3108 * \brief driver's ioctl handler
3109 *
3110 * \param priv driver's private data structure
3111 * \param cmd ioctl command
3112 * \param arg ioct command's parameter
3113 *
3114 * \return TVI_CONTROL_TRUE if success
3115 * \return TVI_CONTROL_FALSE if failure
3116 * \return TVI_CONTROL_UNKNOWN if unknowm cmd called
3117 */
3118 static int control(priv_t * priv, int cmd, void *arg)
3119 {
3120 switch (cmd) {
3121 /* need rewrite */
3122 case TVI_CONTROL_VID_SET_FORMAT:
3123 {
3124 int fcc, i,j;
3125 void* tmp,*tmp2;
3126 int result = TVI_CONTROL_TRUE;
3127
3128 if (priv->state)
3129 return TVI_CONTROL_FALSE;
3130 fcc = *(int *) arg;
3131
3132 if(!priv->chains[0]->arpmt)
3133 return TVI_CONTROL_FALSE;
3134 for (i = 0; priv->chains[0]->arpmt[i]; i++)
3135 if (check_video_format
3136 (priv->chains[0]->arpmt[i], fcc, priv->width, priv->height))
3137 break;
3138 if (!priv->chains[0]->arpmt[i])
3139 {
3140 int fps = 0;
3141 VIDEOINFOHEADER* Vhdr = NULL;
3142 AM_MEDIA_TYPE *pmt;
3143
3144 mp_msg(MSGT_TV, MSGL_V, "tvi_dshow: will try also use undeclared video format: %dx%d, %s\n",priv->width, priv->height, vo_format_name(fcc));
3145
3146 if (priv->chains[0]->arpmt[0])
3147 Vhdr = (VIDEOINFOHEADER *) priv->chains[0]->arpmt[0]->pbFormat;
3148
3149 if(Vhdr && Vhdr->bmiHeader.biSizeImage)
3150 fps = Vhdr->dwBitRate / (8 * Vhdr->bmiHeader.biSizeImage);
3151
3152 pmt=create_video_format(fcc, priv->width, priv->height, fps);
3153 if(!pmt)
3154 {
3155 mp_msg(MSGT_TV, MSGL_V, "tvi_dshow: Unable to create AM_MEDIA_TYPE structure for given format\n");
3156 return TVI_CONTROL_FALSE;
3157 }
3158 priv->chains[0]->arpmt=realloc(priv->chains[0]->arpmt, (i+2)*sizeof(AM_MEDIA_TYPE*));
3159 priv->chains[0]->arpmt[i+1] = NULL;
3160 priv->chains[0]->arpmt[i] = pmt;
3161
3162 priv->chains[0]->arStreamCaps=realloc(priv->chains[0]->arStreamCaps, (i+2)*sizeof(void*));
3163 priv->chains[0]->arpmt[i+1] = NULL;
3164
3165 result = TVI_CONTROL_FALSE;
3166 }
3167
3168
3169 tmp=priv->chains[0]->arpmt[i];
3170 tmp2=priv->chains[0]->arStreamCaps[i];
3171 for(j=i; j>0; j--)
3172 {
3173 priv->chains[0]->arpmt[j] = priv->chains[0]->arpmt[j-1];
3174 priv->chains[0]->arStreamCaps[j] = priv->chains[0]->arStreamCaps[j-1];
3175 }
3176 priv->chains[0]->arpmt[0] = tmp;
3177 priv->chains[0]->arStreamCaps[0] = tmp2;
3178
3179 priv->chains[0]->nFormatUsed = 0;
3180
3181 if (priv->chains[0]->pmt)
3182 DeleteMediaType(priv->chains[0]->pmt);
3183 priv->chains[0]->pmt =
3184 CreateMediaType(priv->chains[0]->arpmt[priv->chains[0]->nFormatUsed]);
3185 DisplayMediaType("VID_SET_FORMAT", priv->chains[0]->pmt);
3186 /*
3187 Setting width & height to preferred by driver values
3188 */
3189 extract_video_format(priv->chains[0]->arpmt[priv->chains[0]->nFormatUsed],
3190 &(priv->fcc), &(priv->width),
3191 &(priv->height));
3192 return result;
3193 }
3194 case TVI_CONTROL_VID_GET_FORMAT:
3195 {
3196 if(!priv->chains[0]->pmt)
3197 return TVI_CONTROL_FALSE;
3198 /*
3199 Build video chain (for video format negotiation).
3200 If this was done before, routine will do nothing.
3201 */
3202 build_video_chain(priv);
3203 DisplayMediaType("VID_GET_FORMAT", priv->chains[0]->pmt);
3204 if (priv->fcc) {
3205 *(int *) arg = priv->fcc;
3206 return TVI_CONTROL_TRUE;
3207 } else
3208 return TVI_CONTROL_FALSE;
3209 }
3210 case TVI_CONTROL_VID_SET_WIDTH:
3211 {
3212 VIDEO_STREAM_CONFIG_CAPS *pCaps;
3213 VIDEOINFOHEADER *Vhdr;
3214 int width = *(int *) arg;
3215 if (priv->state)
3216 return TVI_CONTROL_FALSE;
3217
3218 pCaps = priv->chains[0]->arStreamCaps[priv->chains[0]->nFormatUsed];
3219 if (!pCaps)
3220 return TVI_CONTROL_FALSE;
3221 if (width < pCaps->MinOutputSize.cx
3222 || width > pCaps->MaxOutputSize.cx)
3223 return TVI_CONTROL_FALSE;
3224
3225 if (width % pCaps->OutputGranularityX)
3226 return TVI_CONTROL_FALSE;
3227
3228 if (!priv->chains[0]->pmt || !priv->chains[0]->pmt->pbFormat)
3229 return TVI_CONTROL_FALSE;
3230 Vhdr = (VIDEOINFOHEADER *) priv->chains[0]->pmt->pbFormat;
3231 Vhdr->bmiHeader.biWidth = width;
3232 priv->chains[0]->pmt->lSampleSize = Vhdr->bmiHeader.biSizeImage =
3233 labs(Vhdr->bmiHeader.biBitCount * Vhdr->bmiHeader.biWidth *
3234 Vhdr->bmiHeader.biHeight) >> 3;
3235
3236 priv->width = width;
3237
3238 return TVI_CONTROL_TRUE;
3239 }
3240 case TVI_CONTROL_VID_GET_WIDTH:
3241 {
3242 if (priv->width) {
3243 *(int *) arg = priv->width;
3244 return TVI_CONTROL_TRUE;
3245 } else
3246 return TVI_CONTROL_FALSE;
3247 }
3248 case TVI_CONTROL_VID_CHK_WIDTH:
3249 {
3250 VIDEO_STREAM_CONFIG_CAPS *pCaps;
3251 int width = *(int *) arg;
3252 pCaps = priv->chains[0]->arStreamCaps[priv->chains[0]->nFormatUsed];
3253 if (!pCaps)
3254 return TVI_CONTROL_FALSE;
3255 if (width < pCaps->MinOutputSize.cx
3256 || width > pCaps->MaxOutputSize.cx)
3257 return TVI_CONTROL_FALSE;
3258
3259 if (width % pCaps->OutputGranularityX)
3260 return TVI_CONTROL_FALSE;
3261 return TVI_CONTROL_TRUE;
3262 }
3263 case TVI_CONTROL_VID_SET_HEIGHT:
3264 {
3265 VIDEO_STREAM_CONFIG_CAPS *pCaps;
3266 VIDEOINFOHEADER *Vhdr;
3267 int height = *(int *) arg;
3268 if (priv->state)
3269 return TVI_CONTROL_FALSE;
3270
3271 pCaps = priv->chains[0]->arStreamCaps[priv->chains[0]->nFormatUsed];
3272 if (!pCaps)
3273 return TVI_CONTROL_FALSE;
3274 if (height < pCaps->MinOutputSize.cy
3275 || height > pCaps->MaxOutputSize.cy)
3276 return TVI_CONTROL_FALSE;
3277
3278 if (height % pCaps->OutputGranularityY)
3279 return TVI_CONTROL_FALSE;
3280
3281 if (!priv->chains[0]->pmt || !priv->chains[0]->pmt->pbFormat)
3282 return TVI_CONTROL_FALSE;
3283 Vhdr = (VIDEOINFOHEADER *) priv->chains[0]->pmt->pbFormat;
3284
3285 if (Vhdr->bmiHeader.biHeight < 0)
3286 Vhdr->bmiHeader.biHeight = -height;
3287 else
3288 Vhdr->bmiHeader.biHeight = height;
3289 priv->chains[0]->pmt->lSampleSize = Vhdr->bmiHeader.biSizeImage =
3290 labs(Vhdr->bmiHeader.biBitCount * Vhdr->bmiHeader.biWidth *
3291 Vhdr->bmiHeader.biHeight) >> 3;
3292
3293 priv->height = height;
3294 return TVI_CONTROL_TRUE;
3295 }
3296 case TVI_CONTROL_VID_GET_HEIGHT:
3297 {
3298 if (priv->height) {
3299 *(int *) arg = priv->height;
3300 return TVI_CONTROL_TRUE;
3301 } else
3302 return TVI_CONTROL_FALSE;
3303 }
3304 case TVI_CONTROL_VID_CHK_HEIGHT:
3305 {
3306 VIDEO_STREAM_CONFIG_CAPS *pCaps;
3307 int height = *(int *) arg;
3308 pCaps = priv->chains[0]->arStreamCaps[priv->chains[0]->nFormatUsed];
3309 if (!pCaps)
3310 return TVI_CONTROL_FALSE;
3311 if (height < pCaps->MinOutputSize.cy
3312 || height > pCaps->MaxOutputSize.cy)
3313 return TVI_CONTROL_FALSE;
3314
3315 if (height % pCaps->OutputGranularityY)
3316 return TVI_CONTROL_FALSE;
3317
3318 return TVI_CONTROL_TRUE;
3319 }
3320 case TVI_CONTROL_IS_AUDIO:
3321 if (!priv->chains[1]->pmt)
3322 return TVI_CONTROL_FALSE;
3323 else
3324 return TVI_CONTROL_TRUE;
3325 case TVI_CONTROL_IS_VIDEO:
3326 return TVI_CONTROL_TRUE;
3327 case TVI_CONTROL_AUD_GET_FORMAT:
3328 {
3329 *(int *) arg = AF_FORMAT_S16_LE;
3330 if (!priv->chains[1]->pmt)
3331 return TVI_CONTROL_FALSE;
3332 else
3333 return TVI_CONTROL_TRUE;
3334 }
3335 case TVI_CONTROL_AUD_GET_CHANNELS:
3336 {
3337 *(int *) arg = priv->channels;
3338 if (!priv->chains[1]->pmt)
3339 return TVI_CONTROL_FALSE;
3340 else
3341 return TVI_CONTROL_TRUE;
3342 }
3343 case TVI_CONTROL_AUD_SET_SAMPLERATE:
3344 {
3345 int i, samplerate;
3346 if (priv->state)
3347 return TVI_CONTROL_FALSE;
3348 if (!priv->chains[1]->arpmt[0])
3349 return TVI_CONTROL_FALSE;
3350
3351 samplerate = *(int *) arg;
3352
3353 for (i = 0; priv->chains[1]->arpmt[i]; i++)
3354 if (check_audio_format
3355 (priv->chains[1]->arpmt[i], samplerate, 16, priv->channels))
3356 break;
3357 if (!priv->chains[1]->arpmt[i]) {
3358 //request not found. failing back to first available
3359 mp_tmsg(MSGT_TV, MSGL_WARN, "tvi_dshow: Samplerate %d is not supported by device. Failing back to first available.\n", samplerate);
3360 i = 0;
3361 }
3362 if (priv->chains[1]->pmt)
3363 DeleteMediaType(priv->chains[1]->pmt);
3364 priv->chains[1]->pmt = CreateMediaType(priv->chains[1]->arpmt[i]);
3365 extract_audio_format(priv->chains[1]->arpmt[i], &(priv->samplerate),
3366 NULL, &(priv->channels));
3367 return TVI_CONTROL_TRUE;
3368 }
3369 case TVI_CONTROL_AUD_GET_SAMPLERATE:
3370 {
3371 *(int *) arg = priv->samplerate;
3372 if (!priv->samplerate)
3373 return TVI_CONTROL_FALSE;
3374 if (!priv->chains[1]->pmt)
3375 return TVI_CONTROL_FALSE;
3376 else
3377 return TVI_CONTROL_TRUE;
3378 }
3379 case TVI_CONTROL_AUD_GET_SAMPLESIZE:
3380 {
3381 WAVEFORMATEX *pWF;
3382 if (!priv->chains[1]->pmt)
3383 return TVI_CONTROL_FALSE;
3384 if (!priv->chains[1]->pmt->pbFormat)
3385 return TVI_CONTROL_FALSE;
3386 pWF = (WAVEFORMATEX *) priv->chains[1]->pmt->pbFormat;
3387 *(int *) arg = pWF->wBitsPerSample / 8;
3388 return TVI_CONTROL_TRUE;
3389 }
3390 case TVI_CONTROL_IS_TUNER:
3391 {
3392 if (!priv->pTVTuner)
3393 return TVI_CONTROL_FALSE;
3394
3395 return TVI_CONTROL_TRUE;
3396 }
3397 case TVI_CONTROL_TUN_SET_NORM:
3398 {
3399 IAMAnalogVideoDecoder *pVD;
3400 long lAnalogFormat;
3401 int i;
3402 HRESULT hr;
3403
3404 i = *(int *) arg;
3405 i--;
3406 if (i < 0 || i >= tv_available_norms_count)
3407 return TVI_CONTROL_FALSE;
3408 lAnalogFormat = tv_norms[tv_available_norms[i]].index;
3409
3410 hr = OLE_QUERYINTERFACE(priv->chains[0]->pCaptureFilter,IID_IAMAnalogVideoDecoder, pVD);
3411 if (hr != S_OK)
3412 return TVI_CONTROL_FALSE;
3413 hr = OLE_CALL_ARGS(pVD, put_TVFormat, lAnalogFormat);
3414 OLE_RELEASE_SAFE(pVD);
3415 if (FAILED(hr))
3416 return TVI_CONTROL_FALSE;
3417 else
3418 return TVI_CONTROL_TRUE;
3419 }
3420 case TVI_CONTROL_TUN_GET_NORM:
3421 {
3422 long lAnalogFormat;
3423 int i;
3424 HRESULT hr;
3425 IAMAnalogVideoDecoder *pVD;
3426
3427 hr = OLE_QUERYINTERFACE(priv->chains[0]->pCaptureFilter,IID_IAMAnalogVideoDecoder, pVD);
3428 if (hr == S_OK) {
3429 hr = OLE_CALL_ARGS(pVD, get_TVFormat, &lAnalogFormat);
3430 OLE_RELEASE_SAFE(pVD);
3431 }
3432
3433 if (FAILED(hr)) { //trying another method
3434 if (!priv->pTVTuner)
3435 return TVI_CONTROL_FALSE;
3436 hr=OLE_CALL_ARGS(priv->pTVTuner, get_TVFormat, &lAnalogFormat);
3437 if (FAILED(hr))
3438 return TVI_CONTROL_FALSE;
3439 }
3440 for (i = 0; i < tv_available_norms_count; i++) {
3441 if (tv_norms[tv_available_norms[i]].index == lAnalogFormat) {
3442 *(int *) arg = i + 1;
3443 return TVI_CONTROL_TRUE;
3444 }
3445 }
3446 return TVI_CONTROL_FALSE;
3447 }
3448 case TVI_CONTROL_SPC_GET_NORMID:
3449 {
3450 int i;
3451 if (!priv->pTVTuner)
3452 return TVI_CONTROL_FALSE;
3453 for (i = 0; i < tv_available_norms_count; i++) {
3454 if (!strcasecmp
3455 (tv_norms[tv_available_norms[i]].name, (char *) arg)) {
3456 *(int *) arg = i + 1;
3457 return TVI_CONTROL_TRUE;
3458 }
3459 }
3460 return TVI_CONTROL_FALSE;
3461 }
3462 case TVI_CONTROL_SPC_SET_INPUT:
3463 {
3464 return set_crossbar_input(priv, *(int *) arg);
3465 }
3466 case TVI_CONTROL_TUN_GET_FREQ:
3467 {
3468 unsigned long lFreq;
3469 int ret;
3470 if (!priv->pTVTuner)
3471 return TVI_CONTROL_FALSE;
3472
3473 ret = get_frequency(priv, &lFreq);
3474 lFreq = lFreq / (1000000/16); //convert from Hz to 1/16 MHz units
3475
3476 *(unsigned long *) arg = lFreq;
3477 return ret;
3478 }
3479 case TVI_CONTROL_TUN_SET_FREQ:
3480 {
3481 unsigned long nFreq = *(unsigned long *) arg;
3482 if (!priv->pTVTuner)
3483 return TVI_CONTROL_FALSE;
3484 //convert to Hz
3485 nFreq = (1000000/16) * nFreq; //convert from 1/16 MHz units to Hz
3486 return set_frequency(priv, nFreq);
3487 }
3488 case TVI_CONTROL_VID_SET_HUE:
3489 return set_control(priv, VideoProcAmp_Hue, *(int *) arg);
3490 case TVI_CONTROL_VID_GET_HUE:
3491 return get_control(priv, VideoProcAmp_Hue, (int *) arg);
3492 case TVI_CONTROL_VID_SET_CONTRAST:
3493 return set_control(priv, VideoProcAmp_Contrast, *(int *) arg);
3494 case TVI_CONTROL_VID_GET_CONTRAST:
3495 return get_control(priv, VideoProcAmp_Contrast, (int *) arg);
3496 case TVI_CONTROL_VID_SET_SATURATION:
3497 return set_control(priv, VideoProcAmp_Saturation, *(int *) arg);
3498 case TVI_CONTROL_VID_GET_SATURATION:
3499 return get_control(priv, VideoProcAmp_Saturation, (int *) arg);
3500 case TVI_CONTROL_VID_SET_BRIGHTNESS:
3501 return set_control(priv, VideoProcAmp_Brightness, *(int *) arg);
3502 case TVI_CONTROL_VID_GET_BRIGHTNESS:
3503 return get_control(priv, VideoProcAmp_Brightness, (int *) arg);
3504
3505 case TVI_CONTROL_VID_GET_FPS:
3506 {
3507 VIDEOINFOHEADER *Vhdr;
3508 if (!priv->chains[0]->pmt)
3509 return TVI_CONTROL_FALSE;
3510 if (!priv->chains[0]->pmt->pbFormat)
3511 return TVI_CONTROL_FALSE;
3512 Vhdr = (VIDEOINFOHEADER *) priv->chains[0]->pmt->pbFormat;
3513 *(float *) arg =
3514 (1.0 * Vhdr->dwBitRate) / (Vhdr->bmiHeader.biSizeImage * 8);
3515 return TVI_CONTROL_TRUE;
3516 }
3517 case TVI_CONTROL_IMMEDIATE:
3518 priv->immediate_mode = 1;
3519 return TVI_CONTROL_TRUE;
3520 case TVI_CONTROL_VBI_INIT:
3521 {
3522 void* ptr;
3523 ptr=&(priv->tsp);
3524 if(teletext_control(NULL,TV_VBI_CONTROL_START,&ptr)==VBI_CONTROL_TRUE)
3525 priv->priv_vbi=ptr;
3526 else
3527 priv->priv_vbi=NULL;
3528 return TVI_CONTROL_TRUE;
3529 }
3530 case TVI_CONTROL_GET_VBI_PTR:
3531 *(void **)arg=priv->priv_vbi;
3532 return TVI_CONTROL_TRUE;
3533 }
3534 return TVI_CONTROL_UNKNOWN;
3535 }
MPlayer development branch