Software volume control hook-up in linux.

media/audio/linux/alsa_output.cc

 // Copyright (c) 2009 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.
 //
 // The audio stream implementation is made difficult because different methods
 // are available for calling depending on what state the stream is.  Here is the
 // state transition table for the stream.
 //
 // STATE_CREATED -> Open() -> STATE_OPENED
 // STATE_OPENED -> Start() -> STATE_STARTED
@@ skipping 37 matching lines @@
 // class lock, or under a different lock to avoid unecessarily blocking other
 // threads.
 
 #include "media/audio/linux/alsa_output.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/time.h"
+#include "media/audio/audio_util.h"
 
 // Require 10ms latency from the audio device.  Taken from ALSA documentation
 // example.
 // TODO(ajwong): Figure out what this parameter actually does, and what a good
 // value would be.
 static const unsigned int kTargetLatencyMicroseconds = 10000;
 
 // Minimal amount of time to sleep.  If any future event is expected to
 // execute within this timeframe, treat it as if it should execute immediately.
 //
@@ skipping 14 matching lines @@
       playback_handle_(NULL),
       source_callback_(NULL),
       playback_thread_("PlaybackThread"),
       channels_(channels),
       sample_rate_(sample_rate),
       bits_per_sample_(bits_per_sample),
       min_buffer_frames_((min_buffer_ms * sample_rate_) /
                          base::Time::kMillisecondsPerSecond),
       packet_size_(0),
       device_write_suspended_(true),  // Start suspended.
-      resources_released_(false) {
+      resources_released_(false),
+      volume_(1.0) {
   // Reference self to avoid accidental deletion before the message loop is
   // done.
   AddRef();
 
   // Sanity check input values.
   if (channels_ != 2) {
     LOG(WARNING) << "Only 2-channel audio is supported right now.";
     state_ = STATE_ERROR;
   }
 
@@ skipping 297 matching lines @@
     // TODO(ajwong): Move to cpu@'s non-blocking audio source.
     scoped_ptr<Packet> packet;
     size_t capacity = packet_size_;  // Snag it for non-locked usage.
     {
       AutoUnlock synchronous_data_fetch(lock_);
       packet.reset(new Packet(capacity));
       size_t used = source_callback_->OnMoreData(this, packet->buffer.get(),
                                                  packet->capacity);
       CHECK(used <= capacity) << "Data source overran buffer. Aborting.";
       packet->size = used;
+      media::AdjustVolume(packet->buffer.get(), packet->size,
+                          channels_, bits_per_sample_ >> 3,
+                          volume_);
       // TODO(ajwong): Do more buffer validation here, like checking that the
       // packet is correctly aligned to frames, etc.
     }
     // After reacquiring the lock, recheck state to make sure it is still
     // STATE_STARTED.
     if (state_ != STATE_STARTED) {
       return;
     }
     buffered_packets_.push_back(packet.release());
 
@@ skipping 94 matching lines @@
   // If the memory buffer was not underrun, schedule another fill in the future.
   if (!device_write_suspended_) {
     playback_thread_.message_loop()->PostDelayedTask(
         FROM_HERE,
         NewRunnableMethod(this, &AlsaPCMOutputStream::FillAlsaDeviceBuffer),
         kTargetLatencyMicroseconds / base::Time::kMicrosecondsPerMillisecond);
   }
 }
 
 void AlsaPCMOutputStream::SetVolume(double left_level, double right_level) {
-  NOTIMPLEMENTED();
+  AutoLock l(lock_);

[fbarchard, 2009/07/25 00:57:26]

is this necessary for one variable?

+  volume_ = static_cast<float>(left_level);
 }
 
 void AlsaPCMOutputStream::GetVolume(double* left_level, double* right_level) {
-  NOTIMPLEMENTED();
+  AutoLock l(lock_);
+  *left_level = volume_;
+  *right_level = volume_;

[fbarchard, 2009/07/25 00:57:26]

nit - we should really get rid of this right_level eh.

 }