| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 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/base/android/media_decoder_job.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/callback_helpers.h" | |
| 9 #include "base/single_thread_task_runner.h" | |
| 10 #include "base/threading/thread_task_runner_handle.h" | |
| 11 #include "base/trace_event/trace_event.h" | |
| 12 #include "media/base/android/media_drm_bridge.h" | |
| 13 #include "media/base/bind_to_current_loop.h" | |
| 14 #include "media/base/timestamp_constants.h" | |
| 15 | |
| 16 namespace media { | |
| 17 | |
| 18 // Timeout value for media codec operations. Because the first | |
| 19 // DequeInputBuffer() can take about 150 milliseconds, use 250 milliseconds | |
| 20 // here. See http://b/9357571. | |
| 21 static const int kMediaCodecTimeoutInMilliseconds = 250; | |
| 22 | |
| 23 MediaDecoderJob::MediaDecoderJob( | |
| 24 const scoped_refptr<base::SingleThreadTaskRunner>& decoder_task_runner, | |
| 25 const base::Closure& request_data_cb, | |
| 26 const base::Closure& config_changed_cb) | |
| 27 : need_to_reconfig_decoder_job_(false), | |
| 28 ui_task_runner_(base::ThreadTaskRunnerHandle::Get()), | |
| 29 decoder_task_runner_(decoder_task_runner), | |
| 30 needs_flush_(false), | |
| 31 input_eos_encountered_(false), | |
| 32 output_eos_encountered_(false), | |
| 33 skip_eos_enqueue_(true), | |
| 34 prerolling_(true), | |
| 35 request_data_cb_(request_data_cb), | |
| 36 config_changed_cb_(config_changed_cb), | |
| 37 current_demuxer_data_index_(0), | |
| 38 input_buf_index_(-1), | |
| 39 is_content_encrypted_(false), | |
| 40 stop_decode_pending_(false), | |
| 41 destroy_pending_(false), | |
| 42 is_requesting_demuxer_data_(false), | |
| 43 is_incoming_data_invalid_(false), | |
| 44 release_resources_pending_(false), | |
| 45 drm_bridge_(NULL), | |
| 46 drain_decoder_(false) { | |
| 47 InitializeReceivedData(); | |
| 48 eos_unit_.is_end_of_stream = true; | |
| 49 } | |
| 50 | |
| 51 MediaDecoderJob::~MediaDecoderJob() { | |
| 52 ReleaseMediaCodecBridge(); | |
| 53 } | |
| 54 | |
| 55 void MediaDecoderJob::OnDataReceived(const DemuxerData& data) { | |
| 56 DVLOG(1) << __FUNCTION__ << ": " << data.access_units.size() << " units"; | |
| 57 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 58 DCHECK(NoAccessUnitsRemainingInChunk(false)); | |
| 59 | |
| 60 TRACE_EVENT_ASYNC_END2( | |
| 61 "media", "MediaDecoderJob::RequestData", this, | |
| 62 "Data type", data.type == media::DemuxerStream::AUDIO ? "AUDIO" : "VIDEO", | |
| 63 "Units read", data.access_units.size()); | |
| 64 | |
| 65 if (is_incoming_data_invalid_) { | |
| 66 is_incoming_data_invalid_ = false; | |
| 67 | |
| 68 // If there is a pending callback, need to request the data again to get | |
| 69 // valid data. | |
| 70 if (!data_received_cb_.is_null()) | |
| 71 request_data_cb_.Run(); | |
| 72 else | |
| 73 is_requesting_demuxer_data_ = false; | |
| 74 return; | |
| 75 } | |
| 76 | |
| 77 size_t next_demuxer_data_index = inactive_demuxer_data_index(); | |
| 78 received_data_[next_demuxer_data_index] = data; | |
| 79 access_unit_index_[next_demuxer_data_index] = 0; | |
| 80 is_requesting_demuxer_data_ = false; | |
| 81 | |
| 82 base::Closure done_cb = base::ResetAndReturn(&data_received_cb_); | |
| 83 | |
| 84 // If this data request is for the inactive chunk, or |data_received_cb_| | |
| 85 // was set to null by Flush() or Release(), do nothing. | |
| 86 if (done_cb.is_null()) | |
| 87 return; | |
| 88 | |
| 89 if (stop_decode_pending_) { | |
| 90 DCHECK(is_decoding()); | |
| 91 OnDecodeCompleted(MEDIA_CODEC_ABORT, false, kNoTimestamp, kNoTimestamp); | |
| 92 return; | |
| 93 } | |
| 94 | |
| 95 done_cb.Run(); | |
| 96 } | |
| 97 | |
| 98 void MediaDecoderJob::Prefetch(const base::Closure& prefetch_cb) { | |
| 99 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 100 DCHECK(data_received_cb_.is_null()); | |
| 101 DCHECK(decode_cb_.is_null()); | |
| 102 | |
| 103 if (HasData()) { | |
| 104 DVLOG(1) << __FUNCTION__ << " : using previously received data"; | |
| 105 ui_task_runner_->PostTask(FROM_HERE, prefetch_cb); | |
| 106 return; | |
| 107 } | |
| 108 | |
| 109 DVLOG(1) << __FUNCTION__ << " : requesting data"; | |
| 110 RequestData(prefetch_cb); | |
| 111 } | |
| 112 | |
| 113 MediaDecoderJob::MediaDecoderJobStatus MediaDecoderJob::Decode( | |
| 114 base::TimeTicks start_time_ticks, | |
| 115 base::TimeDelta start_presentation_timestamp, | |
| 116 const DecoderCallback& callback) { | |
| 117 DCHECK(decode_cb_.is_null()); | |
| 118 DCHECK(data_received_cb_.is_null()); | |
| 119 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 120 if (!media_codec_bridge_ || need_to_reconfig_decoder_job_) { | |
| 121 if (drain_decoder_) | |
| 122 OnDecoderDrained(); | |
| 123 MediaDecoderJobStatus status = CreateMediaCodecBridge(); | |
| 124 need_to_reconfig_decoder_job_ = (status != STATUS_SUCCESS); | |
| 125 skip_eos_enqueue_ = true; | |
| 126 if (need_to_reconfig_decoder_job_) | |
| 127 return status; | |
| 128 } | |
| 129 | |
| 130 decode_cb_ = callback; | |
| 131 | |
| 132 if (!HasData()) { | |
| 133 RequestData(base::Bind(&MediaDecoderJob::DecodeCurrentAccessUnit, | |
| 134 base::Unretained(this), | |
| 135 start_time_ticks, | |
| 136 start_presentation_timestamp)); | |
| 137 return STATUS_SUCCESS; | |
| 138 } | |
| 139 | |
| 140 DecodeCurrentAccessUnit(start_time_ticks, start_presentation_timestamp); | |
| 141 return STATUS_SUCCESS; | |
| 142 } | |
| 143 | |
| 144 void MediaDecoderJob::StopDecode() { | |
| 145 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 146 DCHECK(is_decoding()); | |
| 147 stop_decode_pending_ = true; | |
| 148 } | |
| 149 | |
| 150 bool MediaDecoderJob::OutputEOSReached() const { | |
| 151 return !drain_decoder_ && output_eos_encountered_; | |
| 152 } | |
| 153 | |
| 154 void MediaDecoderJob::SetDrmBridge(MediaDrmBridge* drm_bridge) { | |
| 155 drm_bridge_ = drm_bridge; | |
| 156 need_to_reconfig_decoder_job_ = true; | |
| 157 } | |
| 158 | |
| 159 void MediaDecoderJob::Flush() { | |
| 160 DVLOG(1) << __FUNCTION__; | |
| 161 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 162 DCHECK(data_received_cb_.is_null()); | |
| 163 DCHECK(decode_cb_.is_null()); | |
| 164 | |
| 165 // Clean up the received data. | |
| 166 current_demuxer_data_index_ = 0; | |
| 167 InitializeReceivedData(); | |
| 168 if (is_requesting_demuxer_data_) | |
| 169 is_incoming_data_invalid_ = true; | |
| 170 input_eos_encountered_ = false; | |
| 171 output_eos_encountered_ = false; | |
| 172 drain_decoder_ = false; | |
| 173 | |
| 174 // Do nothing, flush when the next Decode() happens. | |
| 175 needs_flush_ = true; | |
| 176 } | |
| 177 | |
| 178 void MediaDecoderJob::BeginPrerolling(base::TimeDelta preroll_timestamp) { | |
| 179 DVLOG(1) << __FUNCTION__ << "(" << preroll_timestamp.InSecondsF() << ")"; | |
| 180 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 181 DCHECK(!is_decoding()); | |
| 182 | |
| 183 preroll_timestamp_ = preroll_timestamp; | |
| 184 prerolling_ = true; | |
| 185 } | |
| 186 | |
| 187 void MediaDecoderJob::ReleaseDecoderResources() { | |
| 188 DVLOG(1) << __FUNCTION__; | |
| 189 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 190 if (decode_cb_.is_null()) { | |
| 191 DCHECK(!drain_decoder_); | |
| 192 // Since the decoder job is not decoding data, we can safely destroy | |
| 193 // |media_codec_bridge_|. | |
| 194 ReleaseMediaCodecBridge(); | |
| 195 return; | |
| 196 } | |
| 197 | |
| 198 // Release |media_codec_bridge_| once decoding is completed. | |
| 199 release_resources_pending_ = true; | |
| 200 } | |
| 201 | |
| 202 jobject MediaDecoderJob::GetMediaCrypto() { | |
| 203 return drm_bridge_ ? drm_bridge_->GetMediaCrypto() : nullptr; | |
| 204 } | |
| 205 | |
| 206 bool MediaDecoderJob::SetCurrentFrameToPreviouslyCachedKeyFrame() { | |
| 207 const std::vector<AccessUnit>& access_units = | |
| 208 received_data_[current_demuxer_data_index_].access_units; | |
| 209 // If the current data chunk is empty, the player must be in an initial or | |
| 210 // seek state. The next access unit will always be a key frame. | |
| 211 if (access_units.size() == 0) | |
| 212 return true; | |
| 213 | |
| 214 // Find key frame in all the access units the decoder have decoded, | |
| 215 // or is about to decode. | |
| 216 int i = std::min(access_unit_index_[current_demuxer_data_index_], | |
| 217 access_units.size() - 1); | |
| 218 for (; i >= 0; --i) { | |
| 219 // Config change is always the last access unit, and it always come with | |
| 220 // a key frame afterwards. | |
| 221 if (access_units[i].status == DemuxerStream::kConfigChanged) | |
| 222 return true; | |
| 223 if (access_units[i].is_key_frame) { | |
| 224 access_unit_index_[current_demuxer_data_index_] = i; | |
| 225 return true; | |
| 226 } | |
| 227 } | |
| 228 return false; | |
| 229 } | |
| 230 | |
| 231 | |
| 232 void MediaDecoderJob::Release() { | |
| 233 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 234 DVLOG(1) << __FUNCTION__; | |
| 235 | |
| 236 // If the decoder job is still decoding, we cannot delete the job immediately. | |
| 237 destroy_pending_ = is_decoding(); | |
| 238 | |
| 239 request_data_cb_.Reset(); | |
| 240 data_received_cb_.Reset(); | |
| 241 decode_cb_.Reset(); | |
| 242 | |
| 243 if (destroy_pending_) { | |
| 244 DVLOG(1) << __FUNCTION__ << " : delete is pending decode completion"; | |
| 245 return; | |
| 246 } | |
| 247 | |
| 248 delete this; | |
| 249 } | |
| 250 | |
| 251 MediaCodecStatus MediaDecoderJob::QueueInputBuffer(const AccessUnit& unit) { | |
| 252 DVLOG(1) << __FUNCTION__; | |
| 253 DCHECK(decoder_task_runner_->BelongsToCurrentThread()); | |
| 254 TRACE_EVENT0("media", __FUNCTION__); | |
| 255 | |
| 256 int input_buf_index = input_buf_index_; | |
| 257 input_buf_index_ = -1; | |
| 258 | |
| 259 // TODO(xhwang): Hide DequeueInputBuffer() and the index in MediaCodecBridge. | |
| 260 if (input_buf_index == -1) { | |
| 261 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds( | |
| 262 kMediaCodecTimeoutInMilliseconds); | |
| 263 MediaCodecStatus status = | |
| 264 media_codec_bridge_->DequeueInputBuffer(timeout, &input_buf_index); | |
| 265 if (status != MEDIA_CODEC_OK) { | |
| 266 DVLOG(1) << "DequeueInputBuffer fails: " << status; | |
| 267 return status; | |
| 268 } | |
| 269 } | |
| 270 | |
| 271 // TODO(qinmin): skip frames if video is falling far behind. | |
| 272 DCHECK_GE(input_buf_index, 0); | |
| 273 if (unit.is_end_of_stream || unit.data.empty()) { | |
| 274 media_codec_bridge_->QueueEOS(input_buf_index); | |
| 275 return MEDIA_CODEC_INPUT_END_OF_STREAM; | |
| 276 } | |
| 277 | |
| 278 if (unit.key_id.empty() || unit.iv.empty()) { | |
| 279 DCHECK(unit.iv.empty() || !unit.key_id.empty()); | |
| 280 return media_codec_bridge_->QueueInputBuffer( | |
| 281 input_buf_index, &unit.data[0], unit.data.size(), unit.timestamp); | |
| 282 } | |
| 283 | |
| 284 MediaCodecStatus status = media_codec_bridge_->QueueSecureInputBuffer( | |
| 285 input_buf_index, &unit.data[0], unit.data.size(), unit.key_id, unit.iv, | |
| 286 unit.subsamples.empty() ? NULL : &unit.subsamples[0], | |
| 287 unit.subsamples.size(), unit.timestamp); | |
| 288 | |
| 289 // In case of MEDIA_CODEC_NO_KEY, we must reuse the |input_buf_index_|. | |
| 290 // Otherwise MediaDrm will report errors. | |
| 291 if (status == MEDIA_CODEC_NO_KEY) | |
| 292 input_buf_index_ = input_buf_index; | |
| 293 | |
| 294 return status; | |
| 295 } | |
| 296 | |
| 297 bool MediaDecoderJob::HasData() const { | |
| 298 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 299 // When |input_eos_encountered_| is set, |access_unit_index_| and | |
| 300 // |current_demuxer_data_index_| must be pointing to an EOS unit, | |
| 301 // or a |kConfigChanged| unit if |drain_decoder_| is true. In both cases, | |
| 302 // we'll feed an EOS input unit to drain the decoder until we hit output EOS. | |
| 303 DCHECK(!input_eos_encountered_ || !NoAccessUnitsRemainingInChunk(true)); | |
| 304 return !NoAccessUnitsRemainingInChunk(true) || | |
| 305 !NoAccessUnitsRemainingInChunk(false); | |
| 306 } | |
| 307 | |
| 308 void MediaDecoderJob::RequestData(const base::Closure& done_cb) { | |
| 309 DVLOG(1) << __FUNCTION__; | |
| 310 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 311 DCHECK(data_received_cb_.is_null()); | |
| 312 DCHECK(!input_eos_encountered_); | |
| 313 DCHECK(NoAccessUnitsRemainingInChunk(false)); | |
| 314 | |
| 315 TRACE_EVENT_ASYNC_BEGIN0("media", "MediaDecoderJob::RequestData", this); | |
| 316 | |
| 317 data_received_cb_ = done_cb; | |
| 318 | |
| 319 // If we are already expecting new data, just set the callback and do | |
| 320 // nothing. | |
| 321 if (is_requesting_demuxer_data_) | |
| 322 return; | |
| 323 | |
| 324 // The new incoming data will be stored as the next demuxer data chunk, since | |
| 325 // the decoder might still be decoding the current one. | |
| 326 size_t next_demuxer_data_index = inactive_demuxer_data_index(); | |
| 327 received_data_[next_demuxer_data_index] = DemuxerData(); | |
| 328 access_unit_index_[next_demuxer_data_index] = 0; | |
| 329 is_requesting_demuxer_data_ = true; | |
| 330 | |
| 331 request_data_cb_.Run(); | |
| 332 } | |
| 333 | |
| 334 void MediaDecoderJob::DecodeCurrentAccessUnit( | |
| 335 base::TimeTicks start_time_ticks, | |
| 336 base::TimeDelta start_presentation_timestamp) { | |
| 337 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 338 DCHECK(!decode_cb_.is_null()); | |
| 339 | |
| 340 RequestCurrentChunkIfEmpty(); | |
| 341 const AccessUnit& access_unit = CurrentAccessUnit(); | |
| 342 if (CurrentAccessUnit().status == DemuxerStream::kConfigChanged) { | |
| 343 int index = CurrentReceivedDataChunkIndex(); | |
| 344 const DemuxerConfigs& configs = received_data_[index].demuxer_configs[0]; | |
| 345 bool reconfigure_needed = IsCodecReconfigureNeeded(configs); | |
| 346 SetDemuxerConfigs(configs); | |
| 347 if (!drain_decoder_) { | |
| 348 // If we haven't decoded any data yet, just skip the current access unit | |
| 349 // and request the MediaCodec to be recreated on next Decode(). | |
| 350 if (skip_eos_enqueue_ || !reconfigure_needed) { | |
| 351 need_to_reconfig_decoder_job_ = | |
| 352 need_to_reconfig_decoder_job_ || reconfigure_needed; | |
| 353 // Report MEDIA_CODEC_OK status so decoder will continue decoding and | |
| 354 // MEDIA_CODEC_OUTPUT_FORMAT_CHANGED status will come later. | |
| 355 ui_task_runner_->PostTask( | |
| 356 FROM_HERE, base::Bind(&MediaDecoderJob::OnDecodeCompleted, | |
| 357 base::Unretained(this), MEDIA_CODEC_OK, false, | |
| 358 kNoTimestamp, kNoTimestamp)); | |
| 359 return; | |
| 360 } | |
| 361 // Start draining the decoder so that all the remaining frames are | |
| 362 // rendered. | |
| 363 drain_decoder_ = true; | |
| 364 } | |
| 365 } | |
| 366 | |
| 367 DCHECK(!(needs_flush_ && drain_decoder_)); | |
| 368 decoder_task_runner_->PostTask(FROM_HERE, base::Bind( | |
| 369 &MediaDecoderJob::DecodeInternal, base::Unretained(this), | |
| 370 drain_decoder_ ? eos_unit_ : access_unit, | |
| 371 start_time_ticks, start_presentation_timestamp, needs_flush_, | |
| 372 media::BindToCurrentLoop(base::Bind( | |
| 373 &MediaDecoderJob::OnDecodeCompleted, base::Unretained(this))))); | |
| 374 needs_flush_ = false; | |
| 375 } | |
| 376 | |
| 377 void MediaDecoderJob::DecodeInternal( | |
| 378 const AccessUnit& unit, | |
| 379 base::TimeTicks start_time_ticks, | |
| 380 base::TimeDelta start_presentation_timestamp, | |
| 381 bool needs_flush, | |
| 382 const MediaDecoderJob::DecoderCallback& callback) { | |
| 383 DVLOG(1) << __FUNCTION__; | |
| 384 DCHECK(decoder_task_runner_->BelongsToCurrentThread()); | |
| 385 TRACE_EVENT0("media", __FUNCTION__); | |
| 386 | |
| 387 if (needs_flush) { | |
| 388 DVLOG(1) << "DecodeInternal needs flush."; | |
| 389 input_eos_encountered_ = false; | |
| 390 output_eos_encountered_ = false; | |
| 391 input_buf_index_ = -1; | |
| 392 MediaCodecStatus flush_status = media_codec_bridge_->Flush(); | |
| 393 if (flush_status != MEDIA_CODEC_OK) { | |
| 394 callback.Run(flush_status, false, kNoTimestamp, kNoTimestamp); | |
| 395 return; | |
| 396 } | |
| 397 } | |
| 398 | |
| 399 // Once output EOS has occurred, we should not be asked to decode again. | |
| 400 // MediaCodec has undefined behavior if similarly asked to decode after output | |
| 401 // EOS. | |
| 402 DCHECK(!output_eos_encountered_); | |
| 403 | |
| 404 // For aborted access unit, just skip it and inform the player. | |
| 405 if (unit.status == DemuxerStream::kAborted) { | |
| 406 callback.Run(MEDIA_CODEC_ABORT, false, kNoTimestamp, kNoTimestamp); | |
| 407 return; | |
| 408 } | |
| 409 | |
| 410 if (skip_eos_enqueue_) { | |
| 411 if (unit.is_end_of_stream || unit.data.empty()) { | |
| 412 input_eos_encountered_ = true; | |
| 413 output_eos_encountered_ = true; | |
| 414 callback.Run(MEDIA_CODEC_OUTPUT_END_OF_STREAM, false, kNoTimestamp, | |
| 415 kNoTimestamp); | |
| 416 return; | |
| 417 } | |
| 418 | |
| 419 skip_eos_enqueue_ = false; | |
| 420 } | |
| 421 | |
| 422 MediaCodecStatus input_status = MEDIA_CODEC_INPUT_END_OF_STREAM; | |
| 423 if (!input_eos_encountered_) { | |
| 424 input_status = QueueInputBuffer(unit); | |
| 425 if (input_status == MEDIA_CODEC_INPUT_END_OF_STREAM) { | |
| 426 input_eos_encountered_ = true; | |
| 427 } else if (input_status == MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER) { | |
| 428 // In some cases, all buffers must be released to codec before format | |
| 429 // change can be resolved. Context: b/21786703 | |
| 430 DVLOG(1) << "dequeueInputBuffer gave AGAIN_LATER, dequeue output buffers"; | |
| 431 } else if (input_status != MEDIA_CODEC_OK) { | |
| 432 callback.Run(input_status, false, kNoTimestamp, kNoTimestamp); | |
| 433 return; | |
| 434 } | |
| 435 } | |
| 436 | |
| 437 int buffer_index = 0; | |
| 438 size_t offset = 0; | |
| 439 size_t size = 0; | |
| 440 base::TimeDelta presentation_timestamp; | |
| 441 | |
| 442 base::TimeDelta timeout = base::TimeDelta::FromMilliseconds( | |
| 443 kMediaCodecTimeoutInMilliseconds); | |
| 444 | |
| 445 MediaCodecStatus status = MEDIA_CODEC_OK; | |
| 446 bool has_format_change = false; | |
| 447 // Dequeue the output buffer until a MEDIA_CODEC_OK, MEDIA_CODEC_ERROR or | |
| 448 // MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER is received. | |
| 449 do { | |
| 450 status = media_codec_bridge_->DequeueOutputBuffer( | |
| 451 timeout, | |
| 452 &buffer_index, | |
| 453 &offset, | |
| 454 &size, | |
| 455 &presentation_timestamp, | |
| 456 &output_eos_encountered_, | |
| 457 NULL); | |
| 458 if (status == MEDIA_CODEC_OUTPUT_FORMAT_CHANGED) { | |
| 459 // TODO(qinmin): instead of waiting for the next output buffer to be | |
| 460 // dequeued, post a task on the UI thread to signal the format change. | |
| 461 if (OnOutputFormatChanged()) | |
| 462 has_format_change = true; | |
| 463 else | |
| 464 status = MEDIA_CODEC_ERROR; | |
| 465 } | |
| 466 } while (status != MEDIA_CODEC_OK && status != MEDIA_CODEC_ERROR && | |
| 467 status != MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER); | |
| 468 | |
| 469 if (status != MEDIA_CODEC_OK) { | |
| 470 callback.Run(status, false, kNoTimestamp, kNoTimestamp); | |
| 471 return; | |
| 472 } | |
| 473 | |
| 474 // TODO(xhwang/qinmin): This logic is correct but strange. Clean it up. | |
| 475 if (output_eos_encountered_) | |
| 476 status = MEDIA_CODEC_OUTPUT_END_OF_STREAM; | |
| 477 else if (has_format_change) | |
| 478 status = MEDIA_CODEC_OUTPUT_FORMAT_CHANGED; | |
| 479 | |
| 480 bool render_output = presentation_timestamp >= preroll_timestamp_ && | |
| 481 (status != MEDIA_CODEC_OUTPUT_END_OF_STREAM || size != 0u); | |
| 482 base::TimeDelta time_to_render; | |
| 483 DCHECK(!start_time_ticks.is_null()); | |
| 484 if (render_output && ComputeTimeToRender()) { | |
| 485 time_to_render = presentation_timestamp - (base::TimeTicks::Now() - | |
| 486 start_time_ticks + start_presentation_timestamp); | |
| 487 } | |
| 488 | |
| 489 if (time_to_render > base::TimeDelta()) { | |
| 490 decoder_task_runner_->PostDelayedTask( | |
| 491 FROM_HERE, base::Bind(&MediaDecoderJob::ReleaseOutputBuffer, | |
| 492 base::Unretained(this), buffer_index, offset, | |
| 493 size, render_output, | |
| 494 false, // this is not a late frame | |
| 495 presentation_timestamp, status, callback), | |
| 496 time_to_render); | |
| 497 return; | |
| 498 } | |
| 499 | |
| 500 // TODO(qinmin): The codec is lagging behind, need to recalculate the | |
| 501 // |start_presentation_timestamp_| and |start_time_ticks_| in | |
| 502 // media_source_player.cc. | |
| 503 DVLOG(1) << "codec is lagging behind :" << time_to_render.InMicroseconds(); | |
| 504 if (render_output) { | |
| 505 // The player won't expect a timestamp smaller than the | |
| 506 // |start_presentation_timestamp|. However, this could happen due to decoder | |
| 507 // errors. | |
| 508 presentation_timestamp = std::max( | |
| 509 presentation_timestamp, start_presentation_timestamp); | |
| 510 } else { | |
| 511 presentation_timestamp = kNoTimestamp; | |
| 512 } | |
| 513 | |
| 514 const bool is_late_frame = (time_to_render < base::TimeDelta()); | |
| 515 ReleaseOutputBuffer(buffer_index, offset, size, render_output, is_late_frame, | |
| 516 presentation_timestamp, status, callback); | |
| 517 } | |
| 518 | |
| 519 void MediaDecoderJob::OnDecodeCompleted( | |
| 520 MediaCodecStatus status, | |
| 521 bool is_late_frame, | |
| 522 base::TimeDelta current_presentation_timestamp, | |
| 523 base::TimeDelta max_presentation_timestamp) { | |
| 524 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 525 | |
| 526 if (destroy_pending_) { | |
| 527 DVLOG(1) << __FUNCTION__ << " : completing pending deletion"; | |
| 528 delete this; | |
| 529 return; | |
| 530 } | |
| 531 | |
| 532 if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) | |
| 533 output_eos_encountered_ = true; | |
| 534 | |
| 535 DCHECK(!decode_cb_.is_null()); | |
| 536 | |
| 537 // If output was queued for rendering, then we have completed prerolling. | |
| 538 if (current_presentation_timestamp != kNoTimestamp || | |
| 539 status == MEDIA_CODEC_OUTPUT_END_OF_STREAM) { | |
| 540 prerolling_ = false; | |
| 541 } | |
| 542 | |
| 543 switch (status) { | |
| 544 case MEDIA_CODEC_OK: | |
| 545 case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER: | |
| 546 case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: | |
| 547 case MEDIA_CODEC_OUTPUT_END_OF_STREAM: | |
| 548 if (!input_eos_encountered_) | |
| 549 access_unit_index_[current_demuxer_data_index_]++; | |
| 550 break; | |
| 551 | |
| 552 case MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER: | |
| 553 case MEDIA_CODEC_INPUT_END_OF_STREAM: | |
| 554 case MEDIA_CODEC_NO_KEY: | |
| 555 case MEDIA_CODEC_ABORT: | |
| 556 case MEDIA_CODEC_ERROR: | |
| 557 // Do nothing. | |
| 558 break; | |
| 559 | |
| 560 case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED: | |
| 561 DCHECK(false) << "Invalid output status"; | |
| 562 break; | |
| 563 }; | |
| 564 | |
| 565 if (status == MEDIA_CODEC_OUTPUT_END_OF_STREAM && drain_decoder_) { | |
| 566 OnDecoderDrained(); | |
| 567 status = MEDIA_CODEC_OK; | |
| 568 } | |
| 569 | |
| 570 if (status == MEDIA_CODEC_OUTPUT_FORMAT_CHANGED) { | |
| 571 if (UpdateOutputFormat()) | |
| 572 config_changed_cb_.Run(); | |
| 573 status = MEDIA_CODEC_OK; | |
| 574 } | |
| 575 | |
| 576 if (release_resources_pending_) { | |
| 577 ReleaseMediaCodecBridge(); | |
| 578 release_resources_pending_ = false; | |
| 579 if (drain_decoder_) | |
| 580 OnDecoderDrained(); | |
| 581 } | |
| 582 | |
| 583 stop_decode_pending_ = false; | |
| 584 base::ResetAndReturn(&decode_cb_) | |
| 585 .Run(status, is_late_frame, current_presentation_timestamp, | |
| 586 max_presentation_timestamp); | |
| 587 } | |
| 588 | |
| 589 const AccessUnit& MediaDecoderJob::CurrentAccessUnit() const { | |
| 590 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 591 DCHECK(HasData()); | |
| 592 size_t index = CurrentReceivedDataChunkIndex(); | |
| 593 return received_data_[index].access_units[access_unit_index_[index]]; | |
| 594 } | |
| 595 | |
| 596 size_t MediaDecoderJob::CurrentReceivedDataChunkIndex() const { | |
| 597 return NoAccessUnitsRemainingInChunk(true) ? | |
| 598 inactive_demuxer_data_index() : current_demuxer_data_index_; | |
| 599 } | |
| 600 | |
| 601 bool MediaDecoderJob::NoAccessUnitsRemainingInChunk( | |
| 602 bool is_active_chunk) const { | |
| 603 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 604 size_t index = is_active_chunk ? current_demuxer_data_index_ : | |
| 605 inactive_demuxer_data_index(); | |
| 606 return received_data_[index].access_units.size() <= access_unit_index_[index]; | |
| 607 } | |
| 608 | |
| 609 void MediaDecoderJob::RequestCurrentChunkIfEmpty() { | |
| 610 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 611 DCHECK(HasData()); | |
| 612 if (!NoAccessUnitsRemainingInChunk(true)) | |
| 613 return; | |
| 614 | |
| 615 // Requests new data if the the last access unit of the next chunk is not EOS. | |
| 616 current_demuxer_data_index_ = inactive_demuxer_data_index(); | |
| 617 const AccessUnit& last_access_unit = | |
| 618 received_data_[current_demuxer_data_index_].access_units.back(); | |
| 619 if (!last_access_unit.is_end_of_stream && | |
| 620 last_access_unit.status != DemuxerStream::kAborted) { | |
| 621 RequestData(base::Closure()); | |
| 622 } | |
| 623 } | |
| 624 | |
| 625 void MediaDecoderJob::InitializeReceivedData() { | |
| 626 for (size_t i = 0; i < 2; ++i) { | |
| 627 received_data_[i] = DemuxerData(); | |
| 628 access_unit_index_[i] = 0; | |
| 629 } | |
| 630 } | |
| 631 | |
| 632 void MediaDecoderJob::OnDecoderDrained() { | |
| 633 DVLOG(1) << __FUNCTION__; | |
| 634 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 635 DCHECK(drain_decoder_); | |
| 636 | |
| 637 input_eos_encountered_ = false; | |
| 638 output_eos_encountered_ = false; | |
| 639 drain_decoder_ = false; | |
| 640 ReleaseMediaCodecBridge(); | |
| 641 // Increase the access unit index so that the new decoder will not handle | |
| 642 // the config change again. | |
| 643 access_unit_index_[current_demuxer_data_index_]++; | |
| 644 } | |
| 645 | |
| 646 MediaDecoderJob::MediaDecoderJobStatus | |
| 647 MediaDecoderJob::CreateMediaCodecBridge() { | |
| 648 DVLOG(1) << __FUNCTION__; | |
| 649 DCHECK(ui_task_runner_->BelongsToCurrentThread()); | |
| 650 DCHECK(decode_cb_.is_null()); | |
| 651 | |
| 652 if (!HasStream()) { | |
| 653 ReleaseMediaCodecBridge(); | |
| 654 return STATUS_FAILURE; | |
| 655 } | |
| 656 | |
| 657 // Create |media_codec_bridge_| only if config changes. | |
| 658 if (media_codec_bridge_ && !need_to_reconfig_decoder_job_) | |
| 659 return STATUS_SUCCESS; | |
| 660 | |
| 661 if (is_content_encrypted_ && !GetMediaCrypto()) | |
| 662 return STATUS_FAILURE; | |
| 663 | |
| 664 ReleaseMediaCodecBridge(); | |
| 665 DVLOG(1) << __FUNCTION__ << " : creating new media codec bridge"; | |
| 666 | |
| 667 return CreateMediaCodecBridgeInternal(); | |
| 668 } | |
| 669 | |
| 670 bool MediaDecoderJob::IsCodecReconfigureNeeded( | |
| 671 const DemuxerConfigs& configs) const { | |
| 672 if (!AreDemuxerConfigsChanged(configs)) | |
| 673 return false; | |
| 674 return true; | |
| 675 } | |
| 676 | |
| 677 bool MediaDecoderJob::OnOutputFormatChanged() { | |
| 678 return true; | |
| 679 } | |
| 680 | |
| 681 bool MediaDecoderJob::UpdateOutputFormat() { | |
| 682 return false; | |
| 683 } | |
| 684 | |
| 685 void MediaDecoderJob::ReleaseMediaCodecBridge() { | |
| 686 if (!media_codec_bridge_) | |
| 687 return; | |
| 688 | |
| 689 media_codec_bridge_.reset(); | |
| 690 input_buf_index_ = -1; | |
| 691 } | |
| 692 | |
| 693 } // namespace media | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2283493003:
Delete browser MSE implementation. (Closed)
