AudioCodingModuleImpl::Encode: Use a Buffer instead of a stack-allocated array

webrtc/modules/audio_coding/main/acm2/audio_coding_module_impl.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 139 matching lines @@
   if (InitializeReceiverSafe() < 0) {
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, id_,
                  "Cannot initialize receiver");
   }
   WEBRTC_TRACE(webrtc::kTraceMemory, webrtc::kTraceAudioCoding, id_, "Created");
 }
 
 AudioCodingModuleImpl::~AudioCodingModuleImpl() = default;
 
 int32_t AudioCodingModuleImpl::Encode(const InputData& input_data) {
-  uint8_t stream[2 * MAX_PAYLOAD_SIZE_BYTE];  // Make room for 1 RED payload.
   AudioEncoder::EncodedInfo encoded_info;
   uint8_t previous_pltype;
 
   // Check if there is an encoder before.
   if (!HaveValidEncoder("Process"))
     return -1;
 
   AudioEncoder* audio_encoder = codec_manager_.CurrentEncoder();
   // Scale the timestamp to the codec's RTP timestamp rate.
   uint32_t rtp_timestamp =
       first_frame_ ? input_data.input_timestamp
                    : last_rtp_timestamp_ +
                          rtc::CheckedDivExact(
                              input_data.input_timestamp - last_timestamp_,
                              static_cast<uint32_t>(rtc::CheckedDivExact(
                                  audio_encoder->SampleRateHz(),
                                  audio_encoder->RtpTimestampRateHz())));
   last_timestamp_ = input_data.input_timestamp;
   last_rtp_timestamp_ = rtp_timestamp;
   first_frame_ = false;
 
-  encoded_info = audio_encoder->Encode(rtp_timestamp, input_data.audio,
-                                       input_data.length_per_channel,
-                                       sizeof(stream), stream);
+  encode_buffer_.SetSize(audio_encoder->MaxEncodedBytes());
+  encoded_info = audio_encoder->Encode(
+      rtp_timestamp, input_data.audio, input_data.length_per_channel,
+      encode_buffer_.size(), encode_buffer_.data());
+  encode_buffer_.SetSize(encoded_info.encoded_bytes);
   bitrate_logger_.MaybeLog(audio_encoder->GetTargetBitrate() / 1000);
-  if (encoded_info.encoded_bytes == 0 && !encoded_info.send_even_if_empty) {
+  if (encode_buffer_.size() == 0 && !encoded_info.send_even_if_empty) {

[hlundin-webrtc, 2015/08/25 12:43:43]

Why change this while still using encoded_info.encoded_bytes below? They hold
the same information, but I think it is cleaner if we stick to reading one of
them.

[kwiberg-webrtc, 2015/08/25 13:20:24]

Indeed, that was dismeticulous of me. Fixed (by using encode_buffer_.size()
everywhere).

[hlundin-webrtc, 2015/08/26 13:10:17]

Meticulosity is restored.

     // Not enough data.
     return 0;
   }
   previous_pltype = previous_pltype_;  // Read it while we have the critsect.
 
   RTPFragmentationHeader my_fragmentation;
   ConvertEncodedInfoToFragmentationHeader(encoded_info, &my_fragmentation);
   FrameType frame_type;
   if (encoded_info.encoded_bytes == 0 && encoded_info.send_even_if_empty) {
     frame_type = kFrameEmpty;
     encoded_info.payload_type = previous_pltype;
   } else {
     DCHECK_GT(encoded_info.encoded_bytes, 0u);
     frame_type = encoded_info.speech ? kAudioFrameSpeech : kAudioFrameCN;
   }
 
   {
     CriticalSectionScoped lock(callback_crit_sect_.get());
     if (packetization_callback_) {
       packetization_callback_->SendData(
           frame_type, encoded_info.payload_type, encoded_info.encoded_timestamp,
-          stream, encoded_info.encoded_bytes,
+          encode_buffer_.data(), encode_buffer_.size(),
           my_fragmentation.fragmentationVectorSize > 0 ? &my_fragmentation
                                                        : nullptr);
     }
 
     if (vad_callback_) {
       // Callback with VAD decision.
       vad_callback_->InFrameType(frame_type);
     }
   }
   previous_pltype_ = encoded_info.payload_type;
@@ skipping 930 matching lines @@
       *channels = 1;
       break;
 #endif
     default:
       FATAL() << "Codec type " << codec_type << " not supported.";
   }
   return true;
 }
 
 }  // namespace webrtc