Home | History | Annotate | Download | only in neteq 
      1 /*
      2  *  Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #include "webrtc/modules/audio_coding/neteq/decision_logic_normal.h"
     12 
     13 #include <assert.h>
     14 
     15 #include <algorithm>
     16 
     17 #include "webrtc/modules/audio_coding/neteq/buffer_level_filter.h"
     18 #include "webrtc/modules/audio_coding/neteq/decoder_database.h"
     19 #include "webrtc/modules/audio_coding/neteq/delay_manager.h"
     20 #include "webrtc/modules/audio_coding/neteq/expand.h"
     21 #include "webrtc/modules/audio_coding/neteq/packet_buffer.h"
     22 #include "webrtc/modules/audio_coding/neteq/sync_buffer.h"
     23 #include "webrtc/modules/interface/module_common_types.h"
     24 
     25 namespace webrtc {
     26 
     27 Operations DecisionLogicNormal::GetDecisionSpecialized(
     28     const SyncBuffer& sync_buffer,
     29     const Expand& expand,
     30     int decoder_frame_length,
     31     const RTPHeader* packet_header,
     32     Modes prev_mode,
     33     bool play_dtmf,
     34     bool* reset_decoder) {
     35   assert(playout_mode_ == kPlayoutOn || playout_mode_ == kPlayoutStreaming);
     36   // Guard for errors, to avoid getting stuck in error mode.
     37   if (prev_mode == kModeError) {
     38     if (!packet_header) {
     39       return kExpand;
     40     } else {
     41       return kUndefined;  // Use kUndefined to flag for a reset.
     42     }
     43   }
     44 
     45   uint32_t target_timestamp = sync_buffer.end_timestamp();
     46   uint32_t available_timestamp = 0;
     47   bool is_cng_packet = false;
     48   if (packet_header) {
     49     available_timestamp = packet_header->timestamp;
     50     is_cng_packet =
     51         decoder_database_->IsComfortNoise(packet_header->payloadType);
     52   }
     53 
     54   if (is_cng_packet) {
     55     return CngOperation(prev_mode, target_timestamp, available_timestamp);
     56   }
     57 
     58   // Handle the case with no packet at all available (except maybe DTMF).
     59   if (!packet_header) {
     60     return NoPacket(play_dtmf);
     61   }
     62 
     63   // If the expand period was very long, reset NetEQ since it is likely that the
     64   // sender was restarted.
     65   if (num_consecutive_expands_ > kReinitAfterExpands) {
     66     *reset_decoder = true;
     67     return kNormal;
     68   }
     69 
     70   // Check if the required packet is available.
     71   if (target_timestamp == available_timestamp) {
     72     return ExpectedPacketAvailable(prev_mode, play_dtmf);
     73   } else if (IsNewerTimestamp(available_timestamp, target_timestamp)) {
     74     return FuturePacketAvailable(sync_buffer, expand, decoder_frame_length,
     75                                  prev_mode, target_timestamp,
     76                                  available_timestamp, play_dtmf);
     77   } else {
     78     // This implies that available_timestamp < target_timestamp, which can
     79     // happen when a new stream or codec is received. Signal for a reset.
     80     return kUndefined;
     81   }
     82 }
     83 
     84 Operations DecisionLogicNormal::CngOperation(Modes prev_mode,
     85                                              uint32_t target_timestamp,
     86                                              uint32_t available_timestamp) {
     87   // Signed difference between target and available timestamp.
     88   int32_t timestamp_diff = (generated_noise_samples_ + target_timestamp) -
     89       available_timestamp;
     90   int32_t optimal_level_samp =
     91       (delay_manager_->TargetLevel() * packet_length_samples_) >> 8;
     92   int32_t excess_waiting_time_samp = -timestamp_diff - optimal_level_samp;
     93 
     94   if (excess_waiting_time_samp > optimal_level_samp / 2) {
     95     // The waiting time for this packet will be longer than 1.5
     96     // times the wanted buffer delay. Advance the clock to cut
     97     // waiting time down to the optimal.
     98     generated_noise_samples_ += excess_waiting_time_samp;
     99     timestamp_diff += excess_waiting_time_samp;
    100   }
    101 
    102   if (timestamp_diff < 0 && prev_mode == kModeRfc3389Cng) {
    103     // Not time to play this packet yet. Wait another round before using this
    104     // packet. Keep on playing CNG from previous CNG parameters.
    105     return kRfc3389CngNoPacket;
    106   } else {
    107     // Otherwise, go for the CNG packet now.
    108     return kRfc3389Cng;
    109   }
    110 }
    111 
    112 Operations DecisionLogicNormal::NoPacket(bool play_dtmf) {
    113   if (cng_state_ == kCngRfc3389On) {
    114     // Keep on playing comfort noise.
    115     return kRfc3389CngNoPacket;
    116   } else if (cng_state_ == kCngInternalOn) {
    117     // Keep on playing codec internal comfort noise.
    118     return kCodecInternalCng;
    119   } else if (play_dtmf) {
    120     return kDtmf;
    121   } else {
    122     // Nothing to play, do expand.
    123     return kExpand;
    124   }
    125 }
    126 
    127 Operations DecisionLogicNormal::ExpectedPacketAvailable(Modes prev_mode,
    128                                                         bool play_dtmf) {
    129   if (prev_mode != kModeExpand && !play_dtmf) {
    130     // Check criterion for time-stretching.
    131     int low_limit, high_limit;
    132     delay_manager_->BufferLimits(&low_limit, &high_limit);
    133     if ((buffer_level_filter_->filtered_current_level() >= high_limit &&
    134         TimescaleAllowed()) ||
    135         buffer_level_filter_->filtered_current_level() >= high_limit << 2) {
    136       // Buffer level higher than limit and time-scaling allowed,
    137       // or buffer level really high.
    138       return kAccelerate;
    139     } else if ((buffer_level_filter_->filtered_current_level() < low_limit)
    140         && TimescaleAllowed()) {
    141       return kPreemptiveExpand;
    142     }
    143   }
    144   return kNormal;
    145 }
    146 
    147 Operations DecisionLogicNormal::FuturePacketAvailable(
    148     const SyncBuffer& sync_buffer,
    149     const Expand& expand,
    150     int decoder_frame_length,
    151     Modes prev_mode,
    152     uint32_t target_timestamp,
    153     uint32_t available_timestamp,
    154     bool play_dtmf) {
    155   // Required packet is not available, but a future packet is.
    156   // Check if we should continue with an ongoing expand because the new packet
    157   // is too far into the future.
    158   uint32_t timestamp_leap = available_timestamp - target_timestamp;
    159   if ((prev_mode == kModeExpand) &&
    160       !ReinitAfterExpands(timestamp_leap) &&
    161       !MaxWaitForPacket() &&
    162       PacketTooEarly(timestamp_leap) &&
    163       UnderTargetLevel()) {
    164     if (play_dtmf) {
    165       // Still have DTMF to play, so do not do expand.
    166       return kDtmf;
    167     } else {
    168       // Nothing to play.
    169       return kExpand;
    170     }
    171   }
    172 
    173   const int samples_left = static_cast<int>(sync_buffer.FutureLength() -
    174       expand.overlap_length());
    175   const int cur_size_samples = samples_left +
    176       packet_buffer_.NumPacketsInBuffer() * decoder_frame_length;
    177 
    178   // If previous was comfort noise, then no merge is needed.
    179   if (prev_mode == kModeRfc3389Cng ||
    180       prev_mode == kModeCodecInternalCng) {
    181     // Keep the same delay as before the CNG (or maximum 70 ms in buffer as
    182     // safety precaution), but make sure that the number of samples in buffer
    183     // is no higher than 4 times the optimal level. (Note that TargetLevel()
    184     // is in Q8.)
    185     int32_t timestamp_diff = (generated_noise_samples_ + target_timestamp) -
    186         available_timestamp;
    187     if (timestamp_diff >= 0 ||
    188         cur_size_samples >
    189         4 * ((delay_manager_->TargetLevel() * packet_length_samples_) >> 8)) {
    190       // Time to play this new packet.
    191       return kNormal;
    192     } else {
    193       // Too early to play this new packet; keep on playing comfort noise.
    194       if (prev_mode == kModeRfc3389Cng) {
    195         return kRfc3389CngNoPacket;
    196       } else {  // prevPlayMode == kModeCodecInternalCng.
    197         return kCodecInternalCng;
    198       }
    199     }
    200   }
    201   // Do not merge unless we have done an expand before.
    202   // (Convert kAllowMergeWithoutExpand from ms to samples by multiplying with
    203   // fs_mult_ * 8 = fs / 1000.)
    204   if (prev_mode == kModeExpand ||
    205       (decoder_frame_length < output_size_samples_ &&
    206        cur_size_samples > kAllowMergeWithoutExpandMs * fs_mult_ * 8)) {
    207     return kMerge;
    208   } else if (play_dtmf) {
    209     // Play DTMF instead of expand.
    210     return kDtmf;
    211   } else {
    212     return kExpand;
    213   }
    214 }
    215 
    216 bool DecisionLogicNormal::UnderTargetLevel() const {
    217   return buffer_level_filter_->filtered_current_level() <=
    218       delay_manager_->TargetLevel();
    219 }
    220 
    221 bool DecisionLogicNormal::ReinitAfterExpands(uint32_t timestamp_leap) const {
    222   return timestamp_leap >=
    223       static_cast<uint32_t>(output_size_samples_ * kReinitAfterExpands);
    224 }
    225 
    226 bool DecisionLogicNormal::PacketTooEarly(uint32_t timestamp_leap) const {
    227   return timestamp_leap >
    228       static_cast<uint32_t>(output_size_samples_ * num_consecutive_expands_);
    229 }
    230 
    231 bool DecisionLogicNormal::MaxWaitForPacket() const {
    232   return num_consecutive_expands_ >= kMaxWaitForPacket;
    233 }
    234 
    235 }  // namespace webrtc
    236