Replace uses of raw uint32's with a type-checked RtpTimeTicks data type.

media/cast/sender/audio_encoder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/audio_encoder.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/sys_byteorder.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "media/cast/common/rtp_time.h"
+#include "media/cast/constants.h"
 
 #if !defined(OS_IOS)
 #include "third_party/opus/src/include/opus.h"
 #endif
 
 #if defined(OS_MACOSX)
 #include <AudioToolbox/AudioToolbox.h>
 #endif
 
 namespace media {
@@ skipping 24 matching lines @@
       : cast_environment_(cast_environment),
         codec_(codec),
         num_channels_(num_channels),
         samples_per_frame_(samples_per_frame),
         callback_(callback),
         operational_status_(STATUS_UNINITIALIZED),
         frame_duration_(base::TimeDelta::FromMicroseconds(
             base::Time::kMicrosecondsPerSecond * samples_per_frame_ /
             sampling_rate)),
         buffer_fill_end_(0),
-        frame_id_(0),
-        frame_rtp_timestamp_(0),
+        frame_id_(kFirstFrameId),
         samples_dropped_from_buffer_(0) {
     // Support for max sampling rate of 48KHz, 2 channels, 100 ms duration.
     const int kMaxSamplesTimesChannelsPerFrame = 48 * 2 * 100;
     if (num_channels_ <= 0 || samples_per_frame_ <= 0 ||
         frame_duration_ == base::TimeDelta() ||
         samples_per_frame_ * num_channels_ > kMaxSamplesTimesChannelsPerFrame) {
       operational_status_ = STATUS_INVALID_CONFIGURATION;
     }
   }
 
@@ skipping 22 matching lines @@
         buffer_fill_end_ * frame_duration_ / samples_per_frame_;
     if (!frame_capture_time_.is_null()) {
       const base::TimeDelta amount_ahead_by =
           recorded_time - (frame_capture_time_ + buffer_fill_duration);
       const int64 num_frames_missed = amount_ahead_by / frame_duration_;
       if (num_frames_missed > kUnderrunSkipThreshold) {
         samples_dropped_from_buffer_ += buffer_fill_end_;
         buffer_fill_end_ = 0;
         buffer_fill_duration = base::TimeDelta();
         frame_rtp_timestamp_ +=
-            static_cast<uint32>(num_frames_missed * samples_per_frame_);
+            RtpTimeDelta::FromTicks(num_frames_missed * samples_per_frame_);
         DVLOG(1) << "Skipping RTP timestamp ahead to account for "
                  << num_frames_missed * samples_per_frame_
                  << " samples' worth of underrun.";
         TRACE_EVENT_INSTANT2("cast.stream", "Audio Skip",
                              TRACE_EVENT_SCOPE_THREAD,
                              "frames missed", num_frames_missed,
                              "samples dropped", samples_dropped_from_buffer_);
       }
     }
     frame_capture_time_ = recorded_time - buffer_fill_duration;
@@ skipping 18 matching lines @@
         break;
 
       scoped_ptr<SenderEncodedFrame> audio_frame(
           new SenderEncodedFrame());
       audio_frame->dependency = EncodedFrame::KEY;
       audio_frame->frame_id = frame_id_;
       audio_frame->referenced_frame_id = frame_id_;
       audio_frame->rtp_timestamp = frame_rtp_timestamp_;
       audio_frame->reference_time = frame_capture_time_;
 
-      TRACE_EVENT_ASYNC_BEGIN2("cast.stream", "Audio Encode", audio_frame.get(),
-                               "frame_id", frame_id_,
-                               "rtp_timestamp", frame_rtp_timestamp_);
+      TRACE_EVENT_ASYNC_BEGIN2(
+          "cast.stream",
+          "Audio Encode", audio_frame.get(),
+          "frame_id", frame_id_,
+          "rtp_timestamp", frame_rtp_timestamp_.lower_32_bits());
       if (EncodeFromFilledBuffer(&audio_frame->data)) {
         // Compute deadline utilization as the real-world time elapsed divided
         // by the signal duration.
         audio_frame->deadline_utilization =
             (base::TimeTicks::Now() - start_time).InSecondsF() /
                 frame_duration_.InSecondsF();
 
         TRACE_EVENT_ASYNC_END1("cast.stream", "Audio Encode", audio_frame.get(),
                                "Deadline utilization",
                                audio_frame->deadline_utilization);
 
         audio_frame->encode_completion_time =
             cast_environment_->Clock()->NowTicks();
         cast_environment_->PostTask(
             CastEnvironment::MAIN,
             FROM_HERE,
             base::Bind(callback_,
                        base::Passed(&audio_frame),
                        samples_dropped_from_buffer_));
         samples_dropped_from_buffer_ = 0;
       }
 
       // Reset the internal buffer, frame ID, and timestamps for the next frame.
       buffer_fill_end_ = 0;
       ++frame_id_;
-      frame_rtp_timestamp_ += samples_per_frame_;
+      frame_rtp_timestamp_ += RtpTimeDelta::FromTicks(samples_per_frame_);
       frame_capture_time_ += frame_duration_;
     }
   }
 
  protected:
   friend class base::RefCountedThreadSafe<ImplBase>;
   virtual ~ImplBase() {}
 
   virtual void TransferSamplesIntoBuffer(const AudioBus* audio_bus,
                                          int source_offset,
@@ skipping 19 matching lines @@
   // buffer, this points to the position at which to populate data in a later
   // call.
   int buffer_fill_end_;
 
   // A counter used to label EncodedFrames.
   uint32 frame_id_;
 
   // The RTP timestamp for the next frame of encoded audio.  This is defined as
   // the number of audio samples encoded so far, plus the estimated number of
   // samples that were missed due to data underruns.  A receiver uses this value
-  // to detect gaps in the audio signal data being provided.  Per the spec, RTP
-  // timestamp values are allowed to overflow and roll around past zero.
-  uint32 frame_rtp_timestamp_;
+  // to detect gaps in the audio signal data being provided.
+  RtpTimeTicks frame_rtp_timestamp_;
 
   // The local system time associated with the start of the next frame of
   // encoded audio.  This value is passed on to a receiver as a reference clock
   // timestamp for the purposes of synchronizing audio and video.  Its
   // progression is expected to drift relative to the elapsed time implied by
   // the RTP timestamps.
   base::TimeTicks frame_capture_time_;
 
   // Set to non-zero to indicate the next output frame skipped over audio
   // samples in order to recover from an input underrun.
@@ skipping 641 matching lines @@
   cast_environment_->PostTask(CastEnvironment::AUDIO,
                               FROM_HERE,
                               base::Bind(&AudioEncoder::ImplBase::EncodeAudio,
                                          impl_,
                                          base::Passed(&audio_bus),
                                          recorded_time));
 }
 
 }  // namespace cast
 }  // namespace media