?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented MJPG handler.
[wine/multimedia.git] / dlls / quartz / mpgparse.c
blob98f1e4e96390bcd4e707c683e8b0f0b535c1cb55
1 /*
2 * Implements MPEG-1 / MPEG-2 Parser(Splitter).
3 *
4 * FIXME - no splitter implementation.
5 * FIXME - no packet support (implemented payload only)
6 * FIXME - no seeking
7 *
8 * Copyright (C) 2002 Hidenori TAKESHIMA <hidenori@a2.ctktv.ne.jp>
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library 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 GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24
25 #include "config.h"
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "mmsystem.h"
32 #include "vfw.h"
33 #include "winerror.h"
34 #include "strmif.h"
35 #include "control.h"
36 #include "vfwmsgs.h"
37 #include "amvideo.h"
38 #include "mmreg.h"
39 #include "uuids.h"
40 #include "dvdmedia.h"
41
42 #include "wine/debug.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
44
45 #include "quartz_private.h"
46 #include "parser.h"
47 #include "mtype.h"
48
49 static const WCHAR QUARTZ_MPEG1Parser_Name[] =
50 { 'M','P','E','G','-','I',' ','S','p','l','i','t','t','e','r',0 };
51 static const WCHAR QUARTZ_MPEG2Parser_Name[] =
52 { 'M','P','E','G','-','2',' ','S','p','l','i','t','t','e','r',0 };
53 static const WCHAR QUARTZ_MPGParserInPin_Name[] =
54 { 'I','n',0 };
55 static const WCHAR QUARTZ_MPGParserOutPin_VideoPinName[] =
56 { 'V','i','d','e','o',0 };
57 static const WCHAR QUARTZ_MPGParserOutPin_AudioPinName[] =
58 { 'A','u','d','i','o',0 };
59 /* FIXME */
60 static const WCHAR QUARTZ_MPGParserOutPin_UnknownTypePinName[] =
61 { 'O','u','t',0 };
62
63
64
65 static DWORD bitratesl1[16] =
66 { 0, 32, 64, 96,128,160,192,224,256,288,320,352,384,416,448, 0};
67 static DWORD bitratesl2[16] =
68 { 0, 32, 48, 56, 64, 80, 96,112,128,160,192,224,256,320,384, 0};
69 static DWORD bitratesl3[16] =
70 { 0, 32, 40, 48, 56, 64, 80, 96,112,128,160,192,224,256,320, 0};
71
72
73 /****************************************************************************
74 *
75 * CMPGParseImpl
76 */
77
78
79 typedef struct CMPGParseImpl CMPGParseImpl;
80 typedef struct CMPGParsePayload CMPGParsePayload;
81
82 enum MPGPayloadType
83 {
84 MPGPayload_Video = 0xe0,
85 MPGPayload_Audio = 0xc0,
86 };
87
88 struct CMPGParseImpl
89 {
90 LONGLONG llPosNext;
91 BOOL bRawPayload;
92 DWORD dwPayloadBlockSizeMax;
93 DWORD cPayloads;
94 CMPGParsePayload* pPayloads;
95 };
96
97 struct CMPGParsePayload
98 {
99 enum MPGPayloadType payloadtype;
100 BOOL bDataDiscontinuity;
101 };
102
103 static HRESULT CMPGParseImpl_GetStreamType( CParserImpl* pImpl, ULONG nStreamIndex, AM_MEDIA_TYPE* pmt );
104
105 static HRESULT CMPGParseImpl_SyncReadPayload(
106 CParserImpl* pImpl, CMPGParseImpl* This,
107 enum MPGPayloadType payloadtype,
108 LONGLONG llPosStart, LONG lLength, BYTE* pbBuf )
109 {
110 if ( This == NULL || This->pPayloads == NULL )
111 return E_UNEXPECTED;
112
113 if ( This->bRawPayload )
114 {
115 if ( payloadtype != This->pPayloads[0].payloadtype )
116 return E_UNEXPECTED;
117 return IAsyncReader_SyncRead( pImpl->m_pReader, llPosStart, lLength, pbBuf );
118 }
119 else
120 {
121 FIXME( "not implemented\n" );
122 }
123
124 return E_NOTIMPL;
125 }
126
127
128
129 static HRESULT CMPGParseImpl_InitParser( CParserImpl* pImpl, ULONG* pcStreams )
130 {
131 CMPGParseImpl* This = NULL;
132 HRESULT hr;
133 DWORD n;
134 AM_MEDIA_TYPE mt;
135 BYTE hdrbuf[8];
136
137 TRACE("(%p,%p)\n",pImpl,pcStreams);
138
139 This = (CMPGParseImpl*)QUARTZ_AllocMem( sizeof(CMPGParseImpl) );
140 if ( This == NULL )
141 return E_OUTOFMEMORY;
142 pImpl->m_pUserData = This;
143 ZeroMemory( This, sizeof(CMPGParseImpl) );
144
145 hr = IAsyncReader_SyncRead( pImpl->m_pReader, 0, 8, hdrbuf );
146 if ( FAILED(hr) )
147 return hr;
148 if ( hr != S_OK )
149 return E_FAIL;
150
151 if ( hdrbuf[0] == 0x00 && hdrbuf[1] == 0x00 &&
152 hdrbuf[2] == 0x01 && hdrbuf[3] == 0xba )
153 {
154 This->bRawPayload = FALSE;
155 This->dwPayloadBlockSizeMax = 0;
156
157 FIXME( "no mpeg/system support\n" );
158 return E_FAIL;
159 }
160 else
161 if ( hdrbuf[0] == 0x00 && hdrbuf[1] == 0x00 &&
162 hdrbuf[2] == 0x01 && hdrbuf[3] == 0xb3 )
163 {
164 TRACE( "mpeg/video payload\n" );
165 This->llPosNext = 0;
166 This->bRawPayload = TRUE;
167 This->dwPayloadBlockSizeMax = 0x4000;
168 This->cPayloads = 1;
169 This->pPayloads = (CMPGParsePayload*)QUARTZ_AllocMem( sizeof(CMPGParsePayload) );
170 if ( This->pPayloads == NULL )
171 return E_OUTOFMEMORY;
172 *pcStreams = 1;
173 This->pPayloads[0].payloadtype = MPGPayload_Video;
174 This->pPayloads[0].bDataDiscontinuity = TRUE;
175 }
176 else
177 if ( hdrbuf[0] == 0xff && (hdrbuf[1]&0xf0) == 0xf0 )
178 {
179 TRACE( "mpeg/audio payload\n" );
180 This->llPosNext = 0;
181 This->bRawPayload = TRUE;
182 This->dwPayloadBlockSizeMax = 0;
183 This->cPayloads = 1;
184 This->pPayloads = (CMPGParsePayload*)QUARTZ_AllocMem( sizeof(CMPGParsePayload) );
185 if ( This->pPayloads == NULL )
186 return E_OUTOFMEMORY;
187 *pcStreams = 1;
188 This->pPayloads[0].payloadtype = MPGPayload_Audio;
189 This->pPayloads[0].bDataDiscontinuity = TRUE;
190 }
191 else
192 {
193 return E_FAIL;
194 }
195
196 /* To determine block size, scan all payloads. */
197 ZeroMemory( &mt, sizeof(mt) );
198 for ( n = 0; n < This->cPayloads; n++ )
199 {
200 CMPGParseImpl_GetStreamType(pImpl,n,&mt);
201 QUARTZ_MediaType_Free(&mt);
202 }
203
204 return S_OK;
205 }
206
207 static HRESULT CMPGParseImpl_UninitParser( CParserImpl* pImpl )
208 {
209 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
210 ULONG nIndex;
211
212 TRACE("(%p)\n",This);
213
214 if ( This == NULL )
215 return NOERROR;
216
217 /* destruct */
218
219 if ( This->pPayloads != NULL )
220 {
221 for ( nIndex = 0; nIndex < This->cPayloads; nIndex++ )
222 {
223 /* release this stream */
224
225
226 }
227 QUARTZ_FreeMem( This->pPayloads );
228 This->pPayloads = NULL;
229 }
230
231 QUARTZ_FreeMem( This );
232 pImpl->m_pUserData = NULL;
233
234 return NOERROR;
235 }
236
237 static LPCWSTR CMPGParseImpl_GetOutPinName( CParserImpl* pImpl, ULONG nStreamIndex )
238 {
239 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
240
241 TRACE("(%p,%lu)\n",This,nStreamIndex);
242
243 if ( This == NULL || nStreamIndex >= This->cPayloads )
244 return NULL;
245
246 switch ( This->pPayloads[nStreamIndex].payloadtype )
247 {
248 case MPGPayload_Video:
249 return QUARTZ_MPGParserOutPin_VideoPinName;
250 case MPGPayload_Audio:
251 return QUARTZ_MPGParserOutPin_AudioPinName;
252 default:
253 FIXME("mpeg - unknown stream type %02x\n",This->pPayloads[nStreamIndex].payloadtype);
254 }
255
256 /* FIXME */
257 return QUARTZ_MPGParserOutPin_UnknownTypePinName;
258 }
259
260 static HRESULT CMPGParseImpl_GetStreamType( CParserImpl* pImpl, ULONG nStreamIndex, AM_MEDIA_TYPE* pmt )
261 {
262 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
263 HRESULT hr;
264 BYTE hdrbuf[140+10];
265 UINT seqhdrlen;
266 MPEG1VIDEOINFO* pmpg1vi;
267 MPEG2VIDEOINFO* pmpg2vi;
268 MPEG1WAVEFORMAT* pmpg1wav;
269 enum MPGPayloadType payloadtype;
270 DWORD dwPayloadBlockSize;
271
272 TRACE("(%p,%lu,%p)\n",This,nStreamIndex,pmt);
273
274 if ( This == NULL )
275 return E_UNEXPECTED;
276 if ( nStreamIndex >= This->cPayloads )
277 return E_INVALIDARG;
278
279 ZeroMemory( pmt, sizeof(AM_MEDIA_TYPE) );
280
281 payloadtype = This->pPayloads[nStreamIndex].payloadtype;
282 switch ( payloadtype )
283 {
284 case MPGPayload_Video:
285 hr = CMPGParseImpl_SyncReadPayload(
286 pImpl, This, payloadtype, 0, 140+10, hdrbuf );
287 if ( FAILED(hr) )
288 return hr;
289 if ( hr != S_OK )
290 return E_FAIL;
291
292 memcpy( &pmt->majortype, &MEDIATYPE_Video, sizeof(GUID) );
293 seqhdrlen = 12;
294 if ( hdrbuf[seqhdrlen-1] & 0x2 )
295 seqhdrlen += 64;
296 if ( hdrbuf[seqhdrlen-1] & 0x1 )
297 seqhdrlen += 64;
298 if ( hdrbuf[seqhdrlen ] == 0x00 && hdrbuf[seqhdrlen+1] == 0x00 &&
299 hdrbuf[seqhdrlen+2] == 0x01 && hdrbuf[seqhdrlen+3] == 0xb5 )
300 {
301 /* video MPEG-2 */
302 FIXME("video MPEG-2\n");
303 if ( (hdrbuf[seqhdrlen+4]&0xf0) != 0x1 )
304 return E_FAIL;
305 memcpy( &pmt->subtype, &MEDIASUBTYPE_MPEG2_VIDEO, sizeof(GUID) );
306 memcpy( &pmt->formattype, &FORMAT_MPEG2_VIDEO, sizeof(GUID) );
307 pmt->bFixedSizeSamples = 0;
308 pmt->bTemporalCompression = 1;
309 pmt->lSampleSize = 0;
310 pmt->cbFormat = sizeof(MPEG2VIDEOINFO);
311 pmt->pbFormat = (BYTE*)CoTaskMemAlloc( sizeof(MPEG2VIDEOINFO) );
312 if ( pmt->pbFormat == NULL )
313 return E_OUTOFMEMORY;
314 ZeroMemory( pmt->pbFormat, sizeof(MPEG2VIDEOINFO) );
315 pmpg2vi = (MPEG2VIDEOINFO*)pmt->pbFormat;
316 pmpg2vi->hdr.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
317 pmpg2vi->hdr.bmiHeader.biWidth = ((UINT)hdrbuf[4] << 4) | ((UINT)hdrbuf[5] >> 4); /* FIXME! */
318 pmpg2vi->hdr.bmiHeader.biHeight = (((UINT)hdrbuf[5] & 0xf) << 8) | ((UINT)hdrbuf[6]); /* FIXME! */
319 pmpg2vi->hdr.dwInterlaceFlags = AMINTERLACE_FieldPatBothRegular; /* FIXME? */
320 pmpg2vi->hdr.dwCopyProtectFlags = AMCOPYPROTECT_RestrictDuplication; /* FIXME? */
321 pmpg2vi->hdr.dwPictAspectRatioX = 1; /* FIXME? */
322 pmpg2vi->hdr.dwPictAspectRatioY = 1; /* FIXME? */
323 pmpg2vi->dwStartTimeCode = 0;
324 pmpg2vi->cbSequenceHeader = seqhdrlen + 10;
325 switch ( hdrbuf[seqhdrlen+4] & 0xf )
326 {
327 case 5: pmpg2vi->dwProfile = AM_MPEG2Profile_Simple; break;
328 case 4: pmpg2vi->dwProfile = AM_MPEG2Profile_Main; break;
329 case 3: pmpg2vi->dwProfile = AM_MPEG2Profile_SNRScalable; break;
330 case 2: pmpg2vi->dwProfile = AM_MPEG2Profile_SpatiallyScalable; break;
331 case 1: pmpg2vi->dwProfile = AM_MPEG2Profile_High; break;
332 default: return E_FAIL;
333 }
334 switch ( hdrbuf[seqhdrlen+5] >> 4 )
335 {
336 case 10: pmpg2vi->dwLevel = AM_MPEG2Level_Low; break;
337 case 8: pmpg2vi->dwLevel = AM_MPEG2Level_Main; break;
338 case 6: pmpg2vi->dwLevel = AM_MPEG2Level_High1440; break;
339 case 4: pmpg2vi->dwLevel = AM_MPEG2Level_High; break;
340 default: return E_FAIL;
341 }
342 pmpg2vi->dwFlags = 0; /* FIXME? */
343 memcpy( pmpg2vi->dwSequenceHeader, hdrbuf, seqhdrlen + 10 );
344
345 return S_OK;
346 }
347 else
348 {
349 /* MPEG-1 */
350 memcpy( &pmt->subtype, &MEDIASUBTYPE_MPEG1Payload, sizeof(GUID) );
351 memcpy( &pmt->formattype, &FORMAT_MPEGVideo, sizeof(GUID) );
352 pmt->bFixedSizeSamples = 0;
353 pmt->bTemporalCompression = 1;
354 pmt->lSampleSize = 0;
355 pmt->cbFormat = sizeof(MPEG1VIDEOINFO);
356 pmt->pbFormat = (BYTE*)CoTaskMemAlloc( sizeof(MPEG1VIDEOINFO) );
357 if ( pmt->pbFormat == NULL )
358 return E_OUTOFMEMORY;
359 ZeroMemory( pmt->pbFormat, sizeof(MPEG1VIDEOINFO) );
360 pmpg1vi = (MPEG1VIDEOINFO*)pmt->pbFormat;
361 pmpg1vi->hdr.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
362 pmpg1vi->hdr.bmiHeader.biWidth = ((UINT)hdrbuf[4] << 4) | ((UINT)hdrbuf[5] >> 4);
363 pmpg1vi->hdr.bmiHeader.biHeight = (((UINT)hdrbuf[5] & 0xf) << 8) | ((UINT)hdrbuf[6]);
364 pmpg1vi->hdr.bmiHeader.biPlanes = 1;
365 pmpg1vi->dwStartTimeCode = 0;
366 pmpg1vi->cbSequenceHeader = seqhdrlen;
367 memcpy( pmpg1vi->bSequenceHeader, hdrbuf, seqhdrlen );
368 }
369
370 return S_OK;
371 case MPGPayload_Audio:
372 hr = CMPGParseImpl_SyncReadPayload(
373 pImpl, This, payloadtype, 0, 4, hdrbuf );
374 if ( FAILED(hr) )
375 return hr;
376 if ( hr != S_OK )
377 return E_FAIL;
378
379 memcpy( &pmt->majortype, &MEDIATYPE_Audio, sizeof(GUID) );
380 memcpy( &pmt->formattype, &FORMAT_WaveFormatEx, sizeof(GUID) );
381
382 if ( !( hdrbuf[1] & 0x8 ) )
383 {
384 /* FIXME!!! */
385 FIXME("audio not MPEG-1\n");
386 return E_FAIL;
387 }
388 else
389 {
390 /* MPEG-1 */
391 memcpy( &pmt->subtype, &MEDIASUBTYPE_MPEG1AudioPayload, sizeof(GUID) );
392 pmt->bFixedSizeSamples = 0;
393 pmt->bTemporalCompression = 1;
394 pmt->lSampleSize = 0;
395 pmt->cbFormat = sizeof(MPEG1WAVEFORMAT);
396 pmt->pbFormat = (BYTE*)CoTaskMemAlloc( sizeof(MPEG1WAVEFORMAT) );
397 if ( pmt->pbFormat == NULL )
398 return E_OUTOFMEMORY;
399 ZeroMemory( pmt->pbFormat, sizeof(MPEG1WAVEFORMAT) );
400 pmpg1wav = (MPEG1WAVEFORMAT*)pmt->pbFormat;
401 switch ( hdrbuf[1] & 0x6 )
402 {
403 case 0x6:
404 TRACE("layer 1\n");
405 pmpg1wav->fwHeadLayer = ACM_MPEG_LAYER1;
406 break;
407 case 0x4:
408 TRACE("layer 2\n");
409 pmpg1wav->fwHeadLayer = ACM_MPEG_LAYER2;
410 break;
411 case 0x2:
412 TRACE("layer 3\n");
413 pmpg1wav->fwHeadLayer = ACM_MPEG_LAYER3;
414 break;
415 default: return E_FAIL;
416 }
417
418 switch ( pmpg1wav->fwHeadLayer )
419 {
420 case ACM_MPEG_LAYER1:
421 pmpg1wav->dwHeadBitrate = bitratesl1[hdrbuf[2]>>4]*1000;
422 break;
423 case ACM_MPEG_LAYER2:
424 pmpg1wav->dwHeadBitrate = bitratesl2[hdrbuf[2]>>4]*1000;
425 break;
426 case ACM_MPEG_LAYER3:
427 pmpg1wav->dwHeadBitrate = bitratesl3[hdrbuf[2]>>4]*1000;
428 break;
429 }
430 if ( pmpg1wav->dwHeadBitrate == 0 )
431 return E_FAIL;
432
433 switch ( hdrbuf[3] & 0xc0 )
434 {
435 case 0x00:
436 TRACE("STEREO\n");
437 pmpg1wav->fwHeadMode = ACM_MPEG_STEREO;
438 break;
439 case 0x40:
440 TRACE("JOINTSTEREO\n");
441 pmpg1wav->fwHeadMode = ACM_MPEG_JOINTSTEREO;
442 break;
443 case 0x80:
444 TRACE("DUALCHANNEL\n");
445 pmpg1wav->fwHeadMode = ACM_MPEG_DUALCHANNEL;
446 break;
447 case 0xc0:
448 TRACE("SINGLECHANNEL\n");
449 pmpg1wav->fwHeadMode = ACM_MPEG_SINGLECHANNEL;
450 break;
451 }
452
453 pmpg1wav->fwHeadModeExt = (hdrbuf[3] & 0x30) >> 4; /* FIXME?? */
454 pmpg1wav->wHeadEmphasis = (hdrbuf[3] & 0x03); /* FIXME?? */
455 pmpg1wav->fwHeadFlags = ACM_MPEG_ID_MPEG1;
456 if ( hdrbuf[1] & 0x1 )
457 pmpg1wav->fwHeadFlags |= ACM_MPEG_PROTECTIONBIT;
458 if ( hdrbuf[2] & 0x1 )
459 pmpg1wav->fwHeadFlags |= ACM_MPEG_PRIVATEBIT;
460 if ( hdrbuf[3] & 0x8 )
461 pmpg1wav->fwHeadFlags |= ACM_MPEG_COPYRIGHT;
462 if ( hdrbuf[3] & 0x4 )
463 pmpg1wav->fwHeadFlags |= ACM_MPEG_ORIGINALHOME;
464 pmpg1wav->dwPTSLow = 0;
465 pmpg1wav->dwPTSHigh = 0;
466
467 pmpg1wav->wfx.wFormatTag = WAVE_FORMAT_MPEG;
468 pmpg1wav->wfx.nChannels = (pmpg1wav->fwHeadMode != ACM_MPEG_SINGLECHANNEL) ? 2 : 1;
469 switch ( hdrbuf[2] & 0x0c )
470 {
471 case 0x00:
472 TRACE("44100Hz\n");
473 pmpg1wav->wfx.nSamplesPerSec = 44100;
474 break;
475 case 0x01:
476 TRACE("48000Hz\n");
477 pmpg1wav->wfx.nSamplesPerSec = 48000;
478 break;
479 case 0x02:
480 TRACE("32000Hz\n");
481 pmpg1wav->wfx.nSamplesPerSec = 32000;
482 break;
483 default: return E_FAIL;
484 }
485 pmpg1wav->wfx.nAvgBytesPerSec = pmpg1wav->dwHeadBitrate >> 3;
486 switch ( pmpg1wav->fwHeadLayer )
487 {
488 case ACM_MPEG_LAYER1:
489 pmpg1wav->wfx.nBlockAlign = (384>>3) * pmpg1wav->dwHeadBitrate / pmpg1wav->wfx.nSamplesPerSec;
490 break;
491 case ACM_MPEG_LAYER2:
492 pmpg1wav->wfx.nBlockAlign = (1152>>3) * pmpg1wav->dwHeadBitrate / pmpg1wav->wfx.nSamplesPerSec;
493 break;
494 case ACM_MPEG_LAYER3:
495 pmpg1wav->wfx.nBlockAlign = 1;
496 break;
497 }
498 pmpg1wav->wfx.wBitsPerSample = 0;
499 pmpg1wav->wfx.cbSize = sizeof(MPEG1WAVEFORMAT) - sizeof(WAVEFORMATEX);
500 if ( pmpg1wav->fwHeadLayer != ACM_MPEG_LAYER3 )
501 {
502 pmt->bFixedSizeSamples = 1;
503 pmt->lSampleSize = pmpg1wav->wfx.nBlockAlign;
504 }
505 dwPayloadBlockSize = (pmpg1wav->wfx.nAvgBytesPerSec + pmpg1wav->wfx.nBlockAlign - 1) / pmpg1wav->wfx.nBlockAlign;
506 if ( dwPayloadBlockSize > This->dwPayloadBlockSizeMax )
507 This->dwPayloadBlockSizeMax = dwPayloadBlockSize;
508 TRACE("payload block size = %lu\n",dwPayloadBlockSize);
509 }
510
511 return S_OK;
512 default:
513 FIXME("mpeg - unknown stream type %02x\n",This->pPayloads[nStreamIndex].payloadtype);
514 break;
515 }
516
517 FIXME("stub\n");
518 return E_NOTIMPL;
519 }
520
521 static HRESULT CMPGParseImpl_CheckStreamType( CParserImpl* pImpl, ULONG nStreamIndex, const AM_MEDIA_TYPE* pmt )
522 {
523 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
524 HRESULT hr;
525 AM_MEDIA_TYPE mt;
526 MPEG1VIDEOINFO* pmpg1vi;
527 MPEG1VIDEOINFO* pmpg1viCheck;
528 MPEG2VIDEOINFO* pmpg2vi;
529 MPEG2VIDEOINFO* pmpg2viCheck;
530 WAVEFORMATEX* pwfx;
531 WAVEFORMATEX* pwfxCheck;
532 enum MPGPayloadType payloadtype;
533
534 TRACE("(%p,%lu,%p)\n",This,nStreamIndex,pmt);
535
536 if ( This == NULL )
537 return E_UNEXPECTED;
538 if ( nStreamIndex >= This->cPayloads )
539 return E_INVALIDARG;
540
541 hr = CMPGParseImpl_GetStreamType( pImpl, nStreamIndex, &mt );
542 if ( FAILED(hr) )
543 return hr;
544 if ( !IsEqualGUID( &pmt->majortype, &mt.majortype ) ||
545 !IsEqualGUID( &pmt->subtype, &mt.subtype ) ||
546 !IsEqualGUID( &pmt->formattype, &mt.formattype ) )
547 {
548 hr = E_FAIL;
549 goto end;
550 }
551
552 TRACE("check format\n");
553 hr = S_OK;
554
555 payloadtype = This->pPayloads[nStreamIndex].payloadtype;
556 switch ( payloadtype )
557 {
558 case MPGPayload_Video:
559 if ( IsEqualGUID( &mt.formattype, &FORMAT_MPEGVideo ) )
560 {
561 /* MPEG-1 Video */
562 if ( pmt->cbFormat != mt.cbFormat ||
563 pmt->pbFormat == NULL )
564 {
565 hr = E_FAIL;
566 goto end;
567 }
568 pmpg1vi = (MPEG1VIDEOINFO*)mt.pbFormat;
569 pmpg1viCheck = (MPEG1VIDEOINFO*)pmt->pbFormat;
570 if ( memcmp( pmpg1vi, pmpg1viCheck, sizeof(MPEG1VIDEOINFO) ) != 0 )
571 {
572 hr = E_FAIL;
573 goto end;
574 }
575 }
576 else
577 if ( IsEqualGUID( &mt.formattype, &FORMAT_MPEG2_VIDEO ) )
578 {
579 /* MPEG-2 Video */
580 if ( pmt->cbFormat != mt.cbFormat ||
581 pmt->pbFormat == NULL )
582 {
583 hr = E_FAIL;
584 goto end;
585 }
586 pmpg2vi = (MPEG2VIDEOINFO*)mt.pbFormat;
587 pmpg2viCheck = (MPEG2VIDEOINFO*)pmt->pbFormat;
588 if ( memcmp( pmpg2vi, pmpg2viCheck, sizeof(MPEG2VIDEOINFO) ) != 0 )
589 {
590 hr = E_FAIL;
591 goto end;
592 }
593 }
594 else
595 {
596 hr = E_FAIL;
597 goto end;
598 }
599 break;
600 case MPGPayload_Audio:
601 if ( IsEqualGUID( &mt.formattype, &FORMAT_WaveFormatEx ) )
602 {
603 if ( mt.cbFormat != pmt->cbFormat ||
604 pmt->pbFormat == NULL )
605 {
606 hr = E_FAIL;
607 goto end;
608 }
609 pwfx = (WAVEFORMATEX*)mt.pbFormat;
610 pwfxCheck = (WAVEFORMATEX*)pmt->pbFormat;
611
612 if ( memcmp( pwfx, pwfxCheck, sizeof(WAVEFORMATEX) ) != 0 )
613 {
614 hr = E_FAIL;
615 goto end;
616 }
617 }
618 else
619 {
620 hr = E_FAIL;
621 goto end;
622 }
623
624 break;
625 default:
626 FIXME( "unsupported payload type\n" );
627 hr = E_FAIL;
628 goto end;
629 }
630
631 hr = S_OK;
632 end:
633 QUARTZ_MediaType_Free( &mt );
634
635 TRACE("%08lx\n",hr);
636
637 return hr;
638 }
639
640 static HRESULT CMPGParseImpl_GetAllocProp( CParserImpl* pImpl, ALLOCATOR_PROPERTIES* pReqProp )
641 {
642 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
643
644 TRACE("(%p,%p)\n",This,pReqProp);
645
646 if ( This == NULL )
647 return E_UNEXPECTED;
648
649 ZeroMemory( pReqProp, sizeof(ALLOCATOR_PROPERTIES) );
650 pReqProp->cBuffers = This->cPayloads;
651 pReqProp->cbBuffer = This->dwPayloadBlockSizeMax;
652
653 TRACE("buf %d size %d\n",
654 (int)This->cPayloads,
655 (int)This->dwPayloadBlockSizeMax);
656
657 return S_OK;
658 }
659
660 static HRESULT CMPGParseImpl_GetNextRequest( CParserImpl* pImpl, ULONG* pnStreamIndex, LONGLONG* pllStart, LONG* plLength, REFERENCE_TIME* prtStart, REFERENCE_TIME* prtStop, DWORD* pdwSampleFlags )
661 {
662 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
663
664 if ( This == NULL )
665 return E_UNEXPECTED;
666 *pdwSampleFlags = AM_SAMPLE_SPLICEPOINT;
667
668 TRACE("(%p)\n",This);
669
670 if ( This->bRawPayload )
671 {
672 if ( This->dwPayloadBlockSizeMax == 0 ||
673 This->cPayloads != 1 || This->pPayloads == NULL )
674 return E_UNEXPECTED;
675 *pnStreamIndex = 0;
676 *pllStart = This->llPosNext;
677 *plLength = This->dwPayloadBlockSizeMax;
678 *prtStart = 0;
679 *prtStop = 0;
680 if ( This->pPayloads[0].bDataDiscontinuity )
681 {
682 *pdwSampleFlags |= AM_SAMPLE_DATADISCONTINUITY;
683 This->pPayloads[0].bDataDiscontinuity = FALSE;
684 }
685 }
686 else
687 {
688 FIXME("stub\n");
689 return E_NOTIMPL;
690 }
691
692 return S_OK;
693 }
694
695 static HRESULT CMPGParseImpl_ProcessSample( CParserImpl* pImpl, ULONG nStreamIndex, LONGLONG llStart, LONG lLength, IMediaSample* pSample )
696 {
697 CMPGParseImpl* This = (CMPGParseImpl*)pImpl->m_pUserData;
698 HRESULT hr;
699
700 TRACE("(%p,%lu,%ld,%ld,%p)\n",This,nStreamIndex,(long)llStart,lLength,pSample);
701
702 if ( This == NULL )
703 return E_UNEXPECTED;
704
705 if ( This->bRawPayload )
706 {
707 hr = IMediaSample_SetTime(pSample,NULL,NULL);
708 if ( FAILED(hr) )
709 return hr;
710 }
711
712 return NOERROR;
713 }
714
715
716 static const struct ParserHandlers CMPGParseImpl_Handlers =
717 {
718 CMPGParseImpl_InitParser,
719 CMPGParseImpl_UninitParser,
720 CMPGParseImpl_GetOutPinName,
721 CMPGParseImpl_GetStreamType,
722 CMPGParseImpl_CheckStreamType,
723 CMPGParseImpl_GetAllocProp,
724 CMPGParseImpl_GetNextRequest,
725 CMPGParseImpl_ProcessSample,
726
727 /* for IQualityControl */
728 NULL, /* pQualityNotify */
729
730 /* for seeking */
731 NULL, /* pGetSeekingCaps */
732 NULL, /* pIsTimeFormatSupported */
733 NULL, /* pGetCurPos */
734 NULL, /* pSetCurPos */
735 NULL, /* pGetDuration */
736 NULL, /* pGetStopPos */
737 NULL, /* pSetStopPos */
738 NULL, /* pGetPreroll */
739 };
740
741 HRESULT QUARTZ_CreateMPEG1Splitter(IUnknown* punkOuter,void** ppobj)
742 {
743 return QUARTZ_CreateParser(
744 punkOuter,ppobj,
745 &CLSID_MPEG1Splitter,
746 QUARTZ_MPEG1Parser_Name,
747 QUARTZ_MPGParserInPin_Name,
748 &CMPGParseImpl_Handlers );
749 }
750
751
Maarten's multimedia branch