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

media/cast/video_sender/external_video_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/video_sender/external_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/shared_memory.h"
@@ skipping 204 matching lines @@
     }
     if (key_frame)
       key_frame_encountered_ = true;
     if (!key_frame_encountered_) {
       // Do not send video until we have encountered the first key frame.
       // Save the bitstream buffer in |stream_header_| to be sent later along
       // with the first key frame.
       stream_header_.append(static_cast<const char*>(output_buffer->memory()),
                             payload_size);
     } else if (!encoded_frame_data_storage_.empty()) {
-      scoped_ptr<transport::EncodedVideoFrame> encoded_frame(
-          new transport::EncodedVideoFrame());
-
-      encoded_frame->codec = codec_;
-      encoded_frame->key_frame = key_frame;
-      encoded_frame->last_referenced_frame_id = last_encoded_frame_id_;
-      last_encoded_frame_id_++;
-      encoded_frame->frame_id = last_encoded_frame_id_;
-      encoded_frame->rtp_timestamp = GetVideoRtpTimestamp(
-          encoded_frame_data_storage_.front().capture_time);
-      if (key_frame) {
-        // Self referenced.
-        encoded_frame->last_referenced_frame_id = encoded_frame->frame_id;
-      }
-
+      scoped_ptr<transport::EncodedFrame> encoded_frame(
+          new transport::EncodedFrame());
+      encoded_frame->dependency = key_frame ? transport::EncodedFrame::KEY :
+          transport::EncodedFrame::DEPENDENT;
+      encoded_frame->frame_id = ++last_encoded_frame_id_;
+      if (key_frame)
+        encoded_frame->referenced_frame_id = encoded_frame->frame_id;
+      else
+        encoded_frame->referenced_frame_id = encoded_frame->frame_id - 1;
+      encoded_frame->reference_time =
+          encoded_frame_data_storage_.front().capture_time;
+      encoded_frame->rtp_timestamp =
+          GetVideoRtpTimestamp(encoded_frame->reference_time);
       if (!stream_header_.empty()) {
         encoded_frame->data = stream_header_;
         stream_header_.clear();
       }
       encoded_frame->data.append(
           static_cast<const char*>(output_buffer->memory()), payload_size);
 
       cast_environment_->PostTask(
           CastEnvironment::MAIN,
           FROM_HERE,
           base::Bind(&LogFrameEncodedEvent,
                      cast_environment_,
                      cast_environment_->Clock()->NowTicks(),
                      encoded_frame->rtp_timestamp,
                      encoded_frame->frame_id));
 
       cast_environment_->PostTask(
           CastEnvironment::MAIN,
           FROM_HERE,
           base::Bind(encoded_frame_data_storage_.front().frame_encoded_callback,
-                     base::Passed(&encoded_frame),
-                     encoded_frame_data_storage_.front().capture_time));
+                     base::Passed(&encoded_frame)));
 
       encoded_frame_data_storage_.pop_front();
     } else {
       VLOG(1) << "BitstreamBufferReady(): no encoded frame data available";
     }
 
     // We need to re-add the output buffer to the encoder after we are done
     // with it.
     video_encode_accelerator_->UseOutputBitstreamBuffer(media::BitstreamBuffer(
         bitstream_buffer_id,
@@ skipping 170 matching lines @@
   // Do nothing not supported.
 }
 
 int ExternalVideoEncoder::NumberOfSkippedFrames() const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   return skip_count_;
 }
 
 }  //  namespace cast
 }  //  namespace media