[SHELL32] CDrivesFolder: Implement the eject and disconnect menu items. CORE-13841
[reactos.git] / dll / win32 / winemp3.acm / mpegl3.c
1 /*
2 * MPEG Layer 3 handling
3 *
4 * Copyright (C) 2002 Eric Pouech
5 * Copyright (C) 2009 CodeWeavers, Aric Stewart
6 * Copyright (C) 2010 Kristofer Henriksson
7 *
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include <config.h>
25 //#include "wine/port.h"
26
27 #include <assert.h>
28 #include <stdarg.h>
29 //#include <string.h>
30
31 #ifdef HAVE_MPG123_H
32 # include <mpg123.h>
33 #else
34 # ifdef HAVE_COREAUDIO_COREAUDIO_H
35 # include <CoreFoundation/CoreFoundation.h>
36 # include <CoreAudio/CoreAudio.h>
37 # endif
38 # ifdef HAVE_AUDIOTOOLBOX_AUDIOCONVERTER_H
39 # include <AudioToolbox/AudioConverter.h>
40 # endif
41 #endif
42
43 #include <windef.h>
44 #include <winbase.h>
45 #include <wingdi.h>
46 #include <winuser.h>
47 #include <winnls.h>
48 //#include "mmsystem.h"
49 //#include "mmreg.h"
50 //#include "msacm.h"
51 #include <msacmdrv.h>
52 #include <wine/debug.h>
53
54 WINE_DEFAULT_DEBUG_CHANNEL(mpeg3);
55
56 /* table to list all supported formats... those are the basic ones. this
57 * also helps given a unique index to each of the supported formats
58 */
59 typedef struct
60 {
61 int nChannels;
62 int nBits;
63 int rate;
64 } Format;
65
66 static const Format PCM_Formats[] =
67 {
68 {1, 8, 8000}, {2, 8, 8000}, {1, 16, 8000}, {2, 16, 8000},
69 {1, 8, 11025}, {2, 8, 11025}, {1, 16, 11025}, {2, 16, 11025},
70 {1, 8, 12000}, {2, 8, 12000}, {1, 16, 12000}, {2, 16, 12000},
71 {1, 8, 16000}, {2, 8, 16000}, {1, 16, 16000}, {2, 16, 16000},
72 {1, 8, 22050}, {2, 8, 22050}, {1, 16, 22050}, {2, 16, 22050},
73 {1, 8, 24000}, {2, 8, 24000}, {1, 16, 24000}, {2, 16, 24000},
74 {1, 8, 32000}, {2, 8, 32000}, {1, 16, 32000}, {2, 16, 32000},
75 {1, 8, 44100}, {2, 8, 44100}, {1, 16, 44100}, {2, 16, 44100},
76 {1, 8, 48000}, {2, 8, 48000}, {1, 16, 48000}, {2, 16, 48000}
77 };
78
79 static const Format MPEG3_Formats[] =
80 {
81 {1, 0, 8000}, {2, 0, 8000},
82 {1, 0, 11025}, {2, 0, 11025},
83 {1, 0, 12000}, {2, 0, 12000},
84 {1, 0, 16000}, {2, 0, 16000},
85 {1, 0, 22050}, {2, 0, 22050},
86 {1, 0, 24000}, {2, 0, 24000},
87 {1, 0, 32000}, {2, 0, 32000},
88 {1, 0, 44100}, {2, 0, 44100},
89 {1, 0, 48000}, {2, 0, 48000}
90 };
91
92 #define NUM_PCM_FORMATS (sizeof(PCM_Formats) / sizeof(PCM_Formats[0]))
93 #define NUM_MPEG3_FORMATS (sizeof(MPEG3_Formats) / sizeof(MPEG3_Formats[0]))
94
95 /***********************************************************************
96 * MPEG3_GetFormatIndex
97 */
98 static DWORD MPEG3_GetFormatIndex(LPWAVEFORMATEX wfx)
99 {
100 int i, hi;
101 const Format *fmts;
102
103 switch (wfx->wFormatTag)
104 {
105 case WAVE_FORMAT_PCM:
106 hi = NUM_PCM_FORMATS;
107 fmts = PCM_Formats;
108 break;
109 case WAVE_FORMAT_MPEG:
110 case WAVE_FORMAT_MPEGLAYER3:
111 hi = NUM_MPEG3_FORMATS;
112 fmts = MPEG3_Formats;
113 break;
114 default:
115 return 0xFFFFFFFF;
116 }
117
118 for (i = 0; i < hi; i++)
119 {
120 if (wfx->nChannels == fmts[i].nChannels &&
121 wfx->nSamplesPerSec == fmts[i].rate &&
122 (wfx->wBitsPerSample == fmts[i].nBits || !fmts[i].nBits))
123 return i;
124 }
125
126 return 0xFFFFFFFF;
127 }
128
129 #ifdef HAVE_MPG123_H
130
131 typedef struct tagAcmMpeg3Data
132 {
133 void (*convert)(PACMDRVSTREAMINSTANCE adsi,
134 const unsigned char*, LPDWORD, unsigned char*, LPDWORD);
135 mpg123_handle *mh;
136 } AcmMpeg3Data;
137
138 /***********************************************************************
139 * MPEG3_drvOpen
140 */
141 static LRESULT MPEG3_drvOpen(LPCSTR str)
142 {
143 mpg123_init();
144 return 1;
145 }
146
147 /***********************************************************************
148 * MPEG3_drvClose
149 */
150 static LRESULT MPEG3_drvClose(DWORD_PTR dwDevID)
151 {
152 mpg123_exit();
153 return 1;
154 }
155
156
157 static void mp3_horse(PACMDRVSTREAMINSTANCE adsi,
158 const unsigned char* src, LPDWORD nsrc,
159 unsigned char* dst, LPDWORD ndst)
160 {
161 AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
162 int ret;
163 size_t size;
164 DWORD dpos = 0;
165
166
167 if (*nsrc > 0)
168 {
169 ret = mpg123_feed(amd->mh, src, *nsrc);
170 if (ret != MPG123_OK)
171 {
172 ERR("Error feeding data\n");
173 *ndst = *nsrc = 0;
174 return;
175 }
176 }
177
178 do {
179 size = 0;
180 ret = mpg123_read(amd->mh, dst + dpos, *ndst - dpos, &size);
181 if (ret == MPG123_ERR)
182 {
183 FIXME("Error occurred during decoding!\n");
184 *ndst = *nsrc = 0;
185 return;
186 }
187
188 if (ret == MPG123_NEW_FORMAT)
189 {
190 long rate;
191 int channels, enc;
192 mpg123_getformat(amd->mh, &rate, &channels, &enc);
193 TRACE("New format: %li Hz, %i channels, encoding value %i\n", rate, channels, enc);
194 }
195 dpos += size;
196 if (dpos >= *ndst) break;
197 } while (ret != MPG123_ERR && ret != MPG123_NEED_MORE);
198 *ndst = dpos;
199 }
200
201 /***********************************************************************
202 * MPEG3_Reset
203 *
204 */
205 static void MPEG3_Reset(PACMDRVSTREAMINSTANCE adsi, AcmMpeg3Data* aad)
206 {
207 mpg123_feedseek(aad->mh, 0, SEEK_SET, NULL);
208 mpg123_close(aad->mh);
209 mpg123_open_feed(aad->mh);
210 }
211
212 /***********************************************************************
213 * MPEG3_StreamOpen
214 *
215 */
216 static LRESULT MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
217 {
218 LRESULT error = MMSYSERR_NOTSUPPORTED;
219 AcmMpeg3Data* aad;
220 int err;
221
222 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
223
224 if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
225 MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
226 return ACMERR_NOTPOSSIBLE;
227
228 aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data));
229 if (aad == 0) return MMSYSERR_NOMEM;
230
231 adsi->dwDriver = (DWORD_PTR)aad;
232
233 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
234 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
235 {
236 goto theEnd;
237 }
238 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
239 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
240 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
241 {
242 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3)
243 {
244 MPEGLAYER3WAVEFORMAT *formatmp3 = (MPEGLAYER3WAVEFORMAT *)adsi->pwfxSrc;
245
246 if (adsi->pwfxSrc->cbSize < MPEGLAYER3_WFX_EXTRA_BYTES ||
247 formatmp3->wID != MPEGLAYER3_ID_MPEG)
248 {
249 error = ACMERR_NOTPOSSIBLE;
250 goto theEnd;
251 }
252 }
253
254 /* resampling or mono <=> stereo not available
255 * MPEG3 algo only define 16 bit per sample output
256 */
257 if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
258 adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
259 adsi->pwfxDst->wBitsPerSample != 16)
260 goto theEnd;
261 aad->convert = mp3_horse;
262 aad->mh = mpg123_new(NULL,&err);
263 mpg123_open_feed(aad->mh);
264
265 #if MPG123_API_VERSION >= 31 /* needed for MPG123_IGNORE_FRAMEINFO enum value */
266 /* mpg123 may find a XING header in the mp3 and use that information
267 * to ask for seeks in order to read specific frames in the file.
268 * We cannot allow that since the caller application is feeding us.
269 * This fixes problems for mp3 files encoded with LAME (bug 42361)
270 */
271 mpg123_param(aad->mh, MPG123_ADD_FLAGS, MPG123_IGNORE_INFOFRAME, 0);
272 #endif
273 }
274 /* no encoding yet
275 else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
276 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3)
277 */
278 else goto theEnd;
279 MPEG3_Reset(adsi, aad);
280
281 return MMSYSERR_NOERROR;
282
283 theEnd:
284 HeapFree(GetProcessHeap(), 0, aad);
285 adsi->dwDriver = 0L;
286 return error;
287 }
288
289 /***********************************************************************
290 * MPEG3_StreamClose
291 *
292 */
293 static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
294 {
295 mpg123_close(((AcmMpeg3Data*)adsi->dwDriver)->mh);
296 mpg123_delete(((AcmMpeg3Data*)adsi->dwDriver)->mh);
297 HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
298 return MMSYSERR_NOERROR;
299 }
300
301 #elif defined(HAVE_AUDIOTOOLBOX_AUDIOCONVERTER_H)
302
303 static const unsigned short Mp3BitRates[2][16] =
304 {
305 {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
306 {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}
307 };
308
309 static const unsigned short Mp3SampleRates[2][4] =
310 {
311 {44100, 48000, 32000, 0},
312 {22050, 24000, 16000, 0}
313 };
314
315 typedef struct tagAcmMpeg3Data
316 {
317 LRESULT (*convert)(PACMDRVSTREAMINSTANCE adsi, unsigned char*,
318 LPDWORD, unsigned char*, LPDWORD);
319 AudioConverterRef acr;
320 AudioStreamBasicDescription in,out;
321
322 AudioBufferList outBuffer;
323 AudioBuffer inBuffer;
324
325 SInt32 tagBytesLeft;
326
327 UInt32 NumberPackets;
328 AudioStreamPacketDescription *PacketDescriptions;
329 } AcmMpeg3Data;
330
331 /***********************************************************************
332 * MPEG3_drvOpen
333 */
334 static LRESULT MPEG3_drvOpen(LPCSTR str)
335 {
336 return 1;
337 }
338
339 /***********************************************************************
340 * MPEG3_drvClose
341 */
342 static LRESULT MPEG3_drvClose(DWORD_PTR dwDevID)
343 {
344 return 1;
345 }
346
347 /*
348 When it asks for data, give it all we have. If we have no data, we assume
349 we will in the future, so give it no packets and return an error, which
350 signals that we will have more later.
351 */
352 static OSStatus Mp3AudioConverterComplexInputDataProc(
353 AudioConverterRef inAudioConverter,
354 UInt32 *ioNumberDataPackets,
355 AudioBufferList *ioData,
356 AudioStreamPacketDescription **outDataPacketDescription,
357 void *inUserData
358 )
359 {
360 AcmMpeg3Data *amd = (AcmMpeg3Data*)inUserData;
361
362 if (amd->inBuffer.mDataByteSize > 0)
363 {
364 *ioNumberDataPackets = amd->NumberPackets;
365 ioData->mNumberBuffers = 1;
366 ioData->mBuffers[0] = amd->inBuffer;
367 amd->inBuffer.mDataByteSize = 0;
368 if (outDataPacketDescription)
369 *outDataPacketDescription = amd->PacketDescriptions;
370 return noErr;
371 }
372 else
373 {
374 *ioNumberDataPackets = 0;
375 return -74;
376 }
377 }
378
379 /*
380 Get the length of the current frame. We need to be at the start of a
381 frame now. The buffer must have at least the four bytes for the header.
382 */
383 static SInt32 Mp3GetPacketLength(const unsigned char* src)
384 {
385 unsigned char mpegv;
386 unsigned short brate, srate;
387 unsigned int size;
388
389 /*
390 Check that our position looks like an MP3 header and see which type
391 of MP3 file we have.
392 */
393 if (src[0] == 0xff && src[1] >> 1 == 0x7d) mpegv = 0; /* MPEG-1 File */
394 else if (src[0] == 0xff && src[1] >> 1 == 0x79) mpegv = 1; /* MPEG-2 File */
395 else return -1;
396
397 /* Fill in bit rate and sample rate. */
398 brate = Mp3BitRates[mpegv][(src[2] & 0xf0) >> 4];
399 srate = Mp3SampleRates[mpegv][(src[2] & 0xc) >> 2];
400
401 /* Certain values for bit rate and sample rate are invalid. */
402 if (brate == 0 || srate == 0) return -1;
403
404 /* Compute frame size, round down */
405 size = 72 * (2 - mpegv) * brate * 1000 / srate;
406
407 /* If there is padding, add one byte */
408 if (src[2] & 0x2) return size + 1;
409 else return size;
410 }
411
412 /*
413 Apple's AudioFileStream does weird things so we deal with parsing the
414 file ourselves. It was also designed for a different use case, so this
415 is not unexpected. We expect to have MP3 data as input (i.e. we can only
416 deal with MPEG-1 or MPEG-2 Layer III), which simplifies parsing a bit. We
417 understand the ID3v2 header and skip over it. Whenever we have data we
418 want to skip at the beginning of the input, we do this by setting *ndst=0
419 and *nsrc to the length of the unwanted data and return no error.
420 */
421 static LRESULT mp3_leopard_horse(PACMDRVSTREAMINSTANCE adsi,
422 unsigned char* src, LPDWORD nsrc,
423 unsigned char* dst, LPDWORD ndst)
424 {
425 OSStatus err;
426 UInt32 size, aspdi, synci, syncSkip;
427 short framelen[4];
428 const unsigned char* psrc;
429 AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
430
431 TRACE("ndst %u %p <- %u %p\n", *ndst, dst, *nsrc, src);
432
433 TRACE("First 16 bytes to input: %s\n", wine_dbgstr_an((const char *)src, 16));
434
435 /* Parse ID3 tag */
436 if (!memcmp(src, "ID3", 3) && amd->tagBytesLeft == -1)
437 {
438 amd->tagBytesLeft = (src[6] << 21) + (src[7] << 14) + (src[8] << 7) + src[9];
439 if (src[5] & 0x10) amd->tagBytesLeft += 20; /* There is a footer */
440 else amd->tagBytesLeft += 10;
441 }
442
443 /* Consume the tag */
444 if (amd->tagBytesLeft >= (SInt32)*nsrc)
445 {
446 *ndst = 0;
447 amd->tagBytesLeft -= *nsrc;
448
449 TRACE("All %d bytes of source data is ID3 tag\n", *nsrc);
450 return MMSYSERR_NOERROR;
451 }
452 else if (amd->tagBytesLeft > 0)
453 {
454 src += amd->tagBytesLeft;
455 *nsrc -= amd->tagBytesLeft;
456 TRACE("Skipping %ld for ID3 tag\n", amd->tagBytesLeft);
457 }
458
459 /*
460 Sync to initial MP3 frame. The largest possible MP3 frame is 1440.
461 Thus, in the first 1440 bytes we must find the beginning of 3 valid
462 frames in a row unless we reach the end of the file first.
463 */
464 syncSkip = 0;
465 for (psrc = src; psrc <= src + *nsrc - 4 && psrc < src + 1440; psrc++)
466 {
467 framelen[0] = 0;
468 for (synci = 1;
469 synci < 4 && psrc + framelen[synci-1] < src + *nsrc - 4;
470 synci++)
471 {
472 framelen[synci] = Mp3GetPacketLength(psrc + framelen[synci-1]);
473 if (framelen[synci] == -1)
474 {
475 synci = 0;
476 break;
477 }
478 framelen[synci] += framelen[synci-1];
479 }
480 if (synci > 0) /* We synced successfully */
481 {
482 if (psrc - src > 0)
483 {
484 syncSkip = psrc - src;
485 src += syncSkip;
486 *nsrc -= syncSkip;
487 TRACE("Skipping %ld for frame sync\n", syncSkip);
488 }
489 break;
490 }
491 }
492
493 if (Mp3GetPacketLength(src) == -1)
494 {
495 *ndst = *nsrc = 0;
496 ERR("Frame sync failed. Cannot play file.\n");
497 return MMSYSERR_ERROR;
498 }
499
500 /*
501 Fill in frame descriptions for all frames. We use an extra pointer
502 to keep track of our position in the input.
503 */
504
505 amd->NumberPackets = 25; /* This is the initial array capacity */
506 amd->PacketDescriptions = HeapAlloc(GetProcessHeap(), 0, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
507 if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
508
509 for (aspdi = 0, psrc = src;
510 psrc <= src + *nsrc - 4;
511 psrc += amd->PacketDescriptions[aspdi].mDataByteSize, aspdi++)
512 {
513 /* Return an error if we can't read the frame header */
514 if (Mp3GetPacketLength(psrc) == -1)
515 {
516 *ndst = *nsrc = 0;
517 ERR("Invalid header at %p.\n", psrc);
518 HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
519 return MMSYSERR_ERROR;
520 }
521
522 /* If we run out of space, double size and reallocate */
523 if (aspdi >= amd->NumberPackets)
524 {
525 amd->NumberPackets *= 2;
526 amd->PacketDescriptions = HeapReAlloc(GetProcessHeap(), 0, amd->PacketDescriptions, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
527 if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
528 }
529
530 /* Fill in packet data */
531 amd->PacketDescriptions[aspdi].mStartOffset = psrc - src;
532 amd->PacketDescriptions[aspdi].mVariableFramesInPacket = 0;
533 amd->PacketDescriptions[aspdi].mDataByteSize = Mp3GetPacketLength(psrc);
534
535 /* If this brings us past the end, the last one doesn't count */
536 if (psrc + amd->PacketDescriptions[aspdi].mDataByteSize > src + *nsrc) break;
537 }
538
539 /* Fill in correct number of frames */
540 amd->NumberPackets = aspdi;
541
542 /* Adjust nsrc to only include full frames */
543 *nsrc = psrc - src;
544
545 amd->inBuffer.mDataByteSize = *nsrc;
546 amd->inBuffer.mData = src;
547 amd->inBuffer.mNumberChannels = amd->in.mChannelsPerFrame;
548
549 amd->outBuffer.mNumberBuffers = 1;
550 amd->outBuffer.mBuffers[0].mDataByteSize = *ndst;
551 amd->outBuffer.mBuffers[0].mData = dst;
552 amd->outBuffer.mBuffers[0].mNumberChannels = amd->out.mChannelsPerFrame;
553
554 /* Convert the data */
555 size = amd->outBuffer.mBuffers[0].mDataByteSize / amd->out.mBytesPerPacket;
556 err = AudioConverterFillComplexBuffer(amd->acr, Mp3AudioConverterComplexInputDataProc, amd, &size, &amd->outBuffer, 0);
557
558 HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
559
560 /* Add skipped bytes back into *nsrc */
561 if (amd->tagBytesLeft > 0)
562 {
563 *nsrc += amd->tagBytesLeft;
564 amd->tagBytesLeft = 0;
565 }
566 *nsrc += syncSkip;
567
568 if (err != noErr && err != -74)
569 {
570 *ndst = *nsrc = 0;
571 ERR("Feed Error: %ld\n", err);
572 return MMSYSERR_ERROR;
573 }
574
575 *ndst = amd->outBuffer.mBuffers[0].mDataByteSize;
576
577 TRACE("convert %d -> %d\n", *nsrc, *ndst);
578
579 return MMSYSERR_NOERROR;
580 }
581
582 /***********************************************************************
583 * MPEG3_Reset
584 *
585 */
586 static void MPEG3_Reset(PACMDRVSTREAMINSTANCE adsi, AcmMpeg3Data* aad)
587 {
588 AudioConverterReset(aad->acr);
589 }
590
591 /***********************************************************************
592 * MPEG3_StreamOpen
593 *
594 */
595 static LRESULT MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
596 {
597 AcmMpeg3Data* aad;
598
599 assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
600
601 if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
602 MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
603 return ACMERR_NOTPOSSIBLE;
604
605 aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data));
606 if (aad == 0) return MMSYSERR_NOMEM;
607
608 adsi->dwDriver = (DWORD_PTR)aad;
609
610 if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
611 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
612 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
613 {
614 OSStatus err;
615
616 aad->in.mSampleRate = adsi->pwfxSrc->nSamplesPerSec;
617 aad->out.mSampleRate = adsi->pwfxDst->nSamplesPerSec;
618 aad->in.mBitsPerChannel = adsi->pwfxSrc->wBitsPerSample;
619 aad->out.mBitsPerChannel = adsi->pwfxDst->wBitsPerSample;
620 aad->in.mFormatID = kAudioFormatMPEGLayer3;
621 aad->out.mFormatID = kAudioFormatLinearPCM;
622 aad->in.mChannelsPerFrame = adsi->pwfxSrc->nChannels;
623 aad->out.mChannelsPerFrame = adsi->pwfxDst->nChannels;
624 aad->in.mFormatFlags = 0;
625 aad->out.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
626 aad->in.mBytesPerFrame = 0;
627 aad->out.mBytesPerFrame = (aad->out.mBitsPerChannel * aad->out.mChannelsPerFrame) / 8;
628 aad->in.mBytesPerPacket = 0;
629 aad->out.mBytesPerPacket = aad->out.mBytesPerFrame;
630 aad->in.mFramesPerPacket = 0;
631 aad->out.mFramesPerPacket = 1;
632 aad->in.mReserved = aad->out.mReserved = 0;
633
634 aad->tagBytesLeft = -1;
635
636 aad->convert = mp3_leopard_horse;
637
638 err = AudioConverterNew(&aad->in, &aad->out, &aad->acr);
639 if (err != noErr)
640 {
641 ERR("Create failed: %ld\n", err);
642 }
643 else
644 {
645 MPEG3_Reset(adsi, aad);
646
647 return MMSYSERR_NOERROR;
648 }
649 }
650
651 HeapFree(GetProcessHeap(), 0, aad);
652 adsi->dwDriver = 0;
653
654 return MMSYSERR_NOTSUPPORTED;
655 }
656
657 /***********************************************************************
658 * MPEG3_StreamClose
659 *
660 */
661 static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
662 {
663 AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
664
665 AudioConverterDispose(amd->acr);
666
667 HeapFree(GetProcessHeap(), 0, amd);
668 adsi->dwDriver = 0;
669
670 return MMSYSERR_NOERROR;
671 }
672
673 #endif
674
675 /***********************************************************************
676 * MPEG3_DriverDetails
677 *
678 */
679 static LRESULT MPEG3_DriverDetails(PACMDRIVERDETAILSW add)
680 {
681 add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
682 add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
683 add->wMid = MM_FRAUNHOFER_IIS;
684 add->wPid = MM_FHGIIS_MPEGLAYER3_DECODE;
685 add->vdwACM = 0x01000000;
686 add->vdwDriver = 0x01000000;
687 add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
688 add->cFormatTags = 3; /* PCM, MPEG3 */
689 add->cFilterTags = 0;
690 add->hicon = NULL;
691 MultiByteToWideChar( CP_ACP, 0, "MPEG Layer-3 Codec", -1,
692 add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
693 MultiByteToWideChar( CP_ACP, 0, "Wine MPEG3 decoder", -1,
694 add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
695 MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
696 add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
697 MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
698 add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
699 add->szFeatures[0] = 0;
700
701 return MMSYSERR_NOERROR;
702 }
703
704 /***********************************************************************
705 * MPEG3_FormatTagDetails
706 *
707 */
708 static LRESULT MPEG3_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
709 {
710 static const WCHAR szPcm[]={'P','C','M',0};
711 static const WCHAR szMpeg3[]={'M','P','e','g','3',0};
712 static const WCHAR szMpeg[]={'M','P','e','g',0};
713
714 switch (dwQuery)
715 {
716 case ACM_FORMATTAGDETAILSF_INDEX:
717 if (aftd->dwFormatTagIndex > 2) return ACMERR_NOTPOSSIBLE;
718 break;
719 case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
720 if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
721 {
722 aftd->dwFormatTagIndex = 2; /* WAVE_FORMAT_MPEG is biggest */
723 break;
724 }
725 /* fall through */
726 case ACM_FORMATTAGDETAILSF_FORMATTAG:
727 switch (aftd->dwFormatTag)
728 {
729 case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
730 case WAVE_FORMAT_MPEGLAYER3: aftd->dwFormatTagIndex = 1; break;
731 case WAVE_FORMAT_MPEG: aftd->dwFormatTagIndex = 2; break;
732 default: return ACMERR_NOTPOSSIBLE;
733 }
734 break;
735 default:
736 WARN("Unsupported query %08x\n", dwQuery);
737 return MMSYSERR_NOTSUPPORTED;
738 }
739
740 aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
741 switch (aftd->dwFormatTagIndex)
742 {
743 case 0:
744 aftd->dwFormatTag = WAVE_FORMAT_PCM;
745 aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
746 aftd->cStandardFormats = NUM_PCM_FORMATS;
747 lstrcpyW(aftd->szFormatTag, szPcm);
748 break;
749 case 1:
750 aftd->dwFormatTag = WAVE_FORMAT_MPEGLAYER3;
751 aftd->cbFormatSize = sizeof(MPEGLAYER3WAVEFORMAT);
752 aftd->cStandardFormats = NUM_MPEG3_FORMATS;
753 lstrcpyW(aftd->szFormatTag, szMpeg3);
754 break;
755 case 2:
756 aftd->dwFormatTag = WAVE_FORMAT_MPEG;
757 aftd->cbFormatSize = sizeof(MPEG1WAVEFORMAT);
758 aftd->cStandardFormats = NUM_MPEG3_FORMATS;
759 lstrcpyW(aftd->szFormatTag, szMpeg);
760 break;
761 }
762 return MMSYSERR_NOERROR;
763 }
764
765 static void fill_in_mp3(unsigned cbwfx, WAVEFORMATEX* wfx, unsigned bit_rate)
766 {
767 MPEGLAYER3WAVEFORMAT* mp3wfx = (MPEGLAYER3WAVEFORMAT*)wfx;
768
769 wfx->nAvgBytesPerSec = bit_rate / 8;
770 if (cbwfx >= sizeof(WAVEFORMATEX))
771 wfx->cbSize = sizeof(MPEGLAYER3WAVEFORMAT) - sizeof(WAVEFORMATEX);
772 if (cbwfx >= sizeof(MPEGLAYER3WAVEFORMAT))
773 {
774 mp3wfx->wID = MPEGLAYER3_ID_MPEG;
775 mp3wfx->fdwFlags = MPEGLAYER3_FLAG_PADDING_OFF;
776 mp3wfx->nBlockSize = (bit_rate * 144) / wfx->nSamplesPerSec;
777 mp3wfx->nFramesPerBlock = 1;
778 mp3wfx->nCodecDelay = 0x0571;
779 }
780 }
781
782 static void fill_in_mpeg(unsigned cbwfx, WAVEFORMATEX* wfx, unsigned bit_rate)
783 {
784 MPEG1WAVEFORMAT* mp3wfx = (MPEG1WAVEFORMAT*)wfx;
785
786 wfx->nAvgBytesPerSec = bit_rate / 8;
787 if (cbwfx >= sizeof(WAVEFORMATEX))
788 wfx->cbSize = sizeof(MPEG1WAVEFORMAT) - sizeof(WAVEFORMATEX);
789 if (cbwfx >= sizeof(MPEG1WAVEFORMAT))
790 {
791 mp3wfx->fwHeadLayer = ACM_MPEG_LAYER3;
792 mp3wfx->dwHeadBitrate = wfx->nAvgBytesPerSec * 8;
793 mp3wfx->fwHeadMode = ACM_MPEG_JOINTSTEREO;
794 mp3wfx->fwHeadModeExt = 0xf;
795 mp3wfx->wHeadEmphasis = 1;
796 mp3wfx->fwHeadFlags = ACM_MPEG_ID_MPEG1;
797 }
798 }
799
800 /***********************************************************************
801 * MPEG3_FormatDetails
802 *
803 */
804 static LRESULT MPEG3_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
805 {
806 switch (dwQuery)
807 {
808 case ACM_FORMATDETAILSF_FORMAT:
809 if (MPEG3_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
810 break;
811 case ACM_FORMATDETAILSF_INDEX:
812 afd->pwfx->wFormatTag = afd->dwFormatTag;
813 switch (afd->dwFormatTag)
814 {
815 case WAVE_FORMAT_PCM:
816 if (afd->dwFormatIndex >= NUM_PCM_FORMATS) return ACMERR_NOTPOSSIBLE;
817 afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
818 afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
819 afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
820 /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
821 * afd->pwfx->cbSize = 0;
822 */
823 afd->pwfx->nBlockAlign =
824 (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
825 afd->pwfx->nAvgBytesPerSec =
826 afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
827 break;
828 case WAVE_FORMAT_MPEGLAYER3:
829 case WAVE_FORMAT_MPEG:
830 if (afd->dwFormatIndex >= NUM_MPEG3_FORMATS) return ACMERR_NOTPOSSIBLE;
831 afd->pwfx->nChannels = MPEG3_Formats[afd->dwFormatIndex].nChannels;
832 afd->pwfx->nSamplesPerSec = MPEG3_Formats[afd->dwFormatIndex].rate;
833 afd->pwfx->wBitsPerSample = MPEG3_Formats[afd->dwFormatIndex].nBits;
834 afd->pwfx->nBlockAlign = 1;
835 if (afd->dwFormatTag == WAVE_FORMAT_MPEGLAYER3)
836 fill_in_mp3(afd->cbwfx, afd->pwfx, 192000);
837 else
838 fill_in_mpeg(afd->cbwfx, afd->pwfx, 192000);
839 break;
840 default:
841 WARN("Unsupported tag %08x\n", afd->dwFormatTag);
842 return MMSYSERR_INVALPARAM;
843 }
844 break;
845 default:
846 WARN("Unsupported query %08x\n", dwQuery);
847 return MMSYSERR_NOTSUPPORTED;
848 }
849 afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
850 afd->szFormat[0] = 0; /* let MSACM format this for us... */
851
852 return MMSYSERR_NOERROR;
853 }
854
855 /***********************************************************************
856 * MPEG3_FormatSuggest
857 *
858 */
859 static LRESULT MPEG3_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
860 {
861 /* some tests ... */
862 if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
863 adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
864 MPEG3_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
865 /* FIXME: should do those tests against the real size (according to format tag */
866
867 /* If no suggestion for destination, then copy source value */
868 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
869 adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
870 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
871 adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
872
873 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
874 {
875 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
876 adfs->pwfxDst->wBitsPerSample = 4;
877 else
878 adfs->pwfxDst->wBitsPerSample = 16;
879 }
880 if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
881 {
882 if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
883 adfs->pwfxDst->wFormatTag = WAVE_FORMAT_MPEGLAYER3;
884 else
885 adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM;
886 }
887
888 /* check if result is ok */
889 if (MPEG3_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
890
891 /* recompute other values */
892 switch (adfs->pwfxDst->wFormatTag)
893 {
894 case WAVE_FORMAT_PCM:
895 adfs->pwfxDst->nBlockAlign = (adfs->pwfxDst->nChannels * adfs->pwfxDst->wBitsPerSample) / 8;
896 adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
897 break;
898 case WAVE_FORMAT_MPEG:
899 adfs->pwfxDst->nBlockAlign = 1;
900 fill_in_mpeg(adfs->cbwfxDst, adfs->pwfxDst, 192000);
901 break;
902 case WAVE_FORMAT_MPEGLAYER3:
903 adfs->pwfxDst->nBlockAlign = 1;
904 fill_in_mp3(adfs->cbwfxDst, adfs->pwfxDst, 192000);
905 break;
906 default:
907 FIXME("\n");
908 break;
909 }
910
911 return MMSYSERR_NOERROR;
912 }
913
914 /***********************************************************************
915 * MPEG3_StreamSize
916 *
917 */
918 static LRESULT MPEG3_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
919 {
920 DWORD nblocks;
921
922 switch (adss->fdwSize)
923 {
924 case ACM_STREAMSIZEF_DESTINATION:
925 /* cbDstLength => cbSrcLength */
926 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
927 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
928 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEG))
929 {
930 nblocks = (adss->cbDstLength - 3000) / (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
931 if (nblocks == 0)
932 return ACMERR_NOTPOSSIBLE;
933 adss->cbSrcLength = nblocks * 1152 * adsi->pwfxSrc->nBlockAlign;
934 }
935 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
936 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
937 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
938 {
939 nblocks = adss->cbDstLength / (adsi->pwfxDst->nBlockAlign * 1152);
940 if (nblocks == 0)
941 return ACMERR_NOTPOSSIBLE;
942 adss->cbSrcLength = nblocks * (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
943 }
944 else
945 {
946 return MMSYSERR_NOTSUPPORTED;
947 }
948 break;
949 case ACM_STREAMSIZEF_SOURCE:
950 /* cbSrcLength => cbDstLength */
951 if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
952 (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
953 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEG))
954 {
955 nblocks = adss->cbSrcLength / (adsi->pwfxSrc->nBlockAlign * 1152);
956 if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nBlockAlign * 1152))
957 /* Round block count up. */
958 nblocks++;
959 if (nblocks == 0)
960 return ACMERR_NOTPOSSIBLE;
961 adss->cbDstLength = 3000 + nblocks * (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
962 }
963 else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
964 adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
965 adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
966 {
967 nblocks = adss->cbSrcLength / (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
968 if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec))
969 /* Round block count up. */
970 nblocks++;
971 if (nblocks == 0)
972 return ACMERR_NOTPOSSIBLE;
973 adss->cbDstLength = nblocks * 1152 * adsi->pwfxDst->nBlockAlign;
974 }
975 else
976 {
977 return MMSYSERR_NOTSUPPORTED;
978 }
979 break;
980 default:
981 WARN("Unsupported query %08x\n", adss->fdwSize);
982 return MMSYSERR_NOTSUPPORTED;
983 }
984 return MMSYSERR_NOERROR;
985 }
986
987 /***********************************************************************
988 * MPEG3_StreamConvert
989 *
990 */
991 static LRESULT MPEG3_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
992 {
993 AcmMpeg3Data* aad = (AcmMpeg3Data*)adsi->dwDriver;
994 DWORD nsrc = adsh->cbSrcLength;
995 DWORD ndst = adsh->cbDstLength;
996
997 if (adsh->fdwConvert &
998 ~(ACM_STREAMCONVERTF_BLOCKALIGN|
999 ACM_STREAMCONVERTF_END|
1000 ACM_STREAMCONVERTF_START))
1001 {
1002 FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert);
1003 }
1004 /* ACM_STREAMCONVERTF_BLOCKALIGN
1005 * currently all conversions are block aligned, so do nothing for this flag
1006 * ACM_STREAMCONVERTF_END
1007 * no pending data, so do nothing for this flag
1008 */
1009 if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
1010 {
1011 MPEG3_Reset(adsi, aad);
1012 }
1013
1014 aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
1015 adsh->cbSrcLengthUsed = nsrc;
1016 adsh->cbDstLengthUsed = ndst;
1017
1018 return MMSYSERR_NOERROR;
1019 }
1020
1021 /**************************************************************************
1022 * MPEG3_DriverProc [exported]
1023 */
1024 LRESULT CALLBACK MPEG3_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1025 LPARAM dwParam1, LPARAM dwParam2)
1026 {
1027 TRACE("(%08lx %p %04x %08lx %08lx);\n",
1028 dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1029
1030 switch (wMsg)
1031 {
1032 case DRV_LOAD: return 1;
1033 case DRV_FREE: return 1;
1034 case DRV_OPEN: return MPEG3_drvOpen((LPSTR)dwParam1);
1035 case DRV_CLOSE: return MPEG3_drvClose(dwDevID);
1036 case DRV_ENABLE: return 1;
1037 case DRV_DISABLE: return 1;
1038 case DRV_QUERYCONFIGURE: return 1;
1039 case DRV_CONFIGURE: MessageBoxA(0, "MPEG3 filter !", "Wine Driver", MB_OK); return 1;
1040 case DRV_INSTALL: return DRVCNF_RESTART;
1041 case DRV_REMOVE: return DRVCNF_RESTART;
1042
1043 case ACMDM_DRIVER_NOTIFY:
1044 /* no caching from other ACM drivers is done so far */
1045 return MMSYSERR_NOERROR;
1046
1047 case ACMDM_DRIVER_DETAILS:
1048 return MPEG3_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
1049
1050 case ACMDM_FORMATTAG_DETAILS:
1051 return MPEG3_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
1052
1053 case ACMDM_FORMAT_DETAILS:
1054 return MPEG3_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
1055
1056 case ACMDM_FORMAT_SUGGEST:
1057 return MPEG3_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
1058
1059 case ACMDM_STREAM_OPEN:
1060 return MPEG3_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
1061
1062 case ACMDM_STREAM_CLOSE:
1063 return MPEG3_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
1064
1065 case ACMDM_STREAM_SIZE:
1066 return MPEG3_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
1067
1068 case ACMDM_STREAM_CONVERT:
1069 return MPEG3_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
1070
1071 case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
1072 case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
1073 /* this converter is not a hardware driver */
1074 case ACMDM_FILTERTAG_DETAILS:
1075 case ACMDM_FILTER_DETAILS:
1076 /* this converter is not a filter */
1077 case ACMDM_STREAM_RESET:
1078 /* only needed for asynchronous driver... we aren't, so just say it */
1079 return MMSYSERR_NOTSUPPORTED;
1080 case ACMDM_STREAM_PREPARE:
1081 case ACMDM_STREAM_UNPREPARE:
1082 /* nothing special to do here... so don't do anything */
1083 return MMSYSERR_NOERROR;
1084
1085 default:
1086 return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1087 }
1088 }