decrypting_demuxer_stream.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  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. #include "media/filters/decrypting_demuxer_stream.h"
  5. #include "base/bind.h"
  6. #include "base/callback_helpers.h"
  7. #include "base/location.h"
  8. #include "base/logging.h"
  9. #include "base/strings/string_number_conversions.h"
  10. #include "base/task/sequenced_task_runner.h"
  11. #include "base/task/single_thread_task_runner.h"
  12. #include "base/trace_event/trace_event.h"
  13. #include "media/base/bind_to_current_loop.h"
  14. #include "media/base/cdm_context.h"
  15. #include "media/base/decoder_buffer.h"
  16. #include "media/base/media_log.h"
  17. #include "media/base/media_util.h"
  18. namespace media {
  19. static bool IsStreamValid(DemuxerStream* stream) {
  20. return ((stream->type() == DemuxerStream::AUDIO &&
  21. stream->audio_decoder_config().IsValidConfig()) ||
  22. (stream->type() == DemuxerStream::VIDEO &&
  23. stream->video_decoder_config().IsValidConfig()));
  24. }
  25. DecryptingDemuxerStream::DecryptingDemuxerStream(
  26. const scoped_refptr<base::SequencedTaskRunner>& task_runner,
  27. MediaLog* media_log,
  28. const WaitingCB& waiting_cb)
  29. : task_runner_(task_runner),
  30. media_log_(media_log),
  31. waiting_cb_(waiting_cb) {
  32. DETACH_FROM_SEQUENCE(sequence_checker_);
  33. }
  34. std::string DecryptingDemuxerStream::GetDisplayName() const {
  35. return "DecryptingDemuxerStream";
  36. }
  37. void DecryptingDemuxerStream::Initialize(DemuxerStream* stream,
  38. CdmContext* cdm_context,
  39. PipelineStatusCallback status_cb) {
  40. DVLOG(2) << __func__;
  41. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  42. DCHECK_EQ(state_, kUninitialized) << state_;
  43. DCHECK(stream);
  44. DCHECK(cdm_context);
  45. DCHECK(!demuxer_stream_);
  46. demuxer_stream_ = stream;
  47. init_cb_ = BindToCurrentLoop(std::move(status_cb));
  48. InitializeDecoderConfig();
  49. if (!cdm_context->GetDecryptor()) {
  50. DVLOG(1) << __func__ << ": no decryptor";
  51. state_ = kUninitialized;
  52. std::move(init_cb_).Run(DECODER_ERROR_NOT_SUPPORTED);
  53. return;
  54. }
  55. decryptor_ = cdm_context->GetDecryptor();
  56. event_cb_registration_ = cdm_context->RegisterEventCB(base::BindRepeating(
  57. &DecryptingDemuxerStream::OnCdmContextEvent, weak_factory_.GetWeakPtr()));
  58. state_ = kIdle;
  59. std::move(init_cb_).Run(PIPELINE_OK);
  60. }
  61. void DecryptingDemuxerStream::Read(ReadCB read_cb) {
  62. DVLOG(3) << __func__;
  63. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  64. DCHECK_EQ(state_, kIdle) << state_;
  65. DCHECK(read_cb);
  66. CHECK(!read_cb_) << "Overlapping reads are not supported.";
  67. read_cb_ = BindToCurrentLoop(std::move(read_cb));
  68. state_ = kPendingDemuxerRead;
  69. demuxer_stream_->Read(
  70. base::BindOnce(&DecryptingDemuxerStream::OnBufferReadFromDemuxerStream,
  71. weak_factory_.GetWeakPtr()));
  72. }
  73. void DecryptingDemuxerStream::Reset(base::OnceClosure closure) {
  74. DVLOG(2) << __func__ << " - state: " << state_;
  75. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  76. DCHECK(state_ != kUninitialized) << state_;
  77. DCHECK(!reset_cb_);
  78. reset_cb_ = BindToCurrentLoop(std::move(closure));
  79. decryptor_->CancelDecrypt(GetDecryptorStreamType());
  80. // Reset() cannot complete if the read callback is still pending.
  81. // Defer the resetting process in this case. The |reset_cb_| will be fired
  82. // after the read callback is fired - see OnBufferReadFromDemuxerStream() and
  83. // OnBufferDecrypted().
  84. if (state_ == kPendingDemuxerRead || state_ == kPendingDecrypt) {
  85. DCHECK(read_cb_);
  86. return;
  87. }
  88. if (state_ == kWaitingForKey) {
  89. CompleteWaitingForDecryptionKey();
  90. DCHECK(read_cb_);
  91. pending_buffer_to_decrypt_ = nullptr;
  92. std::move(read_cb_).Run(kAborted, nullptr);
  93. }
  94. DCHECK(!read_cb_);
  95. DoReset();
  96. }
  97. AudioDecoderConfig DecryptingDemuxerStream::audio_decoder_config() {
  98. DCHECK(state_ != kUninitialized) << state_;
  99. CHECK_EQ(demuxer_stream_->type(), AUDIO);
  100. return audio_config_;
  101. }
  102. VideoDecoderConfig DecryptingDemuxerStream::video_decoder_config() {
  103. DCHECK(state_ != kUninitialized) << state_;
  104. CHECK_EQ(demuxer_stream_->type(), VIDEO);
  105. return video_config_;
  106. }
  107. DemuxerStream::Type DecryptingDemuxerStream::type() const {
  108. DCHECK(state_ != kUninitialized) << state_;
  109. return demuxer_stream_->type();
  110. }
  111. StreamLiveness DecryptingDemuxerStream::liveness() const {
  112. DCHECK(state_ != kUninitialized) << state_;
  113. return demuxer_stream_->liveness();
  114. }
  115. void DecryptingDemuxerStream::EnableBitstreamConverter() {
  116. demuxer_stream_->EnableBitstreamConverter();
  117. }
  118. bool DecryptingDemuxerStream::SupportsConfigChanges() {
  119. return demuxer_stream_->SupportsConfigChanges();
  120. }
  121. bool DecryptingDemuxerStream::HasClearLead() const {
  122. return has_clear_lead_.value_or(false);
  123. }
  124. DecryptingDemuxerStream::~DecryptingDemuxerStream() {
  125. DVLOG(2) << __func__ << " : state_ = " << state_;
  126. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  127. if (state_ == kUninitialized)
  128. return;
  129. if (state_ == kWaitingForKey)
  130. CompleteWaitingForDecryptionKey();
  131. if (state_ == kPendingDecrypt)
  132. CompletePendingDecrypt(Decryptor::kError);
  133. if (decryptor_) {
  134. decryptor_->CancelDecrypt(GetDecryptorStreamType());
  135. decryptor_ = nullptr;
  136. }
  137. if (init_cb_)
  138. std::move(init_cb_).Run(PIPELINE_ERROR_ABORT);
  139. if (read_cb_)
  140. std::move(read_cb_).Run(kAborted, nullptr);
  141. if (reset_cb_)
  142. std::move(reset_cb_).Run();
  143. pending_buffer_to_decrypt_ = nullptr;
  144. }
  145. void DecryptingDemuxerStream::OnBufferReadFromDemuxerStream(
  146. DemuxerStream::Status status,
  147. scoped_refptr<DecoderBuffer> buffer) {
  148. DVLOG(3) << __func__ << ": status = " << status;
  149. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  150. DCHECK_EQ(state_, kPendingDemuxerRead) << state_;
  151. DCHECK(read_cb_);
  152. DCHECK_EQ(buffer.get() != nullptr, status == kOk) << status;
  153. // Even when |reset_cb_|, we need to pass |kConfigChanged| back to
  154. // the caller so that the downstream decoder can be properly reinitialized.
  155. if (status == kConfigChanged) {
  156. DVLOG(2) << __func__ << ": config change";
  157. DCHECK_EQ(demuxer_stream_->type() == AUDIO, audio_config_.IsValidConfig());
  158. DCHECK_EQ(demuxer_stream_->type() == VIDEO, video_config_.IsValidConfig());
  159. // Update the decoder config, which the decoder will use when it is notified
  160. // of kConfigChanged.
  161. InitializeDecoderConfig();
  162. state_ = kIdle;
  163. std::move(read_cb_).Run(kConfigChanged, nullptr);
  164. if (reset_cb_)
  165. DoReset();
  166. return;
  167. }
  168. if (reset_cb_) {
  169. std::move(read_cb_).Run(kAborted, nullptr);
  170. DoReset();
  171. return;
  172. }
  173. if (status == kAborted || status == kError) {
  174. if (status == kError) {
  175. MEDIA_LOG(ERROR, media_log_)
  176. << GetDisplayName() << ": demuxer stream read error.";
  177. }
  178. state_ = kIdle;
  179. std::move(read_cb_).Run(status, nullptr);
  180. return;
  181. }
  182. DCHECK_EQ(kOk, status);
  183. if (buffer->end_of_stream()) {
  184. DVLOG(2) << __func__ << ": EOS buffer";
  185. state_ = kIdle;
  186. std::move(read_cb_).Run(kOk, std::move(buffer));
  187. return;
  188. }
  189. // One time set of `has_clear_lead_`.
  190. if (!has_clear_lead_.has_value()) {
  191. has_clear_lead_ = !buffer->decrypt_config();
  192. }
  193. if (!buffer->decrypt_config()) {
  194. DVLOG(2) << __func__ << ": clear buffer";
  195. state_ = kIdle;
  196. std::move(read_cb_).Run(kOk, std::move(buffer));
  197. return;
  198. }
  199. pending_buffer_to_decrypt_ = std::move(buffer);
  200. state_ = kPendingDecrypt;
  201. DecryptPendingBuffer();
  202. }
  203. void DecryptingDemuxerStream::DecryptPendingBuffer() {
  204. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  205. DCHECK_EQ(state_, kPendingDecrypt) << state_;
  206. DCHECK(!pending_buffer_to_decrypt_->end_of_stream());
  207. TRACE_EVENT_ASYNC_BEGIN2(
  208. "media", "DecryptingDemuxerStream::DecryptPendingBuffer", this, "type",
  209. DemuxerStream::GetTypeName(demuxer_stream_->type()), "timestamp_us",
  210. pending_buffer_to_decrypt_->timestamp().InMicroseconds());
  211. decryptor_->Decrypt(GetDecryptorStreamType(), pending_buffer_to_decrypt_,
  212. BindToCurrentLoop(base::BindOnce(
  213. &DecryptingDemuxerStream::OnBufferDecrypted,
  214. weak_factory_.GetWeakPtr())));
  215. }
  216. void DecryptingDemuxerStream::OnBufferDecrypted(
  217. Decryptor::Status status,
  218. scoped_refptr<DecoderBuffer> decrypted_buffer) {
  219. DVLOG(3) << __func__ << " - status: " << status;
  220. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  221. DCHECK_EQ(state_, kPendingDecrypt) << state_;
  222. DCHECK(read_cb_);
  223. DCHECK(pending_buffer_to_decrypt_);
  224. CompletePendingDecrypt(status);
  225. bool need_to_try_again_if_nokey = key_added_while_decrypt_pending_;
  226. key_added_while_decrypt_pending_ = false;
  227. if (reset_cb_) {
  228. pending_buffer_to_decrypt_ = nullptr;
  229. std::move(read_cb_).Run(kAborted, nullptr);
  230. DoReset();
  231. return;
  232. }
  233. DCHECK_EQ(status == Decryptor::kSuccess, decrypted_buffer.get() != nullptr);
  234. if (status == Decryptor::kError || status == Decryptor::kNeedMoreData) {
  235. DVLOG(2) << __func__ << ": Error with status " << status;
  236. MEDIA_LOG(ERROR, media_log_)
  237. << GetDisplayName() << ": decrypt error " << status;
  238. pending_buffer_to_decrypt_ = nullptr;
  239. state_ = kIdle;
  240. std::move(read_cb_).Run(kError, nullptr);
  241. return;
  242. }
  243. if (status == Decryptor::kNoKey) {
  244. std::string key_id = pending_buffer_to_decrypt_->decrypt_config()->key_id();
  245. std::string log_message =
  246. "no key for key ID " + base::HexEncode(key_id.data(), key_id.size()) +
  247. "; will resume decrypting after new usable key is available";
  248. DVLOG(1) << __func__ << ": " << log_message;
  249. MEDIA_LOG(INFO, media_log_) << GetDisplayName() << ": " << log_message;
  250. if (need_to_try_again_if_nokey) {
  251. // The |state_| is still kPendingDecrypt.
  252. MEDIA_LOG(INFO, media_log_)
  253. << GetDisplayName() << ": key was added, resuming decrypt";
  254. DecryptPendingBuffer();
  255. return;
  256. }
  257. state_ = kWaitingForKey;
  258. TRACE_EVENT_ASYNC_BEGIN0(
  259. "media", "DecryptingDemuxerStream::WaitingForDecryptionKey", this);
  260. waiting_cb_.Run(WaitingReason::kNoDecryptionKey);
  261. return;
  262. }
  263. DCHECK_EQ(status, Decryptor::kSuccess);
  264. // Copy the key frame flag and duration from the encrypted to decrypted
  265. // buffer.
  266. // TODO(crbug.com/1116263): Ensure all fields are copied by Decryptor.
  267. decrypted_buffer->set_is_key_frame(
  268. pending_buffer_to_decrypt_->is_key_frame());
  269. decrypted_buffer->set_duration(pending_buffer_to_decrypt_->duration());
  270. pending_buffer_to_decrypt_ = nullptr;
  271. state_ = kIdle;
  272. std::move(read_cb_).Run(kOk, std::move(decrypted_buffer));
  273. }
  274. void DecryptingDemuxerStream::OnCdmContextEvent(CdmContext::Event event) {
  275. DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
  276. if (event != CdmContext::Event::kHasAdditionalUsableKey)
  277. return;
  278. if (state_ == kPendingDecrypt) {
  279. key_added_while_decrypt_pending_ = true;
  280. return;
  281. }
  282. // Nothing to do.
  283. if (state_ != kWaitingForKey)
  284. return;
  285. CompleteWaitingForDecryptionKey();
  286. MEDIA_LOG(INFO, media_log_)
  287. << GetDisplayName() << ": key was added, resuming decrypt";
  288. state_ = kPendingDecrypt;
  289. DecryptPendingBuffer();
  290. }
  291. void DecryptingDemuxerStream::DoReset() {
  292. DCHECK(state_ != kUninitialized);
  293. DCHECK(!init_cb_);
  294. DCHECK(!read_cb_);
  295. state_ = kIdle;
  296. std::move(reset_cb_).Run();
  297. }
  298. Decryptor::StreamType DecryptingDemuxerStream::GetDecryptorStreamType() const {
  299. if (demuxer_stream_->type() == AUDIO)
  300. return Decryptor::kAudio;
  301. DCHECK_EQ(demuxer_stream_->type(), VIDEO);
  302. return Decryptor::kVideo;
  303. }
  304. void DecryptingDemuxerStream::InitializeDecoderConfig() {
  305. // The decoder selector or upstream demuxer make sure the stream is valid.
  306. DCHECK(IsStreamValid(demuxer_stream_));
  307. // Since |this| is a decrypted version of |demuxer_stream_|, the decoder
  308. // config of |this| should always be a decrypted version of |demuxer_stream_|
  309. // configs.
  310. switch (demuxer_stream_->type()) {
  311. case AUDIO: {
  312. audio_config_ = demuxer_stream_->audio_decoder_config();
  313. if (audio_config_.is_encrypted())
  314. audio_config_.SetIsEncrypted(false);
  315. break;
  316. }
  317. case VIDEO: {
  318. video_config_ = demuxer_stream_->video_decoder_config();
  319. if (video_config_.is_encrypted())
  320. video_config_.SetIsEncrypted(false);
  321. break;
  322. }
  323. default:
  324. NOTREACHED();
  325. return;
  326. }
  327. LogMetadata();
  328. }
  329. void DecryptingDemuxerStream::LogMetadata() {
  330. std::vector<AudioDecoderConfig> audio_metadata{audio_config_};
  331. std::vector<VideoDecoderConfig> video_metadata{video_config_};
  332. media_log_->SetProperty<MediaLogProperty::kAudioTracks>(audio_metadata);
  333. media_log_->SetProperty<MediaLogProperty::kVideoTracks>(video_metadata);
  334. // FFmpegDemuxer also provides a max diration, start time, and bitrate.
  335. }
  336. void DecryptingDemuxerStream::CompletePendingDecrypt(Decryptor::Status status) {
  337. DCHECK_EQ(state_, kPendingDecrypt);
  338. TRACE_EVENT_ASYNC_END1("media",
  339. "DecryptingDemuxerStream::DecryptPendingBuffer", this,
  340. "status", Decryptor::GetStatusName(status));
  341. }
  342. void DecryptingDemuxerStream::CompleteWaitingForDecryptionKey() {
  343. DCHECK_EQ(state_, kWaitingForKey);
  344. TRACE_EVENT_ASYNC_END0(
  345. "media", "DecryptingDemuxerStream::WaitingForDecryptionKey", this);
  346. }
  347. } // namespace media