scrrun: Add stub implementations of DllRegisterServer and DllUnregisterServer.
[wine] / dlls / 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     AcmMpeg3Data*       aad;
219     int err;
220
221     assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
222
223     if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
224         MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
225         return ACMERR_NOTPOSSIBLE;
226
227     aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data));
228     if (aad == 0) return MMSYSERR_NOMEM;
229
230     adsi->dwDriver = (DWORD_PTR)aad;
231
232     if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
233         adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
234     {
235         goto theEnd;
236     }
237     else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
238               adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
239              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
240     {
241         /* resampling or mono <=> stereo not available
242          * MPEG3 algo only define 16 bit per sample output
243          */
244         if (adsi->pwfxSrc->nSamplesPerSec != adsi->pwfxDst->nSamplesPerSec ||
245             adsi->pwfxSrc->nChannels != adsi->pwfxDst->nChannels ||
246             adsi->pwfxDst->wBitsPerSample != 16)
247             goto theEnd;
248         aad->convert = mp3_horse;
249         aad->mh = mpg123_new(NULL,&err);
250         mpg123_open_feed(aad->mh);
251     }
252     /* no encoding yet
253     else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
254              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3)
255     */
256     else goto theEnd;
257     MPEG3_Reset(adsi, aad);
258
259     return MMSYSERR_NOERROR;
260
261  theEnd:
262     HeapFree(GetProcessHeap(), 0, aad);
263     adsi->dwDriver = 0L;
264     return MMSYSERR_NOTSUPPORTED;
265 }
266
267 /***********************************************************************
268  *           MPEG3_StreamClose
269  *
270  */
271 static  LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
272 {
273     mpg123_close(((AcmMpeg3Data*)adsi->dwDriver)->mh);
274     mpg123_delete(((AcmMpeg3Data*)adsi->dwDriver)->mh);
275     HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
276     return MMSYSERR_NOERROR;
277 }
278
279 #elif defined(HAVE_AUDIOTOOLBOX_AUDIOCONVERTER_H)
280
281 static const unsigned short Mp3BitRates[2][16] =
282 {
283     {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
284     {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}
285 };
286
287 static const unsigned short Mp3SampleRates[2][4] =
288 {
289     {44100, 48000, 32000, 0},
290     {22050, 24000, 16000, 0}
291 };
292
293 typedef struct tagAcmMpeg3Data
294 {
295     LRESULT (*convert)(PACMDRVSTREAMINSTANCE adsi, unsigned char*,
296                        LPDWORD, unsigned char*, LPDWORD);
297     AudioConverterRef acr;
298     AudioStreamBasicDescription in,out;
299
300     AudioBufferList outBuffer;
301     AudioBuffer inBuffer;
302
303     SInt32 tagBytesLeft;
304
305     UInt32 NumberPackets;
306     AudioStreamPacketDescription *PacketDescriptions;
307 } AcmMpeg3Data;
308
309 /***********************************************************************
310  *           MPEG3_drvOpen
311  */
312 static LRESULT MPEG3_drvOpen(LPCSTR str)
313 {
314     return 1;
315 }
316
317 /***********************************************************************
318  *           MPEG3_drvClose
319  */
320 static LRESULT MPEG3_drvClose(DWORD_PTR dwDevID)
321 {
322     return 1;
323 }
324
325 /*
326  When it asks for data, give it all we have. If we have no data, we assume
327  we will in the future, so give it no packets and return an error, which
328  signals that we will have more later.
329  */
330 static OSStatus Mp3AudioConverterComplexInputDataProc(
331    AudioConverterRef             inAudioConverter,
332    UInt32                        *ioNumberDataPackets,
333    AudioBufferList               *ioData,
334    AudioStreamPacketDescription  **outDataPacketDescription,
335    void                          *inUserData
336 )
337 {
338     AcmMpeg3Data *amd = (AcmMpeg3Data*)inUserData;
339
340     if (amd->inBuffer.mDataByteSize > 0)
341     {
342         *ioNumberDataPackets = amd->NumberPackets;
343         ioData->mNumberBuffers = 1;
344         ioData->mBuffers[0] = amd->inBuffer;
345         amd->inBuffer.mDataByteSize = 0;
346         if (outDataPacketDescription)
347             *outDataPacketDescription = amd->PacketDescriptions;
348         return noErr;
349     }
350     else
351     {
352         *ioNumberDataPackets = 0;
353         return -74;
354     }
355 }
356
357 /*
358  Get the length of the current frame. We need to be at the start of a
359  frame now. The buffer must have at least the four bytes for the header.
360  */
361 static SInt32 Mp3GetPacketLength(const unsigned char* src)
362 {
363     unsigned char mpegv;
364     unsigned short brate, srate;
365     unsigned int size;
366
367     /*
368      Check that our position looks like an MP3 header and see which type
369      of MP3 file we have.
370      */
371     if (src[0] == 0xff && src[1] >> 1 == 0x7d) mpegv = 0; /* MPEG-1 File */
372     else if (src[0] == 0xff && src[1] >> 1 == 0x79) mpegv = 1; /* MPEG-2 File */
373     else return -1;
374
375     /* Fill in bit rate and sample rate. */
376     brate = Mp3BitRates[mpegv][(src[2] & 0xf0) >> 4];
377     srate = Mp3SampleRates[mpegv][(src[2] & 0xc) >> 2];
378
379     /* Certain values for bit rate and sample rate are invalid. */
380     if (brate == 0 || srate == 0) return -1;
381
382     /* Compute frame size, round down */
383     size = 72 * (2 - mpegv) * brate * 1000 / srate;
384
385     /* If there is padding, add one byte */
386     if (src[2] & 0x2) return size + 1;
387     else return size;
388 }
389
390 /*
391  Apple's AudioFileStream does weird things so we deal with parsing the
392  file ourselves. It was also designed for a different use case, so this
393  is not unexpected. We expect to have MP3 data as input (i.e. we can only
394  deal with MPEG-1 or MPEG-2 Layer III), which simplifies parsing a bit. We
395  understand the ID3v2 header and skip over it. Whenever we have data we
396  want to skip at the beginning of the input, we do this by setting *ndst=0
397  and *nsrc to the length of the unwanted data and return no error.
398  */
399 static LRESULT mp3_leopard_horse(PACMDRVSTREAMINSTANCE adsi,
400                                  unsigned char* src, LPDWORD nsrc,
401                                  unsigned char* dst, LPDWORD ndst)
402 {
403     OSStatus err;
404     UInt32 size, aspdi, synci, syncSkip;
405     short framelen[4];
406     const unsigned char* psrc;
407     AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
408
409     TRACE("ndst %u %p  <-  %u %p\n", *ndst, dst, *nsrc, src);
410
411     TRACE("First 16 bytes to input: %s\n", wine_dbgstr_an((const char *)src, 16));
412
413     /* Parse ID3 tag */
414     if (!memcmp(src, "ID3", 3) && amd->tagBytesLeft == -1)
415     {
416         amd->tagBytesLeft = (src[6] << 21) + (src[7] << 14) + (src[8] << 7) + src[9];
417         if (src[5] & 0x10) amd->tagBytesLeft += 20; /* There is a footer */
418         else amd->tagBytesLeft += 10;
419     }
420
421     /* Consume the tag */
422     if (amd->tagBytesLeft >= (SInt32)*nsrc)
423     {
424         *ndst = 0;
425         amd->tagBytesLeft -= *nsrc;
426
427         TRACE("All %d bytes of source data is ID3 tag\n", *nsrc);
428         return MMSYSERR_NOERROR;
429     }
430     else if (amd->tagBytesLeft > 0)
431     {
432         src += amd->tagBytesLeft;
433         *nsrc -= amd->tagBytesLeft;
434         TRACE("Skipping %ld for ID3 tag\n", amd->tagBytesLeft);
435     }
436
437     /*
438      Sync to initial MP3 frame. The largest possible MP3 frame is 1440.
439      Thus, in the first 1440 bytes we must find the beginning of 3 valid
440      frames in a row unless we reach the end of the file first.
441      */
442     syncSkip = 0;
443     for (psrc = src; psrc <= src + *nsrc - 4 && psrc < src + 1440; psrc++)
444     {
445         framelen[0] = 0;
446         for (synci = 1;
447              synci < 4 && psrc + framelen[synci-1] < src + *nsrc - 4;
448              synci++)
449         {
450             framelen[synci] = Mp3GetPacketLength(psrc + framelen[synci-1]);
451             if (framelen[synci] == -1)
452             {
453                 synci = 0;
454                 break;
455             }
456             framelen[synci] += framelen[synci-1];
457         }
458         if (synci > 0) /* We synced successfully */
459         {
460             if (psrc - src > 0)
461             {
462                 syncSkip = psrc - src;
463                 src += syncSkip;
464                 *nsrc -= syncSkip;
465                 TRACE("Skipping %ld for frame sync\n", syncSkip);
466             }
467             break;
468         }
469     }
470
471     if (Mp3GetPacketLength(src) == -1)
472     {
473         *ndst = *nsrc = 0;
474         ERR("Frame sync failed. Cannot play file.\n");
475         return MMSYSERR_ERROR;
476     }
477
478     /*
479      Fill in frame descriptions for all frames. We use an extra pointer
480      to keep track of our position in the input.
481      */
482
483     amd->NumberPackets = 25; /* This is the initial array capacity */
484     amd->PacketDescriptions = HeapAlloc(GetProcessHeap(), 0, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
485     if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
486
487     for (aspdi = 0, psrc = src;
488          psrc <= src + *nsrc - 4;
489          psrc += amd->PacketDescriptions[aspdi].mDataByteSize, aspdi++)
490     {
491         /* Return an error if we can't read the frame header */
492         if (Mp3GetPacketLength(psrc) == -1)
493         {
494             *ndst = *nsrc = 0;
495             ERR("Invalid header at %p.\n", psrc);
496             HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
497             return MMSYSERR_ERROR;
498         }
499
500         /* If we run out of space, double size and reallocate */
501         if (aspdi >= amd->NumberPackets)
502         {
503             amd->NumberPackets *= 2;
504             amd->PacketDescriptions = HeapReAlloc(GetProcessHeap(), 0, amd->PacketDescriptions, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
505             if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
506         }
507
508         /* Fill in packet data */
509         amd->PacketDescriptions[aspdi].mStartOffset = psrc - src;
510         amd->PacketDescriptions[aspdi].mVariableFramesInPacket = 0;
511         amd->PacketDescriptions[aspdi].mDataByteSize = Mp3GetPacketLength(psrc);
512
513         /* If this brings us past the end, the last one doesn't count */
514         if (psrc + amd->PacketDescriptions[aspdi].mDataByteSize > src + *nsrc) break;
515     }
516
517     /* Fill in correct number of frames */
518     amd->NumberPackets = aspdi;
519
520     /* Adjust nsrc to only include full frames */
521     *nsrc = psrc - src;
522
523     amd->inBuffer.mDataByteSize = *nsrc;
524     amd->inBuffer.mData = src;
525     amd->inBuffer.mNumberChannels = amd->in.mChannelsPerFrame;
526
527     amd->outBuffer.mNumberBuffers = 1;
528     amd->outBuffer.mBuffers[0].mDataByteSize = *ndst;
529     amd->outBuffer.mBuffers[0].mData = dst;
530     amd->outBuffer.mBuffers[0].mNumberChannels = amd->out.mChannelsPerFrame;
531
532     /* Convert the data */
533     size = amd->outBuffer.mBuffers[0].mDataByteSize / amd->out.mBytesPerPacket;
534     err = AudioConverterFillComplexBuffer(amd->acr, Mp3AudioConverterComplexInputDataProc, amd, &size, &amd->outBuffer, 0);
535
536     HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
537
538     /* Add skipped bytes back into *nsrc */
539     if (amd->tagBytesLeft > 0)
540     {
541         *nsrc += amd->tagBytesLeft;
542         amd->tagBytesLeft = 0;
543     }
544     *nsrc += syncSkip;
545
546     if (err != noErr && err != -74)
547     {
548         *ndst = *nsrc = 0;
549         ERR("Feed Error: %ld\n", err);
550         return MMSYSERR_ERROR;
551     }
552
553     *ndst = amd->outBuffer.mBuffers[0].mDataByteSize;
554
555     TRACE("convert %d -> %d\n", *nsrc, *ndst);
556
557     return MMSYSERR_NOERROR;
558 }
559
560 /***********************************************************************
561  *           MPEG3_Reset
562  *
563  */
564 static void MPEG3_Reset(PACMDRVSTREAMINSTANCE adsi, AcmMpeg3Data* aad)
565 {
566     AudioConverterReset(aad->acr);
567 }
568
569 /***********************************************************************
570  *           MPEG3_StreamOpen
571  *
572  */
573 static LRESULT MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
574 {
575     AcmMpeg3Data* aad;
576
577     assert(!(adsi->fdwOpen & ACM_STREAMOPENF_ASYNC));
578
579     if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
580         MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
581         return ACMERR_NOTPOSSIBLE;
582
583     aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data));
584     if (aad == 0) return MMSYSERR_NOMEM;
585
586     adsi->dwDriver = (DWORD_PTR)aad;
587
588     if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
589          adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
590         adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
591     {
592         OSStatus err;
593
594         aad->in.mSampleRate = adsi->pwfxSrc->nSamplesPerSec;
595         aad->out.mSampleRate = adsi->pwfxDst->nSamplesPerSec;
596         aad->in.mBitsPerChannel = adsi->pwfxSrc->wBitsPerSample;
597         aad->out.mBitsPerChannel = adsi->pwfxDst->wBitsPerSample;
598         aad->in.mFormatID = kAudioFormatMPEGLayer3;
599         aad->out.mFormatID = kAudioFormatLinearPCM;
600         aad->in.mChannelsPerFrame = adsi->pwfxSrc->nChannels;
601         aad->out.mChannelsPerFrame = adsi->pwfxDst->nChannels;
602         aad->in.mFormatFlags = 0;
603         aad->out.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
604         aad->in.mBytesPerFrame = 0;
605         aad->out.mBytesPerFrame = (aad->out.mBitsPerChannel * aad->out.mChannelsPerFrame) / 8;
606         aad->in.mBytesPerPacket =  0;
607         aad->out.mBytesPerPacket = aad->out.mBytesPerFrame;
608         aad->in.mFramesPerPacket = 0;
609         aad->out.mFramesPerPacket = 1;
610         aad->in.mReserved = aad->out.mReserved = 0;
611
612         aad->tagBytesLeft = -1;
613
614         aad->convert = mp3_leopard_horse;
615
616         err = AudioConverterNew(&aad->in, &aad->out, &aad->acr);
617         if (err != noErr)
618         {
619             ERR("Create failed: %ld\n", err);
620         }
621         else
622         {
623             MPEG3_Reset(adsi, aad);
624
625             return MMSYSERR_NOERROR;
626         }
627     }
628
629     HeapFree(GetProcessHeap(), 0, aad);
630     adsi->dwDriver = 0;
631
632     return MMSYSERR_NOTSUPPORTED;
633 }
634
635 /***********************************************************************
636  *           MPEG3_StreamClose
637  *
638  */
639 static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
640 {
641     AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
642
643     AudioConverterDispose(amd->acr);
644
645     HeapFree(GetProcessHeap(), 0, amd);
646     adsi->dwDriver = 0;
647
648     return MMSYSERR_NOERROR;
649 }
650
651 #endif
652
653 /***********************************************************************
654  *           MPEG3_DriverDetails
655  *
656  */
657 static  LRESULT MPEG3_DriverDetails(PACMDRIVERDETAILSW add)
658 {
659     add->fccType = ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC;
660     add->fccComp = ACMDRIVERDETAILS_FCCCOMP_UNDEFINED;
661     add->wMid = 0xFF;
662     add->wPid = 0x00;
663     add->vdwACM = 0x01000000;
664     add->vdwDriver = 0x01000000;
665     add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
666     add->cFormatTags = 3; /* PCM, MPEG3 */
667     add->cFilterTags = 0;
668     add->hicon = NULL;
669     MultiByteToWideChar( CP_ACP, 0, "WINE-MPEG3", -1,
670                          add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
671     MultiByteToWideChar( CP_ACP, 0, "Wine MPEG3 decoder", -1,
672                          add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
673     MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
674                          add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
675     MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
676                          add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
677     add->szFeatures[0] = 0;
678
679     return MMSYSERR_NOERROR;
680 }
681
682 /***********************************************************************
683  *           MPEG3_FormatTagDetails
684  *
685  */
686 static  LRESULT MPEG3_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
687 {
688     static const WCHAR szPcm[]={'P','C','M',0};
689     static const WCHAR szMpeg3[]={'M','P','e','g','3',0};
690     static const WCHAR szMpeg[]={'M','P','e','g',0};
691
692     switch (dwQuery)
693     {
694     case ACM_FORMATTAGDETAILSF_INDEX:
695         if (aftd->dwFormatTagIndex > 2) return ACMERR_NOTPOSSIBLE;
696         break;
697     case ACM_FORMATTAGDETAILSF_LARGESTSIZE:
698         if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
699         {
700             aftd->dwFormatTagIndex = 2; /* WAVE_FORMAT_MPEG is biggest */
701             break;
702         }
703         /* fall thru */
704     case ACM_FORMATTAGDETAILSF_FORMATTAG:
705         switch (aftd->dwFormatTag)
706         {
707         case WAVE_FORMAT_PCM:           aftd->dwFormatTagIndex = 0; break;
708         case WAVE_FORMAT_MPEGLAYER3:    aftd->dwFormatTagIndex = 1; break;
709         case WAVE_FORMAT_MPEG:          aftd->dwFormatTagIndex = 2; break;
710         default:                        return ACMERR_NOTPOSSIBLE;
711         }
712         break;
713     default:
714         WARN("Unsupported query %08x\n", dwQuery);
715         return MMSYSERR_NOTSUPPORTED;
716     }
717
718     aftd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
719     switch (aftd->dwFormatTagIndex)
720     {
721     case 0:
722         aftd->dwFormatTag = WAVE_FORMAT_PCM;
723         aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
724         aftd->cStandardFormats = NUM_PCM_FORMATS;
725         lstrcpyW(aftd->szFormatTag, szPcm);
726         break;
727     case 1:
728         aftd->dwFormatTag = WAVE_FORMAT_MPEGLAYER3;
729         aftd->cbFormatSize = sizeof(MPEGLAYER3WAVEFORMAT);
730         aftd->cStandardFormats = NUM_MPEG3_FORMATS;
731         lstrcpyW(aftd->szFormatTag, szMpeg3);
732         break;
733     case 2:
734         aftd->dwFormatTag = WAVE_FORMAT_MPEG;
735         aftd->cbFormatSize = sizeof(MPEG1WAVEFORMAT);
736         aftd->cStandardFormats = NUM_MPEG3_FORMATS;
737         lstrcpyW(aftd->szFormatTag, szMpeg);
738         break;
739     }
740     return MMSYSERR_NOERROR;
741 }
742
743 static void fill_in_mp3(unsigned cbwfx, WAVEFORMATEX* wfx, unsigned bit_rate)
744 {
745     MPEGLAYER3WAVEFORMAT*   mp3wfx = (MPEGLAYER3WAVEFORMAT*)wfx;
746
747     wfx->nAvgBytesPerSec = bit_rate / 8;
748     if (cbwfx >= sizeof(WAVEFORMATEX))
749         wfx->cbSize = sizeof(MPEGLAYER3WAVEFORMAT) - sizeof(WAVEFORMATEX);
750     if (cbwfx >= sizeof(MPEGLAYER3WAVEFORMAT))
751     {
752         mp3wfx->wID = MPEGLAYER3_ID_MPEG;
753         mp3wfx->fdwFlags = MPEGLAYER3_FLAG_PADDING_OFF;
754         mp3wfx->nBlockSize = (bit_rate * 144) / wfx->nSamplesPerSec;
755         mp3wfx->nFramesPerBlock = 1;
756         mp3wfx->nCodecDelay = 0x0571;
757     }
758 }
759
760 static void fill_in_mpeg(unsigned cbwfx, WAVEFORMATEX* wfx, unsigned bit_rate)
761 {
762     MPEG1WAVEFORMAT*   mp3wfx = (MPEG1WAVEFORMAT*)wfx;
763
764     wfx->nAvgBytesPerSec = bit_rate / 8;
765     if (cbwfx >= sizeof(WAVEFORMATEX))
766         wfx->cbSize = sizeof(MPEG1WAVEFORMAT) - sizeof(WAVEFORMATEX);
767     if (cbwfx >= sizeof(MPEG1WAVEFORMAT))
768     {
769         mp3wfx->fwHeadLayer = ACM_MPEG_LAYER3;
770         mp3wfx->dwHeadBitrate = wfx->nAvgBytesPerSec * 8;
771         mp3wfx->fwHeadMode = ACM_MPEG_JOINTSTEREO;
772         mp3wfx->fwHeadModeExt = 0xf;
773         mp3wfx->wHeadEmphasis = 1;
774         mp3wfx->fwHeadFlags = ACM_MPEG_ID_MPEG1;
775     }
776 }
777
778 /***********************************************************************
779  *           MPEG3_FormatDetails
780  *
781  */
782 static  LRESULT MPEG3_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
783 {
784     switch (dwQuery)
785     {
786     case ACM_FORMATDETAILSF_FORMAT:
787         if (MPEG3_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
788         break;
789     case ACM_FORMATDETAILSF_INDEX:
790         afd->pwfx->wFormatTag = afd->dwFormatTag;
791         switch (afd->dwFormatTag)
792         {
793         case WAVE_FORMAT_PCM:
794             if (afd->dwFormatIndex >= NUM_PCM_FORMATS) return ACMERR_NOTPOSSIBLE;
795             afd->pwfx->nChannels = PCM_Formats[afd->dwFormatIndex].nChannels;
796             afd->pwfx->nSamplesPerSec = PCM_Formats[afd->dwFormatIndex].rate;
797             afd->pwfx->wBitsPerSample = PCM_Formats[afd->dwFormatIndex].nBits;
798             /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
799              * afd->pwfx->cbSize = 0;
800              */
801             afd->pwfx->nBlockAlign =
802                 (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
803             afd->pwfx->nAvgBytesPerSec =
804                 afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
805             break;
806         case WAVE_FORMAT_MPEGLAYER3:
807         case WAVE_FORMAT_MPEG:
808             if (afd->dwFormatIndex >= NUM_MPEG3_FORMATS) return ACMERR_NOTPOSSIBLE;
809             afd->pwfx->nChannels = MPEG3_Formats[afd->dwFormatIndex].nChannels;
810             afd->pwfx->nSamplesPerSec = MPEG3_Formats[afd->dwFormatIndex].rate;
811             afd->pwfx->wBitsPerSample = MPEG3_Formats[afd->dwFormatIndex].nBits;
812             afd->pwfx->nBlockAlign = 1;
813             if (afd->dwFormatTag == WAVE_FORMAT_MPEGLAYER3)
814                 fill_in_mp3(afd->cbwfx, afd->pwfx, 192000);
815             else
816                 fill_in_mpeg(afd->cbwfx, afd->pwfx, 192000);
817             break;
818         default:
819             WARN("Unsupported tag %08x\n", afd->dwFormatTag);
820             return MMSYSERR_INVALPARAM;
821         }
822         break;
823     default:
824         WARN("Unsupported query %08x\n", dwQuery);
825         return MMSYSERR_NOTSUPPORTED;
826     }
827     afd->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
828     afd->szFormat[0] = 0; /* let MSACM format this for us... */
829
830     return MMSYSERR_NOERROR;
831 }
832
833 /***********************************************************************
834  *           MPEG3_FormatSuggest
835  *
836  */
837 static  LRESULT MPEG3_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
838 {
839     /* some tests ... */
840     if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
841         adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
842         MPEG3_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
843     /* FIXME: should do those tests against the real size (according to format tag */
844
845     /* If no suggestion for destination, then copy source value */
846     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NCHANNELS))
847         adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
848     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_NSAMPLESPERSEC))
849         adfs->pwfxDst->nSamplesPerSec = adfs->pwfxSrc->nSamplesPerSec;
850
851     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WBITSPERSAMPLE))
852     {
853         if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
854             adfs->pwfxDst->wBitsPerSample = 4;
855         else
856             adfs->pwfxDst->wBitsPerSample = 16;
857     }
858     if (!(adfs->fdwSuggest & ACM_FORMATSUGGESTF_WFORMATTAG))
859     {
860         if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
861             adfs->pwfxDst->wFormatTag = WAVE_FORMAT_MPEGLAYER3;
862         else
863             adfs->pwfxDst->wFormatTag = WAVE_FORMAT_PCM;
864     }
865
866     /* check if result is ok */
867     if (MPEG3_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
868
869     /* recompute other values */
870     switch (adfs->pwfxDst->wFormatTag)
871     {
872     case WAVE_FORMAT_PCM:
873         adfs->pwfxDst->nBlockAlign = (adfs->pwfxDst->nChannels * adfs->pwfxDst->wBitsPerSample) / 8;
874         adfs->pwfxDst->nAvgBytesPerSec = adfs->pwfxDst->nSamplesPerSec * adfs->pwfxDst->nBlockAlign;
875         break;
876     case WAVE_FORMAT_MPEG:
877         adfs->pwfxDst->nBlockAlign = 1;
878         fill_in_mpeg(adfs->cbwfxDst, adfs->pwfxDst, 192000);
879         break;
880     case WAVE_FORMAT_MPEGLAYER3:
881         adfs->pwfxDst->nBlockAlign = 1;
882         fill_in_mp3(adfs->cbwfxDst, adfs->pwfxDst, 192000);
883         break;
884     default:
885         FIXME("\n");
886         break;
887     }
888
889     return MMSYSERR_NOERROR;
890 }
891
892 /***********************************************************************
893  *           MPEG3_StreamSize
894  *
895  */
896 static  LRESULT MPEG3_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
897 {
898     DWORD nblocks;
899
900     switch (adss->fdwSize)
901     {
902     case ACM_STREAMSIZEF_DESTINATION:
903         /* cbDstLength => cbSrcLength */
904         if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
905             (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
906              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEG))
907         {
908             nblocks = (adss->cbDstLength - 3000) / (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
909             if (nblocks == 0)
910                 return ACMERR_NOTPOSSIBLE;
911             adss->cbSrcLength = nblocks * 1152 * adsi->pwfxSrc->nBlockAlign;
912         }
913         else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
914                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
915                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
916         {
917             nblocks = adss->cbDstLength / (adsi->pwfxDst->nBlockAlign * 1152);
918             if (nblocks == 0)
919                 return ACMERR_NOTPOSSIBLE;
920             adss->cbSrcLength = nblocks * (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
921         }
922         else
923         {
924             return MMSYSERR_NOTSUPPORTED;
925         }
926         break;
927     case ACM_STREAMSIZEF_SOURCE:
928         /* cbSrcLength => cbDstLength */
929         if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
930             (adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
931              adsi->pwfxDst->wFormatTag == WAVE_FORMAT_MPEG))
932         {
933             nblocks = adss->cbSrcLength / (adsi->pwfxSrc->nBlockAlign * 1152);
934             if (nblocks == 0)
935                 return ACMERR_NOTPOSSIBLE;
936             if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nBlockAlign * 1152))
937                 /* Round block count up. */
938                 nblocks++;
939             adss->cbDstLength = 3000 + nblocks * (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
940         }
941         else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
942                  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
943                  adsi->pwfxDst->wFormatTag == WAVE_FORMAT_PCM)
944         {
945             nblocks = adss->cbSrcLength / (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
946             if (nblocks == 0)
947                 return ACMERR_NOTPOSSIBLE;
948             if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec))
949                 /* Round block count up. */
950                 nblocks++;
951             adss->cbDstLength = nblocks * 1152 * adsi->pwfxDst->nBlockAlign;
952         }
953         else
954         {
955             return MMSYSERR_NOTSUPPORTED;
956         }
957         break;
958     default:
959         WARN("Unsupported query %08x\n", adss->fdwSize);
960         return MMSYSERR_NOTSUPPORTED;
961     }
962     return MMSYSERR_NOERROR;
963 }
964
965 /***********************************************************************
966  *           MPEG3_StreamConvert
967  *
968  */
969 static LRESULT MPEG3_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
970 {
971     AcmMpeg3Data*       aad = (AcmMpeg3Data*)adsi->dwDriver;
972     DWORD               nsrc = adsh->cbSrcLength;
973     DWORD               ndst = adsh->cbDstLength;
974
975     if (adsh->fdwConvert &
976         ~(ACM_STREAMCONVERTF_BLOCKALIGN|
977           ACM_STREAMCONVERTF_END|
978           ACM_STREAMCONVERTF_START))
979     {
980         FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert);
981     }
982     /* ACM_STREAMCONVERTF_BLOCKALIGN
983      *  currently all conversions are block aligned, so do nothing for this flag
984      * ACM_STREAMCONVERTF_END
985      *  no pending data, so do nothing for this flag
986      */
987     if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
988     {
989         MPEG3_Reset(adsi, aad);
990     }
991
992     aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
993     adsh->cbSrcLengthUsed = nsrc;
994     adsh->cbDstLengthUsed = ndst;
995
996     return MMSYSERR_NOERROR;
997 }
998
999 /**************************************************************************
1000  *                      MPEG3_DriverProc                        [exported]
1001  */
1002 LRESULT CALLBACK MPEG3_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
1003                                          LPARAM dwParam1, LPARAM dwParam2)
1004 {
1005     TRACE("(%08lx %p %04x %08lx %08lx);\n",
1006           dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1007
1008     switch (wMsg)
1009     {
1010     case DRV_LOAD:              return 1;
1011     case DRV_FREE:              return 1;
1012     case DRV_OPEN:              return MPEG3_drvOpen((LPSTR)dwParam1);
1013     case DRV_CLOSE:             return MPEG3_drvClose(dwDevID);
1014     case DRV_ENABLE:            return 1;
1015     case DRV_DISABLE:           return 1;
1016     case DRV_QUERYCONFIGURE:    return 1;
1017     case DRV_CONFIGURE:         MessageBoxA(0, "MPEG3 filter !", "Wine Driver", MB_OK); return 1;
1018     case DRV_INSTALL:           return DRVCNF_RESTART;
1019     case DRV_REMOVE:            return DRVCNF_RESTART;
1020
1021     case ACMDM_DRIVER_NOTIFY:
1022         /* no caching from other ACM drivers is done so far */
1023         return MMSYSERR_NOERROR;
1024
1025     case ACMDM_DRIVER_DETAILS:
1026         return MPEG3_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
1027
1028     case ACMDM_FORMATTAG_DETAILS:
1029         return MPEG3_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
1030
1031     case ACMDM_FORMAT_DETAILS:
1032         return MPEG3_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
1033
1034     case ACMDM_FORMAT_SUGGEST:
1035         return MPEG3_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
1036
1037     case ACMDM_STREAM_OPEN:
1038         return MPEG3_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
1039
1040     case ACMDM_STREAM_CLOSE:
1041         return MPEG3_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
1042
1043     case ACMDM_STREAM_SIZE:
1044         return MPEG3_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
1045
1046     case ACMDM_STREAM_CONVERT:
1047         return MPEG3_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
1048
1049     case ACMDM_HARDWARE_WAVE_CAPS_INPUT:
1050     case ACMDM_HARDWARE_WAVE_CAPS_OUTPUT:
1051         /* this converter is not a hardware driver */
1052     case ACMDM_FILTERTAG_DETAILS:
1053     case ACMDM_FILTER_DETAILS:
1054         /* this converter is not a filter */
1055     case ACMDM_STREAM_RESET:
1056         /* only needed for asynchronous driver... we aren't, so just say it */
1057         return MMSYSERR_NOTSUPPORTED;
1058     case ACMDM_STREAM_PREPARE:
1059     case ACMDM_STREAM_UNPREPARE:
1060         /* nothing special to do here... so don't do anything */
1061         return MMSYSERR_NOERROR;
1062
1063     default:
1064         return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1065     }
1066 }