dlls/avifil32/acmstream.c

   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
  35 WINE_DEFAULT_DEBUG_CHANNEL(avifile);
  36
  37 /***********************************************************************/
  38
  39 typedef struct _IAVIStreamImpl {
  40   /* IUnknown stuff */
  41   IAVIStream      IAVIStream_iface;
  42   LONG            ref;
  43
  44   /* IAVIStream stuff */
  45   PAVISTREAM      pStream;
  46   AVISTREAMINFOW  sInfo;
  47
  48   HACMSTREAM      has;
  49
  50   LPWAVEFORMATEX  lpInFormat;
  51   LONG            cbInFormat;
  52
  53   LPWAVEFORMATEX  lpOutFormat;
  54   LONG            cbOutFormat;
  55
  56   ACMSTREAMHEADER acmStreamHdr;
  57 } IAVIStreamImpl;
  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
  73 static HRESULT AVIFILE_OpenCompressor(IAVIStreamImpl *This)
  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,
 114                     NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME) != S_OK)
 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
 132 static inline IAVIStreamImpl *impl_from_IAVIStream(IAVIStream *iface)
 133 {
 134   return CONTAINING_RECORD(iface, IAVIStreamImpl, IAVIStream_iface);
 135 }
 136
 137 static HRESULT WINAPI ACMStream_fnQueryInterface(IAVIStream *iface,
 138                                                   REFIID refiid, LPVOID *obj)
 139 {
 140   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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
 155 static ULONG WINAPI ACMStream_fnAddRef(IAVIStream *iface)
 156 {
 157   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 158   ULONG ref = InterlockedIncrement(&This->ref);
 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
 169 static ULONG WINAPI ACMStream_fnRelease(IAVIStream* iface)
 170 {
 171   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 172   ULONG ref = InterlockedDecrement(&This->ref);
 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     }
 202     HeapFree(GetProcessHeap(), 0, This);
 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  */
 217 static HRESULT WINAPI ACMStream_fnCreate(IAVIStream *iface, LPARAM lParam1,
 218                                           LPARAM lParam2)
 219 {
 220   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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
 270 static HRESULT WINAPI ACMStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi,
 271                                         LONG size)
 272 {
 273   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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) {
 284     HRESULT hr = AVIFILE_OpenCompressor(This);
 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
 297 static LONG WINAPI ACMStream_fnFindSample(IAVIStream *iface, LONG pos,
 298                                            LONG flags)
 299 {
 300   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 301
 302   TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
 303
 304   if (flags & FIND_FROM_START) {
 305     pos = This->sInfo.dwStart;
 306     flags &= ~(FIND_FROM_START|FIND_PREV);
 307     flags |= FIND_NEXT;
 308   }
 309
 310   /* convert pos from our 'space' to This->pStream's one */
 311   CONVERT_THIS_to_STREAM(&pos);
 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)
 319       CONVERT_STREAM_to_THIS(&pos);
 320   }
 321
 322   return pos;
 323 }
 324
 325 static HRESULT WINAPI ACMStream_fnReadFormat(IAVIStream *iface, LONG pos,
 326                                               LPVOID format, LONG *formatsize)
 327 {
 328   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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) {
 336     HRESULT hr = AVIFILE_OpenCompressor(This);
 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
 360 static HRESULT WINAPI ACMStream_fnSetFormat(IAVIStream *iface, LONG pos,
 361                                              LPVOID format, LONG formatsize)
 362 {
 363   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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 */
 394   hr = AVIFILE_OpenCompressor(This);
 395   if (FAILED(hr))
 396     return hr;
 397
 398   CONVERT_THIS_to_STREAM(&pos);
 399
 400   /* tell the nested stream the new format */
 401   return IAVIStream_SetFormat(This->pStream, pos, This->lpOutFormat,
 402                               This->cbOutFormat);
 403 }
 404
 405 static HRESULT WINAPI ACMStream_fnRead(IAVIStream *iface, LONG start,
 406                                         LONG samples, LPVOID buffer,
 407                                         LONG buffersize, LPLONG bytesread,
 408                                         LPLONG samplesread)
 409 {
 410   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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) {
 426     hr = AVIFILE_OpenCompressor(This);
 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 */
 460   CONVERT_THIS_to_STREAM(&start);
 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)
 510     hr = AVIERR_COMPRESSOR;
 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
 525 static HRESULT WINAPI ACMStream_fnWrite(IAVIStream *iface, LONG start,
 526                                          LONG samples, LPVOID buffer,
 527                                          LONG buffersize, DWORD flags,
 528                                          LPLONG sampwritten,
 529                                          LPLONG byteswritten)
 530 {
 531   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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;
 559   CONVERT_THIS_to_STREAM(&size);
 560   CONVERT_THIS_to_STREAM(&start);
 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)
 605     hr = AVIERR_COMPRESSOR;
 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
 621 static HRESULT WINAPI ACMStream_fnDelete(IAVIStream *iface, LONG start,
 622                                           LONG samples)
 623 {
 624   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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 */
 649   CONVERT_THIS_to_STREAM(&start);
 650   CONVERT_THIS_to_STREAM(&samples);
 651
 652   return IAVIStream_Delete(This->pStream, start, samples);
 653 }
 654
 655 static HRESULT WINAPI ACMStream_fnReadData(IAVIStream *iface, DWORD fcc,
 656                                             LPVOID lp, LPLONG lpread)
 657 {
 658   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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
 667 static HRESULT WINAPI ACMStream_fnWriteData(IAVIStream *iface, DWORD fcc,
 668                                              LPVOID lp, LONG size)
 669 {
 670   IAVIStreamImpl *This = impl_from_IAVIStream(iface);
 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
 679 static HRESULT WINAPI ACMStream_fnSetInfo(IAVIStream *iface,
 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 = {
 688   ACMStream_fnQueryInterface,
 689   ACMStream_fnAddRef,
 690   ACMStream_fnRelease,
 691   ACMStream_fnCreate,
 692   ACMStream_fnInfo,
 693   ACMStream_fnFindSample,
 694   ACMStream_fnReadFormat,
 695   ACMStream_fnSetFormat,
 696   ACMStream_fnRead,
 697   ACMStream_fnWrite,
 698   ACMStream_fnDelete,
 699   ACMStream_fnReadData,
 700   ACMStream_fnWriteData,
 701   ACMStream_fnSetInfo
 702 };
 703
 704 HRESULT AVIFILE_CreateACMStream(REFIID riid, LPVOID *ppv)
 705 {
 706   IAVIStreamImpl *pstream;
 707   HRESULT         hr;
 708
 709   assert(riid != NULL && ppv != NULL);
 710
 711   *ppv = NULL;
 712
 713   pstream = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIStreamImpl));
 714   if (pstream == NULL)
 715     return AVIERR_MEMORY;
 716
 717   pstream->IAVIStream_iface.lpVtbl = &iacmst;
 718
 719   hr = IAVIStream_QueryInterface(&pstream->IAVIStream_iface, riid, ppv);
 720   if (FAILED(hr))
 721     HeapFree(GetProcessHeap(), 0, pstream);
 722
 723   return hr;
 724 }