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