Add mute state field to AudioFrame.

webrtc/modules/audio_coding/test/PCMFile.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 107 matching lines @@
 uint16_t PCMFile::PayloadLength10Ms() const {
   return samples_10ms_;
 }
 
 int32_t PCMFile::Read10MsData(AudioFrame& audio_frame) {
   uint16_t channels = 1;
   if (read_stereo_) {
     channels = 2;
   }
 
-  int32_t payload_size = (int32_t) fread(audio_frame.data_, sizeof(uint16_t),
+  int32_t payload_size = (int32_t) fread(audio_frame.mutable_data(),
+                                         sizeof(uint16_t),
                                          samples_10ms_ * channels, pcm_file_);
   if (payload_size < samples_10ms_ * channels) {
+    int16_t* frame_data = audio_frame.mutable_data();
     for (int k = payload_size; k < samples_10ms_ * channels; k++) {
-      audio_frame.data_[k] = 0;
+      frame_data[k] = 0;
     }
     if (auto_rewind_) {
       rewind(pcm_file_);
       rewinded_ = true;
     } else {
       end_of_file_ = true;
     }
   }
   audio_frame.samples_per_channel_ = samples_10ms_;
   audio_frame.sample_rate_hz_ = frequency_;
   audio_frame.num_channels_ = channels;
   audio_frame.timestamp_ = timestamp_;
   timestamp_ += samples_10ms_;
   ++blocks_read_;
   if (num_10ms_blocks_to_read_ && blocks_read_ >= *num_10ms_blocks_to_read_)
     end_of_file_ = true;
   return samples_10ms_;
 }
 
-void PCMFile::Write10MsData(AudioFrame& audio_frame) {
+void PCMFile::Write10MsData(const AudioFrame& audio_frame) {
   if (audio_frame.num_channels_ == 1) {
     if (!save_stereo_) {
-      if (fwrite(audio_frame.data_, sizeof(uint16_t),
+      if (fwrite(audio_frame.data(), sizeof(uint16_t),
                  audio_frame.samples_per_channel_, pcm_file_) !=
           static_cast<size_t>(audio_frame.samples_per_channel_)) {
         return;
       }
     } else {
+      const int16_t* frame_data = audio_frame.data();
       int16_t* stereo_audio = new int16_t[2 * audio_frame.samples_per_channel_];
       for (size_t k = 0; k < audio_frame.samples_per_channel_; k++) {
-        stereo_audio[k << 1] = audio_frame.data_[k];
-        stereo_audio[(k << 1) + 1] = audio_frame.data_[k];
+        stereo_audio[k << 1] = frame_data[k];
+        stereo_audio[(k << 1) + 1] = frame_data[k];
       }
       if (fwrite(stereo_audio, sizeof(int16_t),
                  2 * audio_frame.samples_per_channel_, pcm_file_) !=
           static_cast<size_t>(2 * audio_frame.samples_per_channel_)) {
         return;
       }
       delete[] stereo_audio;
     }
   } else {
-    if (fwrite(audio_frame.data_, sizeof(int16_t),
+    if (fwrite(audio_frame.data(), sizeof(int16_t),
                audio_frame.num_channels_ * audio_frame.samples_per_channel_,
                pcm_file_) !=
         static_cast<size_t>(audio_frame.num_channels_ *
                             audio_frame.samples_per_channel_)) {
       return;
     }
   }
 }
 
-void PCMFile::Write10MsData(int16_t* playout_buffer, size_t length_smpls) {
+void PCMFile::Write10MsData(const int16_t* playout_buffer,
+                            size_t length_smpls) {
   if (fwrite(playout_buffer, sizeof(uint16_t), length_smpls, pcm_file_) !=
       length_smpls) {
     return;
   }
 }
 
 void PCMFile::Close() {
   fclose(pcm_file_);
   pcm_file_ = NULL;
   blocks_read_ = 0;
@@ skipping 23 matching lines @@
 
 void PCMFile::ReadStereo(bool is_stereo) {
   read_stereo_ = is_stereo;
 }
 
 void PCMFile::SetNum10MsBlocksToRead(int value) {
   num_10ms_blocks_to_read_ = rtc::Optional<int>(value);
 }
 
 }  // namespace webrtc