root/OpenSceneGraph/trunk/src/osgPlugins/directshow/DirectShowTexture.cpp @ 13041

Revision 13041, 71.5 kB (checked in by robert, 14 months ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
Line 
1/* -*-c++-*- OpenSceneGraph - Copyright (C) 2009 Tharsis Software
2 *
3 * This library is open source and may be redistributed and/or modified under
4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
5 * (at your option) any later version.  The full license is in LICENSE file
6 * included with this distribution, and on the openscenegraph.org website.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11 * OpenSceneGraph Public License for more details.
12 *
13 * Authors:
14 *         Cedric Pinson <cedric.pinson@plopbyte.net>
15*/
16
17#include "DirectShowTexture"
18#include <osg/Notify>
19#include <osgDB/WriteFile>
20#include <sstream>
21#include <windows.h>
22#include <mmsystem.h>
23#include <comdef.h>
24
25#include <strsafe.h>
26#include <functional>
27#include <locale>
28#include <string>
29
30HRESULT GetPin(IBaseFilter* pFilter, LPCWSTR pName, IPin** ppPin);
31HRESULT GetPin(IBaseFilter* pFilter, const GUID* pFormat, PIN_DIRECTION PinDir, IPin** ppPin);
32
33
34struct NamedGuid
35{
36    const GUID *pguid;
37    const TCHAR *psz;
38};
39
40// 73646976-0000-0010-8000-00AA00389B71  'vids' == WMMEDIATYPE_Video
41EXTERN_GUID(WMMEDIATYPE_Video,
420x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
43// 73647561-0000-0010-8000-00AA00389B71  'auds' == WMMEDIATYPE_Audio
44EXTERN_GUID(WMMEDIATYPE_Audio,
450x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
46// 73636d64-0000-0010-8000-00AA00389B71  'scmd' == MEDIATYPE_Script
47EXTERN_GUID(WMMEDIATYPE_Script,
480x73636d64, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
49// 34A50FD8-8AA5-4386-81FE-A0EFE0488E31            WMMEDIATYPE_Image
50EXTERN_GUID(WMMEDIATYPE_Image,
510x34a50fd8, 0x8aa5, 0x4386, 0x81, 0xfe, 0xa0, 0xef, 0xe0, 0x48, 0x8e, 0x31);
52// D9E47579-930E-4427-ADFC-AD80F290E470  'fxfr' == WMMEDIATYPE_FileTransfer
53EXTERN_GUID(WMMEDIATYPE_FileTransfer,
540xd9e47579, 0x930e, 0x4427, 0xad, 0xfc, 0xad, 0x80, 0xf2, 0x90, 0xe4, 0x70);
55// 9BBA1EA7-5AB2-4829-BA57-0940209BCF3E      'text' == WMMEDIATYPE_Text
56EXTERN_GUID(WMMEDIATYPE_Text,
570x9bba1ea7, 0x5ab2, 0x4829, 0xba, 0x57, 0x9, 0x40, 0x20, 0x9b, 0xcf, 0x3e);
58
59// 00000000-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_Base
60EXTERN_GUID(WMMEDIASUBTYPE_Base,
610x00000000, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
62// e436eb78-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB1
63EXTERN_GUID(WMMEDIASUBTYPE_RGB1,
640xe436eb78, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
65// e436eb79-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB4
66EXTERN_GUID(WMMEDIASUBTYPE_RGB4,
670xe436eb79, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
68// e436eb7a-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB8
69EXTERN_GUID(WMMEDIASUBTYPE_RGB8,
700xe436eb7a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
71// e436eb7b-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB565
72EXTERN_GUID(WMMEDIASUBTYPE_RGB565,
730xe436eb7b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
74// e436eb7c-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB555
75EXTERN_GUID(WMMEDIASUBTYPE_RGB555,
760xe436eb7c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
77// e436eb7d-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB24
78EXTERN_GUID(WMMEDIASUBTYPE_RGB24,
790xe436eb7d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
80// e436eb7e-524f-11ce-9f53-0020af0ba770            MEDIASUBTYPE_RGB32
81EXTERN_GUID(WMMEDIASUBTYPE_RGB32,
820xe436eb7e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
83// 30323449-0000-0010-8000-00AA00389B71  'YV12' ==  MEDIASUBTYPE_I420
84EXTERN_GUID(WMMEDIASUBTYPE_I420,
850x30323449, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
86// 56555949-0000-0010-8000-00AA00389B71  'YV12' ==  MEDIASUBTYPE_IYUV
87EXTERN_GUID(WMMEDIASUBTYPE_IYUV,
880x56555949, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
89// 31313259-0000-0010-8000-00AA00389B71  'YV12' ==  MEDIASUBTYPE_YV12
90EXTERN_GUID(WMMEDIASUBTYPE_YV12,
910x32315659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
92// 32595559-0000-0010-8000-00AA00389B71  'YUY2' == MEDIASUBTYPE_YUY2
93EXTERN_GUID(WMMEDIASUBTYPE_YUY2,
940x32595559, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
95// 59565955-0000-0010-8000-00AA00389B71  'UYVY' ==  MEDIASUBTYPE_UYVY
96EXTERN_GUID(WMMEDIASUBTYPE_UYVY,
970x59565955, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
98// 55595659-0000-0010-8000-00AA00389B71  'YVYU' == MEDIASUBTYPE_YVYU
99EXTERN_GUID(WMMEDIASUBTYPE_YVYU,
1000x55595659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
101// 39555659-0000-0010-8000-00AA00389B71  'YVU9' == MEDIASUBTYPE_YVU9
102EXTERN_GUID(WMMEDIASUBTYPE_YVU9,
1030x39555659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
104// 3334504D-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_MP43
105EXTERN_GUID(WMMEDIASUBTYPE_MP43,
1060x3334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
107// 5334504D-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_MP4S
108EXTERN_GUID(WMMEDIASUBTYPE_MP4S,
1090x5334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
110// 31564D57-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMV1
111EXTERN_GUID(WMMEDIASUBTYPE_WMV1,
1120x31564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
113// 32564D57-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMV2
114EXTERN_GUID(WMMEDIASUBTYPE_WMV2,
1150x32564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
116// 3153534D-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_MSS1
117EXTERN_GUID(WMMEDIASUBTYPE_MSS1,
1180x3153534D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
119// e06d8026-db46-11cf-b4d1-00805f6cbbea            WMMEDIASUBTYPE_MPEG2_VIDEO
120EXTERN_GUID(WMMEDIASUBTYPE_MPEG2_VIDEO,
1210xe06d8026, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea);
122// 00000001-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_PCM
123EXTERN_GUID(WMMEDIASUBTYPE_PCM,
1240x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
125// 00000009-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_DRM
126EXTERN_GUID(WMMEDIASUBTYPE_DRM,
1270x00000009, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
128// 00000162-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMAudioV9
129EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV9,
1300x00000162, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
131// 00000163-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMAudio_Lossless
132EXTERN_GUID(WMMEDIASUBTYPE_WMAudio_Lossless,
1330x00000163, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
134// 3253534D-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_MSS2
135EXTERN_GUID(WMMEDIASUBTYPE_MSS2,
1360x3253534D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
137// 0000000A-0000-0010-8000-00AA00389B71        WMMEDIASUBTYPE_WMSP1
138EXTERN_GUID( WMMEDIASUBTYPE_WMSP1,
1390x0000000A,0x0000,0x0010,0x80,0x00,0x00,0xAA,0x00,0x38,0x9B,0x71);
140// 33564D57-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMV3
141EXTERN_GUID(WMMEDIASUBTYPE_WMV3,
1420x33564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
143// 00000161-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMAudioV8
144EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV8,
1450x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
146// 00000161-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMAudioV7
147EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV7,
1480x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
149// 00000161-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_WMAudioV2
150EXTERN_GUID(WMMEDIASUBTYPE_WMAudioV2,
1510x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
152// 00000130-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_ACELPnet
153EXTERN_GUID(WMMEDIASUBTYPE_ACELPnet,
1540x00000130, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
155// 00000050-0000-0010-8000-00AA00389B71            WMMEDIASUBTYPE_MP3
156EXTERN_GUID(WMMEDIASUBTYPE_MP3,
1570x00000055, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71);
158// 776257d4-c627-41cb-8f81-7ac7ff1c40cc            WMMEDIASUBTYPE_WebStream
159EXTERN_GUID(WMMEDIASUBTYPE_WebStream,
1600x776257d4, 0xc627, 0x41cb, 0x8f, 0x81, 0x7a, 0xc7, 0xff, 0x1c, 0x40, 0xcc);
161
162// 05589f80-c356-11ce-bf01-00aa0055595a        WMFORMAT_VideoInfo
163EXTERN_GUID(WMFORMAT_VideoInfo,
1640x05589f80, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a);
165// 05589f81-c356-11ce-bf01-00aa0055595a        WMFORMAT_WaveFormatEx
166EXTERN_GUID(WMFORMAT_WaveFormatEx,
1670x05589f81, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a);
168// 5C8510F2-DEBE-4ca7-BBA5-F07A104F8DFF        WMFORMAT_Script
169EXTERN_GUID(WMFORMAT_Script,
1700x5c8510f2, 0xdebe, 0x4ca7, 0xbb, 0xa5, 0xf0, 0x7a, 0x10, 0x4f, 0x8d, 0xff);
171
172// 82f38a70-c29f-11d1-97ad-00a0c95ea850        WMSCRIPTTYPE_TwoStrings
173EXTERN_GUID( WMSCRIPTTYPE_TwoStrings,
1740x82f38a70,0xc29f,0x11d1,0x97,0xad,0x00,0xa0,0xc9,0x5e,0xa8,0x50);
175
176// e06d80e3-db46-11cf-b4d1-00805f6cbbea        WMFORMAT_MPEG2Video
177EXTERN_GUID(WMFORMAT_MPEG2Video,
1780xe06d80e3, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x05f, 0x6c, 0xbb, 0xea);
179
180EXTERN_GUID( CLSID_WMMUTEX_Language, 0xD6E22A00,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE );
181EXTERN_GUID( CLSID_WMMUTEX_Bitrate, 0xD6E22A01,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE );
182EXTERN_GUID( CLSID_WMMUTEX_Presentation, 0xD6E22A02,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE );
183EXTERN_GUID( CLSID_WMMUTEX_Unknown, 0xD6E22A03,0x35DA,0x11D1,0x90,0x34,0x00,0xA0,0xC9,0x03,0x49,0xBE );
184EXTERN_GUID( CLSID_WMBandwidthSharing_Exclusive, 0xaf6060aa,0x5197,0x11d2,0xb6,0xaf,0x00,0xc0,0x4f,0xd9,0x08,0xe9 );
185EXTERN_GUID( CLSID_WMBandwidthSharing_Partial, 0xaf6060ab,0x5197,0x11d2,0xb6,0xaf,0x00,0xc0,0x4f,0xd9,0x08,0xe9 );
186
187const NamedGuid MediaType[]=
188{
189    {&MEDIASUBTYPE_AIFF, TEXT("AIFF\0")},
190    {&MEDIASUBTYPE_AU, TEXT("AU\0")},
191    {&MEDIASUBTYPE_AnalogVideo_NTSC_M, TEXT("AnalogVideo_NTSC_M\0")},
192    {&MEDIASUBTYPE_AnalogVideo_PAL_B, TEXT("AnalogVideo_PAL_B\0")},
193    {&MEDIASUBTYPE_AnalogVideo_PAL_D, TEXT("AnalogVideo_PAL_D\0")},
194    {&MEDIASUBTYPE_AnalogVideo_PAL_G, TEXT("AnalogVideo_PAL_G\0")},
195    {&MEDIASUBTYPE_AnalogVideo_PAL_H, TEXT("AnalogVideo_PAL_H\0")},
196    {&MEDIASUBTYPE_AnalogVideo_PAL_I, TEXT("AnalogVideo_PAL_I\0")},
197    {&MEDIASUBTYPE_AnalogVideo_PAL_M, TEXT("AnalogVideo_PAL_M\0")},
198    {&MEDIASUBTYPE_AnalogVideo_PAL_N, TEXT("AnalogVideo_PAL_N\0")},
199    {&MEDIASUBTYPE_AnalogVideo_SECAM_B, TEXT("AnalogVideo_SECAM_B\0")},
200    {&MEDIASUBTYPE_AnalogVideo_SECAM_D, TEXT("AnalogVideo_SECAM_D\0")},
201    {&MEDIASUBTYPE_AnalogVideo_SECAM_G, TEXT("AnalogVideo_SECAM_G\0")},
202    {&MEDIASUBTYPE_AnalogVideo_SECAM_H, TEXT("AnalogVideo_SECAM_H\0")},
203    {&MEDIASUBTYPE_AnalogVideo_SECAM_K, TEXT("AnalogVideo_SECAM_K\0")},
204    {&MEDIASUBTYPE_AnalogVideo_SECAM_K1, TEXT("AnalogVideo_SECAM_K1\0")},
205    {&MEDIASUBTYPE_AnalogVideo_SECAM_L, TEXT("AnalogVideo_SECAM_L\0")},
206
207    {&MEDIASUBTYPE_ARGB1555, TEXT("ARGB1555\0")},
208    {&MEDIASUBTYPE_ARGB4444, TEXT("ARGB4444\0")},
209    {&MEDIASUBTYPE_ARGB32, TEXT("ARGB32\0")},
210    {&MEDIASUBTYPE_A2R10G10B10, TEXT("A2R10G10B10\0")},
211    {&MEDIASUBTYPE_A2B10G10R10, TEXT("A2B10G10R10\0")},
212
213    {&MEDIASUBTYPE_AYUV, TEXT("AYUV\0")},
214    {&MEDIASUBTYPE_AI44, TEXT("AI44\0")},
215    {&MEDIASUBTYPE_IA44, TEXT("IA44\0")},
216    {&MEDIASUBTYPE_NV12, TEXT("NV12\0")},
217    {&MEDIASUBTYPE_IMC1, TEXT("IMC1\0")},
218    {&MEDIASUBTYPE_IMC2, TEXT("IMC2\0")},
219    {&MEDIASUBTYPE_IMC3, TEXT("IMC3\0")},
220    {&MEDIASUBTYPE_IMC4, TEXT("IMC4\0")},
221
222    {&MEDIASUBTYPE_Asf, TEXT("Asf\0")},
223    {&MEDIASUBTYPE_Avi, TEXT("Avi\0")},
224    {&MEDIASUBTYPE_CFCC, TEXT("CFCC\0")},
225    {&MEDIASUBTYPE_CLJR, TEXT("CLJR\0")},
226    {&MEDIASUBTYPE_CPLA, TEXT("CPLA\0")},
227    {&MEDIASUBTYPE_CLPL, TEXT("CLPL\0")},
228    {&MEDIASUBTYPE_DOLBY_AC3, TEXT("DOLBY_AC3\0")},
229    {&MEDIASUBTYPE_DOLBY_AC3_SPDIF, TEXT("DOLBY_AC3_SPDIF\0")},
230    {&MEDIASUBTYPE_DVCS, TEXT("DVCS\0")},
231    {&MEDIASUBTYPE_DVD_LPCM_AUDIO, TEXT("DVD_LPCM_AUDIO\0")},
232    {&MEDIASUBTYPE_DVD_NAVIGATION_DSI, TEXT("DVD_NAVIGATION_DSI\0")},
233    {&MEDIASUBTYPE_DVD_NAVIGATION_PCI, TEXT("DVD_NAVIGATION_PCI\0")},
234    {&MEDIASUBTYPE_DVD_NAVIGATION_PROVIDER, TEXT("DVD_NAVIGATION_PROVIDER\0")},
235    {&MEDIASUBTYPE_DVD_SUBPICTURE, TEXT("DVD_SUBPICTURE\0")},
236    {&MEDIASUBTYPE_DVSD, TEXT("DVSD\0")},
237    {&MEDIASUBTYPE_DRM_Audio, TEXT("DRM_Audio\0")},
238    {&MEDIASUBTYPE_DssAudio, TEXT("DssAudio\0")},
239    {&MEDIASUBTYPE_DssVideo, TEXT("DssVideo\0")},
240    {&MEDIASUBTYPE_IF09, TEXT("IF09\0")},
241    {&MEDIASUBTYPE_IEEE_FLOAT, TEXT("IEEE_FLOAT\0")},
242    {&MEDIASUBTYPE_IJPG, TEXT("IJPG\0")},
243    {&MEDIASUBTYPE_IYUV, TEXT("IYUV\0")},
244    {&MEDIASUBTYPE_Line21_BytePair, TEXT("Line21_BytePair\0")},
245    {&MEDIASUBTYPE_Line21_GOPPacket, TEXT("Line21_GOPPacket\0")},
246    {&MEDIASUBTYPE_Line21_VBIRawData, TEXT("Line21_VBIRawData\0")},
247    {&MEDIASUBTYPE_MDVF, TEXT("MDVF\0")},
248    {&MEDIASUBTYPE_MJPG, TEXT("MJPG\0")},
249    {&MEDIASUBTYPE_MPEG1Audio, TEXT("MPEG1Audio\0")},
250    {&MEDIASUBTYPE_MPEG1AudioPayload, TEXT("MPEG1AudioPayload\0")},
251    {&MEDIASUBTYPE_MPEG1Packet, TEXT("MPEG1Packet\0")},
252    {&MEDIASUBTYPE_MPEG1Payload, TEXT("MPEG1Payload\0")},
253    {&MEDIASUBTYPE_MPEG1System, TEXT("MPEG1System\0")},
254    {&MEDIASUBTYPE_MPEG1Video, TEXT("MPEG1Video\0")},
255    {&MEDIASUBTYPE_MPEG1VideoCD, TEXT("MPEG1VideoCD\0")},
256    {&MEDIASUBTYPE_MPEG2_AUDIO, TEXT("MPEG2_AUDIO\0")},
257    {&MEDIASUBTYPE_MPEG2_PROGRAM, TEXT("MPEG2_PROGRAM\0")},
258    {&MEDIASUBTYPE_MPEG2_TRANSPORT, TEXT("MPEG2_TRANSPORT\0")},
259    {&MEDIASUBTYPE_MPEG2_VIDEO, TEXT("MPEG2_VIDEO\0")},
260    {&MEDIASUBTYPE_None, TEXT("None\0")},
261    {&MEDIASUBTYPE_Overlay, TEXT("Overlay\0")},
262    {&MEDIASUBTYPE_PCM, TEXT("PCM\0")},
263    {&MEDIASUBTYPE_PCMAudio_Obsolete, TEXT("PCMAudio_Obsolete\0")},
264    {&MEDIASUBTYPE_Plum, TEXT("Plum\0")},
265    {&MEDIASUBTYPE_QTJpeg, TEXT("QTJpeg\0")},
266    {&MEDIASUBTYPE_QTMovie, TEXT("QTMovie\0")},
267    {&MEDIASUBTYPE_QTRle, TEXT("QTRle\0")},
268    {&MEDIASUBTYPE_QTRpza, TEXT("QTRpza\0")},
269    {&MEDIASUBTYPE_QTSmc, TEXT("QTSmc\0")},
270    {&MEDIASUBTYPE_RAW_SPORT, TEXT("RAW_SPORT\0")},
271    {&MEDIASUBTYPE_RGB1, TEXT("RGB1\0")},
272    {&MEDIASUBTYPE_RGB24, TEXT("RGB24\0")},
273    {&MEDIASUBTYPE_RGB32, TEXT("RGB32\0")},
274    {&MEDIASUBTYPE_RGB4, TEXT("RGB4\0")},
275    {&MEDIASUBTYPE_RGB555, TEXT("RGB555\0")},
276    {&MEDIASUBTYPE_RGB565, TEXT("RGB565\0")},
277    {&MEDIASUBTYPE_RGB8, TEXT("RGB8\0")},
278    {&MEDIASUBTYPE_SPDIF_TAG_241h, TEXT("SPDIF_TAG_241h\0")},
279    {&MEDIASUBTYPE_TELETEXT, TEXT("TELETEXT\0")},
280    {&MEDIASUBTYPE_TVMJ, TEXT("TVMJ\0")},
281    {&MEDIASUBTYPE_UYVY, TEXT("UYVY\0")},
282    {&MEDIASUBTYPE_VPVBI, TEXT("VPVBI\0")},
283    {&MEDIASUBTYPE_VPVideo, TEXT("VPVideo\0")},
284    {&MEDIASUBTYPE_WAKE, TEXT("WAKE\0")},
285    {&MEDIASUBTYPE_WAVE, TEXT("WAVE\0")},
286    {&MEDIASUBTYPE_Y211, TEXT("Y211\0")},
287    {&MEDIASUBTYPE_Y411, TEXT("Y411\0")},
288    {&MEDIASUBTYPE_Y41P, TEXT("Y41P\0")},
289    {&MEDIASUBTYPE_YUY2, TEXT("YUY2\0")},
290    {&MEDIASUBTYPE_YV12, TEXT("YV12\0")},
291    {&MEDIASUBTYPE_YVU9, TEXT("YVU9\0")},
292    {&MEDIASUBTYPE_YVYU, TEXT("YVYU\0")},
293    {&MEDIASUBTYPE_YUYV, TEXT("YUYV\0")},
294    {&MEDIASUBTYPE_dvhd, TEXT("dvhd\0")},
295    {&MEDIASUBTYPE_dvsd, TEXT("dvsd\0")},
296    {&MEDIASUBTYPE_dvsl, TEXT("dvsl\0")},
297
298    {&MEDIATYPE_AUXLine21Data, TEXT("AUXLine21Data\0")},
299    {&MEDIATYPE_AnalogAudio, TEXT("AnalogAudio\0")},
300    {&MEDIATYPE_AnalogVideo, TEXT("AnalogVideo\0")},
301    {&MEDIATYPE_Audio, TEXT("Audio\0")},
302    {&MEDIATYPE_DVD_ENCRYPTED_PACK, TEXT("DVD_ENCRYPTED_PACK\0")},
303    {&MEDIATYPE_DVD_NAVIGATION, TEXT("DVD_NAVIGATION\0")},
304    {&MEDIATYPE_File, TEXT("File\0")},
305    {&MEDIATYPE_Interleaved, TEXT("Interleaved\0")},
306    {&MEDIATYPE_LMRT, TEXT("LMRT\0")},
307    {&MEDIATYPE_MPEG1SystemStream, TEXT("MPEG1SystemStream\0")},
308    {&MEDIATYPE_MPEG2_PES, TEXT("MPEG2_PES\0")},
309    {&MEDIATYPE_Midi, TEXT("Midi\0")},
310    {&MEDIATYPE_ScriptCommand, TEXT("ScriptCommand\0")},
311    {&MEDIATYPE_Stream, TEXT("Stream\0")},
312    {&MEDIATYPE_Text, TEXT("Text\0")},
313    {&MEDIATYPE_Timecode, TEXT("Timecode\0")},
314    {&MEDIATYPE_URL_STREAM, TEXT("URL_STREAM\0")},
315    {&MEDIATYPE_VBI, TEXT("VBI\0")},
316    {&MEDIATYPE_Video, TEXT("Video\0")},
317
318    {&WMMEDIATYPE_Audio,  TEXT("WMMEDIATYPE_Audio\0")},
319    {&WMMEDIATYPE_Video,  TEXT("WMMEDIATYPE_Video\0")},
320    {&WMMEDIATYPE_Script, TEXT("WMMEDIATYPE_Script\0")},
321    {&WMMEDIATYPE_Image,  TEXT("WMMEDIATYPE_Image\0")},
322    {&WMMEDIATYPE_FileTransfer, TEXT("WMMEDIATYPE_FileTransfer\0")},
323    {&WMMEDIATYPE_Text,   TEXT("WMMEDIATYPE_Text\0")},
324
325    {&WMMEDIASUBTYPE_Base, TEXT("WMMEDIASUBTYPE_Base\0")},
326    {&WMMEDIASUBTYPE_RGB1, TEXT("WMMEDIASUBTYPE_RGB1\0")},
327    {&WMMEDIASUBTYPE_RGB4, TEXT("WMMEDIASUBTYPE_RGB4\0")},
328    {&WMMEDIASUBTYPE_RGB8, TEXT("WMMEDIASUBTYPE_RGB8\0")},
329    {&WMMEDIASUBTYPE_RGB565, TEXT("WMMEDIASUBTYPE_RGB565\0")},
330    {&WMMEDIASUBTYPE_RGB555, TEXT("WMMEDIASUBTYPE_RGB555\0")},
331    {&WMMEDIASUBTYPE_RGB24, TEXT("WMMEDIASUBTYPE_RGB24\0")},
332    {&WMMEDIASUBTYPE_RGB32, TEXT("WMMEDIASUBTYPE_RGB32\0")},
333    {&WMMEDIASUBTYPE_I420, TEXT("WMMEDIASUBTYPE_I420\0")},
334    {&WMMEDIASUBTYPE_IYUV, TEXT("WMMEDIASUBTYPE_IYUV\0")},
335    {&WMMEDIASUBTYPE_YV12, TEXT("WMMEDIASUBTYPE_YV12\0")},
336    {&WMMEDIASUBTYPE_YUY2, TEXT("WMMEDIASUBTYPE_YUY2\0")},
337    {&WMMEDIASUBTYPE_UYVY, TEXT("WMMEDIASUBTYPE_UYVY\0")},
338    {&WMMEDIASUBTYPE_YVYU, TEXT("WMMEDIASUBTYPE_YVYU\0")},
339    {&WMMEDIASUBTYPE_YVU9, TEXT("WMMEDIASUBTYPE_YVU9\0")},
340    {&WMMEDIASUBTYPE_MP43, TEXT("WMMEDIASUBTYPE_MP43\0")},
341    {&WMMEDIASUBTYPE_MP4S, TEXT("WMMEDIASUBTYPE_MP4S\0")},
342
343    {&WMMEDIASUBTYPE_WMV1, TEXT("WMMEDIASUBTYPE_WMV1\0")},
344    {&WMMEDIASUBTYPE_WMV2, TEXT("WMMEDIASUBTYPE_WMV2\0")},
345    {&WMMEDIASUBTYPE_WMV3, TEXT("WMMEDIASUBTYPE_WMV3\0")},
346    {&WMMEDIASUBTYPE_MSS1, TEXT("WMMEDIASUBTYPE_MSS1\0")},
347    {&WMMEDIASUBTYPE_MSS2, TEXT("WMMEDIASUBTYPE_MSS2\0")},
348    {&WMMEDIASUBTYPE_MPEG2_VIDEO,  TEXT("WMMEDIASUBTYPE_MPEG2_VIDEO\0")},
349    {&WMMEDIASUBTYPE_PCM, TEXT("WMMEDIASUBTYPE_PCM\0")},
350    {&WMMEDIASUBTYPE_DRM, TEXT("WMMEDIASUBTYPE_DRM\0")},
351    {&WMMEDIASUBTYPE_WMAudioV9, TEXT("WMMEDIASUBTYPE_WMAudioV9\0")},
352    {&WMMEDIASUBTYPE_WMAudio_Lossless, TEXT("WMMEDIASUBTYPE_WMAudio_Lossless\0")},
353    {&WMMEDIASUBTYPE_WMAudioV8, TEXT("WMMEDIASUBTYPE_WMAudioV8\0")},
354    {&WMMEDIASUBTYPE_WMAudioV7, TEXT("WMMEDIASUBTYPE_WMAudioV7\0")},
355    {&WMMEDIASUBTYPE_WMAudioV2, TEXT("WMMEDIASUBTYPE_WMAudioV2\0")},
356    {&WMMEDIASUBTYPE_ACELPnet, TEXT("WMMEDIASUBTYPE_ACELPnet\0")},
357    {&WMMEDIASUBTYPE_WMSP1, TEXT("WMMEDIASUBTYPE_WMSP1\0")},
358
359    {&WMFORMAT_VideoInfo,    TEXT("WMFORMAT_VideoInfo\0")},
360    {&WMFORMAT_WaveFormatEx, TEXT("WMFORMAT_WaveFormatEx\0")},
361    {&WMFORMAT_Script,       TEXT("WMFORMAT_Script\0")},
362    {&WMFORMAT_MPEG2Video,   TEXT("WMFORMAT_MPEG2Video\0")},
363
364    {&WMSCRIPTTYPE_TwoStrings, TEXT("WMSCRIPTTYPE_TwoStrings\0")},
365
366    {&PIN_CATEGORY_ANALOGVIDEOIN, TEXT("PIN_CATEGORY_ANALOGVIDEOIN\0")},
367    {&PIN_CATEGORY_CAPTURE, TEXT("PIN_CATEGORY_CAPTURE\0")},
368    {&PIN_CATEGORY_CC, TEXT("PIN_CATEGORY_CC\0")},
369    {&PIN_CATEGORY_EDS, TEXT("PIN_CATEGORY_EDS\0")},
370    {&PIN_CATEGORY_NABTS, TEXT("PIN_CATEGORY_NABTS\0")},
371    {&PIN_CATEGORY_PREVIEW, TEXT("PIN_CATEGORY_PREVIEW\0")},
372    {&PIN_CATEGORY_STILL, TEXT("PIN_CATEGORY_STILL\0")},
373    {&PIN_CATEGORY_TELETEXT, TEXT("PIN_CATEGORY_TELETEXT\0")},
374    {&PIN_CATEGORY_TIMECODE, TEXT("PIN_CATEGORY_TIMECODE\0")},
375    {&PIN_CATEGORY_VBI, TEXT("PIN_CATEGORY_VBI\0")},
376    {&PIN_CATEGORY_VIDEOPORT, TEXT("PIN_CATEGORY_VIDEOPORT\0")},
377    {&PIN_CATEGORY_VIDEOPORT_VBI, TEXT("PIN_CATEGORY_VIDEOPORT_VBI\0")},
378
379    {&CLSID_ACMWrapper, TEXT("CLSID_ACMWrapper\0")},
380    {&CLSID_AVICo, TEXT("CLSID_AVICo\0")},
381    {&CLSID_AVIDec, TEXT("CLSID_AVIDec\0")},
382    {&CLSID_AVIDoc, TEXT("CLSID_AVIDoc\0")},
383    {&CLSID_AVIDraw, TEXT("CLSID_AVIDraw\0")},
384    {&CLSID_AVIMIDIRender, TEXT("CLSID_AVIMIDIRender\0")},
385    {&CLSID_ActiveMovieCategories, TEXT("CLSID_ActiveMovieCategories\0")},
386    {&CLSID_AnalogVideoDecoderPropertyPage, TEXT("CLSID_AnalogVideoDecoderPropertyPage\0")},
387    {&CLSID_WMAsfReader, TEXT("CLSID_WMAsfReader\0")},
388    {&CLSID_WMAsfWriter, TEXT("CLSID_WMAsfWriter\0")},
389    {&CLSID_AsyncReader, TEXT("CLSID_AsyncReader\0")},
390    {&CLSID_AudioCompressorCategory, TEXT("CLSID_AudioCompressorCategory\0")},
391    {&CLSID_AudioInputDeviceCategory, TEXT("CLSID_AudioInputDeviceCategory\0")},
392    {&CLSID_AudioProperties, TEXT("CLSID_AudioProperties\0")},
393    {&CLSID_AudioRecord, TEXT("CLSID_AudioRecord\0")},
394    {&CLSID_AudioRender, TEXT("CLSID_AudioRender\0")},
395    {&CLSID_AudioRendererCategory, TEXT("CLSID_AudioRendererCategory\0")},
396    {&CLSID_AviDest, TEXT("CLSID_AviDest\0")},
397    {&CLSID_AviMuxProptyPage, TEXT("CLSID_AviMuxProptyPage\0")},
398    {&CLSID_AviMuxProptyPage1, TEXT("CLSID_AviMuxProptyPage1\0")},
399    {&CLSID_AviReader, TEXT("CLSID_AviReader\0")},
400    {&CLSID_AviSplitter, TEXT("CLSID_AviSplitter\0")},
401    {&CLSID_CAcmCoClassManager, TEXT("CLSID_CAcmCoClassManager\0")},
402    {&CLSID_CDeviceMoniker, TEXT("CLSID_CDeviceMoniker\0")},
403    {&CLSID_CIcmCoClassManager, TEXT("CLSID_CIcmCoClassManager\0")},
404    {&CLSID_CMidiOutClassManager, TEXT("CLSID_CMidiOutClassManager\0")},
405    {&CLSID_CMpegAudioCodec, TEXT("CLSID_CMpegAudioCodec\0")},
406    {&CLSID_CMpegVideoCodec, TEXT("CLSID_CMpegVideoCodec\0")},
407    {&CLSID_CQzFilterClassManager, TEXT("CLSID_CQzFilterClassManager\0")},
408    {&CLSID_CVidCapClassManager, TEXT("CLSID_CVidCapClassManager\0")},
409    {&CLSID_CWaveOutClassManager, TEXT("CLSID_CWaveOutClassManager\0")},
410    {&CLSID_CWaveinClassManager, TEXT("CLSID_CWaveinClassManager\0")},
411    {&CLSID_CameraControlPropertyPage, TEXT("CLSID_CameraControlPropertyPage\0")},
412    {&CLSID_CaptureGraphBuilder, TEXT("CLSID_CaptureGraphBuilder\0")},
413    {&CLSID_CaptureProperties, TEXT("CLSID_CaptureProperties\0")},
414    {&CLSID_Colour, TEXT("CLSID_Colour\0")},
415    {&CLSID_CrossbarFilterPropertyPage, TEXT("CLSID_CrossbarFilterPropertyPage\0")},
416    {&CLSID_DSoundRender, TEXT("CLSID_DSoundRender\0")},
417    {&CLSID_DVDHWDecodersCategory, TEXT("CLSID_DVDHWDecodersCategory\0")},
418    {&CLSID_DVDNavigator, TEXT("CLSID_DVDNavigator\0")},
419    {&CLSID_DVDecPropertiesPage, TEXT("CLSID_DVDecPropertiesPage\0")},
420    {&CLSID_DVEncPropertiesPage, TEXT("CLSID_DVEncPropertiesPage\0")},
421    {&CLSID_DVMux, TEXT("CLSID_DVMux\0")},
422    {&CLSID_DVMuxPropertyPage, TEXT("CLSID_DVMuxPropertyPage\0")},
423    {&CLSID_DVSplitter, TEXT("CLSID_DVSplitter\0")},
424    {&CLSID_DVVideoCodec, TEXT("CLSID_DVVideoCodec\0")},
425    {&CLSID_DVVideoEnc, TEXT("CLSID_DVVideoEnc\0")},
426    {&CLSID_DirectDraw, TEXT("CLSID_DirectDraw\0")},
427    {&CLSID_DirectDrawClipper, TEXT("CLSID_DirectDrawClipper\0")},
428    {&CLSID_DirectDrawProperties, TEXT("CLSID_DirectDrawProperties\0")},
429    {&CLSID_Dither, TEXT("CLSID_Dither\0")},
430    {&CLSID_DvdGraphBuilder, TEXT("CLSID_DvdGraphBuilder\0")},
431    {&CLSID_FGControl, TEXT("CLSID_FGControl\0")},
432    {&CLSID_FileSource, TEXT("CLSID_FileSource\0")},
433    {&CLSID_FileWriter, TEXT("CLSID_FileWriter\0")},
434    {&CLSID_FilterGraph, TEXT("CLSID_FilterGraph\0")},
435    {&CLSID_FilterGraphNoThread, TEXT("CLSID_FilterGraphNoThread\0")},
436    {&CLSID_FilterMapper, TEXT("CLSID_FilterMapper\0")},
437    {&CLSID_FilterMapper2, TEXT("CLSID_FilterMapper2\0")},
438    {&CLSID_InfTee, TEXT("CLSID_InfTee\0")},
439    {&CLSID_LegacyAmFilterCategory, TEXT("CLSID_LegacyAmFilterCategory\0")},
440    {&CLSID_Line21Decoder, TEXT("CLSID_Line21Decoder\0")},
441    {&CLSID_MOVReader, TEXT("CLSID_MOVReader\0")},
442    {&CLSID_MPEG1Doc, TEXT("CLSID_MPEG1Doc\0")},
443    {&CLSID_MPEG1PacketPlayer, TEXT("CLSID_MPEG1PacketPlayer\0")},
444    {&CLSID_MPEG1Splitter, TEXT("CLSID_MPEG1Splitter\0")},
445    {&CLSID_MediaPropertyBag, TEXT("CLSID_MediaPropertyBag\0")},
446    {&CLSID_MemoryAllocator, TEXT("CLSID_MemoryAllocator\0")},
447    {&CLSID_MidiRendererCategory, TEXT("CLSID_MidiRendererCategory\0")},
448    {&CLSID_ModexProperties, TEXT("CLSID_ModexProperties\0")},
449    {&CLSID_ModexRenderer, TEXT("CLSID_ModexRenderer\0")},
450    {&CLSID_OverlayMixer, TEXT("CLSID_OverlayMixer\0")},
451    {&CLSID_PerformanceProperties, TEXT("CLSID_PerformanceProperties\0")},
452    {&CLSID_PersistMonikerPID, TEXT("CLSID_PersistMonikerPID\0")},
453    {&CLSID_ProtoFilterGraph, TEXT("CLSID_ProtoFilterGraph\0")},
454    {&CLSID_QualityProperties, TEXT("CLSID_QualityProperties\0")},
455    {&CLSID_SeekingPassThru, TEXT("CLSID_SeekingPassThru\0")},
456    {&CLSID_SmartTee, TEXT("CLSID_SmartTee\0")},
457    {&CLSID_SystemClock, TEXT("CLSID_SystemClock\0")},
458    {&CLSID_SystemDeviceEnum, TEXT("CLSID_SystemDeviceEnum\0")},
459    {&CLSID_TVAudioFilterPropertyPage, TEXT("CLSID_TVAudioFilterPropertyPage\0")},
460    {&CLSID_TVTunerFilterPropertyPage, TEXT("CLSID_TVTunerFilterPropertyPage\0")},
461    {&CLSID_TextRender, TEXT("CLSID_TextRender\0")},
462    {&CLSID_URLReader, TEXT("CLSID_URLReader\0")},
463    {&CLSID_VBISurfaces, TEXT("CLSID_VBISurfaces\0")},
464    {&CLSID_VPObject, TEXT("CLSID_VPObject\0")},
465    {&CLSID_VPVBIObject, TEXT("CLSID_VPVBIObject\0")},
466    {&CLSID_VfwCapture, TEXT("CLSID_VfwCapture\0")},
467    {&CLSID_VideoCompressorCategory, TEXT("CLSID_VideoCompressorCategory\0")},
468    {&CLSID_VideoInputDeviceCategory, TEXT("CLSID_VideoInputDeviceCategory\0")},
469    {&CLSID_VideoProcAmpPropertyPage, TEXT("CLSID_VideoProcAmpPropertyPage\0")},
470    {&CLSID_VideoRenderer, TEXT("CLSID_VideoRenderer\0")},
471    {&CLSID_VideoStreamConfigPropertyPage, TEXT("CLSID_VideoStreamConfigPropertyPage\0")},
472
473    {&CLSID_WMMUTEX_Language,      TEXT("CLSID_WMMUTEX_Language\0")},
474    {&CLSID_WMMUTEX_Bitrate,       TEXT("CLSID_WMMUTEX_Bitrate\0")},
475    {&CLSID_WMMUTEX_Presentation,  TEXT("CLSID_WMMUTEX_Presentation\0")},
476    {&CLSID_WMMUTEX_Unknown,       TEXT("CLSID_WMMUTEX_Unknown\0")},
477
478    {&CLSID_WMBandwidthSharing_Exclusive, TEXT("CLSID_WMBandwidthSharing_Exclusive\0")},
479    {&CLSID_WMBandwidthSharing_Partial,   TEXT("CLSID_WMBandwidthSharing_Partial\0")},
480
481    {&FORMAT_AnalogVideo, TEXT("FORMAT_AnalogVideo\0")},
482    {&FORMAT_DVD_LPCMAudio, TEXT("FORMAT_DVD_LPCMAudio\0")},
483    {&FORMAT_DolbyAC3, TEXT("FORMAT_DolbyAC3\0")},
484    {&FORMAT_DvInfo, TEXT("FORMAT_DvInfo\0")},
485    {&FORMAT_MPEG2Audio, TEXT("FORMAT_MPEG2Audio\0")},
486    {&FORMAT_MPEG2Video, TEXT("FORMAT_MPEG2Video\0")},
487    {&FORMAT_MPEG2_VIDEO, TEXT("FORMAT_MPEG2_VIDEO\0")},
488    {&FORMAT_MPEGStreams, TEXT("FORMAT_MPEGStreams\0")},
489    {&FORMAT_MPEGVideo, TEXT("FORMAT_MPEGVideo\0")},
490    {&FORMAT_None, TEXT("FORMAT_None\0")},
491    {&FORMAT_VIDEOINFO2, TEXT("FORMAT_VIDEOINFO2\0")},
492    {&FORMAT_VideoInfo, TEXT("FORMAT_VideoInfo\0")},
493    {&FORMAT_VideoInfo2, TEXT("FORMAT_VideoInfo2\0")},
494    {&FORMAT_WaveFormatEx, TEXT("FORMAT_WaveFormatEx\0")},
495
496    {&TIME_FORMAT_BYTE, TEXT("TIME_FORMAT_BYTE\0")},
497    {&TIME_FORMAT_FIELD, TEXT("TIME_FORMAT_FIELD\0")},
498    {&TIME_FORMAT_FRAME, TEXT("TIME_FORMAT_FRAME\0")},
499    {&TIME_FORMAT_MEDIA_TIME, TEXT("TIME_FORMAT_MEDIA_TIME\0")},
500    {&TIME_FORMAT_SAMPLE, TEXT("TIME_FORMAT_SAMPLE\0")},
501
502    {&AMPROPSETID_Pin, TEXT("AMPROPSETID_Pin\0")},
503    {&AM_INTERFACESETID_Standard, TEXT("AM_INTERFACESETID_Standard\0")},
504    {&AM_KSCATEGORY_AUDIO, TEXT("AM_KSCATEGORY_AUDIO\0")},
505    {&AM_KSCATEGORY_CAPTURE, TEXT("AM_KSCATEGORY_CAPTURE\0")},
506    {&AM_KSCATEGORY_CROSSBAR, TEXT("AM_KSCATEGORY_CROSSBAR\0")},
507    {&AM_KSCATEGORY_DATACOMPRESSOR, TEXT("AM_KSCATEGORY_DATACOMPRESSOR\0")},
508    {&AM_KSCATEGORY_RENDER, TEXT("AM_KSCATEGORY_RENDER\0")},
509    {&AM_KSCATEGORY_TVAUDIO, TEXT("AM_KSCATEGORY_TVAUDIO\0")},
510    {&AM_KSCATEGORY_TVTUNER, TEXT("AM_KSCATEGORY_TVTUNER\0")},
511    {&AM_KSCATEGORY_VIDEO, TEXT("AM_KSCATEGORY_VIDEO\0")},
512    {&AM_KSPROPSETID_AC3, TEXT("AM_KSPROPSETID_AC3\0")},
513    {&AM_KSPROPSETID_CopyProt, TEXT("AM_KSPROPSETID_CopyProt\0")},
514    {&AM_KSPROPSETID_DvdSubPic, TEXT("AM_KSPROPSETID_DvdSubPic\0")},
515    {&AM_KSPROPSETID_TSRateChange, TEXT("AM_KSPROPSETID_TSRateChange\0")},
516
517    {&IID_IAMDirectSound, TEXT("IID_IAMDirectSound\0")},
518    {&IID_IAMLine21Decoder, TEXT("IID_IAMLine21Decoder\0")},
519    {&IID_IBaseVideoMixer, TEXT("IID_IBaseVideoMixer\0")},
520    {&IID_IDDVideoPortContainer, TEXT("IID_IDDVideoPortContainer\0")},
521    {&IID_IDirectDraw, TEXT("IID_IDirectDraw\0")},
522    {&IID_IDirectDraw2, TEXT("IID_IDirectDraw2\0")},
523    {&IID_IDirectDrawClipper, TEXT("IID_IDirectDrawClipper\0")},
524    {&IID_IDirectDrawColorControl, TEXT("IID_IDirectDrawColorControl\0")},
525    {&IID_IDirectDrawKernel, TEXT("IID_IDirectDrawKernel\0")},
526    {&IID_IDirectDrawPalette, TEXT("IID_IDirectDrawPalette\0")},
527    {&IID_IDirectDrawSurface, TEXT("IID_IDirectDrawSurface\0")},
528    {&IID_IDirectDrawSurface2, TEXT("IID_IDirectDrawSurface2\0")},
529    {&IID_IDirectDrawSurface3, TEXT("IID_IDirectDrawSurface3\0")},
530    {&IID_IDirectDrawSurfaceKernel, TEXT("IID_IDirectDrawSurfaceKernel\0")},
531    {&IID_IDirectDrawVideo, TEXT("IID_IDirectDrawVideo\0")},
532    {&IID_IFullScreenVideo, TEXT("IID_IFullScreenVideo\0")},
533    {&IID_IFullScreenVideoEx, TEXT("IID_IFullScreenVideoEx\0")},
534    {&IID_IKsDataTypeHandler, TEXT("IID_IKsDataTypeHandler\0")},
535    {&IID_IKsInterfaceHandler, TEXT("IID_IKsInterfaceHandler\0")},
536    {&IID_IKsPin, TEXT("IID_IKsPin\0")},
537    {&IID_IMixerPinConfig, TEXT("IID_IMixerPinConfig\0")},
538    {&IID_IMixerPinConfig2, TEXT("IID_IMixerPinConfig2\0")},
539    {&IID_IMpegAudioDecoder, TEXT("IID_IMpegAudioDecoder\0")},
540    {&IID_IQualProp, TEXT("IID_IQualProp\0")},
541    {&IID_IVPConfig, TEXT("IID_IVPConfig\0")},
542    {&IID_IVPControl, TEXT("IID_IVPControl\0")},
543    {&IID_IVPNotify, TEXT("IID_IVPNotify\0")},
544    {&IID_IVPNotify2, TEXT("IID_IVPNotify2\0")},
545    {&IID_IVPObject, TEXT("IID_IVPObject\0")},
546    {&IID_IVPVBIConfig, TEXT("IID_IVPVBIConfig\0")},
547    {&IID_IVPVBINotify, TEXT("IID_IVPVBINotify\0")},
548    {&IID_IVPVBIObject, TEXT("IID_IVPVBIObject\0")},
549
550    {&LOOK_DOWNSTREAM_ONLY, TEXT("LOOK_DOWNSTREAM_ONLY\0")},
551    {&LOOK_UPSTREAM_ONLY, TEXT("LOOK_UPSTREAM_ONLY\0")},
552    {0, 0},
553};
554
555//-----------------------------------------------------------------------------
556// GetPin
557// Find the pin of the specified format type on the given filter
558// This method leaves an outstanding reference on the pin if successful
559HRESULT GetPin(IBaseFilter* pFilter, const GUID* pFormat, PIN_DIRECTION PinDir, IPin** ppPin)
560{
561    HRESULT hr = S_OK;
562
563    if (pFilter && pFormat && ppPin)
564    {
565        IEnumPins* pIEnumPins = NULL;
566        hr = pFilter->EnumPins(&pIEnumPins);
567        if (SUCCEEDED(hr))
568        {
569            // find the pin with the specified format
570            IPin* pIPin = NULL;
571            while (S_OK == pIEnumPins->Next(1, &pIPin, NULL))
572            {
573                // match the pin direction
574                PIN_DIRECTION pinDir;
575                pIPin->QueryDirection(&pinDir);
576                if (pinDir == PinDir)
577                {
578                    // match pin direction check the first media type returned from the upstream pin
579                    IEnumMediaTypes* pIEnumMT = NULL;
580                    hr = pIPin->EnumMediaTypes(&pIEnumMT);
581                    if (SUCCEEDED(hr))
582                    {
583                        AM_MEDIA_TYPE* pmt = NULL;
584                        hr = pIEnumMT->Next(1, &pmt, NULL);
585                        if (S_OK == hr)
586                        {
587                            if (pmt->majortype == *pFormat)
588                            {
589                                // found the pin with the specified format
590                                *ppPin = pIPin;
591                                DeleteMediaType(pmt);
592                                break;
593                            }
594                            else
595                            {
596                                DeleteMediaType(pmt);
597                            }
598                        }
599                        pIEnumMT->Release();
600                    }
601                }
602                if (pIPin) pIPin->Release(); pIPin = 0;
603            }
604
605            if (NULL == *ppPin)
606            {
607                // failed to find the named pin
608                hr = E_FAIL;
609            }
610        pIEnumPins->Release();
611        }
612    }
613    else
614    {
615        hr = E_INVALIDARG;
616    }
617
618    return hr;
619}
620//-----------------------------------------------------------------------------
621// GetPin
622// Find the pin of the specified name on the given filter
623// This method leaves an outstanding reference on the pin if successful
624HRESULT GetPin(IBaseFilter* pFilter, LPCWSTR pName, IPin** ppPin)
625{
626    HRESULT hr = S_OK;
627
628    if (pFilter && pName && ppPin)
629    {
630        IEnumPins* pIEnumPins = NULL;
631        hr = pFilter->EnumPins(&pIEnumPins);
632        if (SUCCEEDED(hr))
633        {
634            IPin* pIPin = NULL;
635            while (S_OK == pIEnumPins->Next(1, &pIPin, NULL))
636            {
637                PIN_INFO info = {0};
638                hr = pIPin->QueryPinInfo(&info);
639                if (SUCCEEDED(hr))
640                {
641                    if (info.pFilter) info.pFilter->Release(); info.pFilter = 0;
642
643                    if (0 == wcsncmp(info.achName, pName, wcslen(pName)))
644                    {
645                        // matched the pin category
646                        *ppPin = pIPin;
647                        break;
648                    }
649                }
650                if (pIPin) pIPin->Release(); pIPin = 0;
651            }
652            pIEnumPins->Release();
653        }
654
655        if (NULL == *ppPin)
656        {
657            // failed to find the named pin
658            hr = E_FAIL;
659        }
660    }
661    else
662    {
663        hr = E_INVALIDARG;
664    }
665
666    return hr;
667}
668
669//-----------------------------------------------------------------------------
670// FindPinInterface
671// Attempt to locate the interface on the pin with the specified format or on the first pin if no
672// format is provided.
673HRESULT FindPinInterface(IBaseFilter* pFilter, const GUID* pFormat, PIN_DIRECTION PinDir, const IID& riid, void** ppvInterface)
674{
675    HRESULT hr = S_OK;
676
677    if (pFilter && ppvInterface)
678    {
679        IPin* pIPin = NULL;
680        if (pFormat)
681        {
682            hr = GetPin(pFilter, pFormat, PinDir, &pIPin);
683        }
684        else
685        {
686            IEnumPins* pIEnumPins = NULL;
687            hr = pFilter->EnumPins(&pIEnumPins);
688            if (SUCCEEDED(hr))
689            {
690                hr = pIEnumPins->Next(1, &pIPin, NULL);
691            }
692            pIEnumPins->Release();
693        }
694
695        if (SUCCEEDED(hr))
696        {
697            hr = pIPin->QueryInterface(riid, ppvInterface);
698        }
699        pIPin->Release();
700    }
701    else
702    {
703        hr = E_INVALIDARG;
704    }
705
706    return hr;
707}
708
709std::string getStringFromGUID(const GUID *pGUID)
710{
711    int i=0;
712    // Find format GUID's name in the named guids table
713    while (MediaType[i].pguid != 0)
714    {
715        if(*pGUID == *(MediaType[i].pguid))
716        {
717            return std::string(MediaType[i].psz);
718        }
719        i++;
720    }
721
722    // return the guid if does not recognize the type
723    const int maxChar = 60;
724    LPOLESTR pwszClsid = (LPOLESTR) CoTaskMemAlloc(maxChar*2);
725    CHAR  szCLSID[maxChar];
726    int nchar = StringFromGUID2(*pGUID, pwszClsid, maxChar);
727    // Convert result to ANSI
728    WideCharToMultiByte(CP_ACP, 0, pwszClsid, -1, szCLSID, nchar, NULL, NULL);
729    CoTaskMemFree(pwszClsid);
730    return std::string(szCLSID);
731}
732const GUID* getGUIDFromString(const std::string& str)
733{
734    int i=0;
735    // Find format GUID's name in the named guids table
736    while (MediaType[i].pguid != 0)
737    {
738        if(str == std::string((MediaType[i].psz)))
739            return MediaType[i].pguid;
740        i++;
741    }
742    return 0;
743}
744static std::string getErrorMessage(HRESULT hr)
745{
746    if (FAILED(hr))
747    {
748        TCHAR szErr[MAX_ERROR_TEXT_LEN];
749        DWORD res = AMGetErrorText(hr, szErr, MAX_ERROR_TEXT_LEN);
750        if (res == 0)
751        {
752            StringCchPrintf(szErr, MAX_ERROR_TEXT_LEN, "Unknown Error: 0x%2x", hr);
753        }
754        return std::string (szErr);
755    }
756    return std::string("");
757}
758
759static bool checkError(const std::string& prefix, HRESULT hr)
760{
761    if (FAILED(hr))
762    {
763        OSG_WARN << prefix << " " << getErrorMessage(hr) << std::endl;
764    }
765
766    if (hr == E_ABORT)
767        return false;
768    if (hr == E_FAIL)
769        return false;
770    if (hr == E_OUTOFMEMORY)
771        return false;
772    if (hr == E_POINTER)
773        return false;
774    if (hr == VFW_E_CANNOT_CONNECT)
775        return false;
776    if (hr == 0x80040256)
777        return false;
778    if (hr == 0x80040216)
779        return false;
780
781    return true;
782}
783
784bool CTextureRenderer::initBuildGraph()
785{
786    std::string prefixForMessage;
787    {
788    std::stringstream ss;
789    ss << _imageStream.get();
790    prefixForMessage = ss.str();
791    }
792
793    HRESULT hr;
794    hr = CoCreateInstance( CLSID_FilterGraph, 0, CLSCTX_INPROC,IID_IGraphBuilder, (void **)&_graphBuilder );
795    if (!checkError(prefixForMessage, hr))
796        return false;
797
798    hr = _graphBuilder->QueryInterface( IID_IMediaControl, (void **)&_mediaControl );
799    if (!checkError(prefixForMessage, hr))
800        return false;
801
802    hr = _graphBuilder->QueryInterface( IID_IMediaSeeking, (void **)&_mediaSeeking );
803    if (!checkError(prefixForMessage, hr))
804        return false;
805
806    hr = _graphBuilder->AddFilter((IBaseFilter*)this, L"Sampler");
807    if (!checkError(prefixForMessage, hr))
808        return false;
809
810
811    hr = _graphBuilder->QueryInterface( IID_IBasicAudio, (void **)&_basicAudio);
812    checkError(prefixForMessage, hr); //May be no sound so dont effect return result
813
814    return true;
815}
816
817
818struct ListDeviceAvailable
819{
820    struct DeviceEntry
821    {
822        std::string _name;
823        std::string _clsid;
824        IMoniker* _device;
825        DeviceEntry(const std::string& name = "" , const std::string& clsid = "", IMoniker* device = 0) : _name(name), _clsid(clsid), _device(device) {}
826    };
827    std::vector<DeviceEntry> _listDevice;
828    IEnumMoniker* _enumMoniker;
829    ListDeviceAvailable(IEnumMoniker *enumMoniker) : _enumMoniker(enumMoniker)
830    {
831        createList();
832    }
833    ~ListDeviceAvailable()
834    {
835        for (int i = 0; i < (int)_listDevice.size(); i++)
836            if (_listDevice[i]._device)
837                _listDevice[i]._device->Release();
838    }
839
840    void displayDevicesFound(const std::string& prefixForMessage, osg::NotifySeverity serverity = osg::NOTICE) const
841    {
842        for (int i = 0; i < (int)_listDevice.size(); i++)
843        {
844            OSG_NOTIFY(serverity) << prefixForMessage << " device \"" << _listDevice[i]._name << "\" clsid " << _listDevice[i]._clsid << std::endl;
845        }
846    }
847
848    DeviceEntry getDevice(const std::string& name)
849    {
850        for (int i = 0; i < (int)_listDevice.size(); i++)
851            if (_listDevice[i]._name == name)
852                return _listDevice[i];
853        //if (!_listDevice.empty())
854        //    return _listDevice.front();
855
856        int deviceId = atoi(name.c_str());
857        if(deviceId >= 0 && deviceId < (int)_listDevice.size())
858          return _listDevice[deviceId];
859
860        return DeviceEntry();
861    }
862
863    void createList()
864    {
865        IMoniker *device = NULL;
866        HRESULT hr;
867        // Enumerate all items associated with the moniker
868        while (_enumMoniker->Next(1, &device, NULL) == S_OK)
869        {
870            IPropertyBag *pPropBag = NULL;
871            CLSID clsidFilter;
872
873            VARIANT varName;
874            VARIANT varFilterClsid;
875
876            VariantInit(&varName);
877            VariantInit(&varFilterClsid);
878
879            // Associate moniker with a file
880            hr = device->BindToStorage(0, 0, IID_IPropertyBag,
881                                         (void **)&pPropBag);
882
883            // Read filter name from property bag
884            if (SUCCEEDED(hr))
885            {
886                hr = pPropBag->Read(L"FriendlyName", &varName, 0);
887            }
888
889            // Read filter's CLSID from property bag.  This CLSID string will be
890            // converted to a binary CLSID and passed to AddFilter(), which will
891            // add the filter's name to the listbox and its CLSID to the listbox
892            // item's DataPtr item.  When the user clicks on a filter name in
893            // the listbox, we'll read the stored CLSID, convert it to a string,
894            // and use it to find the filter's filename in the registry.
895
896            if (SUCCEEDED(hr))
897            {
898                // Read CLSID string from property bag
899                hr = pPropBag->Read(L"CLSID", &varFilterClsid, 0);
900
901                // Add filter name and CLSID to listbox
902                if (SUCCEEDED(hr))
903                {
904                    hr = CLSIDFromString(varFilterClsid.bstrVal, &clsidFilter);
905                }
906                else if (hr == E_PROP_ID_UNSUPPORTED)
907                {
908                    clsidFilter = GUID_NULL; // No CLSID is listed.
909                    hr = S_OK;
910                }
911            }
912
913            // covert to std::string
914            _bstr_t bstr_t(varName.bstrVal);
915            std::string deviceName(bstr_t);
916            std::string deviceGUID;
917
918            // Add filter name and filename to list
919            if(SUCCEEDED(hr))
920            {
921                LPOLESTR pwszClsid;
922                CHAR  szCLSID[60];
923                hr = StringFromCLSID(clsidFilter, &pwszClsid);
924                if (!FAILED(hr))
925                {
926                    // Convert result to ANSI
927                    WideCharToMultiByte(CP_ACP, 0, pwszClsid, -1, szCLSID, 60, NULL, NULL);
928                    //OSG_NOTICE << "device \"" << truename << "\" id " << szCLSID << std::endl;
929                    deviceGUID = std::string(szCLSID);
930                }
931                CoTaskMemFree(pwszClsid);
932            }
933
934            VariantClear(&varName);
935            VariantClear(&varFilterClsid);
936
937            // Cleanup interfaces
938            if (pPropBag) pPropBag->Release();
939
940            _listDevice.push_back(DeviceEntry(deviceName, deviceGUID, device));
941        }
942    }
943
944
945};
946
947
948struct ListCapDeviceAvailable
949{
950    typedef std::pair<AM_MEDIA_TYPE*, VIDEOINFOHEADER *> CapEntry;
951    std::vector<CapEntry> _capsList;
952    IAMStreamConfig* _config;
953    ListCapDeviceAvailable(IAMStreamConfig* config) : _config(config)
954    {
955        createList();
956    }
957    ~ListCapDeviceAvailable()
958    {
959        for (int i = 0; i < (int)_capsList.size(); i++)
960            if (_capsList[i].first)
961                DeleteMediaType(_capsList[i].first);
962    }
963
964    void displayCapsFound(const std::string& prefixForMessage = "") const
965    {
966        for (int i = 0; i < (int)_capsList.size(); i++)
967        {
968            VIDEOINFOHEADER* video= _capsList[i].second;
969            displayCap(video, prefixForMessage);
970        }
971    }
972
973    static void displayCap(VIDEOINFOHEADER* video, const std::string& prefix = "")
974    {
975        if (!video)
976            return;
977        double fps = 1.0/ (video->AvgTimePerFrame * 100.0 * 1e-9);
978        FOURCCMap fccMap(video->bmiHeader.biCompression);
979        GUID g1 = (GUID)fccMap;
980        OSG_NOTICE << prefix << " cap " << video->bmiHeader.biWidth << " x " << video->bmiHeader.biHeight << " bit per pixel " << video->bmiHeader.biBitCount << " (" << getStringFromGUID(&g1) << ") at " << fps << " fps" << std::endl;
981    }
982
983    std::pair<AM_MEDIA_TYPE*, VIDEOINFOHEADER *> getCaps(int width, int height, double fps)
984    {
985        std::vector<CapEntry> filterResolution;
986        for (int i = 0; i < (int)_capsList.size(); i++)
987        {
988            VIDEOINFOHEADER* video= _capsList[i].second;
989            if (video->bmiHeader.biWidth == width && video->bmiHeader.biHeight == height)
990            {
991                filterResolution.push_back(_capsList[i]);
992            }
993        }
994        // get the max fps if the fps are not reach on the desired resolution
995        typedef std::multimap<double, CapEntry> ContainerFrameRateSorted;
996        ContainerFrameRateSorted filterFrameRate;
997        for (int i = 0; i < (int)filterResolution.size(); i++)
998        {
999            VIDEOINFOHEADER* video= filterResolution[i].second;
1000            double capfps = 1.0/  (video->AvgTimePerFrame * 100.0 * 1e-9);
1001            double error = fabs(capfps - fps);
1002            filterFrameRate.insert(std::pair<double, CapEntry>(error, filterResolution[i]));
1003        }
1004
1005        CapEntry nullCapEntry(static_cast<AM_MEDIA_TYPE*>(NULL), static_cast<VIDEOINFOHEADER*>(NULL));
1006        CapEntry best = nullCapEntry;
1007        CapEntry first = nullCapEntry;
1008
1009        for (ContainerFrameRateSorted::iterator it = filterFrameRate.begin();
1010               it != filterFrameRate.end();
1011               ++it)
1012        {
1013            if (first == nullCapEntry)
1014                first = it->second;
1015
1016            if (it->first < 1e-3)
1017            {
1018                VIDEOINFOHEADER* video= it->second.second;
1019                FOURCCMap fccMap(video->bmiHeader.biCompression);
1020                GUID g1 = (GUID)fccMap;
1021                if (getStringFromGUID(&g1) == std::string("YUY2"))
1022                    best = it->second;
1023            }
1024        }
1025        if (best != nullCapEntry)
1026            return best;
1027        if (first != nullCapEntry)
1028            return first;
1029
1030        if (!_capsList.empty())
1031            return _capsList.front();
1032        return nullCapEntry;
1033    }
1034
1035    void createList()
1036    {
1037        std::string device = "capture";
1038        // Use the IPin to get the interface:
1039
1040        // get the number of formats and make sure the strutucre size matches
1041        int iCount, iSize;
1042        VIDEO_STREAM_CONFIG_CAPS caps;
1043        _config->GetNumberOfCapabilities(&iCount, &iSize);
1044        if( sizeof(caps) != iSize )
1045            return;
1046
1047        // now go through all formats and use the one you like
1048        for(int i=0; i < iCount; i++)
1049        {
1050            // GetStreamCaps allocats the AM_MEDIA_TYPE, which must be deleted by using DeleteMediaType
1051            AM_MEDIA_TYPE *pmt = NULL;
1052            if( _config->GetStreamCaps(i, &pmt, (BYTE*)&caps) == S_OK )
1053            {
1054                if (pmt->formattype == FORMAT_VideoInfo && pmt->cbFormat >= sizeof(VIDEOINFOHEADER))
1055                {
1056                    VIDEOINFOHEADER *video=
1057                        reinterpret_cast<VIDEOINFOHEADER*>(pmt->pbFormat);
1058                    _capsList.push_back(CapEntry(pmt, video));
1059                }
1060                else
1061                {
1062                    DeleteMediaType(pmt);
1063                }
1064            }
1065        }
1066    }
1067};
1068
1069
1070bool CTextureRenderer::setupOutputSoundDevice(ICreateDevEnum* devs)
1071{
1072    if (!devs)
1073        return false;
1074
1075    std::string prefixForMessage;
1076    {
1077    std::stringstream ss;
1078    ss << _imageStream.get();
1079    prefixForMessage = ss.str();
1080    }
1081
1082    HRESULT hr;
1083    std::string outputdevice = "Default DirectSound Device";
1084    IEnumMoniker*   audioRenderer = 0; hr = devs?devs->CreateClassEnumerator (CLSID_AudioRendererCategory, &audioRenderer, 0):0;
1085    if (!checkError(prefixForMessage, hr))
1086        return false;
1087    ListDeviceAvailable deviceFinder(audioRenderer);
1088
1089    deviceFinder.displayDevicesFound(prefixForMessage + " sounddevice", osg::INFO);
1090
1091    ListDeviceAvailable::DeviceEntry device = deviceFinder.getDevice(outputdevice);
1092    if (!device._device)
1093    {
1094        OSG_WARN << prefixForMessage << " no output sound device \"" << outputdevice << "\" found" << std::endl;
1095        return false;
1096    }
1097
1098    _soundOutputDeviceName = device._name;
1099    IMoniker* mon  = device._device;
1100    hr = mon?mon->BindToObject(0,0,IID_IBaseFilter, (void**)&_soundOutputDevice):0;
1101    checkError(prefixForMessage, hr);
1102    if (FAILED(hr))
1103        return false;
1104
1105    hr = _graphBuilder->AddFilter(_soundOutputDevice,NULL);
1106    checkError(prefixForMessage, hr);
1107    if (FAILED(hr))
1108    {
1109        if (_soundOutputDevice) _soundOutputDevice->Release(); _soundOutputDevice = 0;
1110        return false;
1111    }
1112
1113    return true;
1114}
1115
1116bool CTextureRenderer::openVideoCaptureDevice(const std::string& capture, int wantWidth, int wantHeight, double wantFps)
1117{
1118    std::string prefixForMessage;
1119    {
1120    std::stringstream ss;
1121    ss << _imageStream.get();
1122    prefixForMessage = ss.str();
1123    }
1124
1125    HRESULT hr;
1126    ICreateDevEnum* devs = 0; hr = CoCreateInstance (CLSID_SystemDeviceEnum, 0, CLSCTX_INPROC, IID_ICreateDevEnum, (void **) &devs);
1127    if (!checkError(prefixForMessage, hr))
1128        return false;
1129
1130    IEnumMoniker*   cams = 0; hr = devs?devs->CreateClassEnumerator (CLSID_VideoInputDeviceCategory, &cams, 0):0;
1131    if (!checkError(prefixForMessage, hr))
1132        return false;
1133
1134    ListDeviceAvailable deviceFinder(cams);
1135    {
1136    std::stringstream ss;
1137    ss << std::hex << _imageStream.get() << " capture";
1138    deviceFinder.displayDevicesFound(ss.str(), osg::INFO);
1139    }
1140    ListDeviceAvailable::DeviceEntry device = deviceFinder.getDevice(capture);
1141
1142    if (!device._device)
1143    {
1144        OSG_WARN << _imageStream.get() << " no capture device \"" << capture << "\" found" << std::endl;
1145        return false;
1146    }
1147    _videoCaptureDeviceName = device._name;
1148    OSG_NOTICE << _imageStream.get() << " use capture device \"" << getVideoCaptureDeviceName() << "\"" << std::endl;
1149
1150    {
1151    std::stringstream ss;
1152    ss << _imageStream.get() << " \"" << getVideoCaptureDeviceName() << "\"";
1153    prefixForMessage = ss.str();
1154    }
1155
1156
1157    IMoniker* mon  = device._device;
1158
1159    hr = mon?mon->BindToObject(0,0,IID_IBaseFilter, (void**)&_videoCaptureDevice):0;
1160    if (!checkError(prefixForMessage, hr))
1161        return false;
1162
1163    IEnumPins* pins = 0; hr = _videoCaptureDevice?_videoCaptureDevice->EnumPins(&pins):0;
1164    if (!checkError(prefixForMessage, hr))
1165        return false;
1166
1167    IPin* cap  = 0; hr = pins?pins->Next(1,&cap, 0):0;
1168    if (pins) pins->Release(); pins = 0;
1169    if (!checkError(prefixForMessage, hr))
1170        return false;
1171
1172
1173    IAMStreamConfig* capConfig = 0; hr = cap->QueryInterface( IID_IAMStreamConfig, (void **)&capConfig);
1174    if (capConfig)
1175    {
1176        ListCapDeviceAvailable capsDevice(capConfig);
1177        capsDevice.displayCapsFound(prefixForMessage);
1178        ListCapDeviceAvailable::CapEntry found = capsDevice.getCaps(wantWidth, wantHeight, wantFps);
1179        if (found.first)
1180        {
1181            ListCapDeviceAvailable::displayCap(found.second,  prefixForMessage + " use ");
1182            capConfig->SetFormat(found.first);
1183        }
1184        capConfig->Release();
1185    }
1186
1187    hr = _graphBuilder->AddFilter(_videoCaptureDevice, L"Capture Source");
1188    if (!checkError(prefixForMessage, hr))
1189        return false;
1190
1191    IPin*           rnd  = 0;
1192    hr = FindPin(L"In", &rnd);
1193    if (!checkError(prefixForMessage, hr))
1194        return false;
1195
1196    hr = _graphBuilder->Connect(cap,rnd);
1197
1198    if (rnd) rnd->Release();
1199    if (cap) cap->Release();
1200
1201    bool result = checkError(prefixForMessage, hr);
1202    return result;
1203}
1204
1205
1206bool CTextureRenderer::openSoundCaptureDevice(const std::string& capture, int nbChannels)
1207{
1208    std::string prefixForMessage;
1209    {
1210    std::stringstream ss;
1211    ss << _imageStream.get();
1212    prefixForMessage = ss.str();
1213    }
1214
1215    HRESULT hr;
1216    ICreateDevEnum* devs = 0; hr = CoCreateInstance (CLSID_SystemDeviceEnum, 0, CLSCTX_INPROC, IID_ICreateDevEnum, (void **) &devs);
1217    if (!checkError(prefixForMessage, hr))
1218        return false;
1219
1220    IEnumMoniker*   captureDevices = 0; hr = devs?devs->CreateClassEnumerator (CLSID_AudioInputDeviceCategory, &captureDevices, 0):0;
1221    if (!checkError(prefixForMessage, hr))
1222        return false;
1223
1224    ListDeviceAvailable deviceFinder(captureDevices);
1225    {
1226    std::stringstream ss;
1227    ss << std::hex << _imageStream.get() << " capture sound ";
1228    deviceFinder.displayDevicesFound(ss.str(), osg::INFO);
1229    }
1230    ListDeviceAvailable::DeviceEntry device = deviceFinder.getDevice(capture);
1231
1232    if (!device._device)
1233    {
1234        OSG_WARN << _imageStream.get() << " no sound capture device \"" << capture << "\" found" << std::endl;
1235        return false;
1236    }
1237    _soundCaptureDeviceName = device._name;
1238    OSG_NOTICE << _imageStream.get() << " use sound capture device \"" << getSoundCaptureDeviceName() << "\"" << std::endl;
1239
1240    {
1241    std::stringstream ss;
1242    ss << _imageStream.get() << " \"" << getSoundCaptureDeviceName() << "\"";
1243    prefixForMessage = ss.str();
1244    }
1245
1246
1247    IMoniker* mon  = device._device;
1248
1249    hr = mon?mon->BindToObject(0,0,IID_IBaseFilter, (void**)&_soundCaptureDevice):0;
1250    if (FAILED(hr))
1251    {
1252        checkError(prefixForMessage, hr);
1253        return false;
1254    }
1255
1256    IAMStreamConfig* pISC = NULL;
1257    hr = FindPinInterface(_soundCaptureDevice, &MEDIATYPE_Audio, PINDIR_OUTPUT, IID_IAMStreamConfig, reinterpret_cast<void**>(&pISC));
1258    if (FAILED(hr))
1259    {
1260        checkError(prefixForMessage, hr);
1261        return false;
1262    }
1263    // loop through all the capabilities (audio formats) and populate the control
1264    int count, size;
1265    hr = pISC->GetNumberOfCapabilities(&count, &size);
1266    if (SUCCEEDED(hr))
1267    {
1268        if (sizeof(AUDIO_STREAM_CONFIG_CAPS) == size)
1269        {
1270            AM_MEDIA_TYPE* pmt = NULL;
1271            AUDIO_STREAM_CONFIG_CAPS ascc;
1272            WAVEFORMATEX* pwfex = NULL;
1273
1274            for (int index=0; index<count; ++index)
1275            {
1276                hr = pISC->GetStreamCaps(index, &pmt, reinterpret_cast<BYTE*>(&ascc));
1277                if (SUCCEEDED(hr))
1278                {
1279                    TCHAR buffer[32];
1280
1281                    ZeroMemory(buffer, sizeof(buffer));
1282
1283                    pwfex = (WAVEFORMATEX*)pmt->pbFormat;
1284
1285                    // provide a useful description of the formats
1286                    if (1 == pwfex->nChannels)
1287                    {
1288                        StringCbPrintf(buffer, sizeof(buffer), TEXT("%d channel, %2.1fkHz, %d-bit"), (int)pwfex->nChannels, (float)pwfex->nSamplesPerSec / 1000, (int)pwfex->wBitsPerSample);
1289                    }
1290                    else
1291                    {
1292                        StringCbPrintf(buffer, sizeof(buffer), TEXT("%d channels, %2.1fkHz, %d-bit"), (int)pwfex->nChannels, (float)pwfex->nSamplesPerSec / 1000, (int)pwfex->wBitsPerSample);
1293                    }
1294
1295                    // set default format
1296                    if (pwfex->nChannels == nbChannels)
1297                    {
1298                        pISC->SetFormat(pmt);
1299                        OSG_NOTICE << prefixForMessage << " use format " << buffer << std::endl;
1300                        break;
1301                    }
1302                    else
1303                    {
1304                        OSG_NOTICE << prefixForMessage << buffer << std::endl;
1305                    }
1306
1307                }
1308            }
1309        }
1310        else
1311        {
1312            OSG_WARN << prefixForMessage << " can t retrieve informations pins" << std::endl;
1313        }
1314    }
1315    if (pISC) pISC->Release(); pISC = 0;
1316    IPin* captureOutputDevicePinOut = 0; hr = _soundCaptureDevice? ::GetPin(_soundCaptureDevice,L"Capture",&captureOutputDevicePinOut) : 0;
1317    if (FAILED(hr)) {
1318        checkError(prefixForMessage, hr);
1319        return false;
1320    }
1321
1322    hr = _graphBuilder->AddFilter(_soundCaptureDevice, L"Sound Capture Source");
1323    if (FAILED(hr))
1324    {
1325        checkError(prefixForMessage, hr);
1326        return false;
1327    }
1328
1329    if (!setupOutputSoundDevice(devs))
1330    {
1331        devs->Release(); devs = 0;
1332        if (captureOutputDevicePinOut) captureOutputDevicePinOut->Release(); captureOutputDevicePinOut = 0;
1333        return false;
1334    }
1335    devs->Release(); devs = 0;
1336
1337    std::string prefixForMessageSound;
1338    {
1339    std::stringstream ss;
1340    ss << _imageStream.get() << " " << getSoundOutputDeviceName();
1341    prefixForMessageSound = ss.str();
1342    }
1343
1344    IPin* soundOutputDevicePinIn = 0;
1345    hr = _soundOutputDevice->FindPin(L"Audio Input pin (rendered)", &soundOutputDevicePinIn);
1346    if (FAILED(hr))
1347    {
1348        checkError(prefixForMessageSound, hr);
1349        if (soundOutputDevicePinIn)    soundOutputDevicePinIn->Release(); soundOutputDevicePinIn = 0;
1350        if (captureOutputDevicePinOut) captureOutputDevicePinOut->Release(); captureOutputDevicePinOut = 0;
1351        return false;
1352    }
1353
1354    hr = _graphBuilder->Connect(captureOutputDevicePinOut, soundOutputDevicePinIn);
1355
1356    if (soundOutputDevicePinIn)    soundOutputDevicePinIn->Release(); soundOutputDevicePinIn = 0;
1357    if (captureOutputDevicePinOut) captureOutputDevicePinOut->Release(); captureOutputDevicePinOut = 0;
1358
1359    if (FAILED(hr))
1360    {
1361        checkError(prefixForMessageSound, hr);
1362        return false;
1363    }
1364
1365    return true;
1366}
1367
1368
1369bool CTextureRenderer::openCaptureDevices(const DirectShowImageStream::Options& o)
1370{
1371    std::string prefixForMessage;
1372    {
1373    std::stringstream ss;
1374    ss << _imageStream.get();
1375    prefixForMessage = ss.str();
1376    }
1377
1378    DirectShowImageStream::Options options = o;
1379    syncStreams(false);
1380
1381    for (DirectShowImageStream::Options::iterator it = options.begin(); it != options.end(); it++)
1382    {
1383        OSG_NOTICE << prefixForMessage << " option " << it->first << " = " << it->second << std::endl;
1384    }
1385
1386    std::string soundCaptureDevice = options["captureSoundDevice"];
1387    std::string videoCaptureDevice = options["captureVideoDevice"];
1388
1389    OSG_NOTICE << prefixForMessage << " try to open video capture device " << videoCaptureDevice;
1390    if (!soundCaptureDevice .empty())
1391    {
1392        OSG_NOTICE << " and sound capture device " << soundCaptureDevice ;
1393    }
1394
1395    OSG_NOTICE << std::endl;
1396
1397    if (!initBuildGraph())
1398        return false;
1399
1400    int wantWidth = atoi(options["captureWantedWidth"].c_str());
1401    int wantHeight = atoi(options["captureWantedHeight"].c_str());
1402    float wantFps = atof(options["captureWantedFps"].c_str());
1403    if (!openVideoCaptureDevice(videoCaptureDevice, wantWidth, wantHeight, wantFps))
1404        return false;
1405
1406    if (!soundCaptureDevice.empty() && !openSoundCaptureDevice(soundCaptureDevice ))
1407    {
1408        OSG_WARN << prefixForMessage << " failed to setup sound capture device " << soundCaptureDevice  << std::endl;
1409    }
1410    return true;
1411}
1412
1413
1414bool CTextureRenderer::openFile(const std::string& file)
1415{
1416    syncStreams(true);
1417    WCHAR wFileName[MAX_PATH];
1418    wFileName[MAX_PATH-1] = 0;    // NULL-terminate
1419    if (file.empty())
1420        return false;
1421
1422    _filename = file;
1423    std::string prefixForMessage;
1424    {
1425    std::stringstream ss;
1426    ss << _imageStream.get() << " " << getFilename();
1427    prefixForMessage = ss.str();
1428    }
1429
1430    const char *ansistr = file.c_str();
1431    int lenA = lstrlenA(ansistr);
1432    int lenW;
1433    BSTR unicodestr = 0;
1434
1435    lenW = ::MultiByteToWideChar(CP_ACP, 0, ansistr, lenA, 0, 0);
1436    if (lenW > 0)
1437    {
1438      // Check whether conversion was successful
1439      unicodestr = ::SysAllocStringLen(0, lenW);
1440      ::MultiByteToWideChar(CP_ACP, 0, ansistr, lenA, unicodestr, lenW);
1441    }
1442
1443    if (unicodestr!=0)
1444    {
1445        (void)StringCchCopyW(wFileName, NUMELMS(wFileName), unicodestr);
1446
1447        // when done, free the BSTR
1448        ::SysFreeString(unicodestr);
1449    }
1450
1451    HRESULT hr;
1452    if (!initBuildGraph())
1453        return false;
1454
1455    IPin* videoOutputPin = 0;
1456
1457    std::string lowercase = file;
1458    std::transform(lowercase.begin(), lowercase.end(), lowercase.begin(), tolower);
1459
1460    hr = _graphBuilder->AddSourceFilter(wFileName, L"Source", &_fileSource);
1461    if (!checkError(prefixForMessage, hr))
1462        return false;
1463
1464    //Find the video pin
1465    hr = _fileSource? ::GetPin(_fileSource, &MEDIATYPE_Video, PINDIR_OUTPUT, &videoOutputPin):0;
1466
1467    if (!checkError(prefixForMessage, hr))
1468        return false;
1469
1470    IPin*           rnd  = 0;
1471    hr = FindPin(L"In", &rnd);
1472    if (!checkError(prefixForMessage, hr))
1473        return false;
1474
1475    hr = _graphBuilder->Connect(videoOutputPin, rnd);
1476    if (videoOutputPin) videoOutputPin->Release(); videoOutputPin = 0;
1477
1478    if (rnd) rnd->Release(); rnd = 0;
1479    if (!checkError(prefixForMessage, hr))
1480        return false;
1481
1482    // check if we find the sounds output pin on the streams
1483    IBaseFilter* soundFilter;
1484    hr = _graphBuilder->FindFilterByName(L"AVI Splitter", &soundFilter);
1485    if (FAILED(hr))
1486    {
1487        //Could not find the AVI Splitter filter, try the main source itself
1488        soundFilter = _fileSource;
1489    }
1490
1491    if (soundFilter)
1492    {
1493        IPin* soundStreamPinOut = 0;
1494        //Try to find the audio pin
1495        hr = ::GetPin(soundFilter, &MEDIATYPE_Audio, PINDIR_OUTPUT, &soundStreamPinOut);
1496        if (soundFilter != _fileSource) soundFilter->Release();
1497        soundFilter = 0;
1498
1499        if (FAILED(hr))
1500        {
1501            OSG_WARN << prefixForMessage << " can't find audio pin" << getErrorMessage(hr) << std::endl;
1502        }
1503
1504        if (soundStreamPinOut)
1505        {
1506            // connect sounds to graph
1507            ICreateDevEnum* devs = 0; hr = CoCreateInstance (CLSID_SystemDeviceEnum, 0, CLSCTX_INPROC, IID_ICreateDevEnum, (void **) &devs);
1508            checkError(prefixForMessage, hr);
1509            if (devs && setupOutputSoundDevice(devs))
1510            {
1511                devs->Release(); devs = 0;
1512                std::string prefixForMessageSound;
1513                {
1514                std::stringstream ss;
1515                ss << _imageStream.get() << " " << getSoundOutputDeviceName();
1516                prefixForMessageSound = ss.str();
1517                }
1518
1519                IPin* soundOutputDevicePinIn = 0;
1520                hr = _soundOutputDevice->FindPin(L"Audio Input pin (rendered)", &soundOutputDevicePinIn);
1521                checkError(prefixForMessageSound, hr);
1522
1523                hr = _graphBuilder->Connect(soundStreamPinOut, soundOutputDevicePinIn);
1524
1525                if (soundOutputDevicePinIn)    soundOutputDevicePinIn->Release(); soundOutputDevicePinIn = 0;
1526                if (soundStreamPinOut) soundStreamPinOut->Release(); soundStreamPinOut = 0;
1527
1528                if (!checkError(prefixForMessageSound, hr) && _soundOutputDevice)
1529                {
1530                    _graphBuilder->RemoveFilter(_soundOutputDevice);
1531                    _soundOutputDevice->Release(); _soundOutputDevice = 0;
1532                }
1533            }
1534        }
1535    }
1536
1537    return true;
1538}
1539
1540
1541
1542//-----------------------------------------------------------------------------
1543// CleanupDShow
1544//-----------------------------------------------------------------------------
1545void CTextureRenderer::releaseRessources()
1546{
1547    // Shut down the graph
1548    if (_mediaControl) _mediaControl->Stop();
1549    _imageStream = 0;
1550
1551    if (_mediaControl) _mediaControl->Release(); _mediaControl = 0;
1552    if (_mediaEvent) _mediaEvent->Release(); _mediaEvent = 0;
1553    if (_mediaSeeking) _mediaSeeking->Release(); _mediaSeeking = 0;
1554    if (_basicAudio) _basicAudio->Release(); _basicAudio = 0;
1555    // remove filter outside because this is a filter too.
1556}
1557
1558
1559//-----------------------------------------------------------------------------
1560// CTextureRenderer constructor
1561//-----------------------------------------------------------------------------
1562
1563CTextureRenderer::CTextureRenderer( DirectShowImageStream* is, HRESULT* valid)
1564    : CBaseVideoRenderer(__uuidof(CLSID_TextureRenderer),
1565                         NAME("Texture Renderer"),
1566                         NULL,
1567                         valid)
1568{
1569    std::string prefixForMessage;
1570    {
1571    std::stringstream ss;
1572    ss << is;
1573    prefixForMessage = ss.str();
1574    }
1575
1576    if (FAILED(*valid))
1577        checkError(prefixForMessage, *valid);
1578
1579    _imageStream = is;
1580    _fileSource = 0;
1581    _mediaControl = 0;
1582    _mediaEvent = 0;
1583    _mediaSeeking = 0;
1584    _graphBuilder = 0;
1585    _videoCaptureDevice = 0;
1586    _soundOutputDevice = 0;
1587    _soundCaptureDevice = 0;
1588    _basicAudio = 0;
1589}
1590
1591
1592//-----------------------------------------------------------------------------
1593// CTextureRenderer destructor
1594//-----------------------------------------------------------------------------
1595CTextureRenderer::~CTextureRenderer()
1596{
1597}
1598
1599
1600//-----------------------------------------------------------------------------
1601// CheckMediaType: This method forces the graph to give us an R8G8B8 video
1602// type, making our copy to texture memory trivial.
1603//-----------------------------------------------------------------------------
1604HRESULT CTextureRenderer::CheckMediaType(const CMediaType *pmt)
1605{
1606    HRESULT   hr = E_FAIL;
1607    VIDEOINFO *pvi=0;
1608
1609    CheckPointer(pmt,E_POINTER);
1610
1611    // Reject the connection if this is not a video type
1612    if( *pmt->FormatType() != FORMAT_VideoInfo ) {
1613        return E_INVALIDARG;
1614    }
1615
1616    // Only accept RGB24 video
1617    pvi = (VIDEOINFO *)pmt->Format();
1618
1619    if (!IsEqualGUID( *pmt->Type(),    MEDIATYPE_Video))
1620    {
1621        OSG_WARN << _imageStream.get() << " media type not a video format" << std::endl;
1622    }
1623
1624    if( IsEqualGUID( *pmt->Subtype(), MEDIASUBTYPE_RGB24))
1625    {
1626        OSG_NOTICE << _imageStream.get() << " Texture Renderer use media " << getStringFromGUID(pmt->Subtype()) << std::endl;
1627        hr = S_OK;
1628    }
1629    else
1630    {
1631        OSG_INFO << _imageStream.get() << " Texture Renderer check media " << getStringFromGUID(pmt->Subtype()) << std::endl;
1632    }
1633
1634    return hr;
1635}
1636
1637//-----------------------------------------------------------------------------
1638// SetMediaType: Graph connection has been made.
1639//-----------------------------------------------------------------------------
1640HRESULT CTextureRenderer::SetMediaType(const CMediaType *pmt)
1641{
1642    // Retrive the size of this media type
1643    VIDEOINFO *pviBmp;                      // Bitmap info header
1644    pviBmp = (VIDEOINFO *)pmt->Format();
1645
1646    _width  = pviBmp->bmiHeader.biWidth;
1647    _height = abs(pviBmp->bmiHeader.biHeight);
1648    _pitch  = (_width * 3 + 3) & ~(3); // We are forcing RGB24
1649    _imageStream->setImage(_width, _height, 1, GL_RGB, GL_BGR, GL_UNSIGNED_BYTE, 0, osg::Image::NO_DELETE);
1650    return S_OK;
1651}
1652
1653//-----------------------------------------------------------------------------
1654// DoRenderSample: A sample has been delivered. Copy it to the texture.
1655//-----------------------------------------------------------------------------
1656HRESULT CTextureRenderer::DoRenderSample( IMediaSample * pSample )
1657{
1658    BYTE  *pBmpBuffer; // Bitmap buffer, texture buffer
1659    CheckPointer(pSample,E_POINTER);
1660
1661    // Get the video bitmap buffer
1662    pSample->GetPointer( &pBmpBuffer );
1663    if (_imageStream.valid())
1664        _imageStream->setImage(_width, _height, 1, GL_RGB, GL_BGR, GL_UNSIGNED_BYTE, pBmpBuffer, osg::Image::NO_DELETE);
1665    return S_OK;
1666}
1667
1668void CTextureRenderer::syncStreams(bool state)
1669{
1670    if (state == true)
1671        _dropFrame = !S_OK;
1672    else
1673        _dropFrame = S_OK;
1674}
1675HRESULT CTextureRenderer::ShouldDrawSampleNow(IMediaSample *sample, REFERENCE_TIME *start, REFERENCE_TIME *stop) {
1676    return _dropFrame; // disable droping of frames
1677}
1678
1679bool CTextureRenderer::StopFilters()
1680{
1681    HRESULT hr;
1682    if (_mediaControl)
1683    {
1684        hr = _mediaControl->Stop();
1685        if (FAILED(hr))
1686        {
1687            OSG_WARN << _imageStream.get() << " " << getErrorMessage(hr) << std::endl;
1688            return false;
1689        }
1690    }
1691    return true;
1692}
1693
1694DirectShowImageStream::DirectShowImageStream()
1695{
1696    _options["captureWantedWidth"] = "1920";
1697    _options["captureWantedHeight"] = "1080";
1698    _options["captureWantedFps"] = "30";
1699
1700    HRESULT hr = CoInitialize (NULL);
1701    if (FAILED(hr))
1702    {
1703        OSG_WARN << this << " error in constructor " << getErrorMessage(hr) << std::endl;
1704    }
1705
1706}
1707DirectShowImageStream::DirectShowImageStream(const DirectShowImageStream& d,const osg::CopyOp& c) : osg::ImageStream(d, c)
1708{
1709    // i guess it's invalid
1710}
1711
1712DirectShowImageStream::~DirectShowImageStream()
1713{
1714    stop();
1715    CoUninitialize();
1716}
1717
1718bool DirectShowImageStream::openFile(const std::string& file)
1719{
1720    HRESULT valid = S_OK;
1721    _renderer = new CTextureRenderer(this, &valid);
1722    if (FAILED(valid))
1723    {
1724        return false;
1725    }
1726    if (!_renderer->openFile(file))
1727    {
1728        return false;
1729    }
1730    return true;
1731}
1732
1733bool DirectShowImageStream::openCaptureDevices()
1734{
1735    HRESULT valid = S_OK;
1736    _renderer = new CTextureRenderer(this, &valid);
1737    if (FAILED(valid))
1738    {
1739        return false;
1740    }
1741    if (!_renderer->openCaptureDevices(_options))
1742    {
1743        return false;
1744    }
1745
1746    return true;
1747}
1748
1749
1750
1751void DirectShowImageStream::play()
1752{
1753    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1754    if (_status == PLAYING)
1755        return;
1756
1757    if (_renderer.valid() && _renderer->_mediaControl)
1758    {
1759        HRESULT hr;
1760        hr = _renderer->_mediaControl->Run();
1761        // Start the graph running;
1762        if (FAILED(hr))
1763        {
1764            OSG_WARN << this << " can't run the graph " <<  getErrorMessage(hr) <<  std::endl;
1765        }
1766        else
1767        {
1768            _status = PLAYING;
1769        }
1770    }
1771}
1772
1773void DirectShowImageStream::pause()
1774{
1775    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1776    if (_status == PAUSED)
1777        return;
1778
1779    if (_renderer.valid() && _renderer->_mediaControl)
1780    {
1781        HRESULT hr;
1782        hr = _renderer->_mediaControl->Pause();
1783        if (FAILED(hr))
1784        {
1785            OSG_NOTICE << this << " " << getErrorMessage(hr) << std::endl;
1786        }
1787        else
1788        {
1789            _status = PAUSED;
1790        }
1791    }
1792}
1793
1794void DirectShowImageStream::rewind()
1795{
1796    seek(0);
1797}
1798
1799osg::ImageStream::StreamStatus DirectShowImageStream::getStatus()
1800{
1801    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1802    return _status;
1803}
1804
1805void DirectShowImageStream::seek(double time)
1806{
1807    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1808    if (_renderer.valid() && _renderer->_mediaSeeking)
1809    {
1810        double start = time / (100 * 1e-9);
1811        LONGLONG start2 = static_cast<LONGLONG>(start);
1812        HRESULT hr = _renderer->_mediaSeeking->SetPositions(&start2,AM_SEEKING_AbsolutePositioning, NULL, AM_SEEKING_NoPositioning);
1813        if (FAILED(hr))
1814        {
1815            OSG_NOTICE << this << " " << getErrorMessage(hr) << std::endl;
1816        }
1817    }
1818
1819}
1820
1821double DirectShowImageStream::getCurrentTime() const
1822{
1823    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1824    double currentTime = -1;
1825    if (_renderer.valid() && _renderer->_mediaSeeking)
1826    {
1827
1828       LONGLONG curTimeLL = 0;
1829       HRESULT hr = _renderer->_mediaSeeking->GetCurrentPosition(&curTimeLL);
1830       if (FAILED(hr))
1831       {
1832            OSG_NOTICE << this << " " << getErrorMessage(hr) << std::endl;
1833       }
1834       else
1835       {
1836           currentTime = static_cast<double>(curTimeLL);
1837           currentTime = currentTime * (100.0 * 1e-9); // default unit in directshow IMediaSeeking
1838       }
1839    }
1840    return currentTime;
1841}
1842
1843void DirectShowImageStream::setOptions(const Options& map)
1844{
1845    for (Options::const_iterator it = map.begin(); it != map.end(); it++)
1846        _options[it->first] = it->second;
1847}
1848
1849void DirectShowImageStream::quit(bool waitForThreadToExit)
1850{
1851    stop();
1852}
1853
1854double DirectShowImageStream::getLength() const
1855{
1856    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1857    double duration = 0;
1858    if (_renderer.valid() && _renderer->_mediaSeeking)
1859    {
1860        LONGLONG d = 0;
1861        _renderer->_mediaSeeking->GetDuration(&d);
1862        duration = static_cast<double>(d);
1863        duration = duration * (100.0 * 1e-9); // default unit in directshow IMediaSeeking
1864    }
1865    return duration;
1866}
1867
1868double DirectShowImageStream::getFrameRate() const
1869{
1870    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1871    int frameRate = 0;
1872    if (_renderer.valid())
1873        _renderer->get_AvgFrameRate(&frameRate);
1874    return static_cast<double>(frameRate) * 1e-2;
1875}
1876
1877void DirectShowImageStream::setTimeMultiplier(double rate)
1878{
1879    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1880    if (_renderer.valid() && _renderer->_mediaSeeking)
1881        _renderer->_mediaSeeking->SetRate(rate);
1882}
1883
1884double DirectShowImageStream::getTimeMultiplier() const
1885{
1886    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1887    double rate = 1.0;
1888    if (_renderer.valid() && _renderer->_mediaSeeking)
1889        _renderer->_mediaSeeking->GetRate(&rate);
1890    return rate;
1891}
1892
1893void DirectShowImageStream::setVolume(float vol) {
1894   OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1895   if (_renderer.valid() && _renderer->_basicAudio)
1896   {
1897     _renderer->_basicAudio->put_Volume(vol);
1898   }
1899}
1900
1901float DirectShowImageStream::getVolume() const {
1902  OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1903  double vol = 0;
1904  if (_renderer.valid() && _renderer->_basicAudio)
1905  {
1906    long d = 0;
1907    _renderer->_basicAudio->get_Volume(&d);
1908    vol = static_cast<double>(d);
1909  }
1910  return vol;
1911}
1912
1913void DirectShowImageStream::stop()
1914{
1915    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_mutex);
1916    if (!_renderer.valid())
1917        return;
1918
1919    if (!_renderer->StopFilters())
1920    {
1921        OSG_WARN << this << " cant stop filters" << std::endl;
1922    }
1923
1924    _renderer->releaseRessources();
1925    // Enumerate the filters in the graph.
1926    IEnumFilters *pEnum = NULL;
1927    IGraphBuilder* gb = _renderer->getGraphBuilder();
1928    if (!gb)
1929        return;
1930    HRESULT hr = gb->EnumFilters(&pEnum);
1931    if (SUCCEEDED(hr))
1932    {
1933        IBaseFilter *pFilter = NULL;
1934        while (S_OK == pEnum->Next(1, &pFilter, NULL))
1935         {
1936             // Remove the filter.
1937             gb->RemoveFilter(pFilter);
1938             // Reset the enumerator.
1939             pEnum->Reset();
1940             pFilter->Release();
1941        }
1942        pEnum->Release();
1943    }
1944    if (gb) gb->Release(); gb = 0;
1945    _renderer = 0;
1946}
Note: See TracBrowser for help on using the browser.