Home | History | Annotate | Download | only in filters 
      1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/filters/video_frame_stream.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/callback_helpers.h"
      9 #include "base/location.h"
     10 #include "base/logging.h"
     11 #include "base/message_loop/message_loop_proxy.h"
     12 #include "media/base/bind_to_loop.h"
     13 #include "media/base/decoder_buffer.h"
     14 #include "media/base/demuxer_stream.h"
     15 #include "media/base/video_decoder_config.h"
     16 #include "media/filters/decrypting_demuxer_stream.h"
     17 #include "media/filters/video_decoder_selector.h"
     18 
     19 namespace media {
     20 
     21 VideoFrameStream::VideoFrameStream(
     22     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     23     ScopedVector<VideoDecoder> decoders,
     24     const SetDecryptorReadyCB& set_decryptor_ready_cb)
     25     : message_loop_(message_loop),
     26       weak_factory_(this),
     27       state_(STATE_UNINITIALIZED),
     28       stream_(NULL),
     29       decoder_selector_(new VideoDecoderSelector(message_loop,
     30                                                  decoders.Pass(),
     31                                                  set_decryptor_ready_cb)) {}
     32 
     33 VideoFrameStream::~VideoFrameStream() {
     34   DCHECK(state_ == STATE_UNINITIALIZED || state_ == STATE_STOPPED) << state_;
     35 }
     36 
     37 void VideoFrameStream::Initialize(DemuxerStream* stream,
     38                                   const StatisticsCB& statistics_cb,
     39                                   const InitCB& init_cb) {
     40   DCHECK(message_loop_->BelongsToCurrentThread());
     41   DCHECK_EQ(state_, STATE_UNINITIALIZED) << state_;
     42   DCHECK(init_cb_.is_null());
     43   DCHECK(!init_cb.is_null());
     44 
     45   weak_this_ = weak_factory_.GetWeakPtr();
     46 
     47   statistics_cb_ = statistics_cb;
     48   init_cb_ = init_cb;
     49   stream_ = stream;
     50 
     51   state_ = STATE_INITIALIZING;
     52   // TODO(xhwang): VideoDecoderSelector only needs a config to select a decoder.
     53   decoder_selector_->SelectVideoDecoder(
     54       stream, base::Bind(&VideoFrameStream::OnDecoderSelected, weak_this_));
     55 }
     56 
     57 void VideoFrameStream::Read(const ReadCB& read_cb) {
     58   DCHECK(message_loop_->BelongsToCurrentThread());
     59   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
     60          state_ == STATE_ERROR) << state_;
     61   // No two reads in the flight at any time.
     62   DCHECK(read_cb_.is_null());
     63   // No read during resetting or stopping process.
     64   DCHECK(reset_cb_.is_null());
     65   DCHECK(stop_cb_.is_null());
     66 
     67   if (state_ == STATE_ERROR) {
     68     message_loop_->PostTask(FROM_HERE, base::Bind(
     69         read_cb, DECODE_ERROR, scoped_refptr<VideoFrame>()));
     70     return;
     71   }
     72 
     73   read_cb_ = read_cb;
     74 
     75   if (state_ == STATE_FLUSHING_DECODER) {
     76     FlushDecoder();
     77     return;
     78   }
     79 
     80   ReadFromDemuxerStream();
     81 }
     82 
     83 void VideoFrameStream::Reset(const base::Closure& closure) {
     84   DCHECK(message_loop_->BelongsToCurrentThread());
     85   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
     86   DCHECK(reset_cb_.is_null());
     87   DCHECK(stop_cb_.is_null());
     88 
     89   reset_cb_ = closure;
     90 
     91   // During decoder reinitialization, VideoDecoder does not need to be and
     92   // cannot be Reset(). |decrypting_demuxer_stream_| was reset before decoder
     93   // reinitialization.
     94   // During pending demuxer read, VideoDecoder will be reset after demuxer read
     95   // is returned (in OnBufferReady()).
     96   if (state_ == STATE_REINITIALIZING_DECODER ||
     97       state_ == STATE_PENDING_DEMUXER_READ) {
     98     return;
     99   }
    100 
    101   // VideoDecoder API guarantees that if VideoDecoder::Reset() is called during
    102   // a pending decode, the decode callback must be fired before the reset
    103   // callback is fired. Therefore, we can call VideoDecoder::Reset() regardless
    104   // of if we have a pending decode and always satisfy the reset callback when
    105   // the decoder reset is finished.
    106   if (decrypting_demuxer_stream_) {
    107     decrypting_demuxer_stream_->Reset(base::Bind(
    108         &VideoFrameStream::ResetDecoder, weak_this_));
    109     return;
    110   }
    111 
    112   ResetDecoder();
    113 }
    114 
    115 void VideoFrameStream::Stop(const base::Closure& closure) {
    116   DCHECK(message_loop_->BelongsToCurrentThread());
    117   DCHECK_NE(state_, STATE_STOPPED) << state_;
    118   DCHECK(stop_cb_.is_null());
    119 
    120   stop_cb_ = closure;
    121 
    122   // The stopping process will continue after the pending operation is finished.
    123   // TODO(xhwang): Now we cannot stop the initialization process through
    124   // VideoDecoderSelector. Fix this. See: http://crbug.com/222054
    125   if (state_ == STATE_INITIALIZING || state_ == STATE_PENDING_DEMUXER_READ)
    126     return;
    127 
    128   // VideoDecoder API guarantees that if VideoDecoder::Stop() is called during
    129   // a pending reset or a pending decode, the callbacks are always fired in the
    130   // decode -> reset -> stop order. Therefore, we can call VideoDecoder::Stop()
    131   // regardless of if we have a pending decode or reset and always satisfy the
    132   // stop callback when the decoder decode/reset is finished.
    133   if (decrypting_demuxer_stream_) {
    134     decrypting_demuxer_stream_->Reset(base::Bind(
    135         &VideoFrameStream::StopDecoder, weak_this_));
    136     return;
    137   }
    138 
    139   // We may not have a |decoder_| if Stop() was called during initialization.
    140   if (decoder_) {
    141     StopDecoder();
    142     return;
    143   }
    144 
    145   state_ = STATE_STOPPED;
    146   stream_ = NULL;
    147   decoder_.reset();
    148   decrypting_demuxer_stream_.reset();
    149   message_loop_->PostTask(FROM_HERE, base::ResetAndReturn(&stop_cb_));
    150 }
    151 
    152 bool VideoFrameStream::CanReadWithoutStalling() const {
    153   DCHECK(message_loop_->BelongsToCurrentThread());
    154   return decoder_->CanReadWithoutStalling();
    155 }
    156 
    157 void VideoFrameStream::OnDecoderSelected(
    158     scoped_ptr<VideoDecoder> selected_decoder,
    159     scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream) {
    160   DCHECK(message_loop_->BelongsToCurrentThread());
    161   DCHECK_EQ(state_, STATE_INITIALIZING) << state_;
    162   DCHECK(!init_cb_.is_null());
    163   DCHECK(read_cb_.is_null());
    164   DCHECK(reset_cb_.is_null());
    165 
    166   decoder_selector_.reset();
    167 
    168   if (!selected_decoder) {
    169     state_ = STATE_UNINITIALIZED;
    170     base::ResetAndReturn(&init_cb_).Run(false, false);
    171   } else {
    172     state_ = STATE_NORMAL;
    173     decrypting_demuxer_stream_ = decrypting_demuxer_stream.Pass();
    174     if (decrypting_demuxer_stream_)
    175       stream_ = decrypting_demuxer_stream_.get();
    176     decoder_ = selected_decoder.Pass();
    177     if (decoder_->NeedsBitstreamConversion())
    178       stream_->EnableBitstreamConverter();
    179     // TODO(xhwang): We assume |decoder_->HasAlpha()| does not change after
    180     // reinitialization. Check this condition.
    181     base::ResetAndReturn(&init_cb_).Run(true, decoder_->HasAlpha());
    182   }
    183 
    184   // Stop() called during initialization.
    185   if (!stop_cb_.is_null()) {
    186     Stop(base::ResetAndReturn(&stop_cb_));
    187     return;
    188   }
    189 }
    190 
    191 void VideoFrameStream::SatisfyRead(Status status,
    192                                    const scoped_refptr<VideoFrame>& frame) {
    193   DCHECK(!read_cb_.is_null());
    194   base::ResetAndReturn(&read_cb_).Run(status, frame);
    195 }
    196 
    197 void VideoFrameStream::AbortRead() {
    198   SatisfyRead(ABORTED, NULL);
    199 }
    200 
    201 void VideoFrameStream::Decode(const scoped_refptr<DecoderBuffer>& buffer) {
    202   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
    203   DCHECK(!read_cb_.is_null());
    204   DCHECK(reset_cb_.is_null());
    205   DCHECK(stop_cb_.is_null());
    206   DCHECK(buffer);
    207 
    208   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
    209   decoder_->Decode(buffer, base::Bind(&VideoFrameStream::OnFrameReady,
    210                                       weak_this_, buffer_size));
    211 }
    212 
    213 void VideoFrameStream::FlushDecoder() {
    214   Decode(DecoderBuffer::CreateEOSBuffer());
    215 }
    216 
    217 void VideoFrameStream::OnFrameReady(int buffer_size,
    218                                     const VideoDecoder::Status status,
    219                                     const scoped_refptr<VideoFrame>& frame) {
    220   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER) << state_;
    221   DCHECK(!read_cb_.is_null());
    222 
    223   if (status == VideoDecoder::kDecodeError) {
    224     DCHECK(!frame.get());
    225     state_ = STATE_ERROR;
    226     SatisfyRead(DECODE_ERROR, NULL);
    227     return;
    228   }
    229 
    230   if (status == VideoDecoder::kDecryptError) {
    231     DCHECK(!frame.get());
    232     state_ = STATE_ERROR;
    233     SatisfyRead(DECRYPT_ERROR, NULL);
    234     return;
    235   }
    236 
    237   // Any successful decode counts!
    238   if (buffer_size > 0) {
    239     PipelineStatistics statistics;
    240     statistics.video_bytes_decoded = buffer_size;
    241     statistics_cb_.Run(statistics);
    242   }
    243 
    244   // Drop decoding result if Reset()/Stop() was called during decoding.
    245   // The stopping/resetting process will be handled when the decoder is
    246   // stopped/reset.
    247   if (!stop_cb_.is_null() || !reset_cb_.is_null()) {
    248     AbortRead();
    249     return;
    250   }
    251 
    252   // Decoder flushed. Reinitialize the video decoder.
    253   if (state_ == STATE_FLUSHING_DECODER &&
    254       status == VideoDecoder::kOk && frame->IsEndOfStream()) {
    255     ReinitializeDecoder();
    256     return;
    257   }
    258 
    259   if (status == VideoDecoder::kNotEnoughData) {
    260     if (state_ == STATE_NORMAL)
    261       ReadFromDemuxerStream();
    262     else if (state_ == STATE_FLUSHING_DECODER)
    263       FlushDecoder();
    264     return;
    265   }
    266 
    267   SatisfyRead(OK, frame);
    268 }
    269 
    270 void VideoFrameStream::ReadFromDemuxerStream() {
    271   DCHECK_EQ(state_, STATE_NORMAL) << state_;
    272   DCHECK(!read_cb_.is_null());
    273   DCHECK(reset_cb_.is_null());
    274   DCHECK(stop_cb_.is_null());
    275 
    276   state_ = STATE_PENDING_DEMUXER_READ;
    277   stream_->Read(base::Bind(&VideoFrameStream::OnBufferReady, weak_this_));
    278 }
    279 
    280 void VideoFrameStream::OnBufferReady(
    281     DemuxerStream::Status status,
    282     const scoped_refptr<DecoderBuffer>& buffer) {
    283   DCHECK(message_loop_->BelongsToCurrentThread());
    284   DCHECK_EQ(state_, STATE_PENDING_DEMUXER_READ) << state_;
    285   DCHECK_EQ(buffer.get() != NULL, status == DemuxerStream::kOk) << status;
    286   DCHECK(!read_cb_.is_null());
    287 
    288   state_ = STATE_NORMAL;
    289 
    290   // Reset()/Stop() was postponed during STATE_PENDING_DEMUXER_READ state.
    291   // We need to handle them in this function.
    292 
    293   if (!stop_cb_.is_null()) {
    294     AbortRead();
    295     if (!reset_cb_.is_null())
    296       Reset(base::ResetAndReturn(&reset_cb_));
    297     Stop(base::ResetAndReturn(&stop_cb_));
    298     return;
    299   }
    300 
    301   if (status == DemuxerStream::kConfigChanged) {
    302     state_ = STATE_FLUSHING_DECODER;
    303     if (!reset_cb_.is_null()) {
    304       AbortRead();
    305       Reset(base::ResetAndReturn(&reset_cb_));
    306       // Reinitialization will continue after Reset() is done.
    307     } else {
    308       FlushDecoder();
    309     }
    310     return;
    311   }
    312 
    313   if (!reset_cb_.is_null()) {
    314     AbortRead();
    315     Reset(base::ResetAndReturn(&reset_cb_));
    316     return;
    317   }
    318 
    319   if (status == DemuxerStream::kAborted) {
    320     SatisfyRead(DEMUXER_READ_ABORTED, NULL);
    321     return;
    322   }
    323 
    324   DCHECK(status == DemuxerStream::kOk) << status;
    325   Decode(buffer);
    326 }
    327 
    328 void VideoFrameStream::ReinitializeDecoder() {
    329   DCHECK(message_loop_->BelongsToCurrentThread());
    330   DCHECK_EQ(state_, STATE_FLUSHING_DECODER) << state_;
    331 
    332   DCHECK(stream_->video_decoder_config().IsValidConfig());
    333   state_ = STATE_REINITIALIZING_DECODER;
    334   decoder_->Initialize(
    335       stream_->video_decoder_config(),
    336       base::Bind(&VideoFrameStream::OnDecoderReinitialized, weak_this_));
    337 }
    338 
    339 void VideoFrameStream::OnDecoderReinitialized(PipelineStatus status) {
    340   DCHECK(message_loop_->BelongsToCurrentThread());
    341   DCHECK_EQ(state_, STATE_REINITIALIZING_DECODER) << state_;
    342 
    343   // ReinitializeDecoder() can be called in two cases:
    344   // 1, Flushing decoder finished (see OnFrameReady()).
    345   // 2, Reset() was called during flushing decoder (see OnDecoderReset()).
    346   // Also, Reset()/Stop() can be called during pending ReinitializeDecoder().
    347   // This function needs to handle them all!
    348 
    349   state_ = (status == PIPELINE_OK) ? STATE_NORMAL : STATE_ERROR;
    350 
    351   if (!read_cb_.is_null() && (!stop_cb_.is_null() || !reset_cb_.is_null()))
    352     AbortRead();
    353 
    354   if (!reset_cb_.is_null())
    355     base::ResetAndReturn(&reset_cb_).Run();
    356 
    357   // If !stop_cb_.is_null(), it will be handled in OnDecoderStopped().
    358 
    359   if (read_cb_.is_null())
    360     return;
    361 
    362   if (!stop_cb_.is_null()) {
    363     base::ResetAndReturn(&read_cb_).Run(ABORTED, NULL);
    364     return;
    365   }
    366 
    367   if (state_ == STATE_ERROR) {
    368     SatisfyRead(DECODE_ERROR, NULL);
    369     return;
    370   }
    371 
    372   ReadFromDemuxerStream();
    373 }
    374 
    375 void VideoFrameStream::ResetDecoder() {
    376   DCHECK(message_loop_->BelongsToCurrentThread());
    377   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
    378          state_ == STATE_ERROR) << state_;
    379   DCHECK(!reset_cb_.is_null());
    380 
    381   decoder_->Reset(base::Bind(&VideoFrameStream::OnDecoderReset, weak_this_));
    382 }
    383 
    384 void VideoFrameStream::OnDecoderReset() {
    385   DCHECK(message_loop_->BelongsToCurrentThread());
    386   DCHECK(state_ == STATE_NORMAL || state_ == STATE_FLUSHING_DECODER ||
    387          state_ == STATE_ERROR) << state_;
    388   // If Reset() was called during pending read, read callback should be fired
    389   // before the reset callback is fired.
    390   DCHECK(read_cb_.is_null());
    391   DCHECK(!reset_cb_.is_null());
    392 
    393   if (state_ != STATE_FLUSHING_DECODER || !stop_cb_.is_null()) {
    394     base::ResetAndReturn(&reset_cb_).Run();
    395     return;
    396   }
    397 
    398   // The resetting process will be continued in OnDecoderReinitialized().
    399   ReinitializeDecoder();
    400 }
    401 
    402 void VideoFrameStream::StopDecoder() {
    403   DCHECK(message_loop_->BelongsToCurrentThread());
    404   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
    405   DCHECK(!stop_cb_.is_null());
    406 
    407   decoder_->Stop(base::Bind(&VideoFrameStream::OnDecoderStopped, weak_this_));
    408 }
    409 
    410 void VideoFrameStream::OnDecoderStopped() {
    411   DCHECK(message_loop_->BelongsToCurrentThread());
    412   DCHECK(state_ != STATE_UNINITIALIZED && state_ != STATE_STOPPED) << state_;
    413   // If Stop() was called during pending read/reset, read/reset callback should
    414   // be fired before the stop callback is fired.
    415   DCHECK(read_cb_.is_null());
    416   DCHECK(reset_cb_.is_null());
    417   DCHECK(!stop_cb_.is_null());
    418 
    419   state_ = STATE_STOPPED;
    420   stream_ = NULL;
    421   decoder_.reset();
    422   decrypting_demuxer_stream_.reset();
    423   base::ResetAndReturn(&stop_cb_).Run();
    424 }
    425 
    426 }  // namespace media
    427