2 * MPEG Layer 3 handling
4 * Copyright (C) 2002 Eric Pouech
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(mpeg3
);
41 /***********************************************************************
44 static LRESULT
MPEG3_drvOpen(LPCSTR str
)
49 /***********************************************************************
52 static LRESULT
MPEG3_drvClose(DWORD_PTR dwDevID
)
57 typedef struct tagAcmMpeg3Data
59 void (*convert
)(PACMDRVSTREAMINSTANCE adsi
,
60 const unsigned char*, LPDWORD
, unsigned char*, LPDWORD
);
64 /* table to list all supported formats... those are the basic ones. this
65 * also helps given a unique index to each of the supported formats
74 static const Format PCM_Formats
[] =
76 {1, 8, 8000}, {2, 8, 8000}, {1, 16, 8000}, {2, 16, 8000},
77 {1, 8, 11025}, {2, 8, 11025}, {1, 16, 11025}, {2, 16, 11025},
78 {1, 8, 12000}, {2, 8, 12000}, {1, 16, 12000}, {2, 16, 12000},
79 {1, 8, 16000}, {2, 8, 16000}, {1, 16, 16000}, {2, 16, 16000},
80 {1, 8, 22050}, {2, 8, 22050}, {1, 16, 22050}, {2, 16, 22050},
81 {1, 8, 24000}, {2, 8, 24000}, {1, 16, 24000}, {2, 16, 24000},
82 {1, 8, 32000}, {2, 8, 32000}, {1, 16, 32000}, {2, 16, 32000},
83 {1, 8, 44100}, {2, 8, 44100}, {1, 16, 44100}, {2, 16, 44100},
84 {1, 8, 48000}, {2, 8, 48000}, {1, 16, 48000}, {2, 16, 48000}
87 static const Format MPEG3_Formats
[] =
89 {1, 0, 8000}, {2, 0, 8000},
90 {1, 0, 11025}, {2, 0, 11025},
91 {1, 0, 12000}, {2, 0, 12000},
92 {1, 0, 16000}, {2, 0, 16000},
93 {1, 0, 22050}, {2, 0, 22050},
94 {1, 0, 24000}, {2, 0, 24000},
95 {1, 0, 32000}, {2, 0, 32000},
96 {1, 0, 44100}, {2, 0, 44100},
97 {1, 0, 48000}, {2, 0, 48000}
100 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
101 #define NUM_MPEG3_FORMATS (sizeof(MPEG3_Formats) / sizeof(MPEG3_Formats[0]))
103 /***********************************************************************
104 * MPEG3_GetFormatIndex
106 static DWORD
MPEG3_GetFormatIndex(LPWAVEFORMATEX wfx
)
111 switch (wfx
->wFormatTag
)
113 case WAVE_FORMAT_PCM
:
114 hi
= NUM_PCM_FORMATS
;
117 case WAVE_FORMAT_MPEGLAYER3
:
118 hi
= NUM_MPEG3_FORMATS
;
119 fmts
= MPEG3_Formats
;
125 for (i
= 0; i
< hi
; i
++)
127 if (wfx
->nChannels
== fmts
[i
].nChannels
&&
128 wfx
->nSamplesPerSec
== fmts
[i
].rate
&&
129 (wfx
->wBitsPerSample
== fmts
[i
].nBits
|| !fmts
[i
].nBits
))
136 static DWORD
get_num_buffered_bytes(struct mpstr
*mp
)
139 struct buf
* p
= mp
->tail
;
141 numBuff
+= p
->size
- p
->pos
;
147 static void mp3_horse(PACMDRVSTREAMINSTANCE adsi
,
148 const unsigned char* src
, LPDWORD nsrc
,
149 unsigned char* dst
, LPDWORD ndst
)
151 AcmMpeg3Data
* amd
= (AcmMpeg3Data
*)adsi
->dwDriver
;
154 DWORD buffered_before
;
155 DWORD buffered_during
;
156 DWORD buffered_after
;
158 /* Skip leading ID v3 header */
159 if (amd
->mp
.fsizeold
== -1 && !strncmp("ID3", (char*)src
, 3))
162 const char *header
= (char *)src
;
164 TRACE("Found ID3 v2.%d.%d\n", header
[3], header
[4]);
165 length
+= (header
[6] & 0x7F) << 21;
166 length
+= (header
[7] & 0x7F) << 14;
167 length
+= (header
[8] & 0x7F) << 7;
168 length
+= (header
[9] & 0x7F);
169 TRACE("Length: %u\n", length
);
175 buffered_before
= get_num_buffered_bytes(&amd
->mp
);
176 ret
= decodeMP3(&amd
->mp
, src
, *nsrc
, dst
, *ndst
, &size
);
177 buffered_during
= get_num_buffered_bytes(&amd
->mp
);
181 FIXME("Error occurred during decoding!\n");
187 if (*ndst
- dpos
< 4608) break;
188 ret
= decodeMP3(&amd
->mp
, NULL
, 0,
189 dst
+ dpos
, *ndst
- dpos
, &size
);
190 } while (ret
== MP3_OK
);
193 buffered_after
= get_num_buffered_bytes(&amd
->mp
);
194 TRACE("before %d put %d during %d after %d\n", buffered_before
, *nsrc
, buffered_during
, buffered_after
);
196 *nsrc
-= buffered_after
;
197 ClearMP3Buffer(&amd
->mp
);
200 /***********************************************************************
201 * MPEG3_DriverDetails
204 static LRESULT
MPEG3_DriverDetails(PACMDRIVERDETAILSW add
)
206 add
->fccType
= ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC
;
207 add
->fccComp
= ACMDRIVERDETAILS_FCCCOMP_UNDEFINED
;
210 add
->vdwACM
= 0x01000000;
211 add
->vdwDriver
= 0x01000000;
212 add
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
213 add
->cFormatTags
= 2; /* PCM, MPEG3 */
214 add
->cFilterTags
= 0;
216 MultiByteToWideChar( CP_ACP
, 0, "WINE-MPEG3", -1,
217 add
->szShortName
, sizeof(add
->szShortName
)/sizeof(WCHAR
) );
218 MultiByteToWideChar( CP_ACP
, 0, "Wine MPEG3 decoder", -1,
219 add
->szLongName
, sizeof(add
->szLongName
)/sizeof(WCHAR
) );
220 MultiByteToWideChar( CP_ACP
, 0, "Brought to you by the Wine team (based on mpglib by Michael Hipp)...", -1,
221 add
->szCopyright
, sizeof(add
->szCopyright
)/sizeof(WCHAR
) );
222 MultiByteToWideChar( CP_ACP
, 0, "Refer to LICENSE file", -1,
223 add
->szLicensing
, sizeof(add
->szLicensing
)/sizeof(WCHAR
) );
224 add
->szFeatures
[0] = 0;
226 return MMSYSERR_NOERROR
;
229 /***********************************************************************
230 * MPEG3_FormatTagDetails
233 static LRESULT
MPEG3_FormatTagDetails(PACMFORMATTAGDETAILSW aftd
, DWORD dwQuery
)
235 static const WCHAR szPcm
[]={'P','C','M',0};
236 static const WCHAR szMpeg3
[]={'M','P','e','g','3',0};
240 case ACM_FORMATTAGDETAILSF_INDEX
:
241 if (aftd
->dwFormatTagIndex
>= 2) return ACMERR_NOTPOSSIBLE
;
243 case ACM_FORMATTAGDETAILSF_LARGESTSIZE
:
244 if (aftd
->dwFormatTag
== WAVE_FORMAT_UNKNOWN
)
246 aftd
->dwFormatTagIndex
= 1; /* WAVE_FORMAT_MPEGLAYER3 is bigger than PCM */
250 case ACM_FORMATTAGDETAILSF_FORMATTAG
:
251 switch (aftd
->dwFormatTag
)
253 case WAVE_FORMAT_PCM
: aftd
->dwFormatTagIndex
= 0; break;
254 case WAVE_FORMAT_MPEGLAYER3
: aftd
->dwFormatTagIndex
= 1; break;
255 default: return ACMERR_NOTPOSSIBLE
;
259 WARN("Unsupported query %08x\n", dwQuery
);
260 return MMSYSERR_NOTSUPPORTED
;
263 aftd
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
264 switch (aftd
->dwFormatTagIndex
)
267 aftd
->dwFormatTag
= WAVE_FORMAT_PCM
;
268 aftd
->cbFormatSize
= sizeof(PCMWAVEFORMAT
);
269 aftd
->cStandardFormats
= NUM_PCM_FORMATS
;
270 lstrcpyW(aftd
->szFormatTag
, szPcm
);
273 aftd
->dwFormatTag
= WAVE_FORMAT_MPEGLAYER3
;
274 aftd
->cbFormatSize
= sizeof(MPEGLAYER3WAVEFORMAT
);
275 aftd
->cStandardFormats
= NUM_MPEG3_FORMATS
;
276 lstrcpyW(aftd
->szFormatTag
, szMpeg3
);
279 return MMSYSERR_NOERROR
;
282 static void fill_in_wfx(unsigned cbwfx
, WAVEFORMATEX
* wfx
, unsigned bit_rate
)
284 MPEGLAYER3WAVEFORMAT
* mp3wfx
= (MPEGLAYER3WAVEFORMAT
*)wfx
;
286 wfx
->nAvgBytesPerSec
= bit_rate
/ 8;
287 if (cbwfx
>= sizeof(WAVEFORMATEX
))
288 wfx
->cbSize
= sizeof(MPEGLAYER3WAVEFORMAT
) - sizeof(WAVEFORMATEX
);
289 if (cbwfx
>= sizeof(MPEGLAYER3WAVEFORMAT
))
291 mp3wfx
->wID
= MPEGLAYER3_ID_MPEG
;
292 mp3wfx
->fdwFlags
= MPEGLAYER3_FLAG_PADDING_OFF
;
293 mp3wfx
->nBlockSize
= (bit_rate
* 144) / wfx
->nSamplesPerSec
;
294 mp3wfx
->nFramesPerBlock
= 1;
295 mp3wfx
->nCodecDelay
= 0x0571;
299 /***********************************************************************
300 * MPEG3_FormatDetails
303 static LRESULT
MPEG3_FormatDetails(PACMFORMATDETAILSW afd
, DWORD dwQuery
)
307 case ACM_FORMATDETAILSF_FORMAT
:
308 if (MPEG3_GetFormatIndex(afd
->pwfx
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
310 case ACM_FORMATDETAILSF_INDEX
:
311 afd
->pwfx
->wFormatTag
= afd
->dwFormatTag
;
312 switch (afd
->dwFormatTag
)
314 case WAVE_FORMAT_PCM
:
315 if (afd
->dwFormatIndex
>= NUM_PCM_FORMATS
) return ACMERR_NOTPOSSIBLE
;
316 afd
->pwfx
->nChannels
= PCM_Formats
[afd
->dwFormatIndex
].nChannels
;
317 afd
->pwfx
->nSamplesPerSec
= PCM_Formats
[afd
->dwFormatIndex
].rate
;
318 afd
->pwfx
->wBitsPerSample
= PCM_Formats
[afd
->dwFormatIndex
].nBits
;
319 /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
320 * afd->pwfx->cbSize = 0;
322 afd
->pwfx
->nBlockAlign
=
323 (afd
->pwfx
->nChannels
* afd
->pwfx
->wBitsPerSample
) / 8;
324 afd
->pwfx
->nAvgBytesPerSec
=
325 afd
->pwfx
->nSamplesPerSec
* afd
->pwfx
->nBlockAlign
;
327 case WAVE_FORMAT_MPEGLAYER3
:
328 if (afd
->dwFormatIndex
>= NUM_MPEG3_FORMATS
) return ACMERR_NOTPOSSIBLE
;
329 afd
->pwfx
->nChannels
= MPEG3_Formats
[afd
->dwFormatIndex
].nChannels
;
330 afd
->pwfx
->nSamplesPerSec
= MPEG3_Formats
[afd
->dwFormatIndex
].rate
;
331 afd
->pwfx
->wBitsPerSample
= MPEG3_Formats
[afd
->dwFormatIndex
].nBits
;
332 afd
->pwfx
->nBlockAlign
= 1;
333 fill_in_wfx(afd
->cbwfx
, afd
->pwfx
, 192000);
336 WARN("Unsupported tag %08x\n", afd
->dwFormatTag
);
337 return MMSYSERR_INVALPARAM
;
341 WARN("Unsupported query %08x\n", dwQuery
);
342 return MMSYSERR_NOTSUPPORTED
;
344 afd
->fdwSupport
= ACMDRIVERDETAILS_SUPPORTF_CODEC
;
345 afd
->szFormat
[0] = 0; /* let MSACM format this for us... */
347 return MMSYSERR_NOERROR
;
350 /***********************************************************************
351 * MPEG3_FormatSuggest
354 static LRESULT
MPEG3_FormatSuggest(PACMDRVFORMATSUGGEST adfs
)
357 if (adfs
->cbwfxSrc
< sizeof(PCMWAVEFORMAT
) ||
358 adfs
->cbwfxDst
< sizeof(PCMWAVEFORMAT
) ||
359 MPEG3_GetFormatIndex(adfs
->pwfxSrc
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
360 /* FIXME: should do those tests against the real size (according to format tag */
362 /* If no suggestion for destination, then copy source value */
363 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_NCHANNELS
))
364 adfs
->pwfxDst
->nChannels
= adfs
->pwfxSrc
->nChannels
;
365 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_NSAMPLESPERSEC
))
366 adfs
->pwfxDst
->nSamplesPerSec
= adfs
->pwfxSrc
->nSamplesPerSec
;
368 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_WBITSPERSAMPLE
))
370 if (adfs
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
)
371 adfs
->pwfxDst
->wBitsPerSample
= 4;
373 adfs
->pwfxDst
->wBitsPerSample
= 16;
375 if (!(adfs
->fdwSuggest
& ACM_FORMATSUGGESTF_WFORMATTAG
))
377 if (adfs
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
)
378 adfs
->pwfxDst
->wFormatTag
= WAVE_FORMAT_MPEGLAYER3
;
380 adfs
->pwfxDst
->wFormatTag
= WAVE_FORMAT_PCM
;
383 /* check if result is ok */
384 if (MPEG3_GetFormatIndex(adfs
->pwfxDst
) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE
;
386 /* recompute other values */
387 switch (adfs
->pwfxDst
->wFormatTag
)
389 case WAVE_FORMAT_PCM
:
390 adfs
->pwfxDst
->nBlockAlign
= (adfs
->pwfxDst
->nChannels
* adfs
->pwfxDst
->wBitsPerSample
) / 8;
391 adfs
->pwfxDst
->nAvgBytesPerSec
= adfs
->pwfxDst
->nSamplesPerSec
* adfs
->pwfxDst
->nBlockAlign
;
393 case WAVE_FORMAT_MPEGLAYER3
:
394 adfs
->pwfxDst
->nBlockAlign
= 1;
395 fill_in_wfx(adfs
->cbwfxDst
, adfs
->pwfxDst
, 192000);
402 return MMSYSERR_NOERROR
;
405 /***********************************************************************
409 static void MPEG3_Reset(PACMDRVSTREAMINSTANCE adsi
, AcmMpeg3Data
* aad
)
411 ClearMP3Buffer(&aad
->mp
);
415 /***********************************************************************
419 static LRESULT
MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi
)
423 assert(!(adsi
->fdwOpen
& ACM_STREAMOPENF_ASYNC
));
425 if (MPEG3_GetFormatIndex(adsi
->pwfxSrc
) == 0xFFFFFFFF ||
426 MPEG3_GetFormatIndex(adsi
->pwfxDst
) == 0xFFFFFFFF)
427 return ACMERR_NOTPOSSIBLE
;
429 aad
= HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data
));
430 if (aad
== 0) return MMSYSERR_NOMEM
;
432 adsi
->dwDriver
= (DWORD_PTR
)aad
;
434 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
435 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
439 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_MPEGLAYER3
&&
440 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
442 /* resampling or mono <=> stereo not available
443 * MPEG3 algo only define 16 bit per sample output
445 if (adsi
->pwfxSrc
->nSamplesPerSec
!= adsi
->pwfxDst
->nSamplesPerSec
||
446 adsi
->pwfxSrc
->nChannels
!= adsi
->pwfxDst
->nChannels
||
447 adsi
->pwfxDst
->wBitsPerSample
!= 16)
449 aad
->convert
= mp3_horse
;
453 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
454 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3)
457 MPEG3_Reset(adsi
, aad
);
459 return MMSYSERR_NOERROR
;
462 HeapFree(GetProcessHeap(), 0, aad
);
464 return MMSYSERR_NOTSUPPORTED
;
467 /***********************************************************************
471 static LRESULT
MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi
)
473 ClearMP3Buffer(&((AcmMpeg3Data
*)adsi
->dwDriver
)->mp
);
474 HeapFree(GetProcessHeap(), 0, (void*)adsi
->dwDriver
);
475 return MMSYSERR_NOERROR
;
478 /***********************************************************************
482 static LRESULT
MPEG3_StreamSize(PACMDRVSTREAMINSTANCE adsi
, PACMDRVSTREAMSIZE adss
)
486 switch (adss
->fdwSize
)
488 case ACM_STREAMSIZEF_DESTINATION
:
489 /* cbDstLength => cbSrcLength */
490 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
491 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_MPEGLAYER3
)
493 nblocks
= (adss
->cbDstLength
- 3000) / (DWORD
)(adsi
->pwfxDst
->nAvgBytesPerSec
* 1152 / adsi
->pwfxDst
->nSamplesPerSec
+ 0.5);
495 return ACMERR_NOTPOSSIBLE
;
496 adss
->cbSrcLength
= nblocks
* 1152 * adsi
->pwfxSrc
->nBlockAlign
;
498 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_MPEGLAYER3
&&
499 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
501 nblocks
= adss
->cbDstLength
/ (adsi
->pwfxDst
->nBlockAlign
* 1152);
503 return ACMERR_NOTPOSSIBLE
;
504 adss
->cbSrcLength
= nblocks
* (DWORD
)(adsi
->pwfxSrc
->nAvgBytesPerSec
* 1152 / adsi
->pwfxSrc
->nSamplesPerSec
);
508 return MMSYSERR_NOTSUPPORTED
;
511 case ACM_STREAMSIZEF_SOURCE
:
512 /* cbSrcLength => cbDstLength */
513 if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_PCM
&&
514 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_MPEGLAYER3
)
516 nblocks
= adss
->cbSrcLength
/ (adsi
->pwfxSrc
->nBlockAlign
* 1152);
518 return ACMERR_NOTPOSSIBLE
;
519 if (adss
->cbSrcLength
% (DWORD
)(adsi
->pwfxSrc
->nBlockAlign
* 1152))
520 /* Round block count up. */
522 adss
->cbDstLength
= 3000 + nblocks
* (DWORD
)(adsi
->pwfxDst
->nAvgBytesPerSec
* 1152 / adsi
->pwfxDst
->nSamplesPerSec
+ 0.5);
524 else if (adsi
->pwfxSrc
->wFormatTag
== WAVE_FORMAT_MPEGLAYER3
&&
525 adsi
->pwfxDst
->wFormatTag
== WAVE_FORMAT_PCM
)
527 nblocks
= adss
->cbSrcLength
/ (DWORD
)(adsi
->pwfxSrc
->nAvgBytesPerSec
* 1152 / adsi
->pwfxSrc
->nSamplesPerSec
);
529 return ACMERR_NOTPOSSIBLE
;
530 if (adss
->cbSrcLength
% (DWORD
)(adsi
->pwfxSrc
->nAvgBytesPerSec
* 1152 / adsi
->pwfxSrc
->nSamplesPerSec
))
531 /* Round block count up. */
533 adss
->cbDstLength
= nblocks
* 1152 * adsi
->pwfxDst
->nBlockAlign
;
537 return MMSYSERR_NOTSUPPORTED
;
541 WARN("Unsupported query %08x\n", adss
->fdwSize
);
542 return MMSYSERR_NOTSUPPORTED
;
544 return MMSYSERR_NOERROR
;
547 /***********************************************************************
548 * MPEG3_StreamConvert
551 static LRESULT
MPEG3_StreamConvert(PACMDRVSTREAMINSTANCE adsi
, PACMDRVSTREAMHEADER adsh
)
553 AcmMpeg3Data
* aad
= (AcmMpeg3Data
*)adsi
->dwDriver
;
554 DWORD nsrc
= adsh
->cbSrcLength
;
555 DWORD ndst
= adsh
->cbDstLength
;
557 if (adsh
->fdwConvert
&
558 ~(ACM_STREAMCONVERTF_BLOCKALIGN
|
559 ACM_STREAMCONVERTF_END
|
560 ACM_STREAMCONVERTF_START
))
562 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh
->fdwConvert
);
564 /* ACM_STREAMCONVERTF_BLOCKALIGN
565 * currently all conversions are block aligned, so do nothing for this flag
566 * ACM_STREAMCONVERTF_END
567 * no pending data, so do nothing for this flag
569 if ((adsh
->fdwConvert
& ACM_STREAMCONVERTF_START
))
571 MPEG3_Reset(adsi
, aad
);
574 aad
->convert(adsi
, adsh
->pbSrc
, &nsrc
, adsh
->pbDst
, &ndst
);
575 adsh
->cbSrcLengthUsed
= nsrc
;
576 adsh
->cbDstLengthUsed
= ndst
;
578 return MMSYSERR_NOERROR
;
581 /**************************************************************************
582 * MPEG3_DriverProc [exported]
584 LRESULT CALLBACK
MPEG3_DriverProc(DWORD_PTR dwDevID
, HDRVR hDriv
, UINT wMsg
,
585 LPARAM dwParam1
, LPARAM dwParam2
)
587 TRACE("(%08lx %p %04x %08lx %08lx);\n",
588 dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);
592 case DRV_LOAD
: return 1;
593 case DRV_FREE
: return 1;
594 case DRV_OPEN
: return MPEG3_drvOpen((LPSTR
)dwParam1
);
595 case DRV_CLOSE
: return MPEG3_drvClose(dwDevID
);
596 case DRV_ENABLE
: return 1;
597 case DRV_DISABLE
: return 1;
598 case DRV_QUERYCONFIGURE
: return 1;
599 case DRV_CONFIGURE
: MessageBoxA(0, "MPEG3 filter !", "Wine Driver", MB_OK
); return 1;
600 case DRV_INSTALL
: return DRVCNF_RESTART
;
601 case DRV_REMOVE
: return DRVCNF_RESTART
;
603 case ACMDM_DRIVER_NOTIFY
:
604 /* no caching from other ACM drivers is done so far */
605 return MMSYSERR_NOERROR
;
607 case ACMDM_DRIVER_DETAILS
:
608 return MPEG3_DriverDetails((PACMDRIVERDETAILSW
)dwParam1
);
610 case ACMDM_FORMATTAG_DETAILS
:
611 return MPEG3_FormatTagDetails((PACMFORMATTAGDETAILSW
)dwParam1
, dwParam2
);
613 case ACMDM_FORMAT_DETAILS
:
614 return MPEG3_FormatDetails((PACMFORMATDETAILSW
)dwParam1
, dwParam2
);
616 case ACMDM_FORMAT_SUGGEST
:
617 return MPEG3_FormatSuggest((PACMDRVFORMATSUGGEST
)dwParam1
);
619 case ACMDM_STREAM_OPEN
:
620 return MPEG3_StreamOpen((PACMDRVSTREAMINSTANCE
)dwParam1
);
622 case ACMDM_STREAM_CLOSE
:
623 return MPEG3_StreamClose((PACMDRVSTREAMINSTANCE
)dwParam1
);
625 case ACMDM_STREAM_SIZE
:
626 return MPEG3_StreamSize((PACMDRVSTREAMINSTANCE
)dwParam1
, (PACMDRVSTREAMSIZE
)dwParam2
);
628 case ACMDM_STREAM_CONVERT
:
629 return MPEG3_StreamConvert((PACMDRVSTREAMINSTANCE
)dwParam1
, (PACMDRVSTREAMHEADER
)dwParam2
);
631 case ACMDM_HARDWARE_WAVE_CAPS_INPUT
:
632 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT
:
633 /* this converter is not a hardware driver */
634 case ACMDM_FILTERTAG_DETAILS
:
635 case ACMDM_FILTER_DETAILS
:
636 /* this converter is not a filter */
637 case ACMDM_STREAM_RESET
:
638 /* only needed for asynchronous driver... we aren't, so just say it */
639 return MMSYSERR_NOTSUPPORTED
;
640 case ACMDM_STREAM_PREPARE
:
641 case ACMDM_STREAM_UNPREPARE
:
642 /* nothing special to do here... so don't do anything */
643 return MMSYSERR_NOERROR
;
646 return DefDriverProc(dwDevID
, hDriv
, wMsg
, dwParam1
, dwParam2
);