ReactOS  0.4.14-dev-376-gaedba84
acmstream.c
Go to the documentation of this file.
1 /*
2  * Copyright 2002 Michael Günnewig
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18 
19 #include <assert.h>
20 #include <stdarg.h>
21 
22 #include "windef.h"
23 #include "winbase.h"
24 #include "wingdi.h"
25 #include "winuser.h"
26 #include "winerror.h"
27 #include "mmsystem.h"
28 #include "vfw.h"
29 #include "msacm.h"
30 
31 #include "avifile_private.h"
32 
33 #include "wine/debug.h"
34 
36 
37 /***********************************************************************/
38 
39 typedef struct _IAVIStreamImpl {
40  /* IUnknown stuff */
43 
44  /* IAVIStream stuff */
47 
48  HACMSTREAM has;
49 
52 
55 
58 
59 /***********************************************************************/
60 
61 #define CONVERT_STREAM_to_THIS(a) do { \
62  DWORD __bytes; \
63  acmStreamSize(This->has,*(a) * This->lpInFormat->nBlockAlign,\
64  &__bytes, ACM_STREAMSIZEF_SOURCE); \
65  *(a) = __bytes / This->lpOutFormat->nBlockAlign; } while(0)
66 
67 #define CONVERT_THIS_to_STREAM(a) do { \
68  DWORD __bytes; \
69  acmStreamSize(This->has,*(a) * This->lpOutFormat->nBlockAlign,\
70  &__bytes, ACM_STREAMSIZEF_DESTINATION); \
71  *(a) = __bytes / This->lpInFormat->nBlockAlign; } while(0)
72 
74 {
75  HRESULT hr;
76 
77  /* pre-conditions */
78  assert(This != NULL);
79  assert(This->pStream != NULL);
80 
81  if (This->has != NULL)
82  return AVIERR_OK;
83 
84  if (This->lpInFormat == NULL) {
85  /* decode or encode the data from pStream */
86  hr = AVIStreamFormatSize(This->pStream, This->sInfo.dwStart, &This->cbInFormat);
87  if (FAILED(hr))
88  return hr;
89  This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, This->cbInFormat);
90  if (This->lpInFormat == NULL)
91  return AVIERR_MEMORY;
92 
93  hr = IAVIStream_ReadFormat(This->pStream, This->sInfo.dwStart,
94  This->lpInFormat, &This->cbInFormat);
95  if (FAILED(hr))
96  return hr;
97 
98  if (This->lpOutFormat == NULL) {
99  /* we must decode to default format */
100  This->cbOutFormat = sizeof(PCMWAVEFORMAT);
101  This->lpOutFormat = HeapAlloc(GetProcessHeap(), 0, This->cbOutFormat);
102  if (This->lpOutFormat == NULL)
103  return AVIERR_MEMORY;
104 
105  This->lpOutFormat->wFormatTag = WAVE_FORMAT_PCM;
106  if (acmFormatSuggest(NULL, This->lpInFormat, This->lpOutFormat,
107  This->cbOutFormat, ACM_FORMATSUGGESTF_WFORMATTAG) != S_OK)
108  return AVIERR_NOCOMPRESSOR;
109  }
110  } else if (This->lpOutFormat == NULL)
111  return AVIERR_ERROR; /* To what should I encode? */
112 
113  if (acmStreamOpen(&This->has, NULL, This->lpInFormat, This->lpOutFormat,
115  return AVIERR_NOCOMPRESSOR;
116 
117  /* update AVISTREAMINFO structure */
118  This->sInfo.dwSampleSize = This->lpOutFormat->nBlockAlign;
119  This->sInfo.dwScale = This->lpOutFormat->nBlockAlign;
120  This->sInfo.dwRate = This->lpOutFormat->nAvgBytesPerSec;
121  This->sInfo.dwQuality = (DWORD)ICQUALITY_DEFAULT;
122  SetRectEmpty(&This->sInfo.rcFrame);
123 
124  /* convert positions and sizes to output format */
125  CONVERT_STREAM_to_THIS(&This->sInfo.dwStart);
126  CONVERT_STREAM_to_THIS(&This->sInfo.dwLength);
127  CONVERT_STREAM_to_THIS(&This->sInfo.dwSuggestedBufferSize);
128 
129  return AVIERR_OK;
130 }
131 
133 {
134  return CONTAINING_RECORD(iface, IAVIStreamImpl, IAVIStream_iface);
135 }
136 
138  REFIID refiid, LPVOID *obj)
139 {
141 
142  TRACE("(%p,%s,%p)\n", iface, debugstr_guid(refiid), obj);
143 
144  if (IsEqualGUID(&IID_IUnknown, refiid) ||
145  IsEqualGUID(&IID_IAVIStream, refiid)) {
146  *obj = &This->IAVIStream_iface;
147  IAVIStream_AddRef(iface);
148 
149  return S_OK;
150  }
151 
152  return OLE_E_ENUM_NOMORE;
153 }
154 
156 {
159 
160  TRACE("(%p) -> %d\n", iface, ref);
161 
162  /* also add reference to the nested stream */
163  if (This->pStream != NULL)
164  IAVIStream_AddRef(This->pStream);
165 
166  return ref;
167 }
168 
170 {
173 
174  TRACE("(%p) -> %d\n", iface, ref);
175 
176  if (ref == 0) {
177  /* destruct */
178  if (This->has != NULL) {
179  if (This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)
180  acmStreamUnprepareHeader(This->has, &This->acmStreamHdr, 0);
181  acmStreamClose(This->has, 0);
182  This->has = NULL;
183  }
184  HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc);
185  This->acmStreamHdr.pbSrc = NULL;
186  HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbDst);
187  This->acmStreamHdr.pbDst = NULL;
188  if (This->lpInFormat != NULL) {
189  HeapFree(GetProcessHeap(), 0, This->lpInFormat);
190  This->lpInFormat = NULL;
191  This->cbInFormat = 0;
192  }
193  if (This->lpOutFormat != NULL) {
194  HeapFree(GetProcessHeap(), 0, This->lpOutFormat);
195  This->lpOutFormat = NULL;
196  This->cbOutFormat = 0;
197  }
198  if (This->pStream != NULL) {
199  IAVIStream_Release(This->pStream);
200  This->pStream = NULL;
201  }
203 
204  return 0;
205  }
206 
207  /* also release reference to the nested stream */
208  if (This->pStream != NULL)
209  IAVIStream_Release(This->pStream);
210 
211  return ref;
212 }
213 
214 /* lParam1: PAVISTREAM
215  * lParam2: LPAVICOMPRESSOPTIONS -- even if doc's say LPWAVEFORMAT
216  */
218  LPARAM lParam2)
219 {
221 
222  TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2);
223 
224  /* check for swapped parameters */
225  if ((LPVOID)lParam1 != NULL &&
226  ((LPAVICOMPRESSOPTIONS)lParam1)->fccType == streamtypeAUDIO) {
227  LPARAM tmp = lParam1;
228 
229  lParam1 = lParam2;
230  lParam2 = tmp;
231  }
232 
233  if ((LPVOID)lParam1 == NULL)
234  return AVIERR_BADPARAM;
235 
236  IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
237  if (This->sInfo.fccType != streamtypeAUDIO)
238  return AVIERR_ERROR; /* error in registry or AVIMakeCompressedStream */
239 
240  This->sInfo.fccHandler = 0; /* be paranoid */
241 
242  /* FIXME: check ACM version? Which version does we need? */
243 
244  if ((LPVOID)lParam2 != NULL) {
245  /* We only need the format from the compress-options */
246  if (((LPAVICOMPRESSOPTIONS)lParam2)->fccType == streamtypeAUDIO)
247  lParam2 = (LPARAM)((LPAVICOMPRESSOPTIONS)lParam2)->lpFormat;
248 
249  if (((LPWAVEFORMATEX)lParam2)->wFormatTag != WAVE_FORMAT_PCM)
250  This->cbOutFormat = sizeof(WAVEFORMATEX) + ((LPWAVEFORMATEX)lParam2)->cbSize;
251  else
252  This->cbOutFormat = sizeof(PCMWAVEFORMAT);
253 
254  This->lpOutFormat = HeapAlloc(GetProcessHeap(), 0, This->cbOutFormat);
255  if (This->lpOutFormat == NULL)
256  return AVIERR_MEMORY;
257 
258  memcpy(This->lpOutFormat, (LPVOID)lParam2, This->cbOutFormat);
259  } else {
260  This->lpOutFormat = NULL;
261  This->cbOutFormat = 0;
262  }
263 
264  This->pStream = (PAVISTREAM)lParam1;
265  IAVIStream_AddRef(This->pStream);
266 
267  return AVIERR_OK;
268 }
269 
271  LONG size)
272 {
274 
275  TRACE("(%p,%p,%d)\n", iface, psi, size);
276 
277  if (psi == NULL)
278  return AVIERR_BADPARAM;
279  if (size < 0)
280  return AVIERR_BADSIZE;
281 
282  /* Need codec to correct some values in structure */
283  if (This->has == NULL) {
285 
286  if (FAILED(hr))
287  return hr;
288  }
289 
290  memcpy(psi, &This->sInfo, min(size, (LONG)sizeof(This->sInfo)));
291 
292  if (size < (LONG)sizeof(This->sInfo))
293  return AVIERR_BUFFERTOOSMALL;
294  return AVIERR_OK;
295 }
296 
298  LONG flags)
299 {
301 
302  TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
303 
304  if (flags & FIND_FROM_START) {
305  pos = This->sInfo.dwStart;
307  flags |= FIND_NEXT;
308  }
309 
310  /* convert pos from our 'space' to This->pStream's one */
312 
313  /* ask stream */
314  pos = IAVIStream_FindSample(This->pStream, pos, flags);
315 
316  if (pos != -1) {
317  /* convert pos back to our 'space' if it's no size or physical pos */
318  if ((flags & FIND_RET) == 0)
320  }
321 
322  return pos;
323 }
324 
326  LPVOID format, LONG *formatsize)
327 {
329 
330  TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
331 
332  if (formatsize == NULL)
333  return AVIERR_BADPARAM;
334 
335  if (This->has == NULL) {
337 
338  if (FAILED(hr))
339  return hr;
340  }
341 
342  /* only interested in needed buffersize? */
343  if (format == NULL || *formatsize <= 0) {
344  *formatsize = This->cbOutFormat;
345 
346  return AVIERR_OK;
347  }
348 
349  /* copy initial format (only as much as will fit) */
350  memcpy(format, This->lpOutFormat, min(*formatsize, This->cbOutFormat));
351  if (*formatsize < This->cbOutFormat) {
352  *formatsize = This->cbOutFormat;
353  return AVIERR_BUFFERTOOSMALL;
354  }
355 
356  *formatsize = This->cbOutFormat;
357  return AVIERR_OK;
358 }
359 
361  LPVOID format, LONG formatsize)
362 {
364 
365  HRESULT hr;
366 
367  TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
368 
369  /* check parameters */
370  if (format == NULL || formatsize <= 0)
371  return AVIERR_BADPARAM;
372 
373  /* Input format already known?
374  * Changing is unsupported, but be quiet if it's the same */
375  if (This->lpInFormat != NULL) {
376  if (This->cbInFormat != formatsize ||
377  memcmp(format, This->lpInFormat, formatsize) != 0)
378  return AVIERR_UNSUPPORTED;
379 
380  return AVIERR_OK;
381  }
382 
383  /* Does the nested stream support writing? */
384  if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
385  return AVIERR_READONLY;
386 
387  This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, formatsize);
388  if (This->lpInFormat == NULL)
389  return AVIERR_MEMORY;
390  This->cbInFormat = formatsize;
391  memcpy(This->lpInFormat, format, formatsize);
392 
393  /* initialize formats and get compressor */
395  if (FAILED(hr))
396  return hr;
397 
399 
400  /* tell the nested stream the new format */
401  return IAVIStream_SetFormat(This->pStream, pos, This->lpOutFormat,
402  This->cbOutFormat);
403 }
404 
407  LONG buffersize, LPLONG bytesread,
408  LPLONG samplesread)
409 {
411 
412  HRESULT hr;
413  DWORD size;
414 
415  TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
416  buffersize, bytesread, samplesread);
417 
418  /* clear return parameters if given */
419  if (bytesread != NULL)
420  *bytesread = 0;
421  if (samplesread != NULL)
422  *samplesread = 0;
423 
424  /* Do we have our compressor? */
425  if (This->has == NULL) {
427 
428  if (FAILED(hr))
429  return hr;
430  }
431 
432  /* only need to pass through? */
433  if (This->cbInFormat == This->cbOutFormat &&
434  memcmp(This->lpInFormat, This->lpOutFormat, This->cbInFormat) == 0) {
435  return IAVIStream_Read(This->pStream, start, samples, buffer, buffersize,
436  bytesread, samplesread);
437  }
438 
439  /* read as much as fit? */
440  if (samples == -1)
441  samples = buffersize / This->lpOutFormat->nBlockAlign;
442  /* limit to buffersize */
443  if (samples * This->lpOutFormat->nBlockAlign > buffersize)
444  samples = buffersize / This->lpOutFormat->nBlockAlign;
445 
446  /* only return needed size? */
447  if (buffer == NULL || buffersize <= 0 || samples == 0) {
448  if (bytesread == NULL && samplesread == NULL)
449  return AVIERR_BADPARAM;
450 
451  if (bytesread != NULL)
452  *bytesread = samples * This->lpOutFormat->nBlockAlign;
453  if (samplesread != NULL)
454  *samplesread = samples;
455 
456  return AVIERR_OK;
457  }
458 
459  /* map our positions to pStream positions */
461 
462  /* our needed internal buffersize */
463  size = samples * This->lpInFormat->nBlockAlign;
464 
465  /* Need to free destination buffer used for writing? */
466  if (This->acmStreamHdr.pbDst != NULL) {
467  HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbDst);
468  This->acmStreamHdr.pbDst = NULL;
469  This->acmStreamHdr.dwDstUser = 0;
470  }
471 
472  /* need bigger source buffer? */
473  if (This->acmStreamHdr.pbSrc == NULL ||
474  This->acmStreamHdr.dwSrcUser < size) {
475  if (This->acmStreamHdr.pbSrc == NULL)
476  This->acmStreamHdr.pbSrc = HeapAlloc(GetProcessHeap(), 0, size);
477  else
478  This->acmStreamHdr.pbSrc = HeapReAlloc(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc, size);
479  if (This->acmStreamHdr.pbSrc == NULL)
480  return AVIERR_MEMORY;
481  This->acmStreamHdr.dwSrcUser = size;
482  }
483 
484  This->acmStreamHdr.cbStruct = sizeof(This->acmStreamHdr);
485  This->acmStreamHdr.cbSrcLengthUsed = 0;
486  This->acmStreamHdr.cbDstLengthUsed = 0;
487  This->acmStreamHdr.cbSrcLength = size;
488 
489  /* read source data */
490  hr = IAVIStream_Read(This->pStream, start, -1, This->acmStreamHdr.pbSrc,
491  This->acmStreamHdr.cbSrcLength,
492  (LONG *)&This->acmStreamHdr.cbSrcLength, NULL);
493  if (FAILED(hr) || This->acmStreamHdr.cbSrcLength == 0)
494  return hr;
495 
496  /* need to prepare stream? */
497  This->acmStreamHdr.pbDst = buffer;
498  This->acmStreamHdr.cbDstLength = buffersize;
499  if ((This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED) == 0) {
500  if (acmStreamPrepareHeader(This->has, &This->acmStreamHdr, 0) != S_OK) {
501  This->acmStreamHdr.pbDst = NULL;
502  This->acmStreamHdr.cbDstLength = 0;
503  return AVIERR_COMPRESSOR;
504  }
505  }
506 
507  /* now do the conversion */
508  /* FIXME: use ACM_CONVERTF_* flags */
509  if (acmStreamConvert(This->has, &This->acmStreamHdr, 0) != S_OK)
511 
512  This->acmStreamHdr.pbDst = NULL;
513  This->acmStreamHdr.cbDstLength = 0;
514 
515  /* fill out return parameters if given */
516  if (bytesread != NULL)
517  *bytesread = This->acmStreamHdr.cbDstLengthUsed;
518  if (samplesread != NULL)
519  *samplesread =
520  This->acmStreamHdr.cbDstLengthUsed / This->lpOutFormat->nBlockAlign;
521 
522  return hr;
523 }
524 
527  LONG buffersize, DWORD flags,
528  LPLONG sampwritten,
529  LPLONG byteswritten)
530 {
532 
533  HRESULT hr;
534  ULONG size;
535 
536  TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples,
537  buffer, buffersize, flags, sampwritten, byteswritten);
538 
539  /* clear return parameters if given */
540  if (sampwritten != NULL)
541  *sampwritten = 0;
542  if (byteswritten != NULL)
543  *byteswritten = 0;
544 
545  /* check parameters */
546  if (buffer == NULL && (buffersize > 0 || samples > 0))
547  return AVIERR_BADPARAM;
548 
549  /* Have we write capability? */
550  if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
551  return AVIERR_READONLY;
552 
553  /* also need a compressor */
554  if (This->has == NULL)
555  return AVIERR_NOCOMPRESSOR;
556 
557  /* map our sizes to pStream sizes */
558  size = buffersize;
561 
562  /* no bytes to write? -- short circuit */
563  if (size == 0) {
564  return IAVIStream_Write(This->pStream, -1, samples, buffer, size,
565  flags, sampwritten, byteswritten);
566  }
567 
568  /* Need to free source buffer used for reading? */
569  if (This->acmStreamHdr.pbSrc != NULL) {
570  HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc);
571  This->acmStreamHdr.pbSrc = NULL;
572  This->acmStreamHdr.dwSrcUser = 0;
573  }
574 
575  /* Need bigger destination buffer? */
576  if (This->acmStreamHdr.pbDst == NULL ||
577  This->acmStreamHdr.dwDstUser < size) {
578  if (This->acmStreamHdr.pbDst == NULL)
579  This->acmStreamHdr.pbDst = HeapAlloc(GetProcessHeap(), 0, size);
580  else
581  This->acmStreamHdr.pbDst = HeapReAlloc(GetProcessHeap(), 0, This->acmStreamHdr.pbDst, size);
582  if (This->acmStreamHdr.pbDst == NULL)
583  return AVIERR_MEMORY;
584  This->acmStreamHdr.dwDstUser = size;
585  }
586  This->acmStreamHdr.cbStruct = sizeof(This->acmStreamHdr);
587  This->acmStreamHdr.cbSrcLengthUsed = 0;
588  This->acmStreamHdr.cbDstLengthUsed = 0;
589  This->acmStreamHdr.cbDstLength = This->acmStreamHdr.dwDstUser;
590 
591  /* need to prepare stream? */
592  This->acmStreamHdr.pbSrc = buffer;
593  This->acmStreamHdr.cbSrcLength = buffersize;
594  if ((This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED) == 0) {
595  if (acmStreamPrepareHeader(This->has, &This->acmStreamHdr, 0) != S_OK) {
596  This->acmStreamHdr.pbSrc = NULL;
597  This->acmStreamHdr.cbSrcLength = 0;
598  return AVIERR_COMPRESSOR;
599  }
600  }
601 
602  /* now do the conversion */
603  /* FIXME: use ACM_CONVERTF_* flags */
604  if (acmStreamConvert(This->has, &This->acmStreamHdr, 0) != S_OK)
606  else
607  hr = AVIERR_OK;
608 
609  This->acmStreamHdr.pbSrc = NULL;
610  This->acmStreamHdr.cbSrcLength = 0;
611 
612  if (FAILED(hr))
613  return hr;
614 
615  return IAVIStream_Write(This->pStream,-1,This->acmStreamHdr.cbDstLengthUsed /
616  This->lpOutFormat->nBlockAlign,This->acmStreamHdr.pbDst,
617  This->acmStreamHdr.cbDstLengthUsed,flags,sampwritten,
618  byteswritten);
619 }
620 
622  LONG samples)
623 {
625 
626  TRACE("(%p,%d,%d)\n", iface, start, samples);
627 
628  /* check parameters */
629  if (start < 0 || samples < 0)
630  return AVIERR_BADPARAM;
631 
632  /* Delete before start of stream? */
633  if ((DWORD)(start + samples) < This->sInfo.dwStart)
634  return AVIERR_OK;
635 
636  /* Delete after end of stream? */
637  if ((DWORD)start > This->sInfo.dwLength)
638  return AVIERR_OK;
639 
640  /* For the rest we need write capability */
641  if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
642  return AVIERR_READONLY;
643 
644  /* A compressor is also necessary */
645  if (This->has == NULL)
646  return AVIERR_NOCOMPRESSOR;
647 
648  /* map our positions to pStream positions */
651 
652  return IAVIStream_Delete(This->pStream, start, samples);
653 }
654 
656  LPVOID lp, LPLONG lpread)
657 {
659 
660  TRACE("(%p,0x%08X,%p,%p)\n", iface, fcc, lp, lpread);
661 
662  assert(This->pStream != NULL);
663 
664  return IAVIStream_ReadData(This->pStream, fcc, lp, lpread);
665 }
666 
668  LPVOID lp, LONG size)
669 {
671 
672  TRACE("(%p,0x%08x,%p,%d)\n", iface, fcc, lp, size);
673 
674  assert(This->pStream != NULL);
675 
676  return IAVIStream_WriteData(This->pStream, fcc, lp, size);
677 }
678 
680  LPAVISTREAMINFOW info, LONG infolen)
681 {
682  FIXME("(%p,%p,%d): stub\n", iface, info, infolen);
683 
684  return E_FAIL;
685 }
686 
687 static const struct IAVIStreamVtbl iacmst = {
702 };
703 
705 {
706  IAVIStreamImpl *pstream;
707  HRESULT hr;
708 
709  assert(riid != NULL && ppv != NULL);
710 
711  *ppv = NULL;
712 
714  if (pstream == NULL)
715  return AVIERR_MEMORY;
716 
717  pstream->IAVIStream_iface.lpVtbl = &iacmst;
718 
720  if (FAILED(hr))
721  HeapFree(GetProcessHeap(), 0, pstream);
722 
723  return hr;
724 }
LONG cbOutFormat
Definition: acmstream.c:54
#define AVIERR_NOCOMPRESSOR
Definition: vfw.h:1755
GLsizei samples
Definition: glext.h:7006
#define CONVERT_THIS_to_STREAM(a)
Definition: acmstream.c:67
#define REFIID
Definition: guiddef.h:118
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
static HRESULT WINAPI ACMStream_fnQueryInterface(IAVIStream *iface, REFIID refiid, LPVOID *obj)
Definition: acmstream.c:137
static IAVIStreamImpl * impl_from_IAVIStream(IAVIStream *iface)
Definition: acmstream.c:132
HRESULT hr
Definition: shlfolder.c:183
REFIID riid
Definition: precomp.h:44
#define AVIERR_COMPRESSOR
Definition: vfw.h:1754
#define FIND_RET
Definition: vfw.h:1127
#define IAVIStream_Info(p, a, b)
Definition: vfw.h:1180
HRESULT AVIFILE_CreateACMStream(REFIID riid, LPVOID *ppv)
Definition: acmstream.c:704
static HRESULT WINAPI ACMStream_fnInfo(IAVIStream *iface, LPAVISTREAMINFOW psi, LONG size)
Definition: acmstream.c:270
static ULONG WINAPI ACMStream_fnAddRef(IAVIStream *iface)
Definition: acmstream.c:155
REFIID LPVOID * ppv
Definition: atlbase.h:39
#define ACM_FORMATSUGGESTF_WFORMATTAG
Definition: msacm.h:174
#define IAVIStream_Release(p)
Definition: vfw.h:1177
#define assert(x)
Definition: debug.h:53
GLuint buffer
Definition: glext.h:5915
static HRESULT WINAPI ACMStream_fnReadFormat(IAVIStream *iface, LONG pos, LPVOID format, LONG *formatsize)
Definition: acmstream.c:325
#define OLE_E_ENUM_NOMORE
Definition: winerror.h:2616
struct pcmwaveformat_tag PCMWAVEFORMAT
#define E_FAIL
Definition: ddrawi.h:102
#define DWORD
Definition: nt_native.h:44
static HRESULT WINAPI ACMStream_fnSetInfo(IAVIStream *iface, LPAVISTREAMINFOW info, LONG infolen)
Definition: acmstream.c:679
#define IAVIStream_ReadData(p, a, b, c)
Definition: vfw.h:1187
Definition: send.c:47
AVISTREAMINFOW sInfo
Definition: acmstream.c:46
static const WCHAR avifile[]
Definition: avisplitter.c:273
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#define AVIStreamFormatSize(pavi, lPos, plSize)
Definition: vfw.h:1436
static HRESULT WINAPI ACMStream_fnSetFormat(IAVIStream *iface, LONG pos, LPVOID format, LONG formatsize)
Definition: acmstream.c:360
static HRESULT WINAPI ACMStream_fnWrite(IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, DWORD flags, LPLONG sampwritten, LPLONG byteswritten)
Definition: acmstream.c:525
#define FIND_NEXT
Definition: vfw.h:1118
#define AVIERR_MEMORY
Definition: vfw.h:1745
HACMSTREAM has
Definition: acmstream.c:48
#define WAVE_FORMAT_PCM
Definition: constants.h:425
#define FIND_PREV
Definition: vfw.h:1119
WINE_DEFAULT_DEBUG_CHANNEL(avifile)
long LONG
Definition: pedump.c:60
#define ICQUALITY_DEFAULT
Definition: vfw.h:278
GLenum GLint ref
Definition: glext.h:6028
#define FIXME(fmt,...)
Definition: debug.h:110
#define IAVIStream_AddRef(p)
Definition: vfw.h:1176
struct _WAVEFORMATEX * LPWAVEFORMATEX
smooth NULL
Definition: ftsmooth.c:416
struct IAVIStream * PAVISTREAM
Definition: vfw.h:38
MMRESULT WINAPI acmStreamUnprepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwUnprepare)
Definition: stream.c:449
LONG_PTR LPARAM
Definition: windef.h:208
struct _IAVIStreamImpl IAVIStreamImpl
#define IAVIStream_ReadFormat(p, a, b, c)
Definition: vfw.h:1182
#define debugstr_guid
Definition: kernel32.h:35
static HRESULT WINAPI ACMStream_fnReadData(IAVIStream *iface, DWORD fcc, LPVOID lp, LPLONG lpread)
Definition: acmstream.c:655
#define AVIFILECAPS_CANWRITE
Definition: vfw.h:1061
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define AVIERR_BUFFERTOOSMALL
Definition: vfw.h:1758
#define AVIERR_BADPARAM
Definition: vfw.h:1748
#define AVIERR_UNSUPPORTED
Definition: vfw.h:1743
LPWAVEFORMATEX lpInFormat
Definition: acmstream.c:50
#define IAVIStream_Write(p, a, b, c, d, e, f, g)
Definition: vfw.h:1185
#define TRACE(s)
Definition: solgame.cpp:4
#define IAVIStream_Read(p, a, b, c, d, e, f)
Definition: vfw.h:1184
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define IAVIStream_SetFormat(p, a, b, c)
Definition: vfw.h:1183
LONG HRESULT
Definition: typedefs.h:77
static const struct IAVIStreamVtbl iacmst
Definition: acmstream.c:687
const GUID IID_IUnknown
#define AVIERR_BADSIZE
Definition: vfw.h:1749
#define WINAPI
Definition: msvc.h:8
unsigned long DWORD
Definition: ntddk_ex.h:95
static ULONG WINAPI ACMStream_fnRelease(IAVIStream *iface)
Definition: acmstream.c:169
GLbitfield flags
Definition: glext.h:7161
#define InterlockedDecrement
Definition: armddk.h:52
#define IAVIStream_WriteData(p, a, b, c)
Definition: vfw.h:1188
#define streamtypeAUDIO
Definition: aviriff.h:93
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
IAVIStream IAVIStream_iface
Definition: acmstream.c:41
LPCWSTR lpFormat
Definition: trayclock.cpp:32
BOOL WINAPI SetRectEmpty(_Out_ LPRECT)
static HRESULT WINAPI ACMStream_fnRead(IAVIStream *iface, LONG start, LONG samples, LPVOID buffer, LONG buffersize, LPLONG bytesread, LPLONG samplesread)
Definition: acmstream.c:405
#define IAVIStream_QueryInterface(p, a, b)
Definition: vfw.h:1175
static HRESULT WINAPI ACMStream_fnWriteData(IAVIStream *iface, DWORD fcc, LPVOID lp, LONG size)
Definition: acmstream.c:667
#define AVIERR_OK
Definition: vfw.h:1740
static LONG WINAPI ACMStream_fnFindSample(IAVIStream *iface, LONG pos, LONG flags)
Definition: acmstream.c:297
#define FIND_FROM_START
Definition: vfw.h:1120
#define S_OK
Definition: intsafe.h:59
int32_t * LPLONG
Definition: typedefs.h:56
#define InterlockedIncrement
Definition: armddk.h:53
GLuint start
Definition: gl.h:1545
MMRESULT WINAPI acmFormatSuggest(HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, DWORD cbwfxDst, DWORD fdwSuggest)
Definition: format.c:746
#define HeapReAlloc
Definition: compat.h:401
static HRESULT WINAPI ACMStream_fnDelete(IAVIStream *iface, LONG start, LONG samples)
Definition: acmstream.c:621
#define IAVIStream_Delete(p, a, b)
Definition: vfw.h:1186
#define min(a, b)
Definition: monoChain.cc:55
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
MMRESULT WINAPI acmStreamOpen(PHACMSTREAM phas, HACMDRIVER had, PWAVEFORMATEX pwfxSrc, PWAVEFORMATEX pwfxDst, PWAVEFILTER pwfltr, DWORD_PTR dwCallback, DWORD_PTR dwInstance, DWORD fdwOpen)
Definition: stream.c:149
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
MMRESULT WINAPI acmStreamPrepareHeader(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwPrepare)
Definition: stream.c:299
PAVISTREAM pStream
Definition: acmstream.c:45
#define CONVERT_STREAM_to_THIS(a)
Definition: acmstream.c:61
#define ACM_STREAMOPENF_NONREALTIME
Definition: msacm.h:215
#define ACMSTREAMHEADER_STATUSF_PREPARED
Definition: msacm.h:210
static HRESULT AVIFILE_OpenCompressor(IAVIStreamImpl *This)
Definition: acmstream.c:73
unsigned int ULONG
Definition: retypes.h:1
static HRESULT WINAPI ACMStream_fnCreate(IAVIStream *iface, LPARAM lParam1, LPARAM lParam2)
Definition: acmstream.c:217
ACMSTREAMHEADER acmStreamHdr
Definition: acmstream.c:56
#define AVIERR_READONLY
Definition: vfw.h:1756
LPWAVEFORMATEX lpOutFormat
Definition: acmstream.c:53
#define IAVIStream_FindSample(p, a, b)
Definition: vfw.h:1181
#define HeapFree(x, y, z)
Definition: compat.h:402
MMRESULT WINAPI acmStreamConvert(HACMSTREAM has, PACMSTREAMHEADER pash, DWORD fdwConvert)
Definition: stream.c:89
MMRESULT WINAPI acmStreamClose(HACMSTREAM has, DWORD fdwClose)
Definition: stream.c:65
#define AVIERR_ERROR
Definition: vfw.h:1761