Simplified AudioOutputStream interface.

chrome/browser/renderer_host/audio_renderer_host.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 "chrome/browser/renderer_host/audio_renderer_host.h"
 
 #include "base/lock.h"
 #include "base/metrics/histogram.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
@@ skipping 37 matching lines @@
   base::SysInfo::OperatingSystemVersionNumbers(&major, &minor, &bugfix);
   if (major < 10 || (major == 10 && minor <= 5))
     return kMaxStreamsLeopard;
 #endif
 
   // In OS other than OSX Leopard, the number of audio streams allowed is a
   // lot more so we return a separate number.
   return kMaxStreams;
 }
 
-static uint32 SelectHardwarePacketSize(AudioParameters params) {
+static uint32 SelectSamplesPerPacket(AudioParameters params) {
   // Select the number of samples that can provide at least
   // |kMillisecondsPerHardwarePacket| worth of audio data.
   int samples = kMinSamplesPerHardwarePacket;
   while (samples <= kMaxSamplesPerHardwarePacket &&
          samples * base::Time::kMillisecondsPerSecond <
          params.sample_rate * kMillisecondsPerHardwarePacket) {
     samples *= 2;
   }
-  return params.channels * samples * params.bits_per_sample / 8;
+  return samples;
 }
 
 AudioRendererHost::AudioEntry::AudioEntry()
     : render_view_id(0),
       stream_id(0),
       pending_buffer_request(false),
       pending_close(false) {
 }
 
 AudioRendererHost::AudioEntry::~AudioEntry() {}
@@ skipping 262 matching lines @@
 
   // Limit the number of audio streams opened. This is to prevent using
   // excessive resources for a large number of audio streams. More
   // importantly it prevents instability on certain systems.
   // See bug: http://crbug.com/30242
   if (audio_entries_.size() >= GetMaxAudioStreamsAllowed()) {
     SendErrorMessage(msg.routing_id(), stream_id);
     return;
   }
 
-  // Select the hardwaer packet size if not specified.
-  uint32 hardware_packet_size = params.packet_size;
-  if (!hardware_packet_size) {
-    hardware_packet_size = SelectHardwarePacketSize(params.params);
+  AudioParameters audio_params(params.params);
+
+  // Select the hardware packet size if not specified.
+  if (!audio_params.samples_per_packet) {
+    audio_params.samples_per_packet = SelectSamplesPerPacket(audio_params);
   }
+  uint32 packet_size = audio_params.samples_per_packet *
+      audio_params.channels * audio_params.bits_per_sample / 8;
 
   scoped_ptr<AudioEntry> entry(new AudioEntry());
   // Create the shared memory and share with the renderer process.
-  if (!entry->shared_memory.CreateAndMapAnonymous(hardware_packet_size)) {
+  if (!entry->shared_memory.CreateAndMapAnonymous(packet_size)) {
     // If creation of shared memory failed then send an error message.
     SendErrorMessage(msg.routing_id(), stream_id);
     return;
   }
 
   if (low_latency) {
     // If this is the low latency mode, we need to construct a SyncReader first.
     scoped_ptr<AudioSyncReader> reader(
         new AudioSyncReader(&entry->shared_memory));
 
     // Then try to initialize the sync reader.
     if (!reader->Init()) {
       SendErrorMessage(msg.routing_id(), stream_id);
       return;
     }
 
     // If we have successfully created the SyncReader then assign it to the
     // entry and construct an AudioOutputController.
     entry->reader.reset(reader.release());
     entry->controller =
-        media::AudioOutputController::CreateLowLatency(
-            this, params.params,
-            hardware_packet_size,
-            entry->reader.get());
+        media::AudioOutputController::CreateLowLatency(this, audio_params,
+                                                       entry->reader.get());
   } else {
     // The choice of buffer capacity is based on experiment.
     entry->controller =
-        media::AudioOutputController::Create(this, params.params,
-                                             hardware_packet_size,
-                                             3 * hardware_packet_size);
+        media::AudioOutputController::Create(this, audio_params,
+                                             3 * packet_size);
   }
 
   if (!entry->controller) {
     SendErrorMessage(msg.routing_id(), stream_id);
     return;
   }
 
   // If we have created the controller successfully create a entry and add it
   // to the map.
   entry->render_view_id = msg.routing_id();
@@ skipping 183 matching lines @@
 
   // Iterate the map of entries.
   // TODO(hclam): Implement a faster look up method.
   for (AudioEntryMap::iterator i = audio_entries_.begin();
        i != audio_entries_.end(); ++i) {
     if (controller == i->second->controller.get())
       return i->second;
   }
   return NULL;
 }