Simplified AudioOutputStream interface.

media/audio/win/waveout_output_win.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/win/waveout_output_win.h"
 
 #include <windows.h>
 #include <mmsystem.h>
 #pragma comment(lib, "winmm.lib")
 
@@ skipping 69 matching lines @@
 PCMWaveOutAudioOutputStream::PCMWaveOutAudioOutputStream(
     AudioManagerWin* manager, AudioParameters params, int num_buffers,
     UINT device_id)
     : state_(PCMA_BRAND_NEW),
       manager_(manager),
       device_id_(device_id),
       waveout_(NULL),
       callback_(NULL),
       num_buffers_(num_buffers),
       buffer_(NULL),
-      buffer_size_(0),
+      buffer_size_(params.GetPacketSize()),
       volume_(1),
       channels_(params.channels),
       pending_bytes_(0) {
+
   format_.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
   format_.Format.nChannels = params.channels;
   format_.Format.nSamplesPerSec = params.sample_rate;
   format_.Format.wBitsPerSample = params.bits_per_sample;
   format_.Format.cbSize = sizeof(format_) - sizeof(WAVEFORMATEX);
   // The next are computed from above.
   format_.Format.nBlockAlign = (format_.Format.nChannels *
                                 format_.Format.wBitsPerSample) / 8;
   format_.Format.nAvgBytesPerSec = format_.Format.nBlockAlign *
                                    format_.Format.nSamplesPerSec;
   if (params.channels > kMaxChannelsToMask) {
     format_.dwChannelMask = kChannelsToMask[kMaxChannelsToMask];
   } else {
     format_.dwChannelMask = kChannelsToMask[params.channels];
   }
   format_.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
   format_.Samples.wValidBitsPerSample = params.bits_per_sample;
   // The event is auto-reset.
   stopped_event_.Set(::CreateEventW(NULL, FALSE, FALSE, NULL));
 }
 
 PCMWaveOutAudioOutputStream::~PCMWaveOutAudioOutputStream() {
   DCHECK(NULL == waveout_);
 }
 
-bool PCMWaveOutAudioOutputStream::Open(uint32 buffer_size) {
+bool PCMWaveOutAudioOutputStream::Open() {
   if (state_ != PCMA_BRAND_NEW)
     return false;
-  if (buffer_size > kMaxOpenBufferSize)
-    return false;
   if (num_buffers_ < 2 || num_buffers_ > 5)
     return false;
   // Open the device. We'll be getting callback in WaveCallback function.
   // They occur in a magic, time-critical thread that windows creates.
   MMRESULT result = ::waveOutOpen(&waveout_, device_id_,
                                   reinterpret_cast<LPCWAVEFORMATEX>(&format_),
                                   reinterpret_cast<DWORD_PTR>(WaveCallback),
                                   reinterpret_cast<DWORD_PTR>(this),
                                   CALLBACK_FUNCTION);
   if (result != MMSYSERR_NOERROR)
     return false;
-  // If we don't have a packet size we use 100ms.
-  if (!buffer_size)
-    buffer_size = format_.Format.nAvgBytesPerSec / 10;
 
-  SetupBuffers(buffer_size);
-  buffer_size_ = buffer_size;
+  SetupBuffers();
   state_ = PCMA_READY;
   return true;
 }
 
-void PCMWaveOutAudioOutputStream::SetupBuffers(uint32 rq_size) {
+void PCMWaveOutAudioOutputStream::SetupBuffers() {
   WAVEHDR* last = NULL;
   WAVEHDR* first = NULL;
   for (int ix = 0; ix != num_buffers_; ++ix) {
-    uint32 sz = sizeof(WAVEHDR) + rq_size;
+    uint32 sz = sizeof(WAVEHDR) + buffer_size_;
     buffer_ =  reinterpret_cast<WAVEHDR*>(new char[sz]);
     buffer_->lpData = reinterpret_cast<char*>(buffer_) + sizeof(WAVEHDR);
-    buffer_->dwBufferLength = rq_size;
+    buffer_->dwBufferLength = buffer_size_;
     buffer_->dwBytesRecorded = 0;
     buffer_->dwUser = reinterpret_cast<DWORD_PTR>(last);
     buffer_->dwFlags = WHDR_DONE;
     buffer_->dwLoops = 0;
     if (ix == 0)
       first = buffer_;
     last = buffer_;
     // Tell windows sound drivers about our buffers. Not documented what
     // this does but we can guess that causes the OS to keep a reference to
     // the memory pages so the driver can use them without worries.
@@ skipping 65 matching lines @@
     HandleError(::GetLastError());
     return;
   }
   state_ = PCMA_STOPPED;
   MMRESULT res = ::waveOutReset(waveout_);
   if (res != MMSYSERR_NOERROR) {
     state_ = PCMA_PLAYING;
     HandleError(res);
     return;
   }
+
+  // Don't use callback after Stop().
+  callback_ = NULL;
+
   state_ = PCMA_READY;
 }
 
 // We can Close in any state except that trying to close a stream that is
 // playing Windows generates an error, which we propagate to the source.
 void PCMWaveOutAudioOutputStream::Close() {
   if (waveout_) {
     // waveOutClose generates a callback with WOM_CLOSE id in the same thread.
     MMRESULT res = ::waveOutClose(waveout_);
     if (res != MMSYSERR_NOERROR) {
@@ skipping 92 matching lines @@
     obj->QueueNextPacket(buffer);
 
     // Time to send the buffer to the audio driver. Since we are reusing
     // the same buffers we can get away without calling waveOutPrepareHeader.
     MMRESULT result = ::waveOutWrite(hwo, buffer, sizeof(WAVEHDR));
     if (result != MMSYSERR_NOERROR)
       obj->HandleError(result);
 
     obj->pending_bytes_ += buffer->dwBufferLength;
 
-  } else if (msg == WOM_CLOSE) {
-    // We can be closed before calling Start, so it is possible to have a
-    // null callback at this point.
-    if (obj->callback_)
-      obj->callback_->OnClose(obj);
   }
 }