Introduce dchecked_cast, and start using it

webrtc/modules/audio_coding/neteq/neteq_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 181 matching lines @@
 int NetEqImpl::GetAudio(AudioFrame* audio_frame, bool* muted) {
   TRACE_EVENT0("webrtc", "NetEqImpl::GetAudio");
   rtc::CritScope lock(&crit_sect_);
   int error = GetAudioInternal(audio_frame, muted);
   if (error != 0) {
     error_code_ = error;
     return kFail;
   }
   RTC_DCHECK_EQ(
       audio_frame->sample_rate_hz_,
-      rtc::checked_cast<int>(audio_frame->samples_per_channel_ * 100));
+      rtc::dchecked_cast<int>(audio_frame->samples_per_channel_ * 100));
   SetAudioFrameActivityAndType(vad_->enabled(), LastOutputType(),
                                last_vad_activity_, audio_frame);
   last_vad_activity_ = audio_frame->vad_activity_;
   last_output_sample_rate_hz_ = audio_frame->sample_rate_hz_;
   RTC_DCHECK(last_output_sample_rate_hz_ == 8000 ||
              last_output_sample_rate_hz_ == 16000 ||
              last_output_sample_rate_hz_ == 32000 ||
              last_output_sample_rate_hz_ == 48000)
       << "Unexpected sample rate " << last_output_sample_rate_hz_;
   return kOK;
@@ skipping 606 matching lines @@
     const size_t buffer_length_after_insert =
         packet_buffer_->NumPacketsInBuffer();
 
     if (buffer_length_after_insert > buffer_length_before_insert) {
       const size_t packet_length_samples =
           (buffer_length_after_insert - buffer_length_before_insert) *
           decoder_frame_length_;
       if (packet_length_samples != decision_logic_->packet_length_samples()) {
         decision_logic_->set_packet_length_samples(packet_length_samples);
         delay_manager_->SetPacketAudioLength(
-            rtc::checked_cast<int>((1000 * packet_length_samples) / fs_hz_));
+            rtc::dchecked_cast<int>((1000 * packet_length_samples) / fs_hz_));
       }
     }
 
     // Update statistics.
     if ((int32_t)(main_timestamp - timestamp_) >= 0 && !new_codec_) {
       // Only update statistics if incoming packet is not older than last played
       // out packet, and if new codec flag is not set.
       delay_manager_->Update(main_sequence_number, main_timestamp, fs_hz_);
     }
   } else if (delay_manager_->last_pack_cng_or_dtmf() == -1) {
@@ skipping 284 matching lines @@
 
   assert(expand_.get());
   const int samples_left = static_cast<int>(sync_buffer_->FutureLength() -
       expand_->overlap_length());
   if (last_mode_ == kModeAccelerateSuccess ||
       last_mode_ == kModeAccelerateLowEnergy ||
       last_mode_ == kModePreemptiveExpandSuccess ||
       last_mode_ == kModePreemptiveExpandLowEnergy) {
     // Subtract (samples_left + output_size_samples_) from sampleMemory.
     decision_logic_->AddSampleMemory(
-        -(samples_left + rtc::checked_cast<int>(output_size_samples_)));
+        -(samples_left + rtc::dchecked_cast<int>(output_size_samples_)));
   }
 
   // Check if it is time to play a DTMF event.
   if (dtmf_buffer_->GetEvent(
       static_cast<uint32_t>(
           end_timestamp + generated_noise_samples),
       dtmf_event)) {
     *play_dtmf = true;
   }
 
   // Get instruction.
   assert(sync_buffer_.get());
   assert(expand_.get());
   generated_noise_samples =
       generated_noise_stopwatch_
           ? generated_noise_stopwatch_->ElapsedTicks() * output_size_samples_ +
                 decision_logic_->noise_fast_forward()
           : 0;
   *operation = decision_logic_->GetDecision(
       *sync_buffer_, *expand_, decoder_frame_length_, packet, last_mode_,
       *play_dtmf, generated_noise_samples, &reset_decoder_);
 
   // Check if we already have enough samples in the |sync_buffer_|. If so,
   // change decision to normal, unless the decision was merge, accelerate, or
   // preemptive expand.
-  if (samples_left >= rtc::checked_cast<int>(output_size_samples_) &&
-      *operation != kMerge &&
-      *operation != kAccelerate &&
-      *operation != kFastAccelerate &&
-      *operation != kPreemptiveExpand) {
+  if (samples_left >= rtc::dchecked_cast<int>(output_size_samples_) &&
+      *operation != kMerge && *operation != kAccelerate &&
+      *operation != kFastAccelerate && *operation != kPreemptiveExpand) {
     *operation = kNormal;
     return 0;
   }
 
   decision_logic_->ExpandDecision(*operation);
 
   // Check conditions for reset.
   if (new_codec_ || *operation == kUndefined) {
     // The only valid reason to get kUndefined is that new_codec_ is set.
     assert(new_codec_);
@@ skipping 272 matching lines @@
 }
 
 int NetEqImpl::DecodeCng(AudioDecoder* decoder, int* decoded_length,
                          AudioDecoder::SpeechType* speech_type) {
   if (!decoder) {
     // This happens when active decoder is not defined.
     *decoded_length = -1;
     return 0;
   }
 
-  while (*decoded_length < rtc::checked_cast<int>(output_size_samples_)) {
+  while (*decoded_length < rtc::dchecked_cast<int>(output_size_samples_)) {
     const int length = decoder->Decode(
             nullptr, 0, fs_hz_,
             (decoded_buffer_length_ - *decoded_length) * sizeof(int16_t),
             &decoded_buffer_[*decoded_length], speech_type);
     if (length > 0) {
       *decoded_length += length;
     } else {
       // Error.
       LOG(LS_WARNING) << "Failed to decode CNG";
       *decoded_length = -1;
@@ skipping 25 matching lines @@
            operation == kPreemptiveExpand);
 
     auto opt_result = packet_list->front().frame->Decode(
         rtc::ArrayView<int16_t>(&decoded_buffer_[*decoded_length],
                                 decoded_buffer_length_ - *decoded_length));
     packet_list->pop_front();
     if (opt_result) {
       const auto& result = *opt_result;
       *speech_type = result.speech_type;
       if (result.num_decoded_samples > 0) {
-        *decoded_length += rtc::checked_cast<int>(result.num_decoded_samples);
+        *decoded_length += rtc::dchecked_cast<int>(result.num_decoded_samples);

[ossu, 2017/03/02 00:54:14]

These decoded_length checks (above and below as well) seem scary to me, but not
in a way that a checked_cast would solve, so I guess dchecked_cast is just as
useful.

[kwiberg-webrtc, 2017/03/02 02:13:37]

Acknowledged.

         // Update |decoder_frame_length_| with number of samples per channel.
         decoder_frame_length_ =
             result.num_decoded_samples / decoder->Channels();
       }
     } else {
       // Error.
       // TODO(ossu): What to put here?
       LOG(LS_WARNING) << "Decode error";
       *decoded_length = -1;
       packet_list->clear();
       break;
     }
-    if (*decoded_length > rtc::checked_cast<int>(decoded_buffer_length_)) {
+    if (*decoded_length > rtc::dchecked_cast<int>(decoded_buffer_length_)) {
       // Guard against overflow.
       LOG(LS_WARNING) << "Decoded too much.";
       packet_list->clear();
       return kDecodedTooMuch;
     }
   }  // End of decode loop.
 
   // If the list is not empty at this point, either a decoding error terminated
   // the while-loop, or list must hold exactly one CNG packet.
   assert(
@@ skipping 452 matching lines @@
     }
 
     const bool has_cng_packet =
         decoder_database_->IsComfortNoise(packet->payload_type);
     // Store number of extracted samples.
     size_t packet_duration = 0;
     if (packet->frame) {
       packet_duration = packet->frame->Duration();
       // TODO(ossu): Is this the correct way to track Opus FEC packets?
       if (packet->priority.codec_level > 0) {
-        stats_.SecondaryDecodedSamples(rtc::checked_cast<int>(packet_duration));
+        stats_.SecondaryDecodedSamples(
+            rtc::dchecked_cast<int>(packet_duration));
       }
     } else if (!has_cng_packet) {
       LOG(LS_WARNING) << "Unknown payload type "
                       << static_cast<int>(packet->payload_type);
       RTC_NOTREACHED();
     }
 
     if (packet_duration == 0) {
       // Decoder did not return a packet duration. Assume that the packet
       // contains the same number of samples as the previous one.
@@ skipping 22 matching lines @@
   } while (extracted_samples < required_samples && next_packet_available);
 
   if (extracted_samples > 0) {
     // Delete old packets only when we are going to decode something. Otherwise,
     // we could end up in the situation where we never decode anything, since
     // all incoming packets are considered too old but the buffer will also
     // never be flooded and flushed.
     packet_buffer_->DiscardAllOldPackets(timestamp_);
   }
 
-  return rtc::checked_cast<int>(extracted_samples);
+  return rtc::dchecked_cast<int>(extracted_samples);
 }
 
 void NetEqImpl::UpdatePlcComponents(int fs_hz, size_t channels) {
   // Delete objects and create new ones.
   expand_.reset(expand_factory_->Create(background_noise_.get(),
                                         sync_buffer_.get(), &random_vector_,
                                         &stats_, fs_hz, channels));
   merge_.reset(new Merge(fs_hz, channels, expand_.get(), sync_buffer_.get()));
 }
 
@@ skipping 86 matching lines @@
   }
 }
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(
       fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
       *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
       tick_timer_.get()));
 }
 }  // namespace webrtc