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