Stylizing AudioConferenceMixer.

webrtc/voice_engine/channel.cc

 /*
  *  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 427 matching lines @@
                  "IncomingPacket invalid RTP header");
     return false;
   }
   header.payload_type_frequency =
       rtp_payload_registry_->GetPayloadTypeFrequency(header.payloadType);
   if (header.payload_type_frequency < 0)
     return false;
   return ReceivePacket(rtp_packet, rtp_packet_length, header, false);
 }
 
-int32_t Channel::GetAudioFrame(int32_t id, AudioFrame& audioFrame)
+int32_t Channel::GetAudioFrame(int32_t id, AudioFrame* audioFrame)
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::GetAudioFrame(id=%d)", id);
 
     // Get 10ms raw PCM data from the ACM (mixer limits output frequency)
-    if (audio_coding_->PlayoutData10Ms(audioFrame.sample_rate_hz_,
-                                       &audioFrame) == -1)
+    if (audio_coding_->PlayoutData10Ms(audioFrame->sample_rate_hz_,
+                                       audioFrame) == -1)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice,
                      VoEId(_instanceId,_channelId),
                      "Channel::GetAudioFrame() PlayoutData10Ms() failed!");
         // In all likelihood, the audio in this frame is garbage. We return an
         // error so that the audio mixer module doesn't add it to the mix. As
         // a result, it won't be played out and the actions skipped here are
         // irrelevant.
         return -1;
     }
 
     if (_RxVadDetection)
     {
-        UpdateRxVadDetection(audioFrame);
+        UpdateRxVadDetection(*audioFrame);
     }
 
     // Convert module ID to internal VoE channel ID
-    audioFrame.id_ = VoEChannelId(audioFrame.id_);
+    audioFrame->id_ = VoEChannelId(audioFrame->id_);
     // Store speech type for dead-or-alive detection
-    _outputSpeechType = audioFrame.speech_type_;
+    _outputSpeechType = audioFrame->speech_type_;
 
     ChannelState::State state = channel_state_.Get();
 
     if (state.rx_apm_is_enabled) {
-      int err = rx_audioproc_->ProcessStream(&audioFrame);
+      int err = rx_audioproc_->ProcessStream(audioFrame);
       if (err) {
         LOG(LS_ERROR) << "ProcessStream() error: " << err;
         assert(false);
       }
     }
 
     float output_gain = 1.0f;
     float left_pan =  1.0f;
     float right_pan =  1.0f;
     {
       CriticalSectionScoped cs(&volume_settings_critsect_);
       output_gain = _outputGain;
       left_pan = _panLeft;
       right_pan= _panRight;
     }
 
     // Output volume scaling
     if (output_gain < 0.99f || output_gain > 1.01f)
     {
-        AudioFrameOperations::ScaleWithSat(output_gain, audioFrame);
+        AudioFrameOperations::ScaleWithSat(output_gain, *audioFrame);
     }
 
     // Scale left and/or right channel(s) if stereo and master balance is
     // active
 
     if (left_pan != 1.0f || right_pan != 1.0f)
     {
-        if (audioFrame.num_channels_ == 1)
+        if (audioFrame->num_channels_ == 1)
         {
             // Emulate stereo mode since panning is active.
             // The mono signal is copied to both left and right channels here.
-            AudioFrameOperations::MonoToStereo(&audioFrame);
+            AudioFrameOperations::MonoToStereo(audioFrame);
         }
         // For true stereo mode (when we are receiving a stereo signal), no
         // action is needed.
 
         // Do the panning operation (the audio frame contains stereo at this
         // stage)
-        AudioFrameOperations::Scale(left_pan, right_pan, audioFrame);
+        AudioFrameOperations::Scale(left_pan, right_pan, *audioFrame);
     }
 
     // Mix decoded PCM output with file if file mixing is enabled
     if (state.output_file_playing)
     {
-        MixAudioWithFile(audioFrame, audioFrame.sample_rate_hz_);
+        MixAudioWithFile(*audioFrame, audioFrame->sample_rate_hz_);
     }
 
     // External media
     if (_outputExternalMedia)
     {
         CriticalSectionScoped cs(&_callbackCritSect);
-        const bool isStereo = (audioFrame.num_channels_ == 2);
+        const bool isStereo = (audioFrame->num_channels_ == 2);
         if (_outputExternalMediaCallbackPtr)
         {
             _outputExternalMediaCallbackPtr->Process(
                 _channelId,
                 kPlaybackPerChannel,
-                (int16_t*)audioFrame.data_,
-                audioFrame.samples_per_channel_,
-                audioFrame.sample_rate_hz_,
+                (int16_t*)audioFrame->data_,
+                audioFrame->samples_per_channel_,
+                audioFrame->sample_rate_hz_,
                 isStereo);
         }
     }
 
     // Record playout if enabled
     {
         CriticalSectionScoped cs(&_fileCritSect);
 
         if (_outputFileRecording && _outputFileRecorderPtr)
         {
-            _outputFileRecorderPtr->RecordAudioToFile(audioFrame);
+            _outputFileRecorderPtr->RecordAudioToFile(*audioFrame);
         }
     }
 
     // Measure audio level (0-9)
-    _outputAudioLevel.ComputeLevel(audioFrame);
+    _outputAudioLevel.ComputeLevel(*audioFrame);
 
-    if (capture_start_rtp_time_stamp_ < 0 && audioFrame.timestamp_ != 0) {
+    if (capture_start_rtp_time_stamp_ < 0 && audioFrame->timestamp_ != 0) {
       // The first frame with a valid rtp timestamp.
-      capture_start_rtp_time_stamp_ = audioFrame.timestamp_;
+      capture_start_rtp_time_stamp_ = audioFrame->timestamp_;
     }
 
     if (capture_start_rtp_time_stamp_ >= 0) {
       // audioFrame.timestamp_ should be valid from now on.
 
       // Compute elapsed time.
       int64_t unwrap_timestamp =
-          rtp_ts_wraparound_handler_->Unwrap(audioFrame.timestamp_);
-      audioFrame.elapsed_time_ms_ =
+          rtp_ts_wraparound_handler_->Unwrap(audioFrame->timestamp_);
+      audioFrame->elapsed_time_ms_ =
           (unwrap_timestamp - capture_start_rtp_time_stamp_) /
           (GetPlayoutFrequency() / 1000);
 
       {
         CriticalSectionScoped lock(ts_stats_lock_.get());
         // Compute ntp time.
-        audioFrame.ntp_time_ms_ = ntp_estimator_.Estimate(
-            audioFrame.timestamp_);
+        audioFrame->ntp_time_ms_ = ntp_estimator_.Estimate(
+            audioFrame->timestamp_);
         // |ntp_time_ms_| won't be valid until at least 2 RTCP SRs are received.
-        if (audioFrame.ntp_time_ms_ > 0) {
+        if (audioFrame->ntp_time_ms_ > 0) {
           // Compute |capture_start_ntp_time_ms_| so that
           // |capture_start_ntp_time_ms_| + |elapsed_time_ms_| == |ntp_time_ms_|
           capture_start_ntp_time_ms_ =
-              audioFrame.ntp_time_ms_ - audioFrame.elapsed_time_ms_;
+              audioFrame->ntp_time_ms_ - audioFrame->elapsed_time_ms_;
         }
       }
     }
 
     return 0;
 }
 
 int32_t
-Channel::NeededFrequency(int32_t id)
+Channel::NeededFrequency(int32_t id) const
 {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
                  "Channel::NeededFrequency(id=%d)", id);
 
     int highestNeeded = 0;
 
     // Determine highest needed receive frequency
     int32_t receiveFrequency = audio_coding_->ReceiveFrequency();
 
     // Return the bigger of playout and receive frequency in the ACM.
@@ skipping 3544 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt)
       != 0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc