Passing frame decoded callback to the codec

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/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 113 matching lines @@
   int max_unacked_frames = video_config.rtp_max_delay_ms *
       video_config.max_frame_rate / 1000;
   DCHECK(max_unacked_frames) << "Invalid argument";
 
   framer_.reset(new Framer(cast_environment->Clock(),
                            incoming_payload_feedback_.get(),
                            video_config.incoming_ssrc,
                            video_config.decoder_faster_than_max_frame_rate,
                            max_unacked_frames));
   if (!video_config.use_external_decoder) {
-    video_decoder_.reset(new VideoDecoder(video_config));
+    video_decoder_.reset(new VideoDecoder(video_config, cast_environment));
   }
 
   rtcp_.reset(
       new Rtcp(cast_environment_->Clock(),
                NULL,
                packet_sender,
                NULL,
                rtp_video_receiver_statistics_.get(),
                video_config.rtcp_mode,
                base::TimeDelta::FromMilliseconds(video_config.rtcp_interval),
@@ skipping 28 matching lines @@
 }
 
 // Utility function to run the decoder on a designated decoding thread.
 void VideoReceiver::DecodeVideoFrameThread(
     scoped_ptr<EncodedVideoFrame> encoded_frame,
     const base::TimeTicks render_time,
     const VideoFrameDecodedCallback& frame_decoded_callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::VIDEO_DECODER));
   DCHECK(video_decoder_);
 
-  // TODO(mikhal): Allow the application to allocate this memory.
-  scoped_ptr<I420VideoFrame> video_frame(new I420VideoFrame());
-
-  bool success = video_decoder_->DecodeVideoFrame(encoded_frame.get(),
-      render_time, video_frame.get());
-
-  if (success) {
-    VLOG(1) << "Decoded frame " << static_cast<int>(encoded_frame->frame_id);
-    // Frame decoded - return frame to the user via callback.
-    cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
-          base::Bind(frame_decoded_callback,
-                     base::Passed(&video_frame), render_time));
-  } else {
+  if (!(video_decoder_->DecodeVideoFrame(encoded_frame.get(), render_time,
+                                        frame_decoded_callback))) {
     // This will happen if we decide to decode but not show a frame.
     cast_environment_->PostTask(CastEnvironment::MAIN, FROM_HERE,
         base::Bind(&VideoReceiver::GetRawVideoFrame,
-            weak_factory_.GetWeakPtr(), frame_decoded_callback));
+                   weak_factory_.GetWeakPtr(), frame_decoded_callback));
   }
 }
 
 // Called from the main cast thread.
 void VideoReceiver::GetEncodedVideoFrame(
     const VideoFrameEncodedCallback& callback) {
   scoped_ptr<EncodedVideoFrame> encoded_frame(new EncodedVideoFrame());
   uint32 rtp_timestamp = 0;
   bool next_frame = false;
 
@@ skipping 209 matching lines @@
                 weak_factory_.GetWeakPtr()), time_to_next);
 }
 
 void VideoReceiver::SendNextRtcpReport() {
   rtcp_->SendRtcpReport(incoming_ssrc_);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media