lib/drivers/sound/mmebuddy/wave/streaming.c

   1 /*
   2  * PROJECT:     ReactOS Sound System "MME Buddy" Library
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        lib/drivers/sound/mmebuddy/wave/streaming.c
   5  *
   6  * PURPOSE:     Wave streaming
   7  *
   8  * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
   9 */
  10
  11 #include <windows.h>
  12 #include <mmsystem.h>
  13 #include <mmddk.h>
  14 #include <ntddsnd.h>
  15 #include <mmebuddy.h>
  16 #include <sndtypes.h>
  17
  18
  19 /*
  20     DoWaveStreaming
  21         Check if there is streaming to be done, and if so, do it.
  22 */
  23
  24 VOID
  25 DoWaveStreaming(
  26     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
  27 {
  28     MMRESULT Result;
  29     MMDEVICE_TYPE DeviceType;
  30     PSOUND_DEVICE SoundDevice;
  31     PMMFUNCTION_TABLE FunctionTable;
  32     PWAVEHDR Header;
  33     PWAVEHDR_EXTENSION HeaderExtension;
  34
  35     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
  36     SND_ASSERT( MMSUCCESS(Result) );
  37
  38     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
  39     SND_ASSERT( MMSUCCESS(Result) );
  40
  41     Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
  42     SND_ASSERT( MMSUCCESS(Result) );
  43     SND_ASSERT( FunctionTable );
  44     SND_ASSERT( FunctionTable->CommitWaveBuffer );
  45
  46     /* No point in doing anything if no resources available to use */
  47     if ( SoundDeviceInstance->OutstandingBuffers >= SoundDeviceInstance->BufferCount )
  48     {
  49         SND_TRACE(L"DoWaveStreaming: No available buffers to stream with - doing nothing\n");
  50         return;
  51     }
  52
  53     /* Is there any work to do? */
  54     Header = SoundDeviceInstance->HeadWaveHeader;
  55
  56     if ( ! Header )
  57     {
  58         SND_TRACE(L"DoWaveStreaming: No work to do - doing nothing\n");
  59         return;
  60     }
  61
  62     while ( ( SoundDeviceInstance->OutstandingBuffers < SoundDeviceInstance->BufferCount ) &&
  63             ( Header ) )
  64     {
  65         HeaderExtension = (PWAVEHDR_EXTENSION) Header->reserved;
  66         SND_ASSERT( HeaderExtension );
  67
  68         /* Saniy checks */
  69         SND_ASSERT(Header->dwFlags & WHDR_PREPARED);
  70         SND_ASSERT(Header->dwFlags & WHDR_INQUEUE);
  71
  72         /* Can never be *above* the length */
  73         SND_ASSERT( HeaderExtension->BytesCommitted <= Header->dwBufferLength );
  74
  75         /* Is this header entirely committed? */
  76         if ( HeaderExtension->BytesCommitted == Header->dwBufferLength )
  77         {
  78             {
  79                 /* Move on to the next header */
  80                 SND_ASSERT(Header != Header->lpNext);
  81                 Header = Header->lpNext;
  82             }
  83         }
  84         else
  85         {
  86             PSOUND_OVERLAPPED Overlap;
  87             LPVOID OffsetPtr;
  88             DWORD BytesRemaining, BytesToCommit;
  89             BOOL OK;
  90
  91             /* Where within the header buffer to stream from */
  92             OffsetPtr = Header->lpData + HeaderExtension->BytesCommitted;
  93
  94             /* How much of this header has not been committed */
  95             BytesRemaining = Header->dwBufferLength - HeaderExtension->BytesCommitted;
  96
  97             /* We can commit anything up to the buffer size limit */
  98             BytesToCommit = BytesRemaining > SoundDeviceInstance->FrameSize ?
  99                             SoundDeviceInstance->FrameSize :
 100                             BytesRemaining;
 101
 102             /* Should always have something to commit by this point */
 103             SND_ASSERT( BytesToCommit > 0 );
 104
 105             /* We need a new overlapped info structure for each buffer */
 106             Overlap = AllocateStruct(SOUND_OVERLAPPED);
 107
 108             if ( Overlap )
 109             {
 110                 ZeroMemory(Overlap, sizeof(SOUND_OVERLAPPED));
 111                 Overlap->SoundDeviceInstance = SoundDeviceInstance;
 112                 Overlap->Header = Header;
 113
 114                 /* Don't complete this header if it's part of a loop */
 115                 Overlap->PerformCompletion = TRUE;
 116 //                    ( SoundDeviceInstance->LoopsRemaining > 0 );
 117
 118                 /* Adjust the commit-related counters */
 119                 HeaderExtension->BytesCommitted += BytesToCommit;
 120                 ++ SoundDeviceInstance->OutstandingBuffers;
 121
 122                 OK = MMSUCCESS(FunctionTable->CommitWaveBuffer(SoundDeviceInstance,
 123                                                                OffsetPtr,
 124                                                                BytesToCommit,
 125                                                                Overlap,
 126                                                                CompleteIO));
 127
 128                 if ( ! OK )
 129                 {
 130                     /* Clean-up and try again on the next iteration (is this OK?) */
 131                     SND_WARN(L"FAILED\n");
 132
 133                     FreeMemory(Overlap);
 134                     HeaderExtension->BytesCommitted -= BytesToCommit;
 135                     -- SoundDeviceInstance->OutstandingBuffers;
 136                 }
 137             }
 138         }
 139     }
 140 }
 141
 142
 143 /*
 144     CompleteIO
 145         An APC called as a result of a call to CommitWaveHeaderToKernelDevice.
 146         This will count up the number of bytes which have been dealt with,
 147         and when the entire wave header has been dealt with, will call
 148         CompleteWaveHeader to have the wave header returned to the client.
 149
 150     CommitWaveHeaderToKernelDevice
 151         Sends portions of the buffer described by the wave header to a kernel
 152         device. This must only be called from within the context of the sound
 153         thread. The caller supplies either their own commit routine, or uses
 154         WriteFileEx_Committer. The committer is called with portions of the
 155         buffer specified in the wave header.
 156
 157     WriteFileEx_Committer
 158         Commit buffers using the WriteFileEx API.
 159 */
 160
 161 VOID CALLBACK
 162 CompleteIO(
 163     IN  DWORD dwErrorCode,
 164     IN  DWORD dwNumberOfBytesTransferred,
 165     IN  LPOVERLAPPED lpOverlapped)
 166 {
 167     MMDEVICE_TYPE DeviceType;
 168     PSOUND_DEVICE SoundDevice;
 169     PSOUND_DEVICE_INSTANCE SoundDeviceInstance;
 170     PSOUND_OVERLAPPED SoundOverlapped = (PSOUND_OVERLAPPED) lpOverlapped;
 171     PWAVEHDR WaveHdr;
 172     PWAVEHDR_EXTENSION HdrExtension;
 173     MMRESULT Result;
 174     DWORD Bytes;
 175
 176     WaveHdr = (PWAVEHDR) SoundOverlapped->Header;
 177     SND_ASSERT( WaveHdr );
 178
 179     SND_ASSERT( ERROR_SUCCESS == dwErrorCode );
 180
 181     HdrExtension = (PWAVEHDR_EXTENSION) WaveHdr->reserved;
 182     SND_ASSERT( HdrExtension );
 183
 184     SoundDeviceInstance = SoundOverlapped->SoundDeviceInstance;
 185
 186     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 187     SND_ASSERT( MMSUCCESS(Result) );
 188
 189     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 190     SND_ASSERT( MMSUCCESS(Result) );
 191
 192     do
 193         {
 194
 195         /* We have an available buffer now */
 196         -- SoundDeviceInstance->OutstandingBuffers;
 197
 198         /* Did we finish a WAVEHDR and aren't looping? */
 199         if ( HdrExtension->BytesCompleted + dwNumberOfBytesTransferred >= WaveHdr->dwBufferLength &&
 200             SoundOverlapped->PerformCompletion )
 201         {
 202             /* Wave buffer fully completed */
 203             Bytes = WaveHdr->dwBufferLength - HdrExtension->BytesCompleted;
 204
 205             HdrExtension->BytesCompleted += Bytes;
 206             dwNumberOfBytesTransferred -= Bytes;
 207
 208             CompleteWaveHeader(SoundDeviceInstance, WaveHdr);
 209             SND_TRACE(L"%d/%d bytes of wavehdr completed\n", HdrExtension->BytesCompleted, WaveHdr->dwBufferLength);
 210         }
 211                 else
 212                 {
 213             /* Partially completed */
 214             HdrExtension->BytesCompleted += dwNumberOfBytesTransferred;
 215             SND_TRACE(L"%d/%d bytes of wavehdr completed\n", HdrExtension->BytesCompleted, WaveHdr->dwBufferLength);
 216             break;
 217                 }
 218
 219         /* Move to next wave header */
 220         WaveHdr = WaveHdr->lpNext;
 221
 222         if (!WaveHdr)
 223                 {
 224             /* No following WaveHdr */
 225             SND_ASSERT(dwNumberOfBytesTransferred == 0);
 226             break;
 227                 }
 228
 229         HdrExtension = (PWAVEHDR_EXTENSION) WaveHdr->reserved;
 230         SND_ASSERT( HdrExtension );
 231
 232
 233         }while(dwNumberOfBytesTransferred);
 234
 235     //DoWaveStreaming(SoundDeviceInstance);
 236
 237     //CompleteWavePortion(SoundDeviceInstance, dwNumberOfBytesTransferred);
 238
 239     FreeMemory(lpOverlapped);
 240 }
 241
 242 MMRESULT
 243 WriteFileEx_Committer(
 244     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 245     IN  PVOID OffsetPtr,
 246     IN  DWORD Length,
 247     IN  PSOUND_OVERLAPPED Overlap,
 248     IN  LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
 249 {
 250     HANDLE Handle;
 251
 252     VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
 253     VALIDATE_MMSYS_PARAMETER( OffsetPtr );
 254     VALIDATE_MMSYS_PARAMETER( Overlap );
 255     VALIDATE_MMSYS_PARAMETER( CompletionRoutine );
 256
 257     GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 258
 259     if ( ! WriteFileEx(Handle, OffsetPtr, Length, (LPOVERLAPPED)Overlap, CompletionRoutine) )
 260     {
 261         // TODO
 262     }
 263
 264     return MMSYSERR_NOERROR;
 265 }
 266
 267
 268 /*
 269     Stream control functions
 270     (External/internal thread pairs)
 271
 272     TODO - Move elsewhere as these shouldn't be wave specific!
 273 */
 274
 275 MMRESULT
 276 StopStreamingInSoundThread(
 277     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 278     IN  PVOID Parameter)
 279 {
 280     MMDEVICE_TYPE DeviceType;
 281     PMMFUNCTION_TABLE FunctionTable;
 282     MMRESULT Result;
 283     PSOUND_DEVICE SoundDevice;
 284
 285     /* set state reset in progress */
 286     SoundDeviceInstance->ResetInProgress = TRUE;
 287
 288     /* Get sound device */
 289     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 290     SND_ASSERT( Result == MMSYSERR_NOERROR );
 291
 292     /* Obtain the function table */
 293     Result = GetSoundDeviceFunctionTable(SoundDevice, &FunctionTable);
 294     SND_ASSERT( Result == MMSYSERR_NOERROR );
 295
 296     /* Obtain device instance type */
 297     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 298     SND_ASSERT( Result == MMSYSERR_NOERROR );
 299
 300     /* Check if reset function is supported */
 301     if (FunctionTable->ResetStream)
 302     {
 303          /* cancel all current audio buffers */
 304          FunctionTable->ResetStream(SoundDeviceInstance, DeviceType, TRUE);
 305     }
 306
 307     /* complete all current headers */
 308     while( SoundDeviceInstance->HeadWaveHeader )
 309     {
 310         SND_TRACE(L"StopStreamingInSoundThread: Completing Header %p\n", SoundDeviceInstance->HeadWaveHeader);
 311         CompleteWaveHeader( SoundDeviceInstance, SoundDeviceInstance->HeadWaveHeader );
 312     }
 313
 314     /* there should be no oustanding buffers now */
 315     SND_ASSERT(SoundDeviceInstance->OutstandingBuffers == 0);
 316
 317     while(SoundDeviceInstance->OutstandingBuffers)
 318     {
 319         SND_ERR("StopStreamingInSoundThread OutStandingBufferCount %lu\n", SoundDeviceInstance->OutstandingBuffers);
 320         /* my hack of doom */
 321         Sleep(10);
 322     }
 323
 324     /* Check if reset function is supported */
 325     if (FunctionTable->ResetStream)
 326     {
 327         /* finish the reset */
 328         FunctionTable->ResetStream(SoundDeviceInstance, DeviceType, FALSE);
 329     }
 330
 331     /* clear state reset in progress */
 332     SoundDeviceInstance->ResetInProgress = FALSE;
 333
 334
 335     return MMSYSERR_NOERROR;
 336 }
 337
 338 MMRESULT
 339 StopStreaming(
 340     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance)
 341 {
 342     MMRESULT Result;
 343     PSOUND_DEVICE SoundDevice;
 344     MMDEVICE_TYPE DeviceType;
 345
 346     if ( ! IsValidSoundDeviceInstance(SoundDeviceInstance) )
 347         return MMSYSERR_INVALHANDLE;
 348
 349     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 350     if ( ! MMSUCCESS(Result) )
 351         return TranslateInternalMmResult(Result);
 352
 353     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 354     if ( ! MMSUCCESS(Result) )
 355         return TranslateInternalMmResult(Result);
 356
 357     if ( DeviceType != WAVE_OUT_DEVICE_TYPE && DeviceType != WAVE_IN_DEVICE_TYPE )
 358         return MMSYSERR_NOTSUPPORTED;
 359
 360     return CallSoundThread(SoundDeviceInstance,
 361                            StopStreamingInSoundThread,
 362                            NULL);
 363 }