src/media/base/audio_discard_helper.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/base/audio_discard_helper.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #include "media/base/audio_buffer.h"
  11 #include "media/base/buffers.h"
  12
  13 namespace media {
  14
  15 static void WarnOnNonMonotonicTimestamps(base::TimeDelta last_timestamp,
  16                                          base::TimeDelta current_timestamp) {
  17   if (last_timestamp == kNoTimestamp() || last_timestamp < current_timestamp)
  18     return;
  19
  20   const base::TimeDelta diff = current_timestamp - last_timestamp;
  21   DLOG(WARNING) << "Input timestamps are not monotonically increasing! "
  22                 << " ts " << current_timestamp.InMicroseconds() << " us"
  23                 << " diff " << diff.InMicroseconds() << " us";
  24 }
  25
  26 AudioDiscardHelper::AudioDiscardHelper(int sample_rate, size_t decoder_delay)
  27     : sample_rate_(sample_rate),
  28       decoder_delay_(decoder_delay),
  29       timestamp_helper_(sample_rate_),
  30       discard_frames_(0),
  31       last_input_timestamp_(kNoTimestamp()),
  32       delayed_discard_(false),
  33       delayed_end_discard_(0) {
  34   DCHECK_GT(sample_rate_, 0);
  35 }
  36
  37 AudioDiscardHelper::~AudioDiscardHelper() {
  38 }
  39
  40 size_t AudioDiscardHelper::TimeDeltaToFrames(base::TimeDelta duration) const {
  41   DCHECK(duration >= base::TimeDelta());
  42   return duration.InSecondsF() * sample_rate_ + 0.5;
  43 }
  44
  45 void AudioDiscardHelper::Reset(size_t initial_discard) {
  46   discard_frames_ = initial_discard;
  47   last_input_timestamp_ = kNoTimestamp();
  48   timestamp_helper_.SetBaseTimestamp(kNoTimestamp());
  49   delayed_discard_ = false;
  50   delayed_discard_padding_ = DecoderBuffer::DiscardPadding();
  51 }
  52
  53 bool AudioDiscardHelper::ProcessBuffers(
  54     const scoped_refptr<DecoderBuffer>& encoded_buffer,
  55     const scoped_refptr<AudioBuffer>& decoded_buffer) {
  56   DCHECK(!encoded_buffer->end_of_stream());
  57   DCHECK(encoded_buffer->timestamp() != kNoTimestamp());
  58
  59   // Issue a debug warning when we see non-monotonic timestamps.  Only a warning
  60   // to allow chained OGG playback.
  61   WarnOnNonMonotonicTimestamps(last_input_timestamp_,
  62                                encoded_buffer->timestamp());
  63   last_input_timestamp_ = encoded_buffer->timestamp();
  64
  65   // If this is the first buffer seen, setup the timestamp helper.
  66   const bool first_buffer = !initialized();
  67   if (first_buffer) {
  68     // Clamp the base timestamp to zero.
  69     timestamp_helper_.SetBaseTimestamp(
  70         std::max(base::TimeDelta(), encoded_buffer->timestamp()));
  71   }
  72   DCHECK(initialized());
  73
  74   if (!decoded_buffer) {
  75     // If there's a one buffer delay for decoding, we need to save it so it can
  76     // be processed with the next decoder buffer.
  77     if (first_buffer) {
  78       delayed_discard_ = true;
  79       delayed_discard_padding_ = encoded_buffer->discard_padding();
  80     }
  81     return false;
  82   }
  83
  84   const size_t original_frame_count = decoded_buffer->frame_count();
  85
  86   // If there's a one buffer delay for decoding, pick up the last encoded
  87   // buffer's discard padding for processing with the current decoded buffer.
  88   DecoderBuffer::DiscardPadding current_discard_padding =
  89       encoded_buffer->discard_padding();
  90   if (delayed_discard_) {
  91     // For simplicity disallow cases where decoder delay is present with delayed
  92     // discard (no codecs at present).  Doing so allows us to avoid complexity
  93     // around endpoint tracking when handling complete buffer discards.
  94     DCHECK_EQ(decoder_delay_, 0u);
  95     std::swap(current_discard_padding, delayed_discard_padding_);
  96   }
  97
  98   if (discard_frames_ > 0) {
  99     const size_t decoded_frames = decoded_buffer->frame_count();
 100     const size_t frames_to_discard = std::min(discard_frames_, decoded_frames);
 101     discard_frames_ -= frames_to_discard;
 102
 103     DVLOG(1) << "Initial discard of " << frames_to_discard << " out of "
 104              << decoded_frames << " frames.";
 105
 106     // If everything would be discarded, indicate a new buffer is required.
 107     if (frames_to_discard == decoded_frames) {
 108       // For simplicity disallow cases where a buffer with discard padding is
 109       // present.  Doing so allows us to avoid complexity around tracking
 110       // discards across buffers.
 111       DCHECK(current_discard_padding.first == base::TimeDelta());
 112       DCHECK(current_discard_padding.second == base::TimeDelta());
 113       return false;
 114     }
 115
 116     decoded_buffer->TrimStart(frames_to_discard);
 117   }
 118
 119   // Process any delayed end discard from the previous buffer.
 120   if (delayed_end_discard_ > 0) {
 121     DCHECK_GT(decoder_delay_, 0u);
 122
 123     const size_t discard_index = decoder_delay_ - delayed_end_discard_;
 124     DCHECK_LT(discard_index, decoder_delay_);
 125
 126     const size_t decoded_frames = decoded_buffer->frame_count();
 127     DCHECK_LT(delayed_end_discard_, decoded_frames);
 128
 129     DVLOG(1) << "Delayed end discard of " << delayed_end_discard_ << " out of "
 130              << decoded_frames << " frames starting at " << discard_index;
 131
 132     decoded_buffer->TrimRange(discard_index,
 133                               discard_index + delayed_end_discard_);
 134     delayed_end_discard_ = 0;
 135   }
 136
 137   // Handle front discard padding.
 138   if (current_discard_padding.first > base::TimeDelta()) {
 139     const size_t decoded_frames = decoded_buffer->frame_count();
 140
 141     // If a complete buffer discard is requested and there's no decoder delay,
 142     // just discard all remaining frames from this buffer.  With decoder delay
 143     // we have to estimate the correct number of frames to discard based on the
 144     // duration of the encoded buffer.
 145     const size_t start_frames_to_discard =
 146         current_discard_padding.first == kInfiniteDuration()
 147             ? (decoder_delay_ > 0
 148                    ? TimeDeltaToFrames(encoded_buffer->duration())
 149                    : decoded_frames)
 150             : TimeDeltaToFrames(current_discard_padding.first);
 151
 152     // Regardless of the timestamp on the encoded buffer, the corresponding
 153     // decoded output will appear |decoder_delay_| frames later.
 154     size_t discard_start = decoder_delay_;
 155     if (decoder_delay_ > 0) {
 156       // If we have a |decoder_delay_| and have already discarded frames from
 157       // this buffer, the |discard_start| must be adjusted by the number of
 158       // frames already discarded.
 159       const size_t frames_discarded_so_far =
 160           original_frame_count - decoded_buffer->frame_count();
 161       CHECK_LE(frames_discarded_so_far, decoder_delay_);
 162       discard_start -= frames_discarded_so_far;
 163     }
 164
 165     // For simplicity require the start of the discard to be within the current
 166     // buffer.  Doing so allows us avoid complexity around tracking discards
 167     // across buffers.
 168     CHECK_LT(discard_start, decoded_frames);
 169
 170     const size_t frames_to_discard =
 171         std::min(start_frames_to_discard, decoded_frames - discard_start);
 172
 173     // Carry over any frames which need to be discarded from the front of the
 174     // next buffer.
 175     DCHECK(!discard_frames_);
 176     discard_frames_ = start_frames_to_discard - frames_to_discard;
 177
 178     DVLOG(1) << "Front discard of " << frames_to_discard << " out of "
 179              << decoded_frames << " frames starting at " << discard_start;
 180
 181     // If everything would be discarded, indicate a new buffer is required.
 182     if (frames_to_discard == decoded_frames) {
 183       // The buffer should not have been marked with end discard if the front
 184       // discard removes everything.
 185       DCHECK(current_discard_padding.second == base::TimeDelta());
 186       return false;
 187     }
 188
 189     decoded_buffer->TrimRange(discard_start, discard_start + frames_to_discard);
 190   } else {
 191     DCHECK(current_discard_padding.first == base::TimeDelta());
 192   }
 193
 194   // Handle end discard padding.
 195   if (current_discard_padding.second > base::TimeDelta()) {
 196     const size_t decoded_frames = decoded_buffer->frame_count();
 197     size_t end_frames_to_discard =
 198         TimeDeltaToFrames(current_discard_padding.second);
 199
 200     if (decoder_delay_) {
 201       // Delayed end discard only works if the decoder delay is less than a
 202       // single buffer.
 203       DCHECK_LT(decoder_delay_, original_frame_count);
 204
 205       // If the discard is >= the decoder delay, trim everything we can off the
 206       // end of this buffer and the rest from the start of the next.
 207       if (end_frames_to_discard >= decoder_delay_) {
 208         DCHECK(!discard_frames_);
 209         discard_frames_ = decoder_delay_;
 210         end_frames_to_discard -= decoder_delay_;
 211       } else {
 212         DCHECK(!delayed_end_discard_);
 213         std::swap(delayed_end_discard_, end_frames_to_discard);
 214       }
 215     }
 216
 217     if (end_frames_to_discard > decoded_frames) {
 218       DLOG(ERROR) << "Encountered invalid discard padding value.";
 219       return false;
 220     }
 221
 222     if (end_frames_to_discard > 0) {
 223       DVLOG(1) << "End discard of " << end_frames_to_discard << " out of "
 224                << decoded_frames;
 225
 226       // If everything would be discarded, indicate a new buffer is required.
 227       if (end_frames_to_discard == decoded_frames)
 228         return false;
 229
 230       decoded_buffer->TrimEnd(end_frames_to_discard);
 231     }
 232   } else {
 233     DCHECK(current_discard_padding.second == base::TimeDelta());
 234   }
 235
 236   // Assign timestamp to the buffer.
 237   decoded_buffer->set_timestamp(timestamp_helper_.GetTimestamp());
 238   timestamp_helper_.AddFrames(decoded_buffer->frame_count());
 239   return true;
 240 }
 241
 242 }  // namespace media