Create rtc::AtomicInt POD struct.

webrtc/modules/audio_device/ios/audio_device_ios.mm

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 175 matching lines @@
     LOG(LS_INFO) << " system version: " << ios::GetSystemVersion();
     LOG(LS_INFO) << " device type: " << ios::GetDeviceType();
     LOG(LS_INFO) << " device name: " << ios::GetDeviceName();
   }
 }
 #endif  // !defined(NDEBUG)
 
 AudioDeviceIOS::AudioDeviceIOS()
     : audio_device_buffer_(nullptr),
       vpio_unit_(nullptr),
-      recording_(0),
-      playing_(0),
+      recording_({0}),
+      playing_({0}),
       initialized_(false),
       rec_is_initialized_(false),
       play_is_initialized_(false),
       audio_interruption_observer_(nullptr) {
   LOGI() << "ctor" << ios::GetCurrentThreadDescription();
 }
 
 AudioDeviceIOS::~AudioDeviceIOS() {
   LOGI() << "~dtor";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 40 matching lines @@
   ShutdownPlayOrRecord();
   initialized_ = false;
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitPlayout() {
   LOGI() << "InitPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!play_is_initialized_);
-  RTC_DCHECK(!playing_);
+  RTC_DCHECK(!Playing());
   if (!rec_is_initialized_) {
     if (!InitPlayOrRecord()) {
       LOG_F(LS_ERROR) << "InitPlayOrRecord failed!";
       return -1;
     }
   }
   play_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::InitRecording() {
   LOGI() << "InitRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(initialized_);
   RTC_DCHECK(!rec_is_initialized_);
-  RTC_DCHECK(!recording_);
+  RTC_DCHECK(!Recording());
   if (!play_is_initialized_) {
     if (!InitPlayOrRecord()) {
       LOG_F(LS_ERROR) << "InitPlayOrRecord failed!";
       return -1;
     }
   }
   rec_is_initialized_ = true;
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartPlayout() {
   LOGI() << "StartPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(play_is_initialized_);
-  RTC_DCHECK(!playing_);
+  RTC_DCHECK(!Playing());
   fine_audio_buffer_->ResetPlayout();
-  if (!recording_) {
+  if (!Recording()) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result;
       return -1;
     }
   }
-  rtc::AtomicOps::ReleaseStore(&playing_, 1);
+  rtc::AtomicInt::ReleaseStore(&playing_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopPlayout() {
   LOGI() << "StopPlayout";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!play_is_initialized_ || !playing_) {
+  if (!play_is_initialized_ || !Playing()) {
     return 0;
   }
-  if (!recording_) {
+  if (!Recording()) {
     ShutdownPlayOrRecord();
   }
   play_is_initialized_ = false;
-  rtc::AtomicOps::ReleaseStore(&playing_, 0);
+  rtc::AtomicInt::ReleaseStore(&playing_, 0);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StartRecording() {
   LOGI() << "StartRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(rec_is_initialized_);
-  RTC_DCHECK(!recording_);
+  RTC_DCHECK(!Recording());
   fine_audio_buffer_->ResetRecord();
-  if (!playing_) {
+  if (!Playing()) {
     OSStatus result = AudioOutputUnitStart(vpio_unit_);
     if (result != noErr) {
       LOG_F(LS_ERROR) << "AudioOutputUnitStart failed: " << result;
       return -1;
     }
   }
-  rtc::AtomicOps::ReleaseStore(&recording_, 1);
+  rtc::AtomicInt::ReleaseStore(&recording_, 1);
   return 0;
 }
 
 int32_t AudioDeviceIOS::StopRecording() {
   LOGI() << "StopRecording";
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
-  if (!rec_is_initialized_ || !recording_) {
+  if (!rec_is_initialized_ || !Recording()) {
     return 0;
   }
-  if (!playing_) {
+  if (!Playing()) {
     ShutdownPlayOrRecord();
   }
   rec_is_initialized_ = false;
-  rtc::AtomicOps::ReleaseStore(&recording_, 0);
+  rtc::AtomicInt::ReleaseStore(&recording_, 0);
   return 0;
 }
 
 // Change the default receiver playout route to speaker.
 int32_t AudioDeviceIOS::SetLoudspeakerStatus(bool enable) {
   LOGI() << "SetLoudspeakerStatus(" << enable << ")";
 
   AVAudioSession* session = [AVAudioSession sharedInstance];
   NSString* category = session.category;
   AVAudioSessionCategoryOptions options = session.categoryOptions;
@@ skipping 489 matching lines @@
       io_action_flags, in_time_stamp, in_bus_number, in_number_frames);
 }
 
 OSStatus AudioDeviceIOS::OnRecordedDataIsAvailable(
     AudioUnitRenderActionFlags* io_action_flags,
     const AudioTimeStamp* in_time_stamp,
     UInt32 in_bus_number,
     UInt32 in_number_frames) {
   OSStatus result = noErr;
   // Simply return if recording is not enabled.
-  if (!rtc::AtomicOps::AcquireLoad(&recording_))
+  if (!Recording())
     return result;
   if (in_number_frames != record_parameters_.frames_per_buffer()) {
     // We have seen short bursts (1-2 frames) where |in_number_frames| changes.
     // Add a log to keep track of longer sequences if that should ever happen.
     LOG(LS_WARNING) << "in_number_frames (" << in_number_frames
                     << ") != " << record_parameters_.frames_per_buffer();
   }
   // Obtain the recorded audio samples by initiating a rendering cycle.
   // Since it happens on the input bus, the |io_data| parameter is a reference
   // to the preallocated audio buffer list that the audio unit renders into.
@@ skipping 38 matching lines @@
   // Verify 16-bit, noninterleaved mono PCM signal format.
   RTC_DCHECK_EQ(1u, io_data->mNumberBuffers);
   RTC_DCHECK_EQ(1u, io_data->mBuffers[0].mNumberChannels);
   // Get pointer to internal audio buffer to which new audio data shall be
   // written.
   const UInt32 dataSizeInBytes = io_data->mBuffers[0].mDataByteSize;
   RTC_CHECK_EQ(dataSizeInBytes / kBytesPerSample, in_number_frames);
   SInt8* destination = static_cast<SInt8*>(io_data->mBuffers[0].mData);
   // Produce silence and give audio unit a hint about it if playout is not
   // activated.
-  if (!rtc::AtomicOps::AcquireLoad(&playing_)) {
+  if (!Playing()) {
     *io_action_flags |= kAudioUnitRenderAction_OutputIsSilence;
     memset(destination, 0, dataSizeInBytes);
     return noErr;
   }
   // Read decoded 16-bit PCM samples from WebRTC (using a size that matches
   // the native I/O audio unit) to a preallocated intermediate buffer and
   // copy the result to the audio buffer in the |io_data| destination.
   SInt8* source = playout_audio_buffer_.get();
   fine_audio_buffer_->GetPlayoutData(source);
   memcpy(destination, source, dataSizeInBytes);
   return noErr;
 }
 
 }  // namespace webrtc