Fail out of WASAPI render loop when errors are encountered.

media/audio/win/audio_low_latency_output_win.cc

 // Copyright (c) 2012 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/audio_low_latency_output_win.h"
 
 #include <Functiondiscoverykeys_devpkey.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 454 matching lines @@
                                                FALSE,
                                                INFINITE);
 
     switch (wait_result) {
       case WAIT_OBJECT_0 + 0:
         // |stop_render_event_| has been set.
         playing = false;
         break;
       case WAIT_OBJECT_0 + 1:
         // |audio_samples_render_event_| has been set.
-        RenderAudioFromSource(audio_clock, device_frequency);
+        error = !RenderAudioFromSource(audio_clock, device_frequency);
         break;
       default:
         error = true;
         break;
     }
   }
 
   if (playing && error) {
     // Stop audio rendering since something has gone wrong in our main thread
     // loop. Note that, we are still in a "started" state, hence a Stop() call
     // is required to join the thread properly.
     audio_client_->Stop();
     PLOG(ERROR) << "WASAPI rendering failed.";
   }
 
   // Disable MMCSS.
   if (mm_task && !avrt::AvRevertMmThreadCharacteristics(mm_task)) {
     PLOG(WARNING) << "Failed to disable MMCSS";
   }
 }
 
-void WASAPIAudioOutputStream::RenderAudioFromSource(
+bool WASAPIAudioOutputStream::RenderAudioFromSource(
     IAudioClock* audio_clock, UINT64 device_frequency) {
   TRACE_EVENT0("audio", "RenderAudioFromSource");
 
   HRESULT hr = S_FALSE;
   UINT32 num_queued_frames = 0;
   uint8* audio_data = NULL;
 
   // Contains how much new data we can write to the buffer without
   // the risk of overwriting previously written data that the audio
   // engine has not yet read from the buffer.
   size_t num_available_frames = 0;
 
   if (share_mode_ == AUDCLNT_SHAREMODE_SHARED) {
     // Get the padding value which represents the amount of rendering
     // data that is queued up to play in the endpoint buffer.
     hr = audio_client_->GetCurrentPadding(&num_queued_frames);
     num_available_frames =
         endpoint_buffer_size_frames_ - num_queued_frames;
     if (FAILED(hr)) {
       DLOG(ERROR) << "Failed to retrieve amount of available space: "
                   << std::hex << hr;
-      return;
+      return false;
     }
   } else {
     // While the stream is running, the system alternately sends one
     // buffer or the other to the client. This form of double buffering
     // is referred to as "ping-ponging". Each time the client receives
     // a buffer from the system (triggers this event) the client must
     // process the entire buffer. Calls to the GetCurrentPadding method
     // are unnecessary because the packet size must always equal the
     // buffer size. In contrast to the shared mode buffering scheme,
     // the latency for an event-driven, exclusive-mode stream depends
     // directly on the buffer size.
     num_available_frames = endpoint_buffer_size_frames_;
   }
 
   // Check if there is enough available space to fit the packet size
   // specified by the client.
   if (num_available_frames < packet_size_frames_)
-    return;
+    return true;
 
   DLOG_IF(ERROR, num_available_frames % packet_size_frames_ != 0)
       << "Non-perfect timing detected (num_available_frames="
       << num_available_frames << ", packet_size_frames="
       << packet_size_frames_ << ")";
 
   // Derive the number of packets we need to get from the client to
   // fill up the available area in the endpoint buffer.
   // |num_packets| will always be one for exclusive-mode streams and
   // will be one in most cases for shared mode streams as well.
   // However, we have found that two packets can sometimes be
   // required.
   size_t num_packets = (num_available_frames / packet_size_frames_);
 
   for (size_t n = 0; n < num_packets; ++n) {
     // Grab all available space in the rendering endpoint buffer
     // into which the client can write a data packet.
     hr = audio_render_client_->GetBuffer(packet_size_frames_,
                                          &audio_data);
     if (FAILED(hr)) {
       DLOG(ERROR) << "Failed to use rendering audio buffer: "
                  << std::hex << hr;
-      return;
+      return false;
     }
 
     // Derive the audio delay which corresponds to the delay between
     // a render event and the time when the first audio sample in a
     // packet is played out through the speaker. This delay value
     // can typically be utilized by an acoustic echo-control (AEC)
     // unit at the render side.
     UINT64 position = 0;
     int audio_delay_bytes = 0;
     hr = audio_clock->GetPosition(&position, NULL);
@@ skipping 37 matching lines @@
 
 
     // Release the buffer space acquired in the GetBuffer() call.
     // Render silence if we were not able to fill up the buffer totally.
     DWORD flags = (num_filled_bytes < packet_size_bytes_) ?
         AUDCLNT_BUFFERFLAGS_SILENT : 0;
     audio_render_client_->ReleaseBuffer(packet_size_frames_, flags);
 
     num_written_frames_ += packet_size_frames_;
   }
+
+  return true;
 }
 
 HRESULT WASAPIAudioOutputStream::ExclusiveModeInitialization(
     IAudioClient* client, HANDLE event_handle, uint32* endpoint_buffer_size) {
   DCHECK_EQ(share_mode_, AUDCLNT_SHAREMODE_EXCLUSIVE);
 
   float f = (1000.0 * packet_size_frames_) / format_.Format.nSamplesPerSec;
   REFERENCE_TIME requested_buffer_duration =
       static_cast<REFERENCE_TIME>(f * 10000.0 + 0.5);
 
@@ skipping 80 matching lines @@
 
     // Ensure that we don't quit the main thread loop immediately next
     // time Start() is called.
     ResetEvent(stop_render_event_.Get());
   }
 
   source_ = NULL;
 }
 
 }  // namespace media