Add OSSTATUS_LOG API

media/audio/mac/audio_low_latency_output_mac.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/mac/audio_low_latency_output_mac.h"
 
 #include <CoreServices/CoreServices.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/mac/mac_logging.h"
 #include "media/audio/audio_util.h"
 #include "media/audio/mac/audio_manager_mac.h"
 
 // Reorder PCM from AAC layout to Core Audio 5.1 layout.
 // TODO(fbarchard): Switch layout when ffmpeg is updated.
 template<class Format>
 static void SwizzleCoreAudioLayout5_1(Format* b, uint32 filled) {
   static const int kNumSurroundChannels = 6;
   Format aac[kNumSurroundChannels];
   for (uint32 i = 0; i < filled; i += sizeof(aac), b += kNumSurroundChannels) {
@@ skipping 59 matching lines @@
     kAudioHardwarePropertyDefaultOutputDevice,
     kAudioObjectPropertyScopeGlobal,
     kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                                &default_output_device_address,
                                                0,
                                                0,
                                                &size,
                                                &output_device_id_);
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   // Open and initialize the DefaultOutputUnit.
   Component comp;
   ComponentDescription desc;
 
   desc.componentType = kAudioUnitType_Output;
   desc.componentSubType = kAudioUnitSubType_DefaultOutput;
   desc.componentManufacturer = kAudioUnitManufacturer_Apple;
   desc.componentFlags = 0;
   desc.componentFlagsMask = 0;
   comp = FindNextComponent(0, &desc);
   DCHECK(comp);
 
   result = OpenAComponent(comp, &output_unit_);
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   result = AudioUnitInitialize(output_unit_);
-
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   hardware_latency_frames_ = GetHardwareLatency();
 
   return Configure();
 }
 
 bool AUAudioOutputStream::Configure() {
   // Set the render callback.
   AURenderCallbackStruct input;
   input.inputProc = InputProc;
   input.inputProcRefCon = this;
   OSStatus result = AudioUnitSetProperty(
       output_unit_,
       kAudioUnitProperty_SetRenderCallback,
       kAudioUnitScope_Global,
       0,
       &input,
       sizeof(input));
-
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   // Set the stream format.
   result = AudioUnitSetProperty(
       output_unit_,
       kAudioUnitProperty_StreamFormat,
       kAudioUnitScope_Input,
       0,
       &format_,
       sizeof(format_));
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   // Set the buffer frame size.
   UInt32 buffer_size = number_of_frames_;
   result = AudioUnitSetProperty(
       output_unit_,
       kAudioDevicePropertyBufferFrameSize,
       kAudioUnitScope_Output,
       0,
       &buffer_size,
       sizeof(buffer_size));
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return false;
 
   return true;
 }
 
 void AUAudioOutputStream::Close() {
   if (output_unit_)
     CloseComponent(output_unit_);
 
@@ skipping 91 matching lines @@
       kAudioHardwarePropertyDefaultOutputDevice,
       kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster
   };
   OSStatus result = AudioObjectGetPropertyData(kAudioObjectSystemObject,
                                                &default_output_device_address,
                                                0,
                                                0,
                                                &info_size,
                                                &device_id);
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return 0.0;  // error
 
   Float64 nominal_sample_rate;
   info_size = sizeof(nominal_sample_rate);
 
   AudioObjectPropertyAddress nominal_sample_rate_address = {
       kAudioDevicePropertyNominalSampleRate,
       kAudioObjectPropertyScopeGlobal,
       kAudioObjectPropertyElementMaster
   };
   result = AudioObjectGetPropertyData(device_id,
                                       &nominal_sample_rate_address,
                                       0,
                                       0,
                                       &info_size,
                                       &nominal_sample_rate);
-  DCHECK_EQ(result, 0);
+  OSSTATUS_DCHECK(result == noErr, result);
   if (result)
     return 0.0;  // error
 
   return nominal_sample_rate;
 }
 
 double AUAudioOutputStream::GetHardwareLatency() {
   if (!output_unit_ || output_device_id_ == kAudioObjectUnknown) {
     DLOG(WARNING) << "Audio unit object is NULL or device ID is unknown";
     return 0.0;
   }
 
   // Get audio unit latency.
   Float64 audio_unit_latency_sec = 0.0;
   UInt32 size = sizeof(audio_unit_latency_sec);
   OSStatus result = AudioUnitGetProperty(output_unit_,
                                          kAudioUnitProperty_Latency,
                                          kAudioUnitScope_Global,
                                          0,
                                          &audio_unit_latency_sec,
                                          &size);
-  DLOG_IF(WARNING, result != noErr) << "Could not get audio unit latency.";
+  OSSTATUS_DLOG_IF(WARNING, result != noErr, result)
+      << "Could not get audio unit latency";
 
   // Get output audio device latency.
   AudioObjectPropertyAddress property_address = {
     kAudioDevicePropertyLatency,
     kAudioDevicePropertyScopeOutput,
     kAudioObjectPropertyElementMaster
   };
   UInt32 device_latency_frames = 0;
   size = sizeof(device_latency_frames);
   result = AudioObjectGetPropertyData(output_device_id_,
                                       &property_address,
                                       0,
                                       NULL,
                                       &size,
                                       &device_latency_frames);
-  DLOG_IF(WARNING, result != noErr) << "Could not get audio device latency.";
+  OSSTATUS_DLOG_IF(WARNING, result != noErr, result)
+      << "Could not get audio device latency";
 
   // Get the stream latency.
   property_address.mSelector = kAudioDevicePropertyStreams;
   UInt32 stream_latency_frames = 0;
   result = AudioObjectGetPropertyDataSize(output_device_id_,
                                           &property_address,
                                           0,
                                           NULL,
                                           &size);
   if (!result) {
     scoped_ptr_malloc<AudioStreamID>
         streams(reinterpret_cast<AudioStreamID*>(malloc(size)));
     AudioStreamID* stream_ids = streams.get();
     result = AudioObjectGetPropertyData(output_device_id_,
                                         &property_address,
                                         0,
                                         NULL,
                                         &size,
                                         stream_ids);
     if (!result) {
       property_address.mSelector = kAudioStreamPropertyLatency;
       result = AudioObjectGetPropertyData(stream_ids[0],
                                           &property_address,
                                           0,
                                           NULL,
                                           &size,
                                           &stream_latency_frames);
     }
   }
-  DLOG_IF(WARNING, result != noErr) << "Could not get audio stream latency.";
+  OSSTATUS_DLOG_IF(WARNING, result != noErr, result)
+      << "Could not get audio stream latency";
 
   return static_cast<double>((audio_unit_latency_sec *
       format_.mSampleRate) + device_latency_frames + stream_latency_frames);
 }
 
 double AUAudioOutputStream::GetPlayoutLatency(
     const AudioTimeStamp* output_time_stamp) {
   // Get the delay between the moment getting the callback and the scheduled
   // time stamp that tells when the data is going to be played out.
   UInt64 output_time_ns = AudioConvertHostTimeToNanos(
       output_time_stamp->mHostTime);
   UInt64 now_ns = AudioConvertHostTimeToNanos(AudioGetCurrentHostTime());
   double delay_frames = static_cast<double>
       (1e-9 * (output_time_ns - now_ns) * format_.mSampleRate);
 
   return (delay_frames + hardware_latency_frames_);
 }