content/browser/renderer_host/media/audio_sync_reader.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/renderer_host/media/audio_sync_reader.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/command_line.h"
  10 #include "base/memory/shared_memory.h"
  11 #include "base/metrics/histogram.h"
  12 #include "content/public/common/content_switches.h"
  13 #include "media/audio/audio_buffers_state.h"
  14 #include "media/audio/audio_parameters.h"
  15
  16 using media::AudioBus;
  17
  18 namespace content {
  19
  20 AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory,
  21                                  const media::AudioParameters& params)
  22     : shared_memory_(shared_memory),
  23       mute_audio_(CommandLine::ForCurrentProcess()->HasSwitch(
  24           switches::kMuteAudio)),
  25       packet_size_(shared_memory_->requested_size()),
  26       renderer_callback_count_(0),
  27       renderer_missed_callback_count_(0),
  28 #if defined(OS_MACOSX)
  29       maximum_wait_time_(params.GetBufferDuration() / 2),
  30 #else
  31       // TODO(dalecurtis): Investigate if we can reduce this on all platforms.
  32       maximum_wait_time_(base::TimeDelta::FromMilliseconds(20)),
  33 #endif
  34       buffer_index_(0) {
  35   DCHECK_EQ(packet_size_, AudioBus::CalculateMemorySize(params));
  36   output_bus_ = AudioBus::WrapMemory(params, shared_memory->memory());
  37   output_bus_->Zero();
  38 }
  39
  40 AudioSyncReader::~AudioSyncReader() {
  41   if (!renderer_callback_count_)
  42     return;
  43
  44   // Recording the percentage of deadline misses gives us a rough overview of
  45   // how many users might be running into audio glitches.
  46   int percentage_missed =
  47       100.0 * renderer_missed_callback_count_ / renderer_callback_count_;
  48   UMA_HISTOGRAM_PERCENTAGE(
  49       "Media.AudioRendererMissedDeadline", percentage_missed);
  50 }
  51
  52 // media::AudioOutputController::SyncReader implementations.
  53 void AudioSyncReader::UpdatePendingBytes(uint32 bytes) {
  54   // Zero out the entire output buffer to avoid stuttering/repeating-buffers
  55   // in the anomalous case if the renderer is unable to keep up with real-time.
  56   output_bus_->Zero();
  57   socket_->Send(&bytes, sizeof(bytes));
  58   ++buffer_index_;
  59 }
  60
  61 void AudioSyncReader::Read(AudioBus* dest) {
  62   ++renderer_callback_count_;
  63   if (!WaitUntilDataIsReady()) {
  64     ++renderer_missed_callback_count_;
  65     dest->Zero();
  66     return;
  67   }
  68
  69   if (mute_audio_)
  70     dest->Zero();
  71   else
  72     output_bus_->CopyTo(dest);
  73 }
  74
  75 void AudioSyncReader::Close() {
  76   socket_->Close();
  77 }
  78
  79 bool AudioSyncReader::Init() {
  80   socket_.reset(new base::CancelableSyncSocket());
  81   foreign_socket_.reset(new base::CancelableSyncSocket());
  82   return base::CancelableSyncSocket::CreatePair(socket_.get(),
  83                                                 foreign_socket_.get());
  84 }
  85
  86 #if defined(OS_WIN)
  87 bool AudioSyncReader::PrepareForeignSocketHandle(
  88     base::ProcessHandle process_handle,
  89     base::SyncSocket::Handle* foreign_handle) {
  90   ::DuplicateHandle(GetCurrentProcess(), foreign_socket_->handle(),
  91                     process_handle, foreign_handle,
  92                     0, FALSE, DUPLICATE_SAME_ACCESS);
  93   return (*foreign_handle != 0);
  94 }
  95 #else
  96 bool AudioSyncReader::PrepareForeignSocketHandle(
  97     base::ProcessHandle process_handle,
  98     base::FileDescriptor* foreign_handle) {
  99   foreign_handle->fd = foreign_socket_->handle();
 100   foreign_handle->auto_close = false;
 101   return (foreign_handle->fd != -1);
 102 }
 103 #endif
 104
 105 bool AudioSyncReader::WaitUntilDataIsReady() {
 106   base::TimeDelta timeout = maximum_wait_time_;
 107   const base::TimeTicks start_time = base::TimeTicks::Now();
 108   const base::TimeTicks finish_time = start_time + timeout;
 109
 110   // Check if data is ready and if not, wait a reasonable amount of time for it.
 111   //
 112   // Data readiness is achieved via parallel counters, one on the renderer side
 113   // and one here.  Every time a buffer is requested via UpdatePendingBytes(),
 114   // |buffer_index_| is incremented.  Subsequently every time the renderer has a
 115   // buffer ready it increments its counter and sends the counter value over the
 116   // SyncSocket.  Data is ready when |buffer_index_| matches the counter value
 117   // received from the renderer.
 118   //
 119   // The counter values may temporarily become out of sync if the renderer is
 120   // unable to deliver audio fast enough.  It's assumed that the renderer will
 121   // catch up at some point, which means discarding counter values read from the
 122   // SyncSocket which don't match our current buffer index.
 123   size_t bytes_received = 0;
 124   uint32 renderer_buffer_index = 0;
 125   while (timeout.InMicroseconds() > 0) {
 126     bytes_received = socket_->ReceiveWithTimeout(
 127         &renderer_buffer_index, sizeof(renderer_buffer_index), timeout);
 128     if (!bytes_received)
 129       break;
 130
 131     DCHECK_EQ(bytes_received, sizeof(renderer_buffer_index));
 132     if (renderer_buffer_index == buffer_index_)
 133       break;
 134
 135     // Reduce the timeout value as receives succeed, but aren't the right index.
 136     timeout = finish_time - base::TimeTicks::Now();
 137   }
 138
 139   // Receive timed out or another error occurred.  Receive can timeout if the
 140   // renderer is unable to deliver audio data within the allotted time.
 141   if (!bytes_received || renderer_buffer_index != buffer_index_) {
 142     DVLOG(2) << "AudioSyncReader::WaitUntilDataIsReady() timed out.";
 143
 144     base::TimeDelta time_since_start = base::TimeTicks::Now() - start_time;
 145     UMA_HISTOGRAM_CUSTOM_TIMES("Media.AudioOutputControllerDataNotReady",
 146                                time_since_start,
 147                                base::TimeDelta::FromMilliseconds(1),
 148                                base::TimeDelta::FromMilliseconds(1000),
 149                                50);
 150     return false;
 151   }
 152
 153   return true;
 154 }
 155
 156 }  // namespace content