Adding audio unit tests for Android

media/audio/android/opensles_output.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/android/opensles_output.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "media/audio/android/audio_manager_android.h"
 
@@ skipping 11 matching lines @@
 OpenSLESOutputStream::OpenSLESOutputStream(AudioManagerAndroid* manager,
                                            const AudioParameters& params)
     : audio_manager_(manager),
       callback_(NULL),
       player_(NULL),
       simple_buffer_queue_(NULL),
       active_queue_(0),
       buffer_size_bytes_(0),
       started_(false),
       volume_(1.0) {
+  DVLOG(2) << "OpenSLESOutputStream::OpenSLESOutputStream()";
   format_.formatType = SL_DATAFORMAT_PCM;
   format_.numChannels = static_cast<SLuint32>(params.channels());
   // Provides sampling rate in milliHertz to OpenSLES.
   format_.samplesPerSec = static_cast<SLuint32>(params.sample_rate() * 1000);
   format_.bitsPerSample = params.bits_per_sample();
   format_.containerSize = params.bits_per_sample();
   format_.endianness = SL_BYTEORDER_LITTLEENDIAN;
   if (format_.numChannels == 1)
     format_.channelMask = SL_SPEAKER_FRONT_CENTER;
   else if (format_.numChannels == 2)
     format_.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
   else
     NOTREACHED() << "Unsupported number of channels: " << format_.numChannels;
 
   buffer_size_bytes_ = params.GetBytesPerBuffer();
   audio_bus_ = AudioBus::Create(params);
 
   memset(&audio_data_, 0, sizeof(audio_data_));
 }
 
 OpenSLESOutputStream::~OpenSLESOutputStream() {
+  DVLOG(2) << "OpenSLESOutputStream::~OpenSLESOutputStream()";
   DCHECK(!engine_object_.Get());
   DCHECK(!player_object_.Get());
   DCHECK(!output_mixer_.Get());
   DCHECK(!player_);
   DCHECK(!simple_buffer_queue_);
   DCHECK(!audio_data_[0]);
 }
 
 bool OpenSLESOutputStream::Open() {
+  DVLOG(2) << "OpenSLESOutputStream::Open()";
   if (engine_object_.Get())
     return false;
 
   if (!CreatePlayer())
     return false;
 
   SetupAudioBuffer();
 
   return true;
 }
 
 void OpenSLESOutputStream::Start(AudioSourceCallback* callback) {
+  DVLOG(2) << "OpenSLESOutputStream::Start()";
   DCHECK(callback);
   DCHECK(player_);
   DCHECK(simple_buffer_queue_);
   if (started_)
     return;
 
   // Enable the flags before streaming.
   callback_ = callback;
   active_queue_ = 0;
   started_ = true;
 
   // Avoid start-up glitches by filling up one buffer queue before starting
   // the stream.
   FillBufferQueue();
 
   // Start streaming data by setting the play state to |SL_PLAYSTATE_PLAYING|.
   LOG_ON_FAILURE_AND_RETURN(
       (*player_)->SetPlayState(player_, SL_PLAYSTATE_PLAYING));
 }
 
 void OpenSLESOutputStream::Stop() {
+  DVLOG(2) << "OpenSLESOutputStream::Stop()";
   if (!started_)
     return;
 
   started_ = false;
   // Stop playing by setting the play state to |SL_PLAYSTATE_STOPPED|.
   LOG_ON_FAILURE_AND_RETURN(
       (*player_)->SetPlayState(player_, SL_PLAYSTATE_STOPPED));
 
   // Clear the buffer queue so that the old data won't be played when
   // resuming playing.
   LOG_ON_FAILURE_AND_RETURN(
       (*simple_buffer_queue_)->Clear(simple_buffer_queue_));
 }
 
 void OpenSLESOutputStream::Close() {
+  DVLOG(2) << "OpenSLESOutputStream::Close()";
   // Stop the stream if it is still playing.
   Stop();
 
   // Explicitly free the player objects and invalidate their associated
   // interfaces. They have to be done in the correct order.
   player_object_.Reset();
   output_mixer_.Reset();
   engine_object_.Reset();
   simple_buffer_queue_ = NULL;
   player_ = NULL;
@@ skipping 184 matching lines @@
   }
 }
 
 void OpenSLESOutputStream::HandleError(SLresult error) {
   DLOG(ERROR) << "OpenSLES Output error " << error;
   if (callback_)
     callback_->OnError(this);
 }
 
 }  // namespace media