Add OpenSL configurations

media/audio/android/opensles_input.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_input.h"
 
 #include "base/logging.h"
 #include "media/audio/android/audio_manager_android.h"
 
 namespace media {
@@ skipping 66 matching lines @@
         audio_data_[i],
         buffer_size_bytes_);
     if (SL_RESULT_SUCCESS != err) {
       HandleError(err);
       return;
     }
   }
 
   // Start the recording by setting the state to |SL_RECORDSTATE_RECORDING|.
   err = (*recorder_)->SetRecordState(recorder_, SL_RECORDSTATE_RECORDING);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

I hope you can make a pass (in a different CL) cleaning up the order of
comparisons in these files.

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

What's the deal with the removal of the DCHECKs everywhere in this CL?
Under what conditions can these SL calls fail?

By line-count, these changes (removal of DCHECKs and addition of DLOGs) is by
far the greater part of this CL, yet they are not mentioned in the CL
description.  Please make sure the description explains *why* you make the
changes in the CL.

[leozwang1, 2013/03/22 21:37:09]

sure I will.

[leozwang1, 2013/03/22 21:37:09]

Both Tommi and Qinmin suggested to remove DCHECK and add DLOG.

I haven't experienced any opensl fail so far, however, there are some reports
say opensl could fail, for example, on emulator.

[leozwang1, 2013/03/23 07:00:39]

Done.

[leozwang1, 2013/03/23 07:00:39]

Done.

     HandleError(err);
+  }

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

FYI braces are optional in the C++ style guide for single-line bodies.  
(this is a difference to the Java style guide, which requires braces even for
single-line bodies)

 }
 
 void OpenSLESInputStream::Stop() {
   if (!started_)
     return;
 
   // Stop recording by setting the record state to |SL_RECORDSTATE_STOPPED|.
   SLresult err = (*recorder_)->SetRecordState(recorder_,
                                               SL_RECORDSTATE_STOPPED);
   if (SL_RESULT_SUCCESS != err) {
@@ skipping 53 matching lines @@
   // object, we need to free the object and its resources.
   SLEngineOption option[] = {
     { SL_ENGINEOPTION_THREADSAFE, static_cast<SLuint32>(SL_BOOLEAN_TRUE) }
   };
   SLresult err = slCreateEngine(engine_object_.Receive(),
                                 1,
                                 option,
                                 0,
                                 NULL,
                                 NULL);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "CreateAudioRecorder slCreateEngine: " << err;
     return false;
+  }
 
   // Realize the SL engine object in synchronous mode.
   err = engine_object_->Realize(engine_object_.Get(), SL_BOOLEAN_FALSE);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "CreateAudioRecorder Realize: " << err;
     return false;
+  }
 
   // Get the SL engine interface which is implicit.
   SLEngineItf engine;
   err = engine_object_->GetInterface(
       engine_object_.Get(), SL_IID_ENGINE, &engine);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "GetInterface(SL_IID_ENGINE): " << err;
     return false;
+  }
 
   // Audio source configuration.
   SLDataLocator_IODevice mic_locator = {
     SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT,
     SL_DEFAULTDEVICEID_AUDIOINPUT, NULL
   };
   SLDataSource audio_source = { &mic_locator, NULL };
 
   // Audio sink configuration.
   SLDataLocator_AndroidSimpleBufferQueue buffer_queue = {
     SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, // Locator type.
     static_cast<SLuint32>(kNumOfQueuesInBuffer)  // Number of buffers.
   };
   SLDataSink audio_sink = { &buffer_queue, &format_ };
 
   // Create an audio recorder.
-  const SLuint32 number_of_interfaces = 1;
-  const SLInterfaceID interface_id[number_of_interfaces] = {
-    SL_IID_ANDROIDSIMPLEBUFFERQUEUE
+  const SLInterfaceID interface_id[] = {
+    SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
+    SL_IID_ANDROIDCONFIGURATION
   };
+  const SLuint32 number_of_interfaces = arraysize(interface_id);

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

can inline into the CreateAudioRecorder call.

[leozwang1, 2013/03/22 21:37:09]

Done.

   const SLboolean interface_required[number_of_interfaces] = {

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

number_of_interface is unnecessary.

[leozwang1, 2013/03/22 21:37:09]

Done.

+    SL_BOOLEAN_TRUE,
     SL_BOOLEAN_TRUE
   };
   err = (*engine)->CreateAudioRecorder(engine,
                                        recorder_object_.Receive(),
                                        &audio_source,
                                        &audio_sink,
                                        number_of_interfaces,
                                        interface_id,
                                        interface_required);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
   if (SL_RESULT_SUCCESS != err) {
     DLOG(ERROR) << "CreateAudioRecorder failed with error code " << err;
     return false;
   }
 
+  // Create AudioRecorder and specify SL_IID_ANDROIDCONFIGURATION.

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

"Create AudioRecorder" comment is a bit late here, no?  (it was actually created
at l.208 above)

[leozwang1, 2013/03/22 21:37:09]

Done.

+  SLAndroidConfigurationItf recorder_config;
+  err = recorder_object_->GetInterface(recorder_object_.Get(),
+                                       SL_IID_ANDROIDCONFIGURATION,
+                                       &recorder_config);
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "GetInterface(SL_IID_ANDROIDCONFIGURATION): " << err;
+    return false;
+  }
+
+  SLint32 stream_type = SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION;

[Ami GONE FROM CHROMIUM, 2013/03/22 16:24:41]

this variable is obscuring what the call below actually does.  please inline the
value into the call.

+  err = (*recorder_config)->SetConfiguration(
+      recorder_config,
+      SL_ANDROID_KEY_RECORDING_PRESET,
+      &stream_type, sizeof(SLint32));
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR)
+      << "SetConfiguration(SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION): "
+      << err;
+    return false;
+  }
+
   // Realize the recorder object in synchronous mode.
   err = recorder_object_->Realize(recorder_object_.Get(), SL_BOOLEAN_FALSE);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
   if (SL_RESULT_SUCCESS != err) {
     DLOG(ERROR) << "Recprder Realize() failed with error code " << err;
     return false;
   }
 
   // Get an implicit recorder interface.
   err = recorder_object_->GetInterface(recorder_object_.Get(),
                                        SL_IID_RECORD,
                                        &recorder_);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "GetInterface(SL_IID_RECORD): " << err;
     return false;
+  }
 
   // Get the simple buffer queue interface.
   err = recorder_object_->GetInterface(recorder_object_.Get(),
                                        SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
                                        &simple_buffer_queue_);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
-  if (SL_RESULT_SUCCESS != err)
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "GetInterface(SL_IID_ANDROIDSIMPLEBUFFERQUEUE): " << err;
     return false;
+  }
 
   // Register the input callback for the simple buffer queue.
   // This callback will be called when receiving new data from the device.
   err = (*simple_buffer_queue_)->RegisterCallback(simple_buffer_queue_,
                                                   SimpleBufferQueueCallback,
                                                   this);
-  DCHECK_EQ(SL_RESULT_SUCCESS, err);
+  if (SL_RESULT_SUCCESS != err) {
+    DLOG(ERROR) << "AudioRecorder RegisterCallback: " << err;
+    return false;
+  }
 
-  return (SL_RESULT_SUCCESS == err);
+  return true;
 }
 
 void OpenSLESInputStream::SimpleBufferQueueCallback(
     SLAndroidSimpleBufferQueueItf buffer_queue, void* instance) {
   OpenSLESInputStream* stream =
       reinterpret_cast<OpenSLESInputStream*>(instance);
   stream->ReadBufferQueue();
 }
 
 void OpenSLESInputStream::ReadBufferQueue() {
@@ skipping 34 matching lines @@
   }
 }
 
 void OpenSLESInputStream::HandleError(SLresult error) {
   DLOG(FATAL) << "OpenSLES error " << error;
   if (callback_)
     callback_->OnError(this, error);
 }
 
 }  // namespace media