ReactOS  0.4.14-dev-98-gb0d4763
mpegl3.c
Go to the documentation of this file.
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 
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  */
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:
111  hi = NUM_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 {
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 {
219  AcmMpeg3Data* aad;
220  int err;
221 
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 &&
235  {
236  goto theEnd;
237  }
238  else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
239  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
241  {
243  {
244  MPEGLAYER3WAVEFORMAT *formatmp3 = (MPEGLAYER3WAVEFORMAT *)adsi->pwfxSrc;
245 
247  formatmp3->wID != MPEGLAYER3_ID_MPEG)
248  {
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  */
272 #endif
273  }
274  else if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
277  {
278  WARN("Encoding to MPEG is not supported\n");
279  goto theEnd;
280  }
281  else goto theEnd;
282  MPEG3_Reset(adsi, aad);
283 
284  return MMSYSERR_NOERROR;
285 
286  theEnd:
287  HeapFree(GetProcessHeap(), 0, aad);
288  adsi->dwDriver = 0L;
289  return error;
290 }
291 
292 /***********************************************************************
293  * MPEG3_StreamClose
294  *
295  */
296 static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
297 {
298  mpg123_close(((AcmMpeg3Data*)adsi->dwDriver)->mh);
299  mpg123_delete(((AcmMpeg3Data*)adsi->dwDriver)->mh);
300  HeapFree(GetProcessHeap(), 0, (void*)adsi->dwDriver);
301  return MMSYSERR_NOERROR;
302 }
303 
304 #elif defined(HAVE_AUDIOTOOLBOX_AUDIOCONVERTER_H)
305 
306 static const unsigned short Mp3BitRates[2][16] =
307 {
308  {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
309  {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0}
310 };
311 
312 static const unsigned short Mp3SampleRates[2][4] =
313 {
314  {44100, 48000, 32000, 0},
315  {22050, 24000, 16000, 0}
316 };
317 
318 typedef struct tagAcmMpeg3Data
319 {
320  LRESULT (*convert)(PACMDRVSTREAMINSTANCE adsi, unsigned char*,
321  LPDWORD, unsigned char*, LPDWORD);
322  AudioConverterRef acr;
323  AudioStreamBasicDescription in,out;
324 
325  AudioBufferList outBuffer;
326  AudioBuffer inBuffer;
327 
328  SInt32 tagBytesLeft;
329 
330  UInt32 NumberPackets;
331  AudioStreamPacketDescription *PacketDescriptions;
332 } AcmMpeg3Data;
333 
334 /***********************************************************************
335  * MPEG3_drvOpen
336  */
337 static LRESULT MPEG3_drvOpen(LPCSTR str)
338 {
339  return 1;
340 }
341 
342 /***********************************************************************
343  * MPEG3_drvClose
344  */
345 static LRESULT MPEG3_drvClose(DWORD_PTR dwDevID)
346 {
347  return 1;
348 }
349 
350 /*
351  When it asks for data, give it all we have. If we have no data, we assume
352  we will in the future, so give it no packets and return an error, which
353  signals that we will have more later.
354  */
355 static OSStatus Mp3AudioConverterComplexInputDataProc(
356  AudioConverterRef inAudioConverter,
357  UInt32 *ioNumberDataPackets,
358  AudioBufferList *ioData,
359  AudioStreamPacketDescription **outDataPacketDescription,
360  void *inUserData
361 )
362 {
363  AcmMpeg3Data *amd = (AcmMpeg3Data*)inUserData;
364 
365  if (amd->inBuffer.mDataByteSize > 0)
366  {
367  *ioNumberDataPackets = amd->NumberPackets;
368  ioData->mNumberBuffers = 1;
369  ioData->mBuffers[0] = amd->inBuffer;
370  amd->inBuffer.mDataByteSize = 0;
371  if (outDataPacketDescription)
372  *outDataPacketDescription = amd->PacketDescriptions;
373  return noErr;
374  }
375  else
376  {
377  *ioNumberDataPackets = 0;
378  return -74;
379  }
380 }
381 
382 /*
383  Get the length of the current frame. We need to be at the start of a
384  frame now. The buffer must have at least the four bytes for the header.
385  */
386 static SInt32 Mp3GetPacketLength(const unsigned char* src)
387 {
388  unsigned char mpegv;
389  unsigned short brate, srate;
390  unsigned int size;
391 
392  /*
393  Check that our position looks like an MP3 header and see which type
394  of MP3 file we have.
395  */
396  if (src[0] == 0xff && src[1] >> 1 == 0x7d) mpegv = 0; /* MPEG-1 File */
397  else if (src[0] == 0xff && src[1] >> 1 == 0x79) mpegv = 1; /* MPEG-2 File */
398  else return -1;
399 
400  /* Fill in bit rate and sample rate. */
401  brate = Mp3BitRates[mpegv][(src[2] & 0xf0) >> 4];
402  srate = Mp3SampleRates[mpegv][(src[2] & 0xc) >> 2];
403 
404  /* Certain values for bit rate and sample rate are invalid. */
405  if (brate == 0 || srate == 0) return -1;
406 
407  /* Compute frame size, round down */
408  size = 72 * (2 - mpegv) * brate * 1000 / srate;
409 
410  /* If there is padding, add one byte */
411  if (src[2] & 0x2) return size + 1;
412  else return size;
413 }
414 
415 /*
416  Apple's AudioFileStream does weird things so we deal with parsing the
417  file ourselves. It was also designed for a different use case, so this
418  is not unexpected. We expect to have MP3 data as input (i.e. we can only
419  deal with MPEG-1 or MPEG-2 Layer III), which simplifies parsing a bit. We
420  understand the ID3v2 header and skip over it. Whenever we have data we
421  want to skip at the beginning of the input, we do this by setting *ndst=0
422  and *nsrc to the length of the unwanted data and return no error.
423  */
424 static LRESULT mp3_leopard_horse(PACMDRVSTREAMINSTANCE adsi,
425  unsigned char* src, LPDWORD nsrc,
426  unsigned char* dst, LPDWORD ndst)
427 {
428  OSStatus err;
429  UInt32 size, aspdi, synci, syncSkip;
430  short framelen[4];
431  const unsigned char* psrc;
432  AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
433 
434  TRACE("ndst %u %p <- %u %p\n", *ndst, dst, *nsrc, src);
435 
436  TRACE("First 16 bytes to input: %s\n", wine_dbgstr_an((const char *)src, 16));
437 
438  /* Parse ID3 tag */
439  if (!memcmp(src, "ID3", 3) && amd->tagBytesLeft == -1)
440  {
441  amd->tagBytesLeft = (src[6] << 21) + (src[7] << 14) + (src[8] << 7) + src[9];
442  if (src[5] & 0x10) amd->tagBytesLeft += 20; /* There is a footer */
443  else amd->tagBytesLeft += 10;
444  }
445 
446  /* Consume the tag */
447  if (amd->tagBytesLeft >= (SInt32)*nsrc)
448  {
449  *ndst = 0;
450  amd->tagBytesLeft -= *nsrc;
451 
452  TRACE("All %d bytes of source data is ID3 tag\n", *nsrc);
453  return MMSYSERR_NOERROR;
454  }
455  else if (amd->tagBytesLeft > 0)
456  {
457  src += amd->tagBytesLeft;
458  *nsrc -= amd->tagBytesLeft;
459  TRACE("Skipping %ld for ID3 tag\n", amd->tagBytesLeft);
460  }
461 
462  /*
463  Sync to initial MP3 frame. The largest possible MP3 frame is 1440.
464  Thus, in the first 1440 bytes we must find the beginning of 3 valid
465  frames in a row unless we reach the end of the file first.
466  */
467  syncSkip = 0;
468  for (psrc = src; psrc <= src + *nsrc - 4 && psrc < src + 1440; psrc++)
469  {
470  framelen[0] = 0;
471  for (synci = 1;
472  synci < 4 && psrc + framelen[synci-1] < src + *nsrc - 4;
473  synci++)
474  {
475  framelen[synci] = Mp3GetPacketLength(psrc + framelen[synci-1]);
476  if (framelen[synci] == -1)
477  {
478  synci = 0;
479  break;
480  }
481  framelen[synci] += framelen[synci-1];
482  }
483  if (synci > 0) /* We synced successfully */
484  {
485  if (psrc - src > 0)
486  {
487  syncSkip = psrc - src;
488  src += syncSkip;
489  *nsrc -= syncSkip;
490  TRACE("Skipping %ld for frame sync\n", syncSkip);
491  }
492  break;
493  }
494  }
495 
496  if (Mp3GetPacketLength(src) == -1)
497  {
498  *ndst = *nsrc = 0;
499  ERR("Frame sync failed. Cannot play file.\n");
500  return MMSYSERR_ERROR;
501  }
502 
503  /*
504  Fill in frame descriptions for all frames. We use an extra pointer
505  to keep track of our position in the input.
506  */
507 
508  amd->NumberPackets = 25; /* This is the initial array capacity */
509  amd->PacketDescriptions = HeapAlloc(GetProcessHeap(), 0, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
510  if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
511 
512  for (aspdi = 0, psrc = src;
513  psrc <= src + *nsrc - 4;
514  psrc += amd->PacketDescriptions[aspdi].mDataByteSize, aspdi++)
515  {
516  /* Return an error if we can't read the frame header */
517  if (Mp3GetPacketLength(psrc) == -1)
518  {
519  *ndst = *nsrc = 0;
520  ERR("Invalid header at %p.\n", psrc);
521  HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
522  return MMSYSERR_ERROR;
523  }
524 
525  /* If we run out of space, double size and reallocate */
526  if (aspdi >= amd->NumberPackets)
527  {
528  amd->NumberPackets *= 2;
529  amd->PacketDescriptions = HeapReAlloc(GetProcessHeap(), 0, amd->PacketDescriptions, amd->NumberPackets * sizeof(AudioStreamPacketDescription));
530  if (amd->PacketDescriptions == 0) return MMSYSERR_NOMEM;
531  }
532 
533  /* Fill in packet data */
534  amd->PacketDescriptions[aspdi].mStartOffset = psrc - src;
535  amd->PacketDescriptions[aspdi].mVariableFramesInPacket = 0;
536  amd->PacketDescriptions[aspdi].mDataByteSize = Mp3GetPacketLength(psrc);
537 
538  /* If this brings us past the end, the last one doesn't count */
539  if (psrc + amd->PacketDescriptions[aspdi].mDataByteSize > src + *nsrc) break;
540  }
541 
542  /* Fill in correct number of frames */
543  amd->NumberPackets = aspdi;
544 
545  /* Adjust nsrc to only include full frames */
546  *nsrc = psrc - src;
547 
548  amd->inBuffer.mDataByteSize = *nsrc;
549  amd->inBuffer.mData = src;
550  amd->inBuffer.mNumberChannels = amd->in.mChannelsPerFrame;
551 
552  amd->outBuffer.mNumberBuffers = 1;
553  amd->outBuffer.mBuffers[0].mDataByteSize = *ndst;
554  amd->outBuffer.mBuffers[0].mData = dst;
555  amd->outBuffer.mBuffers[0].mNumberChannels = amd->out.mChannelsPerFrame;
556 
557  /* Convert the data */
558  size = amd->outBuffer.mBuffers[0].mDataByteSize / amd->out.mBytesPerPacket;
559  err = AudioConverterFillComplexBuffer(amd->acr, Mp3AudioConverterComplexInputDataProc, amd, &size, &amd->outBuffer, 0);
560 
561  HeapFree(GetProcessHeap(), 0, amd->PacketDescriptions);
562 
563  /* Add skipped bytes back into *nsrc */
564  if (amd->tagBytesLeft > 0)
565  {
566  *nsrc += amd->tagBytesLeft;
567  amd->tagBytesLeft = 0;
568  }
569  *nsrc += syncSkip;
570 
571  if (err != noErr && err != -74)
572  {
573  *ndst = *nsrc = 0;
574  ERR("Feed Error: %ld\n", err);
575  return MMSYSERR_ERROR;
576  }
577 
578  *ndst = amd->outBuffer.mBuffers[0].mDataByteSize;
579 
580  TRACE("convert %d -> %d\n", *nsrc, *ndst);
581 
582  return MMSYSERR_NOERROR;
583 }
584 
585 /***********************************************************************
586  * MPEG3_Reset
587  *
588  */
589 static void MPEG3_Reset(PACMDRVSTREAMINSTANCE adsi, AcmMpeg3Data* aad)
590 {
591  AudioConverterReset(aad->acr);
592 }
593 
594 /***********************************************************************
595  * MPEG3_StreamOpen
596  *
597  */
598 static LRESULT MPEG3_StreamOpen(PACMDRVSTREAMINSTANCE adsi)
599 {
600  AcmMpeg3Data* aad;
601 
603 
604  if (MPEG3_GetFormatIndex(adsi->pwfxSrc) == 0xFFFFFFFF ||
605  MPEG3_GetFormatIndex(adsi->pwfxDst) == 0xFFFFFFFF)
606  return ACMERR_NOTPOSSIBLE;
607 
608  aad = HeapAlloc(GetProcessHeap(), 0, sizeof(AcmMpeg3Data));
609  if (aad == 0) return MMSYSERR_NOMEM;
610 
611  adsi->dwDriver = (DWORD_PTR)aad;
612 
613  if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
614  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
616  {
617  OSStatus err;
618 
619  aad->in.mSampleRate = adsi->pwfxSrc->nSamplesPerSec;
620  aad->out.mSampleRate = adsi->pwfxDst->nSamplesPerSec;
621  aad->in.mBitsPerChannel = adsi->pwfxSrc->wBitsPerSample;
622  aad->out.mBitsPerChannel = adsi->pwfxDst->wBitsPerSample;
623  aad->in.mFormatID = kAudioFormatMPEGLayer3;
624  aad->out.mFormatID = kAudioFormatLinearPCM;
625  aad->in.mChannelsPerFrame = adsi->pwfxSrc->nChannels;
626  aad->out.mChannelsPerFrame = adsi->pwfxDst->nChannels;
627  aad->in.mFormatFlags = 0;
628  aad->out.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger;
629  aad->in.mBytesPerFrame = 0;
630  aad->out.mBytesPerFrame = (aad->out.mBitsPerChannel * aad->out.mChannelsPerFrame) / 8;
631  aad->in.mBytesPerPacket = 0;
632  aad->out.mBytesPerPacket = aad->out.mBytesPerFrame;
633  aad->in.mFramesPerPacket = 0;
634  aad->out.mFramesPerPacket = 1;
635  aad->in.mReserved = aad->out.mReserved = 0;
636 
637  aad->tagBytesLeft = -1;
638 
639  aad->convert = mp3_leopard_horse;
640 
641  err = AudioConverterNew(&aad->in, &aad->out, &aad->acr);
642  if (err != noErr)
643  {
644  ERR("Create failed: %ld\n", err);
645  }
646  else
647  {
648  MPEG3_Reset(adsi, aad);
649 
650  return MMSYSERR_NOERROR;
651  }
652  }
653 
654  HeapFree(GetProcessHeap(), 0, aad);
655  adsi->dwDriver = 0;
656 
657  return MMSYSERR_NOTSUPPORTED;
658 }
659 
660 /***********************************************************************
661  * MPEG3_StreamClose
662  *
663  */
664 static LRESULT MPEG3_StreamClose(PACMDRVSTREAMINSTANCE adsi)
665 {
666  AcmMpeg3Data* amd = (AcmMpeg3Data*)adsi->dwDriver;
667 
668  AudioConverterDispose(amd->acr);
669 
670  HeapFree(GetProcessHeap(), 0, amd);
671  adsi->dwDriver = 0;
672 
673  return MMSYSERR_NOERROR;
674 }
675 
676 #endif
677 
678 /***********************************************************************
679  * MPEG3_DriverDetails
680  *
681  */
683 {
686  add->wMid = MM_FRAUNHOFER_IIS;
688  add->vdwACM = 0x01000000;
689  add->vdwDriver = 0x01000000;
690  add->fdwSupport = ACMDRIVERDETAILS_SUPPORTF_CODEC;
691  add->cFormatTags = 3; /* PCM, MPEG3 */
692  add->cFilterTags = 0;
693  add->hicon = NULL;
694  MultiByteToWideChar( CP_ACP, 0, "MPEG Layer-3 Codec", -1,
695  add->szShortName, sizeof(add->szShortName)/sizeof(WCHAR) );
696  MultiByteToWideChar( CP_ACP, 0, "Wine MPEG3 decoder", -1,
697  add->szLongName, sizeof(add->szLongName)/sizeof(WCHAR) );
698  MultiByteToWideChar( CP_ACP, 0, "Brought to you by the Wine team...", -1,
699  add->szCopyright, sizeof(add->szCopyright)/sizeof(WCHAR) );
700  MultiByteToWideChar( CP_ACP, 0, "Refer to LICENSE file", -1,
701  add->szLicensing, sizeof(add->szLicensing)/sizeof(WCHAR) );
702  add->szFeatures[0] = 0;
703 
704  return MMSYSERR_NOERROR;
705 }
706 
707 /***********************************************************************
708  * MPEG3_FormatTagDetails
709  *
710  */
712 {
713  static const WCHAR szPcm[]={'P','C','M',0};
714  static const WCHAR szMpeg3[]={'M','P','e','g','3',0};
715  static const WCHAR szMpeg[]={'M','P','e','g',0};
716 
717  switch (dwQuery)
718  {
720  if (aftd->dwFormatTagIndex > 2) return ACMERR_NOTPOSSIBLE;
721  break;
723  if (aftd->dwFormatTag == WAVE_FORMAT_UNKNOWN)
724  {
725  aftd->dwFormatTagIndex = 2; /* WAVE_FORMAT_MPEG is biggest */
726  break;
727  }
728  /* fall through */
730  switch (aftd->dwFormatTag)
731  {
732  case WAVE_FORMAT_PCM: aftd->dwFormatTagIndex = 0; break;
733  case WAVE_FORMAT_MPEGLAYER3: aftd->dwFormatTagIndex = 1; break;
734  case WAVE_FORMAT_MPEG: aftd->dwFormatTagIndex = 2; break;
735  default: return ACMERR_NOTPOSSIBLE;
736  }
737  break;
738  default:
739  WARN("Unsupported query %08x\n", dwQuery);
740  return MMSYSERR_NOTSUPPORTED;
741  }
742 
744  switch (aftd->dwFormatTagIndex)
745  {
746  case 0:
748  aftd->cbFormatSize = sizeof(PCMWAVEFORMAT);
750  lstrcpyW(aftd->szFormatTag, szPcm);
751  break;
752  case 1:
754  aftd->cbFormatSize = sizeof(MPEGLAYER3WAVEFORMAT);
755  aftd->cStandardFormats = 0;
756  lstrcpyW(aftd->szFormatTag, szMpeg3);
757  break;
758  case 2:
760  aftd->cbFormatSize = sizeof(MPEG1WAVEFORMAT);
761  aftd->cStandardFormats = 0;
762  lstrcpyW(aftd->szFormatTag, szMpeg);
763  break;
764  }
765  return MMSYSERR_NOERROR;
766 }
767 
768 /***********************************************************************
769  * MPEG3_FormatDetails
770  *
771  */
773 {
774  switch (dwQuery)
775  {
777  if (MPEG3_GetFormatIndex(afd->pwfx) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
778  break;
780  afd->pwfx->wFormatTag = afd->dwFormatTag;
781  switch (afd->dwFormatTag)
782  {
783  case WAVE_FORMAT_PCM:
788  /* native MSACM uses a PCMWAVEFORMAT structure, so cbSize is not accessible
789  * afd->pwfx->cbSize = 0;
790  */
791  afd->pwfx->nBlockAlign =
792  (afd->pwfx->nChannels * afd->pwfx->wBitsPerSample) / 8;
793  afd->pwfx->nAvgBytesPerSec =
794  afd->pwfx->nSamplesPerSec * afd->pwfx->nBlockAlign;
795  break;
797  case WAVE_FORMAT_MPEG:
798  WARN("Encoding to MPEG is not supported\n");
799  return ACMERR_NOTPOSSIBLE;
800  default:
801  WARN("Unsupported tag %08x\n", afd->dwFormatTag);
802  return MMSYSERR_INVALPARAM;
803  }
804  break;
805  default:
806  WARN("Unsupported query %08x\n", dwQuery);
807  return MMSYSERR_NOTSUPPORTED;
808  }
810  afd->szFormat[0] = 0; /* let MSACM format this for us... */
811 
812  return MMSYSERR_NOERROR;
813 }
814 
815 /***********************************************************************
816  * MPEG3_FormatSuggest
817  *
818  */
820 {
821  /* some tests ... */
822  if (adfs->cbwfxSrc < sizeof(PCMWAVEFORMAT) ||
823  adfs->cbwfxDst < sizeof(PCMWAVEFORMAT) ||
824  MPEG3_GetFormatIndex(adfs->pwfxSrc) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
825  /* FIXME: should do those tests against the real size (according to format tag */
826 
827  /* If no suggestion for destination, then copy source value */
829  adfs->pwfxDst->nChannels = adfs->pwfxSrc->nChannels;
833  adfs->pwfxDst->wBitsPerSample = 16;
835  {
836  if (adfs->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM)
837  {
838  WARN("Encoding to MPEG is not supported\n");
839  return ACMERR_NOTPOSSIBLE;
840  }
841  else
843  }
844 
845  /* check if result is ok */
846  if (MPEG3_GetFormatIndex(adfs->pwfxDst) == 0xFFFFFFFF) return ACMERR_NOTPOSSIBLE;
847 
848  /* recompute other values */
849  switch (adfs->pwfxDst->wFormatTag)
850  {
851  case WAVE_FORMAT_PCM:
852  adfs->pwfxDst->nBlockAlign = (adfs->pwfxDst->nChannels * adfs->pwfxDst->wBitsPerSample) / 8;
854  break;
855  case WAVE_FORMAT_MPEG:
857  WARN("Encoding to MPEG is not supported\n");
858  return ACMERR_NOTPOSSIBLE;
859  break;
860  default:
861  FIXME("\n");
862  break;
863  }
864 
865  return MMSYSERR_NOERROR;
866 }
867 
868 /***********************************************************************
869  * MPEG3_StreamSize
870  *
871  */
873 {
874  DWORD nblocks;
875 
876  switch (adss->fdwSize)
877  {
879  /* cbDstLength => cbSrcLength */
880  if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
883  {
884  nblocks = (adss->cbDstLength - 3000) / (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
885  if (nblocks == 0)
886  return ACMERR_NOTPOSSIBLE;
887  adss->cbSrcLength = nblocks * 1152 * adsi->pwfxSrc->nBlockAlign;
888  }
889  else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
890  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
892  {
893  nblocks = adss->cbDstLength / (adsi->pwfxDst->nBlockAlign * 1152);
894  if (nblocks == 0)
895  return ACMERR_NOTPOSSIBLE;
896  adss->cbSrcLength = nblocks * (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
897  }
898  else
899  {
900  return MMSYSERR_NOTSUPPORTED;
901  }
902  break;
904  /* cbSrcLength => cbDstLength */
905  if (adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_PCM &&
908  {
909  nblocks = adss->cbSrcLength / (adsi->pwfxSrc->nBlockAlign * 1152);
910  if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nBlockAlign * 1152))
911  /* Round block count up. */
912  nblocks++;
913  if (nblocks == 0)
914  return ACMERR_NOTPOSSIBLE;
915  adss->cbDstLength = 3000 + nblocks * (DWORD)(adsi->pwfxDst->nAvgBytesPerSec * 1152 / adsi->pwfxDst->nSamplesPerSec + 0.5);
916  }
917  else if ((adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEGLAYER3 ||
918  adsi->pwfxSrc->wFormatTag == WAVE_FORMAT_MPEG) &&
920  {
921  nblocks = adss->cbSrcLength / (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec);
922  if (adss->cbSrcLength % (DWORD)(adsi->pwfxSrc->nAvgBytesPerSec * 1152 / adsi->pwfxSrc->nSamplesPerSec))
923  /* Round block count up. */
924  nblocks++;
925  if (nblocks == 0)
926  return ACMERR_NOTPOSSIBLE;
927  adss->cbDstLength = nblocks * 1152 * adsi->pwfxDst->nBlockAlign;
928  }
929  else
930  {
931  return MMSYSERR_NOTSUPPORTED;
932  }
933  break;
934  default:
935  WARN("Unsupported query %08x\n", adss->fdwSize);
936  return MMSYSERR_NOTSUPPORTED;
937  }
938  return MMSYSERR_NOERROR;
939 }
940 
941 /***********************************************************************
942  * MPEG3_StreamConvert
943  *
944  */
946 {
947  AcmMpeg3Data* aad = (AcmMpeg3Data*)adsi->dwDriver;
948  DWORD nsrc = adsh->cbSrcLength;
949  DWORD ndst = adsh->cbDstLength;
950 
951  if (adsh->fdwConvert &
955  {
956  FIXME("Unsupported fdwConvert (%08x), ignoring it\n", adsh->fdwConvert);
957  }
958  /* ACM_STREAMCONVERTF_BLOCKALIGN
959  * currently all conversions are block aligned, so do nothing for this flag
960  * ACM_STREAMCONVERTF_END
961  * no pending data, so do nothing for this flag
962  */
963  if ((adsh->fdwConvert & ACM_STREAMCONVERTF_START))
964  {
965  MPEG3_Reset(adsi, aad);
966  }
967 
968  aad->convert(adsi, adsh->pbSrc, &nsrc, adsh->pbDst, &ndst);
969  adsh->cbSrcLengthUsed = nsrc;
970  adsh->cbDstLengthUsed = ndst;
971 
972  return MMSYSERR_NOERROR;
973 }
974 
975 /**************************************************************************
976  * MPEG3_DriverProc [exported]
977  */
978 LRESULT CALLBACK MPEG3_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg,
979  LPARAM dwParam1, LPARAM dwParam2)
980 {
981  TRACE("(%08lx %p %04x %08lx %08lx);\n",
982  dwDevID, hDriv, wMsg, dwParam1, dwParam2);
983 
984  switch (wMsg)
985  {
986  case DRV_LOAD: return 1;
987  case DRV_FREE: return 1;
988  case DRV_OPEN: return MPEG3_drvOpen((LPSTR)dwParam1);
989  case DRV_CLOSE: return MPEG3_drvClose(dwDevID);
990  case DRV_ENABLE: return 1;
991  case DRV_DISABLE: return 1;
992  case DRV_QUERYCONFIGURE: return 1;
993  case DRV_CONFIGURE: MessageBoxA(0, "MPEG3 filter !", "Wine Driver", MB_OK); return 1;
994  case DRV_INSTALL: return DRVCNF_RESTART;
995  case DRV_REMOVE: return DRVCNF_RESTART;
996 
997  case ACMDM_DRIVER_NOTIFY:
998  /* no caching from other ACM drivers is done so far */
999  return MMSYSERR_NOERROR;
1000 
1001  case ACMDM_DRIVER_DETAILS:
1002  return MPEG3_DriverDetails((PACMDRIVERDETAILSW)dwParam1);
1003 
1005  return MPEG3_FormatTagDetails((PACMFORMATTAGDETAILSW)dwParam1, dwParam2);
1006 
1007  case ACMDM_FORMAT_DETAILS:
1008  return MPEG3_FormatDetails((PACMFORMATDETAILSW)dwParam1, dwParam2);
1009 
1010  case ACMDM_FORMAT_SUGGEST:
1011  return MPEG3_FormatSuggest((PACMDRVFORMATSUGGEST)dwParam1);
1012 
1013  case ACMDM_STREAM_OPEN:
1014  return MPEG3_StreamOpen((PACMDRVSTREAMINSTANCE)dwParam1);
1015 
1016  case ACMDM_STREAM_CLOSE:
1017  return MPEG3_StreamClose((PACMDRVSTREAMINSTANCE)dwParam1);
1018 
1019  case ACMDM_STREAM_SIZE:
1020  return MPEG3_StreamSize((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMSIZE)dwParam2);
1021 
1022  case ACMDM_STREAM_CONVERT:
1023  return MPEG3_StreamConvert((PACMDRVSTREAMINSTANCE)dwParam1, (PACMDRVSTREAMHEADER)dwParam2);
1024 
1027  /* this converter is not a hardware driver */
1029  case ACMDM_FILTER_DETAILS:
1030  /* this converter is not a filter */
1031  case ACMDM_STREAM_RESET:
1032  /* only needed for asynchronous driver... we aren't, so just say it */
1033  return MMSYSERR_NOTSUPPORTED;
1034  case ACMDM_STREAM_PREPARE:
1036  /* nothing special to do here... so don't do anything */
1037  return MMSYSERR_NOERROR;
1038 
1039  default:
1040  return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
1041  }
1042 }
PWAVEFORMATEX pwfx
Definition: msacm.h:507
#define DRV_DISABLE
Definition: mmsystem.h:123
LRESULT CALLBACK MPEG3_DriverProc(DWORD_PTR dwDevID, HDRVR hDriv, UINT wMsg, LPARAM dwParam1, LPARAM dwParam2)
Definition: mpegl3.c:978
#define WAVE_FORMAT_UNKNOWN
Definition: mmreg.h:95
int add
Definition: i386-dis.c:3122
#define ACM_STREAMSIZEF_DESTINATION
Definition: msacm.h:218
MPG123_EXPORT int mpg123_open_feed(mpg123_handle *mh)
Definition: libmpg123.c:468
MPG123_EXPORT off_t mpg123_feedseek(mpg123_handle *mh, off_t sampleoff, int whence, off_t *input_offset)
Definition: lfs_wrap.c:291
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define ACM_FORMATSUGGESTF_NSAMPLESPERSEC
Definition: msacm.h:176
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define DWORD_PTR
Definition: treelist.c:76
#define error(str)
Definition: mkdosfs.c:1605
#define ACM_STREAMCONVERTF_BLOCKALIGN
Definition: msacm.h:205
WINE_DEFAULT_DEBUG_CHANNEL(mpeg3)
DWORD UInt32
Definition: chm_lib.c:106
PWAVEFORMATEX pwfxDst
Definition: msacmdrv.h:153
#define MM_FHGIIS_MPEGLAYER3_DECODE
Definition: mmreg.h:153
#define MPEGLAYER3_WFX_EXTRA_BYTES
Definition: mmreg.h:439
#define CP_ACP
Definition: compat.h:99
DWORD nAvgBytesPerSec
Definition: mmreg.h:81
MPG123_EXPORT int mpg123_getformat(mpg123_handle *mh, long *rate, int *channels, int *encoding)
Definition: libmpg123.c:1066
WORD nChannels
Definition: mmreg.h:79
#define WARN(fmt,...)
Definition: debug.h:111
#define ACMDRIVERDETAILS_SUPPORTF_CODEC
Definition: msacm.h:61
#define ACMDM_STREAM_RESET
Definition: msacmdrv.h:62
#define CALLBACK
Definition: compat.h:27
#define ACM_FORMATSUGGESTF_WFORMATTAG
Definition: msacm.h:174
static LRESULT MPEG3_FormatSuggest(PACMDRVFORMATSUGGEST adfs)
Definition: mpegl3.c:819
int nChannels
Definition: imaadp32.c:63
#define assert(x)
Definition: debug.h:53
MPG123_EXPORT mpg123_handle * mpg123_new(const char *decoder, int *error)
Definition: libmpg123.c:55
#define DRV_CLOSE
Definition: mmsystem.h:122
int This channels
Definition: rdpsnd_libao.c:37
int nBits
Definition: imaadp32.c:64
int rate
Definition: pcmconverter.c:98
#define ACMDM_STREAM_OPEN
Definition: msacmdrv.h:58
#define ACMDM_FORMATTAG_DETAILS
Definition: msacmdrv.h:51
char * LPSTR
Definition: xmlstorage.h:182
#define ACMDM_STREAM_PREPARE
Definition: msacmdrv.h:63
struct pcmwaveformat_tag PCMWAVEFORMAT
int nChannels
Definition: pcmconverter.c:96
MPG123_EXPORT int mpg123_init(void)
Definition: libmpg123.c:22
#define DWORD
Definition: nt_native.h:44
#define ACM_STREAMCONVERTF_END
Definition: msacm.h:207
#define WAVE_FORMAT_MPEG
Definition: mmreg.h:126
#define ACMDM_STREAM_CLOSE
Definition: msacmdrv.h:59
#define DRV_QUERYCONFIGURE
Definition: mmsystem.h:126
#define DRV_OPEN
Definition: mmsystem.h:121
int WINAPI MessageBoxA(_In_opt_ HWND, _In_opt_ LPCSTR, _In_opt_ LPCSTR, _In_ UINT)
#define ACMDM_DRIVER_NOTIFY
Definition: msacmdrv.h:45
#define ACMDM_FORMAT_SUGGEST
Definition: msacmdrv.h:53
#define MMSYSERR_NOMEM
Definition: mmsystem.h:103
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define WAVE_FORMAT_PCM
Definition: constants.h:425
#define ACM_FORMATDETAILSF_FORMAT
Definition: msacm.h:161
MPG123_EXPORT int mpg123_param(mpg123_handle *mh, enum mpg123_parms type, long value, double fvalue)
Definition: libmpg123.c:125
static LRESULT MPEG3_FormatDetails(PACMFORMATDETAILSW afd, DWORD dwQuery)
Definition: mpegl3.c:772
MPG123_EXPORT int mpg123_feed(mpg123_handle *mh, const unsigned char *in, size_t size)
Definition: libmpg123.c:873
#define ACMDM_DRIVER_DETAILS
Definition: msacmdrv.h:46
static const Format MPEG3_Formats[]
Definition: mpegl3.c:79
#define ACMDM_STREAM_CONVERT
Definition: msacmdrv.h:61
#define FIXME(fmt,...)
Definition: debug.h:110
MPG123_EXPORT int mpg123_close(mpg123_handle *mh)
Definition: libmpg123.c:1602
static struct fmt fmts[]
DWORD cStandardFormats
Definition: msacm.h:534
#define ACMDRIVERDETAILS_FCCCOMP_UNDEFINED
Definition: msacm.h:59
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
LONG_PTR LPARAM
Definition: windef.h:208
#define ACM_FORMATSUGGESTF_NCHANNELS
Definition: msacm.h:175
#define DRV_LOAD(x)
struct mpeg1waveformat_tag MPEG1WAVEFORMAT
MPG123_EXPORT void mpg123_delete(mpg123_handle *mh)
Definition: libmpg123.c:1620
const char * LPCSTR
Definition: xmlstorage.h:183
int nBits
Definition: pcmconverter.c:97
#define DRVCNF_RESTART
Definition: mmsystem.h:135
#define DRV_REMOVE
Definition: mmsystem.h:128
#define ACMDM_HARDWARE_WAVE_CAPS_OUTPUT
Definition: msacmdrv.h:49
#define ACMDM_HARDWARE_WAVE_CAPS_INPUT
Definition: msacmdrv.h:48
#define MPEGLAYER3_ID_MPEG
Definition: mmreg.h:442
PWAVEFORMATEX pwfxDst
Definition: msacmdrv.h:101
#define SEEK_SET
Definition: jmemansi.c:26
static LRESULT MPEG3_DriverDetails(PACMDRIVERDETAILSW add)
Definition: mpegl3.c:682
#define TRACE(s)
Definition: solgame.cpp:4
#define ACM_FORMATTAGDETAILSF_FORMATTAG
Definition: msacm.h:183
GLsizeiptr size
Definition: glext.h:5919
#define MMSYSERR_NOERROR
Definition: mmsystem.h:96
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define MMSYSERR_ERROR
Definition: mmsystem.h:97
#define DRV_CONFIGURE
Definition: mmsystem.h:125
int convert
Definition: msacm.c:1362
const char * wine_dbgstr_an(const char *str, int n)
Definition: compat.c:288
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define ACM_STREAMSIZEF_SOURCE
Definition: msacm.h:217
#define ACM_FORMATTAGDETAILSF_INDEX
Definition: msacm.h:182
static DWORD MPEG3_GetFormatIndex(LPWAVEFORMATEX wfx)
Definition: mpegl3.c:98
#define MM_FRAUNHOFER_IIS
Definition: mmreg.h:152
static FILE * out
Definition: regtests2xml.c:44
unsigned long DWORD
Definition: ntddk_ex.h:95
#define NUM_PCM_FORMATS
Definition: mpegl3.c:92
static LRESULT MPEG3_FormatTagDetails(PACMFORMATTAGDETAILSW aftd, DWORD dwQuery)
Definition: mpegl3.c:711
WCHAR szFormat[ACMFORMATDETAILS_FORMAT_CHARS]
Definition: msacm.h:509
#define ACM_STREAMOPENF_ASYNC
Definition: msacm.h:214
#define DRV_FREE
Definition: mmsystem.h:124
#define MMSYSERR_NOTSUPPORTED
Definition: mmsystem.h:104
WORD wFormatTag
Definition: mmreg.h:78
#define ACMDM_FILTERTAG_DETAILS
Definition: msacmdrv.h:55
DWORD dwFormatIndex
Definition: msacm.h:504
int ret
#define LPDWORD
Definition: nt_native.h:46
static const WCHAR L[]
Definition: oid.c:1250
MPG123_EXPORT int mpg123_read(mpg123_handle *mh, unsigned char *outmemory, size_t outmemsize, size_t *done)
Definition: libmpg123.c:868
#define WAVE_FORMAT_MPEGLAYER3
Definition: mmreg.h:127
#define LRESULT
Definition: ole.h:14
#define ACM_FORMATTAGDETAILSF_LARGESTSIZE
Definition: msacm.h:184
GLenum src
Definition: glext.h:6340
#define err(...)
struct mpeglayer3waveformat_tag MPEGLAYER3WAVEFORMAT
DWORD dwFormatTagIndex
Definition: msacm.h:530
uint32_t DWORD_PTR
Definition: typedefs.h:63
#define ACMERR_NOTPOSSIBLE
Definition: msacm.h:36
#define ACMDM_STREAM_UNPREPARE
Definition: msacmdrv.h:64
#define DRV_ENABLE
Definition: mmsystem.h:120
#define ERR(fmt,...)
Definition: debug.h:109
#define ACM_STREAMCONVERTF_START
Definition: msacm.h:206
#define lstrcpyW
Definition: compat.h:406
GLuint in
Definition: glext.h:9616
#define MMSYSERR_INVALPARAM
Definition: mmsystem.h:107
static LRESULT MPEG3_StreamConvert(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMHEADER adsh)
Definition: mpegl3.c:945
DWORD fdwSupport
Definition: msacm.h:506
PWAVEFORMATEX pwfxSrc
Definition: msacmdrv.h:151
#define HeapReAlloc
Definition: compat.h:393
WORD cbSize
Definition: mmreg.h:84
GLenum GLenum dst
Definition: glext.h:6340
DWORD_PTR dwDriver
Definition: msacmdrv.h:107
unsigned int UINT
Definition: ndis.h:50
#define MB_OK
Definition: winuser.h:784
WCHAR szFormatTag[ACMFORMATTAGDETAILS_FORMATTAG_CHARS]
Definition: msacm.h:535
#define MultiByteToWideChar
Definition: compat.h:100
_In_ CLIPOBJ _In_ BRUSHOBJ _In_ LONG _In_ LONG _In_ LONG x2
Definition: winddi.h:3706
MPG123_EXPORT void mpg123_exit(void)
Definition: libmpg123.c:49
DWORD nSamplesPerSec
Definition: mmreg.h:80
WORD nBlockAlign
Definition: mmreg.h:82
#define ACM_FORMATDETAILSF_INDEX
Definition: msacm.h:160
int rate
Definition: imaadp32.c:65
static const Format PCM_Formats[]
Definition: mpegl3.c:66
uint32_t * LPDWORD
Definition: typedefs.h:57
WORD wBitsPerSample
Definition: mmreg.h:83
PWAVEFORMATEX pwfxSrc
Definition: msacmdrv.h:100
#define DRV_INSTALL
Definition: mmsystem.h:127
LRESULT WINAPI DefDriverProc(DWORD_PTR dwDriverIdentifier, HDRVR hDrv, UINT Msg, LPARAM lParam1, LPARAM lParam2)
Definition: driver.c:554
LONG_PTR LRESULT
Definition: windef.h:209
#define NUM_MPEG3_FORMATS
Definition: mpegl3.c:93
DWORD dwFormatTag
Definition: msacm.h:505
#define HeapFree(x, y, z)
Definition: compat.h:394
#define ACM_FORMATSUGGESTF_WBITSPERSAMPLE
Definition: msacm.h:177
#define ACMDM_FORMAT_DETAILS
Definition: msacmdrv.h:52
static LRESULT MPEG3_StreamSize(PACMDRVSTREAMINSTANCE adsi, PACMDRVSTREAMSIZE adss)
Definition: mpegl3.c:872
#define ACMDRIVERDETAILS_FCCTYPE_AUDIOCODEC
Definition: msacm.h:58
ACPI_BUFFER *RetBuffer ACPI_BUFFER *RetBuffer char ACPI_WALK_RESOURCE_CALLBACK void *Context ACPI_BUFFER *RetBuffer UINT16 ACPI_RESOURCE **ResourcePtr ACPI_GENERIC_ADDRESS *Reg UINT32 *ReturnValue UINT8 UINT8 *Slp_TypB ACPI_PHYSICAL_ADDRESS PhysicalAddress64 UINT32 UINT32 *TimeElapsed UINT32 ACPI_STATUS const char * Format
Definition: acpixf.h:1206
#define ACMDM_STREAM_SIZE
Definition: msacmdrv.h:60
#define ACMDM_FILTER_DETAILS
Definition: msacmdrv.h:56