Home | History | Annotate | Download | only in filters 
      1 // Copyright (c) 2012 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/decrypting_demuxer_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/single_thread_task_runner.h"
     12 #include "media/base/audio_decoder_config.h"
     13 #include "media/base/bind_to_current_loop.h"
     14 #include "media/base/decoder_buffer.h"
     15 #include "media/base/decryptor.h"
     16 #include "media/base/demuxer_stream.h"
     17 #include "media/base/pipeline.h"
     18 #include "media/base/video_decoder_config.h"
     19 
     20 namespace media {
     21 
     22 static bool IsStreamValidAndEncrypted(DemuxerStream* stream) {
     23   return ((stream->type() == DemuxerStream::AUDIO &&
     24            stream->audio_decoder_config().IsValidConfig() &&
     25            stream->audio_decoder_config().is_encrypted()) ||
     26           (stream->type() == DemuxerStream::VIDEO &&
     27            stream->video_decoder_config().IsValidConfig() &&
     28            stream->video_decoder_config().is_encrypted()));
     29 }
     30 
     31 DecryptingDemuxerStream::DecryptingDemuxerStream(
     32     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     33     const SetDecryptorReadyCB& set_decryptor_ready_cb)
     34     : task_runner_(task_runner),
     35       state_(kUninitialized),
     36       demuxer_stream_(NULL),
     37       set_decryptor_ready_cb_(set_decryptor_ready_cb),
     38       decryptor_(NULL),
     39       key_added_while_decrypt_pending_(false),
     40       weak_factory_(this) {}
     41 
     42 void DecryptingDemuxerStream::Initialize(DemuxerStream* stream,
     43                                          const PipelineStatusCB& status_cb) {
     44   DVLOG(2) << __FUNCTION__;
     45   DCHECK(task_runner_->BelongsToCurrentThread());
     46   DCHECK_EQ(state_, kUninitialized) << state_;
     47 
     48   DCHECK(!demuxer_stream_);
     49   weak_this_ = weak_factory_.GetWeakPtr();
     50   demuxer_stream_ = stream;
     51   init_cb_ = BindToCurrentLoop(status_cb);
     52 
     53   InitializeDecoderConfig();
     54 
     55   state_ = kDecryptorRequested;
     56   set_decryptor_ready_cb_.Run(BindToCurrentLoop(
     57       base::Bind(&DecryptingDemuxerStream::SetDecryptor, weak_this_)));
     58 }
     59 
     60 void DecryptingDemuxerStream::Read(const ReadCB& read_cb) {
     61   DVLOG(3) << __FUNCTION__;
     62   DCHECK(task_runner_->BelongsToCurrentThread());
     63   DCHECK_EQ(state_, kIdle) << state_;
     64   DCHECK(!read_cb.is_null());
     65   CHECK(read_cb_.is_null()) << "Overlapping reads are not supported.";
     66 
     67   read_cb_ = BindToCurrentLoop(read_cb);
     68   state_ = kPendingDemuxerRead;
     69   demuxer_stream_->Read(
     70       base::Bind(&DecryptingDemuxerStream::DecryptBuffer, weak_this_));
     71 }
     72 
     73 void DecryptingDemuxerStream::Reset(const base::Closure& closure) {
     74   DVLOG(2) << __FUNCTION__ << " - state: " << state_;
     75   DCHECK(task_runner_->BelongsToCurrentThread());
     76   DCHECK(state_ != kUninitialized) << state_;
     77   DCHECK(reset_cb_.is_null());
     78 
     79   reset_cb_ = BindToCurrentLoop(closure);
     80 
     81   // TODO(xhwang): This should not happen. Remove it, DCHECK against the
     82   // condition and clean up related tests.
     83   if (state_ == kDecryptorRequested) {
     84     DCHECK(!init_cb_.is_null());
     85     set_decryptor_ready_cb_.Run(DecryptorReadyCB());
     86     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
     87     DoReset();
     88     return;
     89   }
     90 
     91   decryptor_->CancelDecrypt(GetDecryptorStreamType());
     92 
     93   // Reset() cannot complete if the read callback is still pending.
     94   // Defer the resetting process in this case. The |reset_cb_| will be fired
     95   // after the read callback is fired - see DoDecryptBuffer() and
     96   // DoDeliverBuffer().
     97   if (state_ == kPendingDemuxerRead || state_ == kPendingDecrypt) {
     98     DCHECK(!read_cb_.is_null());
     99     return;
    100   }
    101 
    102   if (state_ == kWaitingForKey) {
    103     DCHECK(!read_cb_.is_null());
    104     pending_buffer_to_decrypt_ = NULL;
    105     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    106   }
    107 
    108   DCHECK(read_cb_.is_null());
    109   DoReset();
    110 }
    111 
    112 AudioDecoderConfig DecryptingDemuxerStream::audio_decoder_config() {
    113   DCHECK(state_ != kUninitialized && state_ != kDecryptorRequested) << state_;
    114   CHECK_EQ(demuxer_stream_->type(), AUDIO);
    115   return audio_config_;
    116 }
    117 
    118 VideoDecoderConfig DecryptingDemuxerStream::video_decoder_config() {
    119   DCHECK(state_ != kUninitialized && state_ != kDecryptorRequested) << state_;
    120   CHECK_EQ(demuxer_stream_->type(), VIDEO);
    121   return video_config_;
    122 }
    123 
    124 DemuxerStream::Type DecryptingDemuxerStream::type() {
    125   DCHECK(state_ != kUninitialized && state_ != kDecryptorRequested) << state_;
    126   return demuxer_stream_->type();
    127 }
    128 
    129 void DecryptingDemuxerStream::EnableBitstreamConverter() {
    130   demuxer_stream_->EnableBitstreamConverter();
    131 }
    132 
    133 bool DecryptingDemuxerStream::SupportsConfigChanges() {
    134   return demuxer_stream_->SupportsConfigChanges();
    135 }
    136 
    137 VideoRotation DecryptingDemuxerStream::video_rotation() {
    138   return VIDEO_ROTATION_0;
    139 }
    140 
    141 DecryptingDemuxerStream::~DecryptingDemuxerStream() {
    142   DVLOG(2) << __FUNCTION__ << " : state_ = " << state_;
    143   DCHECK(task_runner_->BelongsToCurrentThread());
    144 
    145   if (state_ == kUninitialized)
    146     return;
    147 
    148   if (decryptor_) {
    149     decryptor_->CancelDecrypt(GetDecryptorStreamType());
    150     decryptor_ = NULL;
    151   }
    152   if (!set_decryptor_ready_cb_.is_null())
    153     base::ResetAndReturn(&set_decryptor_ready_cb_).Run(DecryptorReadyCB());
    154   if (!init_cb_.is_null())
    155     base::ResetAndReturn(&init_cb_).Run(PIPELINE_ERROR_ABORT);
    156   if (!read_cb_.is_null())
    157     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    158   if (!reset_cb_.is_null())
    159     base::ResetAndReturn(&reset_cb_).Run();
    160   pending_buffer_to_decrypt_ = NULL;
    161 }
    162 
    163 void DecryptingDemuxerStream::SetDecryptor(
    164     Decryptor* decryptor,
    165     const DecryptorAttachedCB& decryptor_attached_cb) {
    166   DVLOG(2) << __FUNCTION__;
    167   DCHECK(task_runner_->BelongsToCurrentThread());
    168   DCHECK_EQ(state_, kDecryptorRequested) << state_;
    169   DCHECK(!init_cb_.is_null());
    170   DCHECK(!set_decryptor_ready_cb_.is_null());
    171 
    172   set_decryptor_ready_cb_.Reset();
    173 
    174   if (!decryptor) {
    175     state_ = kUninitialized;
    176     base::ResetAndReturn(&init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
    177     decryptor_attached_cb.Run(false);
    178     return;
    179   }
    180 
    181   decryptor_ = decryptor;
    182 
    183   decryptor_->RegisterNewKeyCB(
    184       GetDecryptorStreamType(),
    185       BindToCurrentLoop(
    186           base::Bind(&DecryptingDemuxerStream::OnKeyAdded, weak_this_)));
    187 
    188   state_ = kIdle;
    189   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
    190   decryptor_attached_cb.Run(true);
    191 }
    192 
    193 void DecryptingDemuxerStream::DecryptBuffer(
    194     DemuxerStream::Status status,
    195     const scoped_refptr<DecoderBuffer>& buffer) {
    196   DVLOG(3) << __FUNCTION__;
    197   DCHECK(task_runner_->BelongsToCurrentThread());
    198   DCHECK_EQ(state_, kPendingDemuxerRead) << state_;
    199   DCHECK(!read_cb_.is_null());
    200   DCHECK_EQ(buffer.get() != NULL, status == kOk) << status;
    201 
    202   // Even when |!reset_cb_.is_null()|, we need to pass |kConfigChanged| back to
    203   // the caller so that the downstream decoder can be properly reinitialized.
    204   if (status == kConfigChanged) {
    205     DVLOG(2) << "DoDecryptBuffer() - kConfigChanged.";
    206     DCHECK_EQ(demuxer_stream_->type() == AUDIO, audio_config_.IsValidConfig());
    207     DCHECK_EQ(demuxer_stream_->type() == VIDEO, video_config_.IsValidConfig());
    208 
    209     // Update the decoder config, which the decoder will use when it is notified
    210     // of kConfigChanged.
    211     InitializeDecoderConfig();
    212     state_ = kIdle;
    213     base::ResetAndReturn(&read_cb_).Run(kConfigChanged, NULL);
    214     if (!reset_cb_.is_null())
    215       DoReset();
    216     return;
    217   }
    218 
    219   if (!reset_cb_.is_null()) {
    220     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    221     DoReset();
    222     return;
    223   }
    224 
    225   if (status == kAborted) {
    226     DVLOG(2) << "DoDecryptBuffer() - kAborted.";
    227     state_ = kIdle;
    228     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    229     return;
    230   }
    231 
    232   if (buffer->end_of_stream()) {
    233     DVLOG(2) << "DoDecryptBuffer() - EOS buffer.";
    234     state_ = kIdle;
    235     base::ResetAndReturn(&read_cb_).Run(status, buffer);
    236     return;
    237   }
    238 
    239   DCHECK(buffer->decrypt_config());
    240   // An empty iv string signals that the frame is unencrypted.
    241   if (buffer->decrypt_config()->iv().empty()) {
    242     DVLOG(2) << "DoDecryptBuffer() - clear buffer.";
    243     scoped_refptr<DecoderBuffer> decrypted = DecoderBuffer::CopyFrom(
    244         buffer->data(), buffer->data_size());
    245     decrypted->set_timestamp(buffer->timestamp());
    246     decrypted->set_duration(buffer->duration());
    247     state_ = kIdle;
    248     base::ResetAndReturn(&read_cb_).Run(kOk, decrypted);
    249     return;
    250   }
    251 
    252   pending_buffer_to_decrypt_ = buffer;
    253   state_ = kPendingDecrypt;
    254   DecryptPendingBuffer();
    255 }
    256 
    257 void DecryptingDemuxerStream::DecryptPendingBuffer() {
    258   DCHECK(task_runner_->BelongsToCurrentThread());
    259   DCHECK_EQ(state_, kPendingDecrypt) << state_;
    260   decryptor_->Decrypt(
    261       GetDecryptorStreamType(),
    262       pending_buffer_to_decrypt_,
    263       BindToCurrentLoop(
    264           base::Bind(&DecryptingDemuxerStream::DeliverBuffer, weak_this_)));
    265 }
    266 
    267 void DecryptingDemuxerStream::DeliverBuffer(
    268     Decryptor::Status status,
    269     const scoped_refptr<DecoderBuffer>& decrypted_buffer) {
    270   DVLOG(3) << __FUNCTION__ << " - status: " << status;
    271   DCHECK(task_runner_->BelongsToCurrentThread());
    272   DCHECK_EQ(state_, kPendingDecrypt) << state_;
    273   DCHECK_NE(status, Decryptor::kNeedMoreData);
    274   DCHECK(!read_cb_.is_null());
    275   DCHECK(pending_buffer_to_decrypt_.get());
    276 
    277   bool need_to_try_again_if_nokey = key_added_while_decrypt_pending_;
    278   key_added_while_decrypt_pending_ = false;
    279 
    280   if (!reset_cb_.is_null()) {
    281     pending_buffer_to_decrypt_ = NULL;
    282     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    283     DoReset();
    284     return;
    285   }
    286 
    287   DCHECK_EQ(status == Decryptor::kSuccess, decrypted_buffer.get() != NULL);
    288 
    289   if (status == Decryptor::kError) {
    290     DVLOG(2) << "DoDeliverBuffer() - kError";
    291     pending_buffer_to_decrypt_ = NULL;
    292     state_ = kIdle;
    293     base::ResetAndReturn(&read_cb_).Run(kAborted, NULL);
    294     return;
    295   }
    296 
    297   if (status == Decryptor::kNoKey) {
    298     DVLOG(2) << "DoDeliverBuffer() - kNoKey";
    299     if (need_to_try_again_if_nokey) {
    300       // The |state_| is still kPendingDecrypt.
    301       DecryptPendingBuffer();
    302       return;
    303     }
    304 
    305     state_ = kWaitingForKey;
    306     return;
    307   }
    308 
    309   DCHECK_EQ(status, Decryptor::kSuccess);
    310   pending_buffer_to_decrypt_ = NULL;
    311   state_ = kIdle;
    312   base::ResetAndReturn(&read_cb_).Run(kOk, decrypted_buffer);
    313 }
    314 
    315 void DecryptingDemuxerStream::OnKeyAdded() {
    316   DCHECK(task_runner_->BelongsToCurrentThread());
    317 
    318   if (state_ == kPendingDecrypt) {
    319     key_added_while_decrypt_pending_ = true;
    320     return;
    321   }
    322 
    323   if (state_ == kWaitingForKey) {
    324     state_ = kPendingDecrypt;
    325     DecryptPendingBuffer();
    326   }
    327 }
    328 
    329 void DecryptingDemuxerStream::DoReset() {
    330   DCHECK(state_ != kUninitialized);
    331   DCHECK(init_cb_.is_null());
    332   DCHECK(read_cb_.is_null());
    333 
    334   if (state_ == kDecryptorRequested)
    335     state_ = kUninitialized;
    336   else
    337     state_ = kIdle;
    338 
    339   base::ResetAndReturn(&reset_cb_).Run();
    340 }
    341 
    342 Decryptor::StreamType DecryptingDemuxerStream::GetDecryptorStreamType() const {
    343   if (demuxer_stream_->type() == AUDIO)
    344     return Decryptor::kAudio;
    345 
    346   DCHECK_EQ(demuxer_stream_->type(), VIDEO);
    347   return Decryptor::kVideo;
    348 }
    349 
    350 void DecryptingDemuxerStream::InitializeDecoderConfig() {
    351   // The decoder selector or upstream demuxer make sure the stream is valid and
    352   // potentially encrypted.
    353   DCHECK(IsStreamValidAndEncrypted(demuxer_stream_));
    354 
    355   switch (demuxer_stream_->type()) {
    356     case AUDIO: {
    357       AudioDecoderConfig input_audio_config =
    358           demuxer_stream_->audio_decoder_config();
    359       audio_config_.Initialize(input_audio_config.codec(),
    360                                input_audio_config.sample_format(),
    361                                input_audio_config.channel_layout(),
    362                                input_audio_config.samples_per_second(),
    363                                input_audio_config.extra_data(),
    364                                input_audio_config.extra_data_size(),
    365                                false,  // Output audio is not encrypted.
    366                                false,
    367                                input_audio_config.seek_preroll(),
    368                                input_audio_config.codec_delay());
    369       break;
    370     }
    371 
    372     case VIDEO: {
    373       VideoDecoderConfig input_video_config =
    374           demuxer_stream_->video_decoder_config();
    375       video_config_.Initialize(input_video_config.codec(),
    376                                input_video_config.profile(),
    377                                input_video_config.format(),
    378                                input_video_config.coded_size(),
    379                                input_video_config.visible_rect(),
    380                                input_video_config.natural_size(),
    381                                input_video_config.extra_data(),
    382                                input_video_config.extra_data_size(),
    383                                false,  // Output video is not encrypted.
    384                                false);
    385       break;
    386     }
    387 
    388     default:
    389       NOTREACHED();
    390       return;
    391   }
    392 }
    393 
    394 }  // namespace media
    395