Separate DemuxerStream and VideoDecoder.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/gpu_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/cpu.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
-#include "media/base/demuxer_stream.h"
 #include "media/base/pipeline.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder_config.h"
 
 namespace media {
 
 // Proxies calls to a VideoDecodeAccelerator::Client from the calling thread to
 // the client's thread.
 //
 // TODO(scherkus): VDAClientProxy should hold onto GpuVideoDecoder::Factories
@@ skipping 127 matching lines @@
     int32 bbid, base::TimeDelta ts, const gfx::Rect& vr, const gfx::Size& ns)
     : bitstream_buffer_id(bbid), timestamp(ts), visible_rect(vr),
       natural_size(ns) {
 }
 
 GpuVideoDecoder::BufferData::~BufferData() {}
 
 GpuVideoDecoder::GpuVideoDecoder(
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     const scoped_refptr<Factories>& factories)
-    : demuxer_stream_(NULL),
-      needs_bitstream_conversion_(false),
+    : needs_bitstream_conversion_(false),
       gvd_loop_proxy_(message_loop),
       weak_factory_(this),
       vda_loop_proxy_(factories->GetMessageLoop()),
       factories_(factories),
       state_(kNormal),
-      demuxer_read_in_progress_(false),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       next_bitstream_buffer_id_(0),
       available_pictures_(-1) {
   DCHECK(factories_);
+  DCHECK(!config_.IsValidConfig());
 }
 
 void GpuVideoDecoder::Reset(const base::Closure& closure)  {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ == kDrainingDecoder && !factories_->IsAborted()) {
     gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &GpuVideoDecoder::Reset, weak_this_, closure));
     // NOTE: if we're deferring Reset() until a Flush() completes, return
     // queued pictures to the VDA so they can be used to finish that Flush().
@@ skipping 21 matching lines @@
 }
 
 void GpuVideoDecoder::Stop(const base::Closure& closure) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   if (vda_)
     DestroyVDA();
   if (!pending_read_cb_.is_null())
     EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
-  demuxer_stream_ = NULL;
   BindToCurrentLoop(closure).Run();
 }
 
 static bool IsCodedSizeSupported(const gfx::Size& coded_size) {
   // Only non-Windows, Ivy Bridge+ platforms can support more than 1920x1080.
   // We test against 1088 to account for 16x16 macroblocks.
   if (coded_size.width() <= 1920 && coded_size.height() <= 1088)
     return true;
 
   base::CPU cpu;
   bool hw_large_video_support =
       (cpu.vendor_name() == "GenuineIntel") && cpu.model() >= 58;
   bool os_large_video_support = true;
 #if defined(OS_WIN)
   os_large_video_support = false;
 #endif
   return os_large_video_support && hw_large_video_support;
 }
 
-void GpuVideoDecoder::Initialize(DemuxerStream* stream,
+void GpuVideoDecoder::Initialize(const VideoDecoderConfig& config,
                                  const PipelineStatusCB& orig_status_cb,
                                  const StatisticsCB& statistics_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
-  DCHECK(stream);
+  DCHECK(config.IsValidConfig());
+  DCHECK(!config.is_encrypted());
 
   weak_this_ = weak_factory_.GetWeakPtr();
 
   PipelineStatusCB status_cb = CreateUMAReportingPipelineCB(
       "Media.GpuVideoDecoderInitializeStatus",
       BindToCurrentLoop(orig_status_cb));
 
-  if (demuxer_stream_) {
+  if (config_.IsValidConfig()) {
     // TODO(xhwang): Make GpuVideoDecoder reinitializable.
     // See http://crbug.com/233608
     DVLOG(1) << "GpuVideoDecoder reinitialization not supported.";
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  const VideoDecoderConfig& config = stream->video_decoder_config();
-  DCHECK(config.IsValidConfig());
-  DCHECK(!config.is_encrypted());
-
   if (!IsCodedSizeSupported(config.coded_size())) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
   client_proxy_ = new VDAClientProxy(this);
   VideoDecodeAccelerator* vda =
       factories_->CreateVideoDecodeAccelerator(config.profile(), client_proxy_);
   if (!vda) {
     status_cb.Run(DECODER_ERROR_NOT_SUPPORTED);
     return;
   }
 
-  demuxer_stream_ = stream;
   statistics_cb_ = statistics_cb;
   needs_bitstream_conversion_ = (config.codec() == kCodecH264);
 
   DVLOG(1) << "GpuVideoDecoder::Initialize() succeeded.";
   PostTaskAndReplyWithResult(
       vda_loop_proxy_, FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::AsWeakPtr, base::Unretained(vda)),
       base::Bind(&GpuVideoDecoder::SetVDA, weak_this_, status_cb, vda));
 }
 
 void GpuVideoDecoder::SetVDA(
     const PipelineStatusCB& status_cb,
     VideoDecodeAccelerator* vda,
     base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!vda_.get());
   vda_.reset(vda);
   weak_vda_ = weak_vda;
   status_cb.Run(PIPELINE_OK);
 }
 
 void GpuVideoDecoder::DestroyTextures() {
   for (std::map<int32, PictureBuffer>::iterator it =
-          picture_buffers_in_decoder_.begin();
-          it != picture_buffers_in_decoder_.end(); ++it) {
+           picture_buffers_in_decoder_.begin();
+       it != picture_buffers_in_decoder_.end();
+       ++it) {
     factories_->DeleteTexture(it->second.texture_id());
   }
   picture_buffers_in_decoder_.clear();
 }
 
 static void DestroyVDAWithClientProxy(
     const scoped_refptr<VDAClientProxy>& client_proxy,
     base::WeakPtr<VideoDecodeAccelerator> weak_vda) {
   if (weak_vda) {
     weak_vda->Destroy();
     DCHECK(!weak_vda);  // Check VDA::Destroy() contract.
   }
 }
 
 void GpuVideoDecoder::DestroyVDA() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
 
   // |client_proxy| must stay alive until |weak_vda_| has been destroyed.
   vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &DestroyVDAWithClientProxy, client_proxy_, weak_vda_));
 
   VideoDecodeAccelerator* vda ALLOW_UNUSED = vda_.release();
   client_proxy_->Detach();
   client_proxy_ = NULL;
 
   DestroyTextures();
 }
 
-void GpuVideoDecoder::Read(const ReadCB& read_cb) {
+void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
+                             const ReadCB& read_cb) {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(pending_reset_cb_.is_null());
   DCHECK(pending_read_cb_.is_null());
+
   pending_read_cb_ = BindToCurrentLoop(read_cb);
 
   if (state_ == kError) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 
-  // TODO(xhwang): It's odd that we return kOk after VDA has been released.
-  // Fix this and simplify cases.
   if (!vda_) {
     base::ResetAndReturn(&pending_read_cb_).Run(
-        kOk, VideoFrame::CreateEmptyFrame());
+        kDecodeError, VideoFrame::CreateEmptyFrame());
     return;
   }
 
-  if (!ready_video_frames_.empty()) {
+  if (!ready_video_frames_.empty())
     EnqueueFrameAndTriggerFrameDelivery(NULL);
-    return;
+
+  if (buffer->IsEndOfStream()) {
+    if (state_ == kNormal) {
+      state_ = kDrainingDecoder;
+      vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+          &VideoDecodeAccelerator::Flush, weak_vda_));
+    }
+  } else {
+    size_t size = buffer->GetDataSize();
+    SHMBuffer* shm_buffer = GetSHM(size);
+    if (!shm_buffer) {
+      state_ = kError;
+      return;
+    }
+
+    memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
+    BitstreamBuffer bitstream_buffer(
+        next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
+    // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
+    next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
+    bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
+        bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
+    DCHECK(inserted);
+    RecordBufferData(bitstream_buffer, *buffer);
+
+    vda_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
   }
 
+  if (CanMoreDecodeWorkBeDone()) {
+    base::ResetAndReturn(&pending_read_cb_).Run(kNotEnoughData, NULL);
+  }
+
+/*
   switch (state_) {
     case kDecoderDrained:
       state_ = kNormal;
       // Fall-through.
     case kNormal:
       EnsureDemuxOrDecode();
       break;
     case kDrainingDecoder:
       // Do nothing.  Will be satisfied either by a PictureReady or
       // NotifyFlushDone below.
       break;
     case kError:
       NOTREACHED();
       break;
   }
+*/
 }
 
 bool GpuVideoDecoder::CanMoreDecodeWorkBeDone() {
   return bitstream_buffers_in_decoder_.size() < kMaxInFlightDecodes;
 }
 
-void GpuVideoDecoder::RequestBufferDecode(
-    DemuxerStream::Status status,
-    const scoped_refptr<DecoderBuffer>& buffer) {
-  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
-  DCHECK_EQ(status != DemuxerStream::kOk, !buffer) << status;
-
-  demuxer_read_in_progress_ = false;
-
-  if (status == DemuxerStream::kAborted) {
-    if (pending_read_cb_.is_null())
-      return;
-    base::ResetAndReturn(&pending_read_cb_).Run(kOk, NULL);
-    return;
-  }
-
-  // VideoFrameStream ensures no kConfigChanged is passed to VideoDecoders.
-  DCHECK_EQ(status, DemuxerStream::kOk) << status;
-
-  if (!vda_) {
-    EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
-    return;
-  }
-
-  if (buffer->IsEndOfStream()) {
-    if (state_ == kNormal) {
-      state_ = kDrainingDecoder;
-      vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-          &VideoDecodeAccelerator::Flush, weak_vda_));
-    }
-    return;
-  }
-
-  if (!pending_reset_cb_.is_null())
-    return;
-
-  size_t size = buffer->GetDataSize();
-  SHMBuffer* shm_buffer = GetSHM(size);
-  if (!shm_buffer)
-    return;
-
-  memcpy(shm_buffer->shm->memory(), buffer->GetData(), size);
-  BitstreamBuffer bitstream_buffer(
-      next_bitstream_buffer_id_, shm_buffer->shm->handle(), size);
-  // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
-  next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
-  bool inserted = bitstream_buffers_in_decoder_.insert(std::make_pair(
-      bitstream_buffer.id(), BufferPair(shm_buffer, buffer))).second;
-  DCHECK(inserted);
-  RecordBufferData(bitstream_buffer, *buffer);
-
-  vda_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-      &VideoDecodeAccelerator::Decode, weak_vda_, bitstream_buffer));
-
-  if (CanMoreDecodeWorkBeDone()) {
-    // Force post here to prevent reentrancy into DemuxerStream.
-    gvd_loop_proxy_->PostTask(FROM_HERE, base::Bind(
-        &GpuVideoDecoder::EnsureDemuxOrDecode, weak_this_));
-  }
-}
-
-void GpuVideoDecoder::RecordBufferData(
-    const BitstreamBuffer& bitstream_buffer, const DecoderBuffer& buffer) {
-  input_buffer_data_.push_front(BufferData(
-      bitstream_buffer.id(), buffer.GetTimestamp(),
-      demuxer_stream_->video_decoder_config().visible_rect(),
-      demuxer_stream_->video_decoder_config().natural_size()));
+void GpuVideoDecoder::RecordBufferData(const BitstreamBuffer& bitstream_buffer,
+                                       const DecoderBuffer& buffer) {
+  input_buffer_data_.push_front(BufferData(bitstream_buffer.id(),
+                                           buffer.GetTimestamp(),
+                                           config_.visible_rect(),
+                                           config_.natural_size()));
   // Why this value?  Because why not.  avformat.h:MAX_REORDER_DELAY is 16, but
   // that's too small for some pathological B-frame test videos.  The cost of
   // using too-high a value is low (192 bits per extra slot).
   static const size_t kMaxInputBufferDataSize = 128;
   // Pop from the back of the list, because that's the oldest and least likely
   // to be useful in the future data.
   if (input_buffer_data_.size() > kMaxInputBufferDataSize)
     input_buffer_data_.pop_back();
 }
 
 void GpuVideoDecoder::GetBufferData(int32 id, base::TimeDelta* timestamp,
                                     gfx::Rect* visible_rect,
                                     gfx::Size* natural_size) {
-  for (std::list<BufferData>::const_iterator it =
-           input_buffer_data_.begin(); it != input_buffer_data_.end();
+  for (std::list<BufferData>::const_iterator it = input_buffer_data_.begin();
+       it != input_buffer_data_.end();
        ++it) {
     if (it->bitstream_buffer_id != id)
       continue;
     *timestamp = it->timestamp;
     *visible_rect = it->visible_rect;
     *natural_size = it->natural_size;
     return;
   }
   NOTREACHED() << "Missing bitstreambuffer id: " << id;
 }
@@ skipping 188 matching lines @@
   for (std::map<int32, BufferPair>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     it->second.shm_buffer->shm->Close();
   }
   bitstream_buffers_in_decoder_.clear();
 
   DestroyTextures();
 }
 
-void GpuVideoDecoder::EnsureDemuxOrDecode() {
-  DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
-
-  // The second condition can happen during the tear-down process.
-  // GpuVideoDecoder::Stop() returns the |pending_read_cb_| immediately without
-  // waiting for the demuxer read to be returned. Therefore, this function could
-  // be called even after the decoder has been stopped.
-  if (demuxer_read_in_progress_ || !demuxer_stream_)
-    return;
-
-  demuxer_read_in_progress_ = true;
-  demuxer_stream_->Read(base::Bind(
-      &GpuVideoDecoder::RequestBufferDecode, weak_this_));
-}
-
 void GpuVideoDecoder::NotifyFlushDone() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kDrainingDecoder);
   state_ = kDecoderDrained;
   EnqueueFrameAndTriggerFrameDelivery(VideoFrame::CreateEmptyFrame());
 }
 
 void GpuVideoDecoder::NotifyResetDone() {
   DCHECK(gvd_loop_proxy_->BelongsToCurrentThread());
   DCHECK(ready_video_frames_.empty());
@@ skipping 19 matching lines @@
 
   state_ = kError;
 
   if (!pending_read_cb_.is_null()) {
     base::ResetAndReturn(&pending_read_cb_).Run(kDecodeError, NULL);
     return;
   }
 }
 
 }  // namespace media