<video> decode in hardware!

media/filters/ffmpeg_video_decoder.cc

 // Copyright (c) 2011 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/filters/ffmpeg_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/filter_host.h"
 #include "media/base/limits.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/video/ffmpeg_video_decode_engine.h"
 
 namespace media {
 
 FFmpegVideoDecoder::FFmpegVideoDecoder(MessageLoop* message_loop)
     : message_loop_(message_loop),
       state_(kUninitialized),
       decode_engine_(new FFmpegVideoDecodeEngine()) {
 }
 
 FFmpegVideoDecoder::~FFmpegVideoDecoder() {}
 
 void FFmpegVideoDecoder::Initialize(DemuxerStream* demuxer_stream,
-                                    const base::Closure& callback,
+                                    const PipelineStatusCB& callback,
                                     const StatisticsCallback& stats_callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Initialize, this,
         make_scoped_refptr(demuxer_stream), callback, stats_callback));
     return;
   }
 
   DCHECK(!demuxer_stream_);
 
   if (!demuxer_stream) {
-    host()->SetError(PIPELINE_ERROR_DECODE);

[scherkus (not reviewing), 2011/12/06 00:27:44]

\o/

[Ami GONE FROM CHROMIUM, 2011/12/07 00:03:04]

Done.

-    callback.Run();
+    callback.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   demuxer_stream_ = demuxer_stream;
   statistics_callback_ = stats_callback;
 
   const VideoDecoderConfig& config = demuxer_stream->video_decoder_config();
 
   // TODO(scherkus): this check should go in PipelineImpl prior to creating
   // decoder objects.
   if (!config.IsValidConfig()) {
-    DLOG(ERROR) << "Invalid video stream -"
-                << " codec: " << config.codec()
-                << " format: " << config.format()
-                << " coded size: [" << config.coded_size().width()
-                << "," << config.coded_size().height() << "]"
-                << " visible rect: [" << config.visible_rect().x()
-                << "," << config.visible_rect().y()
-                << "," << config.visible_rect().width()
-                << "," << config.visible_rect().height() << "]"
-                << " natural size: [" << config.natural_size().width()
-                << "," << config.natural_size().height() << "]"
-                << " frame rate: " << config.frame_rate_numerator()
-                << "/" << config.frame_rate_denominator()
-                << " aspect ratio: " << config.aspect_ratio_numerator()
-                << "/" << config.aspect_ratio_denominator();
-
-    host()->SetError(PIPELINE_ERROR_DECODE);
-    callback.Run();
+    DLOG(ERROR) << "Invalid video stream - " << config.AsHumanReadableString();
+    callback.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   pts_stream_.Initialize(GetFrameDuration(config));
   natural_size_ = config.natural_size();
 
   if (!decode_engine_->Initialize(config)) {
-    host()->SetError(PIPELINE_ERROR_DECODE);
-    callback.Run();
+    callback.Run(PIPELINE_ERROR_DECODE);
     return;
   }
 
   state_ = kNormal;
-  callback.Run();
+  callback.Run(PIPELINE_OK);
 }
 
 void FFmpegVideoDecoder::Stop(const base::Closure& callback) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &FFmpegVideoDecoder::Stop, this, callback));
     return;
   }
 
   decode_engine_->Uninitialize();
@@ skipping 163 matching lines @@
 
 void FFmpegVideoDecoder::DeliverFrame(
     const scoped_refptr<VideoFrame>& video_frame) {
   // Reset the callback before running to protect against reentrancy.
   ReadCB read_cb = read_cb_;
   read_cb_.Reset();
   read_cb.Run(video_frame);
 }
 
 }  // namespace media