dll/win32/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 static HRESULT WINAPI ACMStream_fnQueryInterface(IAVIStream*iface,REFIID refiid,LPVOID *obj);
  40 static ULONG   WINAPI ACMStream_fnAddRef(IAVIStream*iface);
  41 static ULONG   WINAPI ACMStream_fnRelease(IAVIStream* iface);
  42 static HRESULT WINAPI ACMStream_fnCreate(IAVIStream*iface,LPARAM lParam1,LPARAM lParam2);
  43 static HRESULT WINAPI ACMStream_fnInfo(IAVIStream*iface,AVISTREAMINFOW *psi,LONG size);
  44 static LONG    WINAPI ACMStream_fnFindSample(IAVIStream*iface,LONG pos,LONG flags);
  45 static HRESULT WINAPI ACMStream_fnReadFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG *formatsize);
  46 static HRESULT WINAPI ACMStream_fnSetFormat(IAVIStream*iface,LONG pos,LPVOID format,LONG formatsize);
  47 static HRESULT WINAPI ACMStream_fnRead(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,LONG *bytesread,LONG *samplesread);
  48 static HRESULT WINAPI ACMStream_fnWrite(IAVIStream*iface,LONG start,LONG samples,LPVOID buffer,LONG buffersize,DWORD flags,LONG *sampwritten,LONG *byteswritten);
  49 static HRESULT WINAPI ACMStream_fnDelete(IAVIStream*iface,LONG start,LONG samples);
  50 static HRESULT WINAPI ACMStream_fnReadData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG *lpread);
  51 static HRESULT WINAPI ACMStream_fnWriteData(IAVIStream*iface,DWORD fcc,LPVOID lp,LONG size);
  52 static HRESULT WINAPI ACMStream_fnSetInfo(IAVIStream*iface,AVISTREAMINFOW*info,LONG infolen);
  53
  54 static const struct IAVIStreamVtbl iacmst = {
  55   ACMStream_fnQueryInterface,
  56   ACMStream_fnAddRef,
  57   ACMStream_fnRelease,
  58   ACMStream_fnCreate,
  59   ACMStream_fnInfo,
  60   ACMStream_fnFindSample,
  61   ACMStream_fnReadFormat,
  62   ACMStream_fnSetFormat,
  63   ACMStream_fnRead,
  64   ACMStream_fnWrite,
  65   ACMStream_fnDelete,
  66   ACMStream_fnReadData,
  67   ACMStream_fnWriteData,
  68   ACMStream_fnSetInfo
  69 };
  70
  71 typedef struct _IAVIStreamImpl {
  72   /* IUnknown stuff */
  73   const IAVIStreamVtbl *lpVtbl;
  74   LONG            ref;
  75
  76   /* IAVIStream stuff */
  77   PAVISTREAM      pStream;
  78   AVISTREAMINFOW  sInfo;
  79
  80   HACMSTREAM      has;
  81
  82   LPWAVEFORMATEX  lpInFormat;
  83   LONG            cbInFormat;
  84
  85   LPWAVEFORMATEX  lpOutFormat;
  86   LONG            cbOutFormat;
  87
  88   ACMSTREAMHEADER acmStreamHdr;
  89 } IAVIStreamImpl;
  90
  91 /***********************************************************************/
  92
  93 #define CONVERT_STREAM_to_THIS(a) do { \
  94            DWORD __bytes; \
  95            acmStreamSize(This->has,*(a) * This->lpInFormat->nBlockAlign,\
  96                          &__bytes, ACM_STREAMSIZEF_SOURCE); \
  97            *(a) = __bytes / This->lpOutFormat->nBlockAlign; } while(0)
  98
  99 #define CONVERT_THIS_to_STREAM(a) do { \
 100            DWORD __bytes; \
 101            acmStreamSize(This->has,*(a) * This->lpOutFormat->nBlockAlign,\
 102                          &__bytes, ACM_STREAMSIZEF_DESTINATION); \
 103            *(a) = __bytes / This->lpInFormat->nBlockAlign; } while(0)
 104
 105 static HRESULT AVIFILE_OpenCompressor(IAVIStreamImpl *This);
 106
 107 HRESULT AVIFILE_CreateACMStream(REFIID riid, LPVOID *ppv)
 108 {
 109   IAVIStreamImpl *pstream;
 110   HRESULT         hr;
 111
 112   assert(riid != NULL && ppv != NULL);
 113
 114   *ppv = NULL;
 115
 116   pstream = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IAVIStreamImpl));
 117   if (pstream == NULL)
 118     return AVIERR_MEMORY;
 119
 120   pstream->lpVtbl = &iacmst;
 121
 122   hr = IAVIStream_QueryInterface((IAVIStream*)pstream, riid, ppv);
 123   if (FAILED(hr))
 124     HeapFree(GetProcessHeap(), 0, pstream);
 125
 126   return hr;
 127 }
 128
 129 static HRESULT WINAPI ACMStream_fnQueryInterface(IAVIStream *iface,
 130                                                   REFIID refiid, LPVOID *obj)
 131 {
 132   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 133
 134   TRACE("(%p,%s,%p)\n", iface, debugstr_guid(refiid), obj);
 135
 136   if (IsEqualGUID(&IID_IUnknown, refiid) ||
 137       IsEqualGUID(&IID_IAVIStream, refiid)) {
 138     *obj = This;
 139     IAVIStream_AddRef(iface);
 140
 141     return S_OK;
 142   }
 143
 144   return OLE_E_ENUM_NOMORE;
 145 }
 146
 147 static ULONG WINAPI ACMStream_fnAddRef(IAVIStream *iface)
 148 {
 149   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 150   ULONG ref = InterlockedIncrement(&This->ref);
 151
 152   TRACE("(%p) -> %d\n", iface, ref);
 153
 154   /* also add reference to the nested stream */
 155   if (This->pStream != NULL)
 156     IAVIStream_AddRef(This->pStream);
 157
 158   return ref;
 159 }
 160
 161 static ULONG WINAPI ACMStream_fnRelease(IAVIStream* iface)
 162 {
 163   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 164   ULONG ref = InterlockedDecrement(&This->ref);
 165
 166   TRACE("(%p) -> %d\n", iface, ref);
 167
 168   if (ref == 0) {
 169     /* destruct */
 170     if (This->has != NULL) {
 171       if (This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED)
 172         acmStreamUnprepareHeader(This->has, &This->acmStreamHdr, 0);
 173       acmStreamClose(This->has, 0);
 174       This->has = NULL;
 175     }
 176     HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc);
 177     This->acmStreamHdr.pbSrc = NULL;
 178     HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbDst);
 179     This->acmStreamHdr.pbDst = NULL;
 180     if (This->lpInFormat != NULL) {
 181       HeapFree(GetProcessHeap(), 0, This->lpInFormat);
 182       This->lpInFormat = NULL;
 183       This->cbInFormat = 0;
 184     }
 185     if (This->lpOutFormat != NULL) {
 186       HeapFree(GetProcessHeap(), 0, This->lpOutFormat);
 187       This->lpOutFormat = NULL;
 188       This->cbOutFormat = 0;
 189     }
 190     if (This->pStream != NULL) {
 191       IAVIStream_Release(This->pStream);
 192       This->pStream = NULL;
 193     }
 194     HeapFree(GetProcessHeap(), 0, This);
 195
 196     return 0;
 197   }
 198
 199   /* also release reference to the nested stream */
 200   if (This->pStream != NULL)
 201     IAVIStream_Release(This->pStream);
 202
 203   return ref;
 204 }
 205
 206 /* lParam1: PAVISTREAM
 207  * lParam2: LPAVICOMPRESSOPTIONS -- even if doc's say LPWAVEFORMAT
 208  */
 209 static HRESULT WINAPI ACMStream_fnCreate(IAVIStream *iface, LPARAM lParam1,
 210                                           LPARAM lParam2)
 211 {
 212   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 213
 214   TRACE("(%p,0x%08lX,0x%08lX)\n", iface, lParam1, lParam2);
 215
 216   /* check for swapped parameters */
 217   if ((LPVOID)lParam1 != NULL &&
 218       ((LPAVICOMPRESSOPTIONS)lParam1)->fccType == streamtypeAUDIO) {
 219     register LPARAM tmp = lParam1;
 220
 221     lParam1 = lParam2;
 222     lParam2 = tmp;
 223   }
 224
 225   if ((LPVOID)lParam1 == NULL)
 226     return AVIERR_BADPARAM;
 227
 228   IAVIStream_Info((PAVISTREAM)lParam1, &This->sInfo, sizeof(This->sInfo));
 229   if (This->sInfo.fccType != streamtypeAUDIO)
 230     return AVIERR_ERROR; /* error in registry or AVIMakeCompressedStream */
 231
 232   This->sInfo.fccHandler = 0; /* be paranoid */
 233
 234   /* FIXME: check ACM version? Which version does we need? */
 235
 236   if ((LPVOID)lParam2 != NULL) {
 237     /* We only need the format from the compress-options */
 238     if (((LPAVICOMPRESSOPTIONS)lParam2)->fccType == streamtypeAUDIO)
 239       lParam2 = (LPARAM)((LPAVICOMPRESSOPTIONS)lParam2)->lpFormat;
 240
 241     if (((LPWAVEFORMATEX)lParam2)->wFormatTag != WAVE_FORMAT_PCM)
 242       This->cbOutFormat = sizeof(WAVEFORMATEX) + ((LPWAVEFORMATEX)lParam2)->cbSize;
 243     else
 244       This->cbOutFormat = sizeof(PCMWAVEFORMAT);
 245
 246     This->lpOutFormat = HeapAlloc(GetProcessHeap(), 0, This->cbOutFormat);
 247     if (This->lpOutFormat == NULL)
 248       return AVIERR_MEMORY;
 249
 250     memcpy(This->lpOutFormat, (LPVOID)lParam2, This->cbOutFormat);
 251   } else {
 252     This->lpOutFormat = NULL;
 253     This->cbOutFormat = 0;
 254   }
 255
 256   This->pStream = (PAVISTREAM)lParam1;
 257   IAVIStream_AddRef(This->pStream);
 258
 259   return AVIERR_OK;
 260 }
 261
 262 static HRESULT WINAPI ACMStream_fnInfo(IAVIStream *iface,LPAVISTREAMINFOW psi,
 263                                         LONG size)
 264 {
 265   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 266
 267   TRACE("(%p,%p,%d)\n", iface, psi, size);
 268
 269   if (psi == NULL)
 270     return AVIERR_BADPARAM;
 271   if (size < 0)
 272     return AVIERR_BADSIZE;
 273
 274   /* Need codec to correct some values in structure */
 275   if (This->has == NULL) {
 276     HRESULT hr = AVIFILE_OpenCompressor(This);
 277
 278     if (FAILED(hr))
 279       return hr;
 280   }
 281
 282   memcpy(psi, &This->sInfo, min(size, (LONG)sizeof(This->sInfo)));
 283
 284   if (size < (LONG)sizeof(This->sInfo))
 285     return AVIERR_BUFFERTOOSMALL;
 286   return AVIERR_OK;
 287 }
 288
 289 static LONG WINAPI ACMStream_fnFindSample(IAVIStream *iface, LONG pos,
 290                                            LONG flags)
 291 {
 292   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 293
 294   TRACE("(%p,%d,0x%08X)\n",iface,pos,flags);
 295
 296   if (flags & FIND_FROM_START) {
 297     pos = This->sInfo.dwStart;
 298     flags &= ~(FIND_FROM_START|FIND_PREV);
 299     flags |= FIND_NEXT;
 300   }
 301
 302   /* convert pos from our 'space' to This->pStream's one */
 303   CONVERT_THIS_to_STREAM(&pos);
 304
 305   /* ask stream */
 306   pos = IAVIStream_FindSample(This->pStream, pos, flags);
 307
 308   if (pos != -1) {
 309     /* convert pos back to our 'space' if it's no size or physical pos */
 310     if ((flags & FIND_RET) == 0)
 311       CONVERT_STREAM_to_THIS(&pos);
 312   }
 313
 314   return pos;
 315 }
 316
 317 static HRESULT WINAPI ACMStream_fnReadFormat(IAVIStream *iface, LONG pos,
 318                                               LPVOID format, LONG *formatsize)
 319 {
 320   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 321
 322   TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
 323
 324   if (formatsize == NULL)
 325     return AVIERR_BADPARAM;
 326
 327   if (This->has == NULL) {
 328     HRESULT hr = AVIFILE_OpenCompressor(This);
 329
 330     if (FAILED(hr))
 331       return hr;
 332   }
 333
 334   /* only interested in needed buffersize? */
 335   if (format == NULL || *formatsize <= 0) {
 336     *formatsize = This->cbOutFormat;
 337
 338     return AVIERR_OK;
 339   }
 340
 341   /* copy initial format (only as much as will fit) */
 342   memcpy(format, This->lpOutFormat, min(*formatsize, This->cbOutFormat));
 343   if (*formatsize < This->cbOutFormat) {
 344     *formatsize = This->cbOutFormat;
 345     return AVIERR_BUFFERTOOSMALL;
 346   }
 347
 348   *formatsize = This->cbOutFormat;
 349   return AVIERR_OK;
 350 }
 351
 352 static HRESULT WINAPI ACMStream_fnSetFormat(IAVIStream *iface, LONG pos,
 353                                              LPVOID format, LONG formatsize)
 354 {
 355   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 356
 357   HRESULT hr;
 358
 359   TRACE("(%p,%d,%p,%d)\n", iface, pos, format, formatsize);
 360
 361   /* check parameters */
 362   if (format == NULL || formatsize <= 0)
 363     return AVIERR_BADPARAM;
 364
 365   /* Input format already known?
 366    * Changing is unsupported, but be quiet if it's the same */
 367   if (This->lpInFormat != NULL) {
 368     if (This->cbInFormat != formatsize ||
 369         memcmp(format, This->lpInFormat, formatsize) != 0)
 370       return AVIERR_UNSUPPORTED;
 371
 372     return AVIERR_OK;
 373   }
 374
 375   /* Does the nested stream support writing? */
 376   if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
 377     return AVIERR_READONLY;
 378
 379   This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, formatsize);
 380   if (This->lpInFormat == NULL)
 381     return AVIERR_MEMORY;
 382   This->cbInFormat = formatsize;
 383   memcpy(This->lpInFormat, format, formatsize);
 384
 385   /* initialize formats and get compressor */
 386   hr = AVIFILE_OpenCompressor(This);
 387   if (FAILED(hr))
 388     return hr;
 389
 390   CONVERT_THIS_to_STREAM(&pos);
 391
 392   /* tell the nested stream the new format */
 393   return IAVIStream_SetFormat(This->pStream, pos, This->lpOutFormat,
 394                               This->cbOutFormat);
 395 }
 396
 397 static HRESULT WINAPI ACMStream_fnRead(IAVIStream *iface, LONG start,
 398                                         LONG samples, LPVOID buffer,
 399                                         LONG buffersize, LPLONG bytesread,
 400                                         LPLONG samplesread)
 401 {
 402   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 403
 404   HRESULT hr;
 405   DWORD   size;
 406
 407   TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
 408         buffersize, bytesread, samplesread);
 409
 410   /* clear return parameters if given */
 411   if (bytesread != NULL)
 412     *bytesread = 0;
 413   if (samplesread != NULL)
 414     *samplesread = 0;
 415
 416   /* Do we have our compressor? */
 417   if (This->has == NULL) {
 418     hr = AVIFILE_OpenCompressor(This);
 419
 420     if (FAILED(hr))
 421       return hr;
 422   }
 423
 424   /* only need to pass through? */
 425   if (This->cbInFormat == This->cbOutFormat &&
 426       memcmp(This->lpInFormat, This->lpOutFormat, This->cbInFormat) == 0) {
 427     return IAVIStream_Read(This->pStream, start, samples, buffer, buffersize,
 428                            bytesread, samplesread);
 429   }
 430
 431   /* read as much as fit? */
 432   if (samples == -1)
 433     samples = buffersize / This->lpOutFormat->nBlockAlign;
 434   /* limit to buffersize */
 435   if (samples * This->lpOutFormat->nBlockAlign > buffersize)
 436     samples = buffersize / This->lpOutFormat->nBlockAlign;
 437
 438   /* only return needed size? */
 439   if (buffer == NULL || buffersize <= 0 || samples == 0) {
 440     if (bytesread == NULL && samplesread == NULL)
 441       return AVIERR_BADPARAM;
 442
 443     if (bytesread != NULL)
 444       *bytesread = samples * This->lpOutFormat->nBlockAlign;
 445     if (samplesread != NULL)
 446       *samplesread = samples;
 447
 448     return AVIERR_OK;
 449   }
 450
 451   /* map our positions to pStream positions */
 452   CONVERT_THIS_to_STREAM(&start);
 453
 454   /* our needed internal buffersize */
 455   size = samples * This->lpInFormat->nBlockAlign;
 456
 457   /* Need to free destination buffer used for writing? */
 458   if (This->acmStreamHdr.pbDst != NULL) {
 459     HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbDst);
 460     This->acmStreamHdr.pbDst     = NULL;
 461     This->acmStreamHdr.dwDstUser = 0;
 462   }
 463
 464   /* need bigger source buffer? */
 465   if (This->acmStreamHdr.pbSrc == NULL ||
 466       This->acmStreamHdr.dwSrcUser < size) {
 467     if (This->acmStreamHdr.pbSrc == NULL)
 468       This->acmStreamHdr.pbSrc = HeapAlloc(GetProcessHeap(), 0, size);
 469     else
 470       This->acmStreamHdr.pbSrc = HeapReAlloc(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc, size);
 471     if (This->acmStreamHdr.pbSrc == NULL)
 472       return AVIERR_MEMORY;
 473     This->acmStreamHdr.dwSrcUser = size;
 474   }
 475
 476   This->acmStreamHdr.cbStruct = sizeof(This->acmStreamHdr);
 477   This->acmStreamHdr.cbSrcLengthUsed = 0;
 478   This->acmStreamHdr.cbDstLengthUsed = 0;
 479   This->acmStreamHdr.cbSrcLength     = size;
 480
 481   /* read source data */
 482   hr = IAVIStream_Read(This->pStream, start, -1, This->acmStreamHdr.pbSrc,
 483                        This->acmStreamHdr.cbSrcLength,
 484                        (LONG *)&This->acmStreamHdr.cbSrcLength, NULL);
 485   if (FAILED(hr) || This->acmStreamHdr.cbSrcLength == 0)
 486     return hr;
 487
 488   /* need to prepare stream? */
 489   This->acmStreamHdr.pbDst       = buffer;
 490   This->acmStreamHdr.cbDstLength = buffersize;
 491   if ((This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED) == 0) {
 492     if (acmStreamPrepareHeader(This->has, &This->acmStreamHdr, 0) != S_OK) {
 493       This->acmStreamHdr.pbDst       = NULL;
 494       This->acmStreamHdr.cbDstLength = 0;
 495       return AVIERR_COMPRESSOR;
 496     }
 497   }
 498
 499   /* now do the conversion */
 500   /* FIXME: use ACM_CONVERTF_* flags */
 501   if (acmStreamConvert(This->has, &This->acmStreamHdr, 0) != S_OK)
 502     hr = AVIERR_COMPRESSOR;
 503
 504   This->acmStreamHdr.pbDst       = NULL;
 505   This->acmStreamHdr.cbDstLength = 0;
 506
 507   /* fill out return parameters if given */
 508   if (bytesread != NULL)
 509     *bytesread = This->acmStreamHdr.cbDstLengthUsed;
 510   if (samplesread != NULL)
 511     *samplesread =
 512       This->acmStreamHdr.cbDstLengthUsed / This->lpOutFormat->nBlockAlign;
 513
 514   return hr;
 515 }
 516
 517 static HRESULT WINAPI ACMStream_fnWrite(IAVIStream *iface, LONG start,
 518                                          LONG samples, LPVOID buffer,
 519                                          LONG buffersize, DWORD flags,
 520                                          LPLONG sampwritten,
 521                                          LPLONG byteswritten)
 522 {
 523   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 524
 525   HRESULT hr;
 526   ULONG   size;
 527
 528   TRACE("(%p,%d,%d,%p,%d,0x%08X,%p,%p)\n", iface, start, samples,
 529         buffer, buffersize, flags, sampwritten, byteswritten);
 530
 531   /* clear return parameters if given */
 532   if (sampwritten != NULL)
 533     *sampwritten = 0;
 534   if (byteswritten != NULL)
 535     *byteswritten = 0;
 536
 537   /* check parameters */
 538   if (buffer == NULL && (buffersize > 0 || samples > 0))
 539     return AVIERR_BADPARAM;
 540
 541   /* Have we write capability? */
 542   if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
 543     return AVIERR_READONLY;
 544
 545   /* also need a compressor */
 546   if (This->has == NULL)
 547     return AVIERR_NOCOMPRESSOR;
 548
 549   /* map our sizes to pStream sizes */
 550   size = buffersize;
 551   CONVERT_THIS_to_STREAM(&size);
 552   CONVERT_THIS_to_STREAM(&start);
 553
 554   /* no bytes to write? -- short circuit */
 555   if (size == 0) {
 556     return IAVIStream_Write(This->pStream, -1, samples, buffer, size,
 557                             flags, sampwritten, byteswritten);
 558   }
 559
 560   /* Need to free source buffer used for reading? */
 561   if (This->acmStreamHdr.pbSrc != NULL) {
 562     HeapFree(GetProcessHeap(), 0, This->acmStreamHdr.pbSrc);
 563     This->acmStreamHdr.pbSrc     = NULL;
 564     This->acmStreamHdr.dwSrcUser = 0;
 565   }
 566
 567   /* Need bigger destination buffer? */
 568   if (This->acmStreamHdr.pbDst == NULL ||
 569       This->acmStreamHdr.dwDstUser < size) {
 570     if (This->acmStreamHdr.pbDst == NULL)
 571       This->acmStreamHdr.pbDst = HeapAlloc(GetProcessHeap(), 0, size);
 572     else
 573       This->acmStreamHdr.pbDst = HeapReAlloc(GetProcessHeap(), 0, This->acmStreamHdr.pbDst, size);
 574     if (This->acmStreamHdr.pbDst == NULL)
 575       return AVIERR_MEMORY;
 576     This->acmStreamHdr.dwDstUser = size;
 577   }
 578   This->acmStreamHdr.cbStruct        = sizeof(This->acmStreamHdr);
 579   This->acmStreamHdr.cbSrcLengthUsed = 0;
 580   This->acmStreamHdr.cbDstLengthUsed = 0;
 581   This->acmStreamHdr.cbDstLength     = This->acmStreamHdr.dwDstUser;
 582
 583   /* need to prepare stream? */
 584   This->acmStreamHdr.pbSrc       = buffer;
 585   This->acmStreamHdr.cbSrcLength = buffersize;
 586   if ((This->acmStreamHdr.fdwStatus & ACMSTREAMHEADER_STATUSF_PREPARED) == 0) {
 587     if (acmStreamPrepareHeader(This->has, &This->acmStreamHdr, 0) != S_OK) {
 588       This->acmStreamHdr.pbSrc       = NULL;
 589       This->acmStreamHdr.cbSrcLength = 0;
 590       return AVIERR_COMPRESSOR;
 591     }
 592   }
 593
 594   /* now do the conversion */
 595   /* FIXME: use ACM_CONVERTF_* flags */
 596   if (acmStreamConvert(This->has, &This->acmStreamHdr, 0) != S_OK)
 597     hr = AVIERR_COMPRESSOR;
 598   else
 599     hr = AVIERR_OK;
 600
 601   This->acmStreamHdr.pbSrc       = NULL;
 602   This->acmStreamHdr.cbSrcLength = 0;
 603
 604   if (FAILED(hr))
 605     return hr;
 606
 607   return IAVIStream_Write(This->pStream,-1,This->acmStreamHdr.cbDstLengthUsed /
 608                           This->lpOutFormat->nBlockAlign,This->acmStreamHdr.pbDst,
 609                           This->acmStreamHdr.cbDstLengthUsed,flags,sampwritten,
 610                           byteswritten);
 611 }
 612
 613 static HRESULT WINAPI ACMStream_fnDelete(IAVIStream *iface, LONG start,
 614                                           LONG samples)
 615 {
 616   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 617
 618   TRACE("(%p,%d,%d)\n", iface, start, samples);
 619
 620   /* check parameters */
 621   if (start < 0 || samples < 0)
 622     return AVIERR_BADPARAM;
 623
 624   /* Delete before start of stream? */
 625   if ((DWORD)(start + samples) < This->sInfo.dwStart)
 626     return AVIERR_OK;
 627
 628   /* Delete after end of stream? */
 629   if ((DWORD)start > This->sInfo.dwLength)
 630     return AVIERR_OK;
 631
 632   /* For the rest we need write capability */
 633   if ((This->sInfo.dwCaps & AVIFILECAPS_CANWRITE) == 0)
 634     return AVIERR_READONLY;
 635
 636   /* A compressor is also necessary */
 637   if (This->has == NULL)
 638     return AVIERR_NOCOMPRESSOR;
 639
 640   /* map our positions to pStream positions */
 641   CONVERT_THIS_to_STREAM(&start);
 642   CONVERT_THIS_to_STREAM(&samples);
 643
 644   return IAVIStream_Delete(This->pStream, start, samples);
 645 }
 646
 647 static HRESULT WINAPI ACMStream_fnReadData(IAVIStream *iface, DWORD fcc,
 648                                             LPVOID lp, LPLONG lpread)
 649 {
 650   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 651
 652   TRACE("(%p,0x%08X,%p,%p)\n", iface, fcc, lp, lpread);
 653
 654   assert(This->pStream != NULL);
 655
 656   return IAVIStream_ReadData(This->pStream, fcc, lp, lpread);
 657 }
 658
 659 static HRESULT WINAPI ACMStream_fnWriteData(IAVIStream *iface, DWORD fcc,
 660                                              LPVOID lp, LONG size)
 661 {
 662   IAVIStreamImpl *This = (IAVIStreamImpl *)iface;
 663
 664   TRACE("(%p,0x%08x,%p,%d)\n", iface, fcc, lp, size);
 665
 666   assert(This->pStream != NULL);
 667
 668   return IAVIStream_WriteData(This->pStream, fcc, lp, size);
 669 }
 670
 671 static HRESULT WINAPI ACMStream_fnSetInfo(IAVIStream *iface,
 672                                            LPAVISTREAMINFOW info, LONG infolen)
 673 {
 674   FIXME("(%p,%p,%d): stub\n", iface, info, infolen);
 675
 676   return E_FAIL;
 677 }
 678
 679 /***********************************************************************/
 680
 681 static HRESULT AVIFILE_OpenCompressor(IAVIStreamImpl *This)
 682 {
 683   HRESULT hr;
 684
 685   /* pre-conditions */
 686   assert(This != NULL);
 687   assert(This->pStream != NULL);
 688
 689   if (This->has != NULL)
 690     return AVIERR_OK;
 691
 692   if (This->lpInFormat == NULL) {
 693     /* decode or encode the data from pStream */
 694     hr = AVIStreamFormatSize(This->pStream, This->sInfo.dwStart, &This->cbInFormat);
 695     if (FAILED(hr))
 696       return hr;
 697     This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, This->cbInFormat);
 698     if (This->lpInFormat == NULL)
 699       return AVIERR_MEMORY;
 700
 701     hr = IAVIStream_ReadFormat(This->pStream, This->sInfo.dwStart,
 702                                This->lpInFormat, &This->cbInFormat);
 703     if (FAILED(hr))
 704       return hr;
 705
 706     if (This->lpOutFormat == NULL) {
 707       /* we must decode to default format */
 708       This->cbOutFormat = sizeof(PCMWAVEFORMAT);
 709       This->lpOutFormat = HeapAlloc(GetProcessHeap(), 0, This->cbOutFormat);
 710       if (This->lpOutFormat == NULL)
 711         return AVIERR_MEMORY;
 712
 713       This->lpOutFormat->wFormatTag = WAVE_FORMAT_PCM;
 714       if (acmFormatSuggest(NULL, This->lpInFormat, This->lpOutFormat,
 715                            This->cbOutFormat, ACM_FORMATSUGGESTF_WFORMATTAG) != S_OK)
 716         return AVIERR_NOCOMPRESSOR;
 717     }
 718   } else if (This->lpOutFormat == NULL)
 719     return AVIERR_ERROR; /* To what should I encode? */
 720
 721   if (acmStreamOpen(&This->has, NULL, This->lpInFormat, This->lpOutFormat,
 722                     NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME) != S_OK)
 723     return AVIERR_NOCOMPRESSOR;
 724
 725   /* update AVISTREAMINFO structure */
 726   This->sInfo.dwSampleSize = This->lpOutFormat->nBlockAlign;
 727   This->sInfo.dwScale      = This->lpOutFormat->nBlockAlign;
 728   This->sInfo.dwRate       = This->lpOutFormat->nAvgBytesPerSec;
 729   This->sInfo.dwQuality    = (DWORD)ICQUALITY_DEFAULT;
 730   SetRectEmpty(&This->sInfo.rcFrame);
 731
 732   /* convert positions and sizes to output format */
 733   CONVERT_STREAM_to_THIS(&This->sInfo.dwStart);
 734   CONVERT_STREAM_to_THIS(&This->sInfo.dwLength);
 735   CONVERT_STREAM_to_THIS(&This->sInfo.dwSuggestedBufferSize);
 736
 737   return AVIERR_OK;
 738 }