[Cast] EncodedAudioFrame+EncodedVideoFrame+reference_time --> EncodedFrame

media/cast/video_receiver/video_receiver.cc

 // Copyright 2013 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/video_receiver/video_receiver.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 76 matching lines @@
   GetEncodedVideoFrame(base::Bind(
       &VideoReceiver::DecodeEncodedVideoFrame,
       // Note: Use of Unretained is safe since this Closure is guaranteed to be
       // invoked before destruction of |this|.
       base::Unretained(this),
       callback));
 }
 
 void VideoReceiver::DecodeEncodedVideoFrame(
     const VideoFrameDecodedCallback& callback,
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame,
-    const base::TimeTicks& playout_time) {
+    scoped_ptr<transport::EncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!encoded_frame) {
-    callback.Run(make_scoped_refptr<VideoFrame>(NULL), playout_time, false);
+    callback.Run(
+        make_scoped_refptr<VideoFrame>(NULL), base::TimeTicks(), false);
     return;
   }
   const uint32 frame_id = encoded_frame->frame_id;
   const uint32 rtp_timestamp = encoded_frame->rtp_timestamp;
+  const base::TimeTicks playout_time = encoded_frame->reference_time;
   video_decoder_->DecodeFrame(encoded_frame.Pass(),
                               base::Bind(&VideoReceiver::EmitRawVideoFrame,
                                          cast_environment_,
                                          callback,
                                          frame_id,
                                          rtp_timestamp,
                                          playout_time));
 }
 
 // static
@@ skipping 15 matching lines @@
         playout_time - now);
     // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
     TRACE_EVENT_INSTANT1(
         "cast_perf_test", "FrameDecoded",
         TRACE_EVENT_SCOPE_THREAD,
         "rtp_timestamp", rtp_timestamp);
   }
   callback.Run(video_frame, playout_time, is_continuous);
 }
 
-void VideoReceiver::GetEncodedVideoFrame(
-    const VideoFrameEncodedCallback& callback) {
+void VideoReceiver::GetEncodedVideoFrame(const FrameEncodedCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   frame_request_queue_.push_back(callback);
   EmitAvailableEncodedFrames();
 }
 
 void VideoReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
-    scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-        new transport::EncodedVideoFrame());
+    scoped_ptr<transport::EncodedFrame> encoded_frame(
+        new transport::EncodedFrame());
     bool is_consecutively_next_frame = false;
     if (!framer_.GetEncodedVideoFrame(encoded_frame.get(),
                                       &is_consecutively_next_frame)) {
       VLOG(1) << "Wait for more video packets to produce a completed frame.";
       return;  // OnReceivedPayloadData() will invoke this method in the future.
     }
 
     // If |framer_| has a frame ready that is out of sequence, examine the
     // playout time to determine whether it's acceptable to continue, thereby
     // skipping one or more frames.  Skip if the missing frame wouldn't complete
@@ skipping 27 matching lines @@
                               encoded_frame->data,
                               &decrypted_video_data)) {
         // Decryption failed.  Give up on this frame, releasing it from the
         // jitter buffer.
         framer_.ReleaseFrame(encoded_frame->frame_id);
         continue;
       }
       encoded_frame->data.swap(decrypted_video_data);
     }
 
-    // At this point, we have a decrypted EncodedVideoFrame ready to be emitted.
-    encoded_frame->codec = codec_;
+    // At this point, we have a decrypted EncodedFrame ready to be emitted.
+    encoded_frame->reference_time = playout_time;
     framer_.ReleaseFrame(encoded_frame->frame_id);
     // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
     TRACE_EVENT_INSTANT2(
         "cast_perf_test", "PullEncodedVideoFrame",
         TRACE_EVENT_SCOPE_THREAD,
         "rtp_timestamp", encoded_frame->rtp_timestamp,
         // TODO(miu): Need to find an alternative to using ToInternalValue():
         "render_time", playout_time.ToInternalValue());
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(frame_request_queue_.front(),
-                                           base::Passed(&encoded_frame),
-                                           playout_time));
+                                           base::Passed(&encoded_frame)));
     frame_request_queue_.pop_front();
   }
 }
 
 void VideoReceiver::EmitAvailableEncodedFramesAfterWaiting() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(is_waiting_for_consecutive_frame_);
   is_waiting_for_consecutive_frame_ = false;
   EmitAvailableEncodedFrames();
 }
@@ skipping 181 matching lines @@
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   rtcp_.SendRtcpFromRtpReceiver(NULL, NULL);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media