NuPlayer.cpp revision c387f2b719a1a26c8306f77d79cc9a6f26b36813
11ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski/* 21ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * Copyright (C) 2010 The Android Open Source Project 31ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * 41ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * Licensed under the Apache License, Version 2.0 (the "License"); 51ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * you may not use this file except in compliance with the License. 61ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * You may obtain a copy of the License at 71ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * 81ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * http://www.apache.org/licenses/LICENSE-2.0 91ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * 101ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * Unless required by applicable law or agreed to in writing, software 111ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * distributed under the License is distributed on an "AS IS" BASIS, 121ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 131ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * See the License for the specific language governing permissions and 141ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski * limitations under the License. 151ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski */ 161ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 171ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski//#define LOG_NDEBUG 0 181ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#define LOG_TAG "NuPlayer" 191ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 2059e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski#include <inttypes.h> 21cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 221ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include <utils/Log.h> 231ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 241ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include "NuPlayer.h" 251ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 26cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include "HTTPLiveSource.h" 27ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "NuPlayerCCDecoder.h" 281ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include "NuPlayerDecoder.h" 291ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include "NuPlayerDecoderBase.h" 30cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include "NuPlayerDecoderPassThrough.h" 31cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include "NuPlayerDriver.h" 32ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski#include "NuPlayerRenderer.h" 33ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski#include "NuPlayerSource.h" 34ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "RTSPSource.h" 35ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "StreamingSource.h" 36ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "GenericSource.h" 37ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "TextDescriptions.h" 38ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 39ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include "ATSParser.h" 40ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 41ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include <cutils/properties.h> 42ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski 43ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski#include <media/AudioResamplerPublic.h> 44ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski#include <media/AVSyncSettings.h> 45ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski#include <media/MediaCodecBuffer.h> 46ceb9b2f80f853059233cdd29057f39a5960a74aeAdam Lesinski 471ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include <media/stagefright/foundation/hexdump.h> 481ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include <media/stagefright/foundation/ABuffer.h> 49470f8fcb5c0c59b28b5f73ee011a797b05085da7Chih-Hung Hsieh#include <media/stagefright/foundation/ADebug.h> 50ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include <media/stagefright/foundation/AMessage.h> 51ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include <media/stagefright/MediaBuffer.h> 52ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include <media/stagefright/MediaDefs.h> 53cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include <media/stagefright/MediaErrors.h> 541ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include <media/stagefright/MetaData.h> 551ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 56cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include <gui/IGraphicBufferProducer.h> 57cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include <gui/Surface.h> 581ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 591ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski#include "avc_utils.h" 60cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 61cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski#include "ESDS.h" 62ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski#include <media/stagefright/Utils.h> 63ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 64cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinskinamespace android { 65ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 66cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinskistruct NuPlayer::Action : public RefBase { 67ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski Action() {} 681ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 69cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski virtual void execute(NuPlayer *player) = 0; 701ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 71ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinskiprivate: 72cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(Action); 73ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski}; 74cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 751ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinskistruct NuPlayer::SeekAction : public Action { 76cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski explicit SeekAction(int64_t seekTimeUs, MediaPlayerSeekMode mode) 77ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski : mSeekTimeUs(seekTimeUs), 78ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski mMode(mode) { 791ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski } 80cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 811ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski virtual void execute(NuPlayer *player) { 82ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski player->performSeek(mSeekTimeUs, mMode); 83cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski } 84ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 851ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinskiprivate: 86cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski int64_t mSeekTimeUs; 871ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski MediaPlayerSeekMode mMode; 88ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 89cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(SeekAction); 90cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski}; 91ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 92cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinskistruct NuPlayer::ResumeDecoderAction : public Action { 931ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski explicit ResumeDecoderAction(bool needNotify) 94cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski : mNeedNotify(needNotify) { 951ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski } 96ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 97cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski virtual void execute(NuPlayer *player) { 98ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski player->performResumeDecoders(mNeedNotify); 991ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski } 100cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 1011ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinskiprivate: 102cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski bool mNeedNotify; 103cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 104cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(ResumeDecoderAction); 105cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski}; 106cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 1071ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinskistruct NuPlayer::SetSurfaceAction : public Action { 1081ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski explicit SetSurfaceAction(const sp<Surface> &surface) 1091ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski : mSurface(surface) { 1101ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski } 1111ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 1121ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski virtual void execute(NuPlayer *player) { 1131ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski player->performSetSurface(mSurface); 114cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski } 1151ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 116ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinskiprivate: 1171ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski sp<Surface> mSurface; 1181ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 1191ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(SetSurfaceAction); 120e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski}; 121e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski 122e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinskistruct NuPlayer::FlushDecoderAction : public Action { 123e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski FlushDecoderAction(FlushCommand audio, FlushCommand video) 124cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski : mAudio(audio), 125e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski mVideo(video) { 126ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski } 127e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski 128e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski virtual void execute(NuPlayer *player) { 129458b877488c12ea4336d8fc00a95d9c0298bd6d0Adam Lesinski player->performDecoderFlush(mAudio, mVideo); 130ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski } 131ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 132458b877488c12ea4336d8fc00a95d9c0298bd6d0Adam Lesinskiprivate: 133458b877488c12ea4336d8fc00a95d9c0298bd6d0Adam Lesinski FlushCommand mAudio; 134e78fd617ec60139a973a01925fa7adad31febb39Adam Lesinski FlushCommand mVideo; 1351ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 1361ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(FlushDecoderAction); 1371ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski}; 1381ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 139ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinskistruct NuPlayer::PostMessageAction : public Action { 140cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski explicit PostMessageAction(const sp<AMessage> &msg) 141cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski : mMessage(msg) { 142cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski } 143cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 144ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski virtual void execute(NuPlayer *) { 145cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski mMessage->post(); 1461ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski } 1471ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinski 148ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinskiprivate: 149cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski sp<AMessage> mMessage; 150cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 151cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski DISALLOW_EVIL_CONSTRUCTORS(PostMessageAction); 152ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski}; 153ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 154cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski// Use this if there's no state necessary to save in order to execute 15559e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski// the action. 156cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinskistruct NuPlayer::SimpleAction : public Action { 15759e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski typedef void (NuPlayer::*ActionFunc)(); 15859e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski 159ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski explicit SimpleAction(ActionFunc func) 160cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski : mFunc(func) { 161cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski } 162ce5e56e243d262a9b65459c3bd0bb9eaadd40628Adam Lesinski 163cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski virtual void execute(NuPlayer *player) { 16459e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski (player->*mFunc)(); 16559e04c6f92da584b322c87072f18e6cab4de4c60Adam Lesinski } 166cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski 1671ab598f46c3ff520a67f9d80194847741f3467abAdam Lesinskiprivate: 168cacb28f2d60858106e2819cc7d95a65e8bda890bAdam Lesinski ActionFunc mFunc; 169 170 DISALLOW_EVIL_CONSTRUCTORS(SimpleAction); 171}; 172 173//////////////////////////////////////////////////////////////////////////////// 174 175NuPlayer::NuPlayer(pid_t pid) 176 : mUIDValid(false), 177 mPID(pid), 178 mSourceFlags(0), 179 mOffloadAudio(false), 180 mAudioDecoderGeneration(0), 181 mVideoDecoderGeneration(0), 182 mRendererGeneration(0), 183 mPreviousSeekTimeUs(0), 184 mAudioEOS(false), 185 mVideoEOS(false), 186 mScanSourcesPending(false), 187 mScanSourcesGeneration(0), 188 mPollDurationGeneration(0), 189 mTimedTextGeneration(0), 190 mFlushingAudio(NONE), 191 mFlushingVideo(NONE), 192 mResumePending(false), 193 mVideoScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW), 194 mPlaybackSettings(AUDIO_PLAYBACK_RATE_DEFAULT), 195 mVideoFpsHint(-1.f), 196 mStarted(false), 197 mPrepared(false), 198 mResetting(false), 199 mSourceStarted(false), 200 mPaused(false), 201 mPausedByClient(true), 202 mPausedForBuffering(false), 203 mIsDrmProtected(false) { 204 clearFlushComplete(); 205} 206 207NuPlayer::~NuPlayer() { 208} 209 210void NuPlayer::setUID(uid_t uid) { 211 mUIDValid = true; 212 mUID = uid; 213} 214 215void NuPlayer::setDriver(const wp<NuPlayerDriver> &driver) { 216 mDriver = driver; 217} 218 219void NuPlayer::setDataSourceAsync(const sp<IStreamSource> &source) { 220 sp<AMessage> msg = new AMessage(kWhatSetDataSource, this); 221 222 sp<AMessage> notify = new AMessage(kWhatSourceNotify, this); 223 224 msg->setObject("source", new StreamingSource(notify, source)); 225 msg->post(); 226} 227 228static bool IsHTTPLiveURL(const char *url) { 229 if (!strncasecmp("http://", url, 7) 230 || !strncasecmp("https://", url, 8) 231 || !strncasecmp("file://", url, 7)) { 232 size_t len = strlen(url); 233 if (len >= 5 && !strcasecmp(".m3u8", &url[len - 5])) { 234 return true; 235 } 236 237 if (strstr(url,"m3u8")) { 238 return true; 239 } 240 } 241 242 return false; 243} 244 245void NuPlayer::setDataSourceAsync( 246 const sp<IMediaHTTPService> &httpService, 247 const char *url, 248 const KeyedVector<String8, String8> *headers) { 249 250 sp<AMessage> msg = new AMessage(kWhatSetDataSource, this); 251 size_t len = strlen(url); 252 253 sp<AMessage> notify = new AMessage(kWhatSourceNotify, this); 254 255 sp<Source> source; 256 if (IsHTTPLiveURL(url)) { 257 source = new HTTPLiveSource(notify, httpService, url, headers); 258 ALOGV("setDataSourceAsync HTTPLiveSource %s", url); 259 } else if (!strncasecmp(url, "rtsp://", 7)) { 260 source = new RTSPSource( 261 notify, httpService, url, headers, mUIDValid, mUID); 262 ALOGV("setDataSourceAsync RTSPSource %s", url); 263 } else if ((!strncasecmp(url, "http://", 7) 264 || !strncasecmp(url, "https://", 8)) 265 && ((len >= 4 && !strcasecmp(".sdp", &url[len - 4])) 266 || strstr(url, ".sdp?"))) { 267 source = new RTSPSource( 268 notify, httpService, url, headers, mUIDValid, mUID, true); 269 ALOGV("setDataSourceAsync RTSPSource http/https/.sdp %s", url); 270 } else { 271 ALOGV("setDataSourceAsync GenericSource %s", url); 272 273 sp<GenericSource> genericSource = 274 new GenericSource(notify, mUIDValid, mUID); 275 276 status_t err = genericSource->setDataSource(httpService, url, headers); 277 278 if (err == OK) { 279 source = genericSource; 280 } else { 281 ALOGE("Failed to set data source!"); 282 } 283 } 284 msg->setObject("source", source); 285 msg->post(); 286} 287 288void NuPlayer::setDataSourceAsync(int fd, int64_t offset, int64_t length) { 289 sp<AMessage> msg = new AMessage(kWhatSetDataSource, this); 290 291 sp<AMessage> notify = new AMessage(kWhatSourceNotify, this); 292 293 sp<GenericSource> source = 294 new GenericSource(notify, mUIDValid, mUID); 295 296 ALOGV("setDataSourceAsync fd %d/%lld/%lld source: %p", 297 fd, (long long)offset, (long long)length, source.get()); 298 299 status_t err = source->setDataSource(fd, offset, length); 300 301 if (err != OK) { 302 ALOGE("Failed to set data source!"); 303 source = NULL; 304 } 305 306 msg->setObject("source", source); 307 msg->post(); 308} 309 310void NuPlayer::setDataSourceAsync(const sp<DataSource> &dataSource) { 311 sp<AMessage> msg = new AMessage(kWhatSetDataSource, this); 312 sp<AMessage> notify = new AMessage(kWhatSourceNotify, this); 313 314 sp<GenericSource> source = new GenericSource(notify, mUIDValid, mUID); 315 status_t err = source->setDataSource(dataSource); 316 317 if (err != OK) { 318 ALOGE("Failed to set data source!"); 319 source = NULL; 320 } 321 322 msg->setObject("source", source); 323 msg->post(); 324} 325 326status_t NuPlayer::getDefaultBufferingSettings( 327 BufferingSettings *buffering /* nonnull */) { 328 sp<AMessage> msg = new AMessage(kWhatGetDefaultBufferingSettings, this); 329 sp<AMessage> response; 330 status_t err = msg->postAndAwaitResponse(&response); 331 if (err == OK && response != NULL) { 332 CHECK(response->findInt32("err", &err)); 333 if (err == OK) { 334 readFromAMessage(response, buffering); 335 } 336 } 337 return err; 338} 339 340status_t NuPlayer::setBufferingSettings(const BufferingSettings& buffering) { 341 sp<AMessage> msg = new AMessage(kWhatSetBufferingSettings, this); 342 writeToAMessage(msg, buffering); 343 sp<AMessage> response; 344 status_t err = msg->postAndAwaitResponse(&response); 345 if (err == OK && response != NULL) { 346 CHECK(response->findInt32("err", &err)); 347 } 348 return err; 349} 350 351void NuPlayer::prepareAsync() { 352 ALOGV("prepareAsync"); 353 354 (new AMessage(kWhatPrepare, this))->post(); 355} 356 357void NuPlayer::setVideoSurfaceTextureAsync( 358 const sp<IGraphicBufferProducer> &bufferProducer) { 359 sp<AMessage> msg = new AMessage(kWhatSetVideoSurface, this); 360 361 if (bufferProducer == NULL) { 362 msg->setObject("surface", NULL); 363 } else { 364 msg->setObject("surface", new Surface(bufferProducer, true /* controlledByApp */)); 365 } 366 367 msg->post(); 368} 369 370void NuPlayer::setAudioSink(const sp<MediaPlayerBase::AudioSink> &sink) { 371 sp<AMessage> msg = new AMessage(kWhatSetAudioSink, this); 372 msg->setObject("sink", sink); 373 msg->post(); 374} 375 376void NuPlayer::start() { 377 (new AMessage(kWhatStart, this))->post(); 378} 379 380status_t NuPlayer::setPlaybackSettings(const AudioPlaybackRate &rate) { 381 // do some cursory validation of the settings here. audio modes are 382 // only validated when set on the audiosink. 383 if ((rate.mSpeed != 0.f && rate.mSpeed < AUDIO_TIMESTRETCH_SPEED_MIN) 384 || rate.mSpeed > AUDIO_TIMESTRETCH_SPEED_MAX 385 || rate.mPitch < AUDIO_TIMESTRETCH_SPEED_MIN 386 || rate.mPitch > AUDIO_TIMESTRETCH_SPEED_MAX) { 387 return BAD_VALUE; 388 } 389 sp<AMessage> msg = new AMessage(kWhatConfigPlayback, this); 390 writeToAMessage(msg, rate); 391 sp<AMessage> response; 392 status_t err = msg->postAndAwaitResponse(&response); 393 if (err == OK && response != NULL) { 394 CHECK(response->findInt32("err", &err)); 395 } 396 return err; 397} 398 399status_t NuPlayer::getPlaybackSettings(AudioPlaybackRate *rate /* nonnull */) { 400 sp<AMessage> msg = new AMessage(kWhatGetPlaybackSettings, this); 401 sp<AMessage> response; 402 status_t err = msg->postAndAwaitResponse(&response); 403 if (err == OK && response != NULL) { 404 CHECK(response->findInt32("err", &err)); 405 if (err == OK) { 406 readFromAMessage(response, rate); 407 } 408 } 409 return err; 410} 411 412status_t NuPlayer::setSyncSettings(const AVSyncSettings &sync, float videoFpsHint) { 413 sp<AMessage> msg = new AMessage(kWhatConfigSync, this); 414 writeToAMessage(msg, sync, videoFpsHint); 415 sp<AMessage> response; 416 status_t err = msg->postAndAwaitResponse(&response); 417 if (err == OK && response != NULL) { 418 CHECK(response->findInt32("err", &err)); 419 } 420 return err; 421} 422 423status_t NuPlayer::getSyncSettings( 424 AVSyncSettings *sync /* nonnull */, float *videoFps /* nonnull */) { 425 sp<AMessage> msg = new AMessage(kWhatGetSyncSettings, this); 426 sp<AMessage> response; 427 status_t err = msg->postAndAwaitResponse(&response); 428 if (err == OK && response != NULL) { 429 CHECK(response->findInt32("err", &err)); 430 if (err == OK) { 431 readFromAMessage(response, sync, videoFps); 432 } 433 } 434 return err; 435} 436 437void NuPlayer::pause() { 438 (new AMessage(kWhatPause, this))->post(); 439} 440 441void NuPlayer::resetAsync() { 442 sp<Source> source; 443 { 444 Mutex::Autolock autoLock(mSourceLock); 445 source = mSource; 446 } 447 448 if (source != NULL) { 449 // During a reset, the data source might be unresponsive already, we need to 450 // disconnect explicitly so that reads exit promptly. 451 // We can't queue the disconnect request to the looper, as it might be 452 // queued behind a stuck read and never gets processed. 453 // Doing a disconnect outside the looper to allows the pending reads to exit 454 // (either successfully or with error). 455 source->disconnect(); 456 } 457 458 (new AMessage(kWhatReset, this))->post(); 459} 460 461void NuPlayer::seekToAsync(int64_t seekTimeUs, MediaPlayerSeekMode mode, bool needNotify) { 462 sp<AMessage> msg = new AMessage(kWhatSeek, this); 463 msg->setInt64("seekTimeUs", seekTimeUs); 464 msg->setInt32("mode", mode); 465 msg->setInt32("needNotify", needNotify); 466 msg->post(); 467} 468 469 470void NuPlayer::writeTrackInfo( 471 Parcel* reply, const sp<AMessage>& format) const { 472 if (format == NULL) { 473 ALOGE("NULL format"); 474 return; 475 } 476 int32_t trackType; 477 if (!format->findInt32("type", &trackType)) { 478 ALOGE("no track type"); 479 return; 480 } 481 482 AString mime; 483 if (!format->findString("mime", &mime)) { 484 // Java MediaPlayer only uses mimetype for subtitle and timedtext tracks. 485 // If we can't find the mimetype here it means that we wouldn't be needing 486 // the mimetype on the Java end. We still write a placeholder mime to keep the 487 // (de)serialization logic simple. 488 if (trackType == MEDIA_TRACK_TYPE_AUDIO) { 489 mime = "audio/"; 490 } else if (trackType == MEDIA_TRACK_TYPE_VIDEO) { 491 mime = "video/"; 492 } else { 493 ALOGE("unknown track type: %d", trackType); 494 return; 495 } 496 } 497 498 AString lang; 499 if (!format->findString("language", &lang)) { 500 ALOGE("no language"); 501 return; 502 } 503 504 reply->writeInt32(2); // write something non-zero 505 reply->writeInt32(trackType); 506 reply->writeString16(String16(mime.c_str())); 507 reply->writeString16(String16(lang.c_str())); 508 509 if (trackType == MEDIA_TRACK_TYPE_SUBTITLE) { 510 int32_t isAuto, isDefault, isForced; 511 CHECK(format->findInt32("auto", &isAuto)); 512 CHECK(format->findInt32("default", &isDefault)); 513 CHECK(format->findInt32("forced", &isForced)); 514 515 reply->writeInt32(isAuto); 516 reply->writeInt32(isDefault); 517 reply->writeInt32(isForced); 518 } 519} 520 521void NuPlayer::onMessageReceived(const sp<AMessage> &msg) { 522 switch (msg->what()) { 523 case kWhatSetDataSource: 524 { 525 ALOGV("kWhatSetDataSource"); 526 527 CHECK(mSource == NULL); 528 529 status_t err = OK; 530 sp<RefBase> obj; 531 CHECK(msg->findObject("source", &obj)); 532 if (obj != NULL) { 533 Mutex::Autolock autoLock(mSourceLock); 534 mSource = static_cast<Source *>(obj.get()); 535 } else { 536 err = UNKNOWN_ERROR; 537 } 538 539 CHECK(mDriver != NULL); 540 sp<NuPlayerDriver> driver = mDriver.promote(); 541 if (driver != NULL) { 542 driver->notifySetDataSourceCompleted(err); 543 } 544 break; 545 } 546 547 case kWhatGetDefaultBufferingSettings: 548 { 549 sp<AReplyToken> replyID; 550 CHECK(msg->senderAwaitsResponse(&replyID)); 551 552 ALOGV("kWhatGetDefaultBufferingSettings"); 553 BufferingSettings buffering; 554 status_t err = OK; 555 if (mSource != NULL) { 556 err = mSource->getDefaultBufferingSettings(&buffering); 557 } else { 558 err = INVALID_OPERATION; 559 } 560 sp<AMessage> response = new AMessage; 561 if (err == OK) { 562 writeToAMessage(response, buffering); 563 } 564 response->setInt32("err", err); 565 response->postReply(replyID); 566 break; 567 } 568 569 case kWhatSetBufferingSettings: 570 { 571 sp<AReplyToken> replyID; 572 CHECK(msg->senderAwaitsResponse(&replyID)); 573 574 ALOGV("kWhatSetBufferingSettings"); 575 BufferingSettings buffering; 576 readFromAMessage(msg, &buffering); 577 status_t err = OK; 578 if (mSource != NULL) { 579 err = mSource->setBufferingSettings(buffering); 580 } else { 581 err = INVALID_OPERATION; 582 } 583 sp<AMessage> response = new AMessage; 584 response->setInt32("err", err); 585 response->postReply(replyID); 586 break; 587 } 588 589 case kWhatPrepare: 590 { 591 ALOGV("onMessageReceived kWhatPrepare"); 592 593 mSource->prepareAsync(); 594 break; 595 } 596 597 case kWhatGetTrackInfo: 598 { 599 sp<AReplyToken> replyID; 600 CHECK(msg->senderAwaitsResponse(&replyID)); 601 602 Parcel* reply; 603 CHECK(msg->findPointer("reply", (void**)&reply)); 604 605 size_t inbandTracks = 0; 606 if (mSource != NULL) { 607 inbandTracks = mSource->getTrackCount(); 608 } 609 610 size_t ccTracks = 0; 611 if (mCCDecoder != NULL) { 612 ccTracks = mCCDecoder->getTrackCount(); 613 } 614 615 // total track count 616 reply->writeInt32(inbandTracks + ccTracks); 617 618 // write inband tracks 619 for (size_t i = 0; i < inbandTracks; ++i) { 620 writeTrackInfo(reply, mSource->getTrackInfo(i)); 621 } 622 623 // write CC track 624 for (size_t i = 0; i < ccTracks; ++i) { 625 writeTrackInfo(reply, mCCDecoder->getTrackInfo(i)); 626 } 627 628 sp<AMessage> response = new AMessage; 629 response->postReply(replyID); 630 break; 631 } 632 633 case kWhatGetSelectedTrack: 634 { 635 status_t err = INVALID_OPERATION; 636 if (mSource != NULL) { 637 err = OK; 638 639 int32_t type32; 640 CHECK(msg->findInt32("type", (int32_t*)&type32)); 641 media_track_type type = (media_track_type)type32; 642 ssize_t selectedTrack = mSource->getSelectedTrack(type); 643 644 Parcel* reply; 645 CHECK(msg->findPointer("reply", (void**)&reply)); 646 reply->writeInt32(selectedTrack); 647 } 648 649 sp<AMessage> response = new AMessage; 650 response->setInt32("err", err); 651 652 sp<AReplyToken> replyID; 653 CHECK(msg->senderAwaitsResponse(&replyID)); 654 response->postReply(replyID); 655 break; 656 } 657 658 case kWhatSelectTrack: 659 { 660 sp<AReplyToken> replyID; 661 CHECK(msg->senderAwaitsResponse(&replyID)); 662 663 size_t trackIndex; 664 int32_t select; 665 int64_t timeUs; 666 CHECK(msg->findSize("trackIndex", &trackIndex)); 667 CHECK(msg->findInt32("select", &select)); 668 CHECK(msg->findInt64("timeUs", &timeUs)); 669 670 status_t err = INVALID_OPERATION; 671 672 size_t inbandTracks = 0; 673 if (mSource != NULL) { 674 inbandTracks = mSource->getTrackCount(); 675 } 676 size_t ccTracks = 0; 677 if (mCCDecoder != NULL) { 678 ccTracks = mCCDecoder->getTrackCount(); 679 } 680 681 if (trackIndex < inbandTracks) { 682 err = mSource->selectTrack(trackIndex, select, timeUs); 683 684 if (!select && err == OK) { 685 int32_t type; 686 sp<AMessage> info = mSource->getTrackInfo(trackIndex); 687 if (info != NULL 688 && info->findInt32("type", &type) 689 && type == MEDIA_TRACK_TYPE_TIMEDTEXT) { 690 ++mTimedTextGeneration; 691 } 692 } 693 } else { 694 trackIndex -= inbandTracks; 695 696 if (trackIndex < ccTracks) { 697 err = mCCDecoder->selectTrack(trackIndex, select); 698 } 699 } 700 701 sp<AMessage> response = new AMessage; 702 response->setInt32("err", err); 703 704 response->postReply(replyID); 705 break; 706 } 707 708 case kWhatPollDuration: 709 { 710 int32_t generation; 711 CHECK(msg->findInt32("generation", &generation)); 712 713 if (generation != mPollDurationGeneration) { 714 // stale 715 break; 716 } 717 718 int64_t durationUs; 719 if (mDriver != NULL && mSource->getDuration(&durationUs) == OK) { 720 sp<NuPlayerDriver> driver = mDriver.promote(); 721 if (driver != NULL) { 722 driver->notifyDuration(durationUs); 723 } 724 } 725 726 msg->post(1000000ll); // poll again in a second. 727 break; 728 } 729 730 case kWhatSetVideoSurface: 731 { 732 733 sp<RefBase> obj; 734 CHECK(msg->findObject("surface", &obj)); 735 sp<Surface> surface = static_cast<Surface *>(obj.get()); 736 737 ALOGD("onSetVideoSurface(%p, %s video decoder)", 738 surface.get(), 739 (mSource != NULL && mStarted && mSource->getFormat(false /* audio */) != NULL 740 && mVideoDecoder != NULL) ? "have" : "no"); 741 742 // Need to check mStarted before calling mSource->getFormat because NuPlayer might 743 // be in preparing state and it could take long time. 744 // When mStarted is true, mSource must have been set. 745 if (mSource == NULL || !mStarted || mSource->getFormat(false /* audio */) == NULL 746 // NOTE: mVideoDecoder's mSurface is always non-null 747 || (mVideoDecoder != NULL && mVideoDecoder->setVideoSurface(surface) == OK)) { 748 performSetSurface(surface); 749 break; 750 } 751 752 mDeferredActions.push_back( 753 new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */, 754 FLUSH_CMD_SHUTDOWN /* video */)); 755 756 mDeferredActions.push_back(new SetSurfaceAction(surface)); 757 758 if (obj != NULL || mAudioDecoder != NULL) { 759 if (mStarted) { 760 // Issue a seek to refresh the video screen only if started otherwise 761 // the extractor may not yet be started and will assert. 762 // If the video decoder is not set (perhaps audio only in this case) 763 // do not perform a seek as it is not needed. 764 int64_t currentPositionUs = 0; 765 if (getCurrentPosition(¤tPositionUs) == OK) { 766 mDeferredActions.push_back( 767 new SeekAction(currentPositionUs, 768 MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */)); 769 } 770 } 771 772 // If there is a new surface texture, instantiate decoders 773 // again if possible. 774 mDeferredActions.push_back( 775 new SimpleAction(&NuPlayer::performScanSources)); 776 } 777 778 // After a flush without shutdown, decoder is paused. 779 // Don't resume it until source seek is done, otherwise it could 780 // start pulling stale data too soon. 781 mDeferredActions.push_back( 782 new ResumeDecoderAction(false /* needNotify */)); 783 784 processDeferredActions(); 785 break; 786 } 787 788 case kWhatSetAudioSink: 789 { 790 ALOGV("kWhatSetAudioSink"); 791 792 sp<RefBase> obj; 793 CHECK(msg->findObject("sink", &obj)); 794 795 mAudioSink = static_cast<MediaPlayerBase::AudioSink *>(obj.get()); 796 break; 797 } 798 799 case kWhatStart: 800 { 801 ALOGV("kWhatStart"); 802 if (mStarted) { 803 // do not resume yet if the source is still buffering 804 if (!mPausedForBuffering) { 805 onResume(); 806 } 807 } else { 808 onStart(); 809 } 810 mPausedByClient = false; 811 break; 812 } 813 814 case kWhatConfigPlayback: 815 { 816 sp<AReplyToken> replyID; 817 CHECK(msg->senderAwaitsResponse(&replyID)); 818 AudioPlaybackRate rate /* sanitized */; 819 readFromAMessage(msg, &rate); 820 status_t err = OK; 821 if (mRenderer != NULL) { 822 // AudioSink allows only 1.f and 0.f for offload mode. 823 // For other speed, switch to non-offload mode. 824 if (mOffloadAudio && ((rate.mSpeed != 0.f && rate.mSpeed != 1.f) 825 || rate.mPitch != 1.f)) { 826 int64_t currentPositionUs; 827 if (getCurrentPosition(¤tPositionUs) != OK) { 828 currentPositionUs = mPreviousSeekTimeUs; 829 } 830 831 // Set mPlaybackSettings so that the new audio decoder can 832 // be created correctly. 833 mPlaybackSettings = rate; 834 if (!mPaused) { 835 mRenderer->pause(); 836 } 837 restartAudio( 838 currentPositionUs, true /* forceNonOffload */, 839 true /* needsToCreateAudioDecoder */); 840 if (!mPaused) { 841 mRenderer->resume(); 842 } 843 } 844 845 err = mRenderer->setPlaybackSettings(rate); 846 } 847 if (err == OK) { 848 if (rate.mSpeed == 0.f) { 849 onPause(); 850 mPausedByClient = true; 851 // save all other settings (using non-paused speed) 852 // so we can restore them on start 853 AudioPlaybackRate newRate = rate; 854 newRate.mSpeed = mPlaybackSettings.mSpeed; 855 mPlaybackSettings = newRate; 856 } else { /* rate.mSpeed != 0.f */ 857 mPlaybackSettings = rate; 858 if (mStarted) { 859 // do not resume yet if the source is still buffering 860 if (!mPausedForBuffering) { 861 onResume(); 862 } 863 } else if (mPrepared) { 864 onStart(); 865 } 866 867 mPausedByClient = false; 868 } 869 } 870 871 if (mVideoDecoder != NULL) { 872 sp<AMessage> params = new AMessage(); 873 params->setFloat("playback-speed", mPlaybackSettings.mSpeed); 874 mVideoDecoder->setParameters(params); 875 } 876 877 sp<AMessage> response = new AMessage; 878 response->setInt32("err", err); 879 response->postReply(replyID); 880 break; 881 } 882 883 case kWhatGetPlaybackSettings: 884 { 885 sp<AReplyToken> replyID; 886 CHECK(msg->senderAwaitsResponse(&replyID)); 887 AudioPlaybackRate rate = mPlaybackSettings; 888 status_t err = OK; 889 if (mRenderer != NULL) { 890 err = mRenderer->getPlaybackSettings(&rate); 891 } 892 if (err == OK) { 893 // get playback settings used by renderer, as it may be 894 // slightly off due to audiosink not taking small changes. 895 mPlaybackSettings = rate; 896 if (mPaused) { 897 rate.mSpeed = 0.f; 898 } 899 } 900 sp<AMessage> response = new AMessage; 901 if (err == OK) { 902 writeToAMessage(response, rate); 903 } 904 response->setInt32("err", err); 905 response->postReply(replyID); 906 break; 907 } 908 909 case kWhatConfigSync: 910 { 911 sp<AReplyToken> replyID; 912 CHECK(msg->senderAwaitsResponse(&replyID)); 913 914 ALOGV("kWhatConfigSync"); 915 AVSyncSettings sync; 916 float videoFpsHint; 917 readFromAMessage(msg, &sync, &videoFpsHint); 918 status_t err = OK; 919 if (mRenderer != NULL) { 920 err = mRenderer->setSyncSettings(sync, videoFpsHint); 921 } 922 if (err == OK) { 923 mSyncSettings = sync; 924 mVideoFpsHint = videoFpsHint; 925 } 926 sp<AMessage> response = new AMessage; 927 response->setInt32("err", err); 928 response->postReply(replyID); 929 break; 930 } 931 932 case kWhatGetSyncSettings: 933 { 934 sp<AReplyToken> replyID; 935 CHECK(msg->senderAwaitsResponse(&replyID)); 936 AVSyncSettings sync = mSyncSettings; 937 float videoFps = mVideoFpsHint; 938 status_t err = OK; 939 if (mRenderer != NULL) { 940 err = mRenderer->getSyncSettings(&sync, &videoFps); 941 if (err == OK) { 942 mSyncSettings = sync; 943 mVideoFpsHint = videoFps; 944 } 945 } 946 sp<AMessage> response = new AMessage; 947 if (err == OK) { 948 writeToAMessage(response, sync, videoFps); 949 } 950 response->setInt32("err", err); 951 response->postReply(replyID); 952 break; 953 } 954 955 case kWhatScanSources: 956 { 957 int32_t generation; 958 CHECK(msg->findInt32("generation", &generation)); 959 if (generation != mScanSourcesGeneration) { 960 // Drop obsolete msg. 961 break; 962 } 963 964 mScanSourcesPending = false; 965 966 ALOGV("scanning sources haveAudio=%d, haveVideo=%d", 967 mAudioDecoder != NULL, mVideoDecoder != NULL); 968 969 bool mHadAnySourcesBefore = 970 (mAudioDecoder != NULL) || (mVideoDecoder != NULL); 971 bool rescan = false; 972 973 // initialize video before audio because successful initialization of 974 // video may change deep buffer mode of audio. 975 if (mSurface != NULL) { 976 if (instantiateDecoder(false, &mVideoDecoder) == -EWOULDBLOCK) { 977 rescan = true; 978 } 979 } 980 981 // Don't try to re-open audio sink if there's an existing decoder. 982 if (mAudioSink != NULL && mAudioDecoder == NULL) { 983 if (instantiateDecoder(true, &mAudioDecoder) == -EWOULDBLOCK) { 984 rescan = true; 985 } 986 } 987 988 if (!mHadAnySourcesBefore 989 && (mAudioDecoder != NULL || mVideoDecoder != NULL)) { 990 // This is the first time we've found anything playable. 991 992 if (mSourceFlags & Source::FLAG_DYNAMIC_DURATION) { 993 schedulePollDuration(); 994 } 995 } 996 997 status_t err; 998 if ((err = mSource->feedMoreTSData()) != OK) { 999 if (mAudioDecoder == NULL && mVideoDecoder == NULL) { 1000 // We're not currently decoding anything (no audio or 1001 // video tracks found) and we just ran out of input data. 1002 1003 if (err == ERROR_END_OF_STREAM) { 1004 notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0); 1005 } else { 1006 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 1007 } 1008 } 1009 break; 1010 } 1011 1012 if (rescan) { 1013 msg->post(100000ll); 1014 mScanSourcesPending = true; 1015 } 1016 break; 1017 } 1018 1019 case kWhatVideoNotify: 1020 case kWhatAudioNotify: 1021 { 1022 bool audio = msg->what() == kWhatAudioNotify; 1023 1024 int32_t currentDecoderGeneration = 1025 (audio? mAudioDecoderGeneration : mVideoDecoderGeneration); 1026 int32_t requesterGeneration = currentDecoderGeneration - 1; 1027 CHECK(msg->findInt32("generation", &requesterGeneration)); 1028 1029 if (requesterGeneration != currentDecoderGeneration) { 1030 ALOGV("got message from old %s decoder, generation(%d:%d)", 1031 audio ? "audio" : "video", requesterGeneration, 1032 currentDecoderGeneration); 1033 sp<AMessage> reply; 1034 if (!(msg->findMessage("reply", &reply))) { 1035 return; 1036 } 1037 1038 reply->setInt32("err", INFO_DISCONTINUITY); 1039 reply->post(); 1040 return; 1041 } 1042 1043 int32_t what; 1044 CHECK(msg->findInt32("what", &what)); 1045 1046 if (what == DecoderBase::kWhatInputDiscontinuity) { 1047 int32_t formatChange; 1048 CHECK(msg->findInt32("formatChange", &formatChange)); 1049 1050 ALOGV("%s discontinuity: formatChange %d", 1051 audio ? "audio" : "video", formatChange); 1052 1053 if (formatChange) { 1054 mDeferredActions.push_back( 1055 new FlushDecoderAction( 1056 audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE, 1057 audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN)); 1058 } 1059 1060 mDeferredActions.push_back( 1061 new SimpleAction( 1062 &NuPlayer::performScanSources)); 1063 1064 processDeferredActions(); 1065 } else if (what == DecoderBase::kWhatEOS) { 1066 int32_t err; 1067 CHECK(msg->findInt32("err", &err)); 1068 1069 if (err == ERROR_END_OF_STREAM) { 1070 ALOGV("got %s decoder EOS", audio ? "audio" : "video"); 1071 } else { 1072 ALOGV("got %s decoder EOS w/ error %d", 1073 audio ? "audio" : "video", 1074 err); 1075 } 1076 1077 mRenderer->queueEOS(audio, err); 1078 } else if (what == DecoderBase::kWhatFlushCompleted) { 1079 ALOGV("decoder %s flush completed", audio ? "audio" : "video"); 1080 1081 handleFlushComplete(audio, true /* isDecoder */); 1082 finishFlushIfPossible(); 1083 } else if (what == DecoderBase::kWhatVideoSizeChanged) { 1084 sp<AMessage> format; 1085 CHECK(msg->findMessage("format", &format)); 1086 1087 sp<AMessage> inputFormat = 1088 mSource->getFormat(false /* audio */); 1089 1090 setVideoScalingMode(mVideoScalingMode); 1091 updateVideoSize(inputFormat, format); 1092 } else if (what == DecoderBase::kWhatShutdownCompleted) { 1093 ALOGV("%s shutdown completed", audio ? "audio" : "video"); 1094 if (audio) { 1095 mAudioDecoder.clear(); 1096 ++mAudioDecoderGeneration; 1097 1098 CHECK_EQ((int)mFlushingAudio, (int)SHUTTING_DOWN_DECODER); 1099 mFlushingAudio = SHUT_DOWN; 1100 } else { 1101 mVideoDecoder.clear(); 1102 ++mVideoDecoderGeneration; 1103 1104 CHECK_EQ((int)mFlushingVideo, (int)SHUTTING_DOWN_DECODER); 1105 mFlushingVideo = SHUT_DOWN; 1106 } 1107 1108 finishFlushIfPossible(); 1109 } else if (what == DecoderBase::kWhatResumeCompleted) { 1110 finishResume(); 1111 } else if (what == DecoderBase::kWhatError) { 1112 status_t err; 1113 if (!msg->findInt32("err", &err) || err == OK) { 1114 err = UNKNOWN_ERROR; 1115 } 1116 1117 // Decoder errors can be due to Source (e.g. from streaming), 1118 // or from decoding corrupted bitstreams, or from other decoder 1119 // MediaCodec operations (e.g. from an ongoing reset or seek). 1120 // They may also be due to openAudioSink failure at 1121 // decoder start or after a format change. 1122 // 1123 // We try to gracefully shut down the affected decoder if possible, 1124 // rather than trying to force the shutdown with something 1125 // similar to performReset(). This method can lead to a hang 1126 // if MediaCodec functions block after an error, but they should 1127 // typically return INVALID_OPERATION instead of blocking. 1128 1129 FlushStatus *flushing = audio ? &mFlushingAudio : &mFlushingVideo; 1130 ALOGE("received error(%#x) from %s decoder, flushing(%d), now shutting down", 1131 err, audio ? "audio" : "video", *flushing); 1132 1133 switch (*flushing) { 1134 case NONE: 1135 mDeferredActions.push_back( 1136 new FlushDecoderAction( 1137 audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE, 1138 audio ? FLUSH_CMD_NONE : FLUSH_CMD_SHUTDOWN)); 1139 processDeferredActions(); 1140 break; 1141 case FLUSHING_DECODER: 1142 *flushing = FLUSHING_DECODER_SHUTDOWN; // initiate shutdown after flush. 1143 break; // Wait for flush to complete. 1144 case FLUSHING_DECODER_SHUTDOWN: 1145 break; // Wait for flush to complete. 1146 case SHUTTING_DOWN_DECODER: 1147 break; // Wait for shutdown to complete. 1148 case FLUSHED: 1149 getDecoder(audio)->initiateShutdown(); // In the middle of a seek. 1150 *flushing = SHUTTING_DOWN_DECODER; // Shut down. 1151 break; 1152 case SHUT_DOWN: 1153 finishFlushIfPossible(); // Should not occur. 1154 break; // Finish anyways. 1155 } 1156 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 1157 } else { 1158 ALOGV("Unhandled decoder notification %d '%c%c%c%c'.", 1159 what, 1160 what >> 24, 1161 (what >> 16) & 0xff, 1162 (what >> 8) & 0xff, 1163 what & 0xff); 1164 } 1165 1166 break; 1167 } 1168 1169 case kWhatRendererNotify: 1170 { 1171 int32_t requesterGeneration = mRendererGeneration - 1; 1172 CHECK(msg->findInt32("generation", &requesterGeneration)); 1173 if (requesterGeneration != mRendererGeneration) { 1174 ALOGV("got message from old renderer, generation(%d:%d)", 1175 requesterGeneration, mRendererGeneration); 1176 return; 1177 } 1178 1179 int32_t what; 1180 CHECK(msg->findInt32("what", &what)); 1181 1182 if (what == Renderer::kWhatEOS) { 1183 int32_t audio; 1184 CHECK(msg->findInt32("audio", &audio)); 1185 1186 int32_t finalResult; 1187 CHECK(msg->findInt32("finalResult", &finalResult)); 1188 1189 if (audio) { 1190 mAudioEOS = true; 1191 } else { 1192 mVideoEOS = true; 1193 } 1194 1195 if (finalResult == ERROR_END_OF_STREAM) { 1196 ALOGV("reached %s EOS", audio ? "audio" : "video"); 1197 } else { 1198 ALOGE("%s track encountered an error (%d)", 1199 audio ? "audio" : "video", finalResult); 1200 1201 notifyListener( 1202 MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, finalResult); 1203 } 1204 1205 if ((mAudioEOS || mAudioDecoder == NULL) 1206 && (mVideoEOS || mVideoDecoder == NULL)) { 1207 notifyListener(MEDIA_PLAYBACK_COMPLETE, 0, 0); 1208 } 1209 } else if (what == Renderer::kWhatFlushComplete) { 1210 int32_t audio; 1211 CHECK(msg->findInt32("audio", &audio)); 1212 1213 if (audio) { 1214 mAudioEOS = false; 1215 } else { 1216 mVideoEOS = false; 1217 } 1218 1219 ALOGV("renderer %s flush completed.", audio ? "audio" : "video"); 1220 if (audio && (mFlushingAudio == NONE || mFlushingAudio == FLUSHED 1221 || mFlushingAudio == SHUT_DOWN)) { 1222 // Flush has been handled by tear down. 1223 break; 1224 } 1225 handleFlushComplete(audio, false /* isDecoder */); 1226 finishFlushIfPossible(); 1227 } else if (what == Renderer::kWhatVideoRenderingStart) { 1228 notifyListener(MEDIA_INFO, MEDIA_INFO_RENDERING_START, 0); 1229 } else if (what == Renderer::kWhatMediaRenderingStart) { 1230 ALOGV("media rendering started"); 1231 notifyListener(MEDIA_STARTED, 0, 0); 1232 } else if (what == Renderer::kWhatAudioTearDown) { 1233 int32_t reason; 1234 CHECK(msg->findInt32("reason", &reason)); 1235 ALOGV("Tear down audio with reason %d.", reason); 1236 if (reason == Renderer::kDueToTimeout && !(mPaused && mOffloadAudio)) { 1237 // TimeoutWhenPaused is only for offload mode. 1238 ALOGW("Receive a stale message for teardown."); 1239 break; 1240 } 1241 int64_t positionUs; 1242 if (!msg->findInt64("positionUs", &positionUs)) { 1243 positionUs = mPreviousSeekTimeUs; 1244 } 1245 1246 restartAudio( 1247 positionUs, reason == Renderer::kForceNonOffload /* forceNonOffload */, 1248 reason != Renderer::kDueToTimeout /* needsToCreateAudioDecoder */); 1249 } 1250 break; 1251 } 1252 1253 case kWhatMoreDataQueued: 1254 { 1255 break; 1256 } 1257 1258 case kWhatReset: 1259 { 1260 ALOGV("kWhatReset"); 1261 1262 mResetting = true; 1263 1264 mDeferredActions.push_back( 1265 new FlushDecoderAction( 1266 FLUSH_CMD_SHUTDOWN /* audio */, 1267 FLUSH_CMD_SHUTDOWN /* video */)); 1268 1269 mDeferredActions.push_back( 1270 new SimpleAction(&NuPlayer::performReset)); 1271 1272 processDeferredActions(); 1273 break; 1274 } 1275 1276 case kWhatSeek: 1277 { 1278 int64_t seekTimeUs; 1279 int32_t mode; 1280 int32_t needNotify; 1281 CHECK(msg->findInt64("seekTimeUs", &seekTimeUs)); 1282 CHECK(msg->findInt32("mode", &mode)); 1283 CHECK(msg->findInt32("needNotify", &needNotify)); 1284 1285 ALOGV("kWhatSeek seekTimeUs=%lld us, mode=%d, needNotify=%d", 1286 (long long)seekTimeUs, mode, needNotify); 1287 1288 if (!mStarted) { 1289 // Seek before the player is started. In order to preview video, 1290 // need to start the player and pause it. This branch is called 1291 // only once if needed. After the player is started, any seek 1292 // operation will go through normal path. 1293 // Audio-only cases are handled separately. 1294 onStart(seekTimeUs, (MediaPlayerSeekMode)mode); 1295 if (mStarted) { 1296 onPause(); 1297 mPausedByClient = true; 1298 } 1299 if (needNotify) { 1300 notifyDriverSeekComplete(); 1301 } 1302 break; 1303 } 1304 1305 mDeferredActions.push_back( 1306 new FlushDecoderAction(FLUSH_CMD_FLUSH /* audio */, 1307 FLUSH_CMD_FLUSH /* video */)); 1308 1309 mDeferredActions.push_back( 1310 new SeekAction(seekTimeUs, (MediaPlayerSeekMode)mode)); 1311 1312 // After a flush without shutdown, decoder is paused. 1313 // Don't resume it until source seek is done, otherwise it could 1314 // start pulling stale data too soon. 1315 mDeferredActions.push_back( 1316 new ResumeDecoderAction(needNotify)); 1317 1318 processDeferredActions(); 1319 break; 1320 } 1321 1322 case kWhatPause: 1323 { 1324 onPause(); 1325 mPausedByClient = true; 1326 break; 1327 } 1328 1329 case kWhatSourceNotify: 1330 { 1331 onSourceNotify(msg); 1332 break; 1333 } 1334 1335 case kWhatClosedCaptionNotify: 1336 { 1337 onClosedCaptionNotify(msg); 1338 break; 1339 } 1340 1341 case kWhatPrepareDrm: 1342 { 1343 status_t status = onPrepareDrm(msg); 1344 1345 sp<AMessage> response = new AMessage; 1346 response->setInt32("status", status); 1347 sp<AReplyToken> replyID; 1348 CHECK(msg->senderAwaitsResponse(&replyID)); 1349 response->postReply(replyID); 1350 break; 1351 } 1352 1353 case kWhatReleaseDrm: 1354 { 1355 status_t status = onReleaseDrm(); 1356 1357 sp<AMessage> response = new AMessage; 1358 response->setInt32("status", status); 1359 sp<AReplyToken> replyID; 1360 CHECK(msg->senderAwaitsResponse(&replyID)); 1361 response->postReply(replyID); 1362 break; 1363 } 1364 1365 default: 1366 TRESPASS(); 1367 break; 1368 } 1369} 1370 1371void NuPlayer::onResume() { 1372 if (!mPaused || mResetting) { 1373 ALOGD_IF(mResetting, "resetting, onResume discarded"); 1374 return; 1375 } 1376 mPaused = false; 1377 if (mSource != NULL) { 1378 mSource->resume(); 1379 } else { 1380 ALOGW("resume called when source is gone or not set"); 1381 } 1382 // |mAudioDecoder| may have been released due to the pause timeout, so re-create it if 1383 // needed. 1384 if (audioDecoderStillNeeded() && mAudioDecoder == NULL) { 1385 instantiateDecoder(true /* audio */, &mAudioDecoder); 1386 } 1387 if (mRenderer != NULL) { 1388 mRenderer->resume(); 1389 } else { 1390 ALOGW("resume called when renderer is gone or not set"); 1391 } 1392 1393 mLastStartedPlayingTimeNs = systemTime(); 1394} 1395 1396status_t NuPlayer::onInstantiateSecureDecoders() { 1397 status_t err; 1398 if (!(mSourceFlags & Source::FLAG_SECURE)) { 1399 return BAD_TYPE; 1400 } 1401 1402 if (mRenderer != NULL) { 1403 ALOGE("renderer should not be set when instantiating secure decoders"); 1404 return UNKNOWN_ERROR; 1405 } 1406 1407 // TRICKY: We rely on mRenderer being null, so that decoder does not start requesting 1408 // data on instantiation. 1409 if (mSurface != NULL) { 1410 err = instantiateDecoder(false, &mVideoDecoder); 1411 if (err != OK) { 1412 return err; 1413 } 1414 } 1415 1416 if (mAudioSink != NULL) { 1417 err = instantiateDecoder(true, &mAudioDecoder); 1418 if (err != OK) { 1419 return err; 1420 } 1421 } 1422 return OK; 1423} 1424 1425void NuPlayer::onStart(int64_t startPositionUs, MediaPlayerSeekMode mode) { 1426 ALOGV("onStart: mCrypto: %p (%d)", mCrypto.get(), 1427 (mCrypto != NULL ? mCrypto->getStrongCount() : 0)); 1428 1429 if (!mSourceStarted) { 1430 mSourceStarted = true; 1431 mSource->start(); 1432 } 1433 if (startPositionUs > 0) { 1434 performSeek(startPositionUs, mode); 1435 if (mSource->getFormat(false /* audio */) == NULL) { 1436 return; 1437 } 1438 } 1439 1440 mOffloadAudio = false; 1441 mAudioEOS = false; 1442 mVideoEOS = false; 1443 mStarted = true; 1444 mPaused = false; 1445 1446 uint32_t flags = 0; 1447 1448 if (mSource->isRealTime()) { 1449 flags |= Renderer::FLAG_REAL_TIME; 1450 } 1451 1452 bool hasAudio = (mSource->getFormat(true /* audio */) != NULL); 1453 bool hasVideo = (mSource->getFormat(false /* audio */) != NULL); 1454 if (!hasAudio && !hasVideo) { 1455 ALOGE("no metadata for either audio or video source"); 1456 mSource->stop(); 1457 mSourceStarted = false; 1458 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_MALFORMED); 1459 return; 1460 } 1461 ALOGV_IF(!hasAudio, "no metadata for audio source"); // video only stream 1462 1463 sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */); 1464 1465 audio_stream_type_t streamType = AUDIO_STREAM_MUSIC; 1466 if (mAudioSink != NULL) { 1467 streamType = mAudioSink->getAudioStreamType(); 1468 } 1469 1470 mOffloadAudio = 1471 canOffloadStream(audioMeta, hasVideo, mSource->isStreaming(), streamType) 1472 && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f); 1473 1474 // Modular DRM: Disabling audio offload if the source is protected 1475 if (mOffloadAudio && mIsDrmProtected) { 1476 mOffloadAudio = false; 1477 ALOGV("onStart: Disabling mOffloadAudio now that the source is protected."); 1478 } 1479 1480 if (mOffloadAudio) { 1481 flags |= Renderer::FLAG_OFFLOAD_AUDIO; 1482 } 1483 1484 sp<AMessage> notify = new AMessage(kWhatRendererNotify, this); 1485 ++mRendererGeneration; 1486 notify->setInt32("generation", mRendererGeneration); 1487 mRenderer = new Renderer(mAudioSink, notify, flags); 1488 mRendererLooper = new ALooper; 1489 mRendererLooper->setName("NuPlayerRenderer"); 1490 mRendererLooper->start(false, false, ANDROID_PRIORITY_AUDIO); 1491 mRendererLooper->registerHandler(mRenderer); 1492 1493 status_t err = mRenderer->setPlaybackSettings(mPlaybackSettings); 1494 if (err != OK) { 1495 mSource->stop(); 1496 mSourceStarted = false; 1497 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, err); 1498 return; 1499 } 1500 1501 float rate = getFrameRate(); 1502 if (rate > 0) { 1503 mRenderer->setVideoFrameRate(rate); 1504 } 1505 1506 if (mVideoDecoder != NULL) { 1507 mVideoDecoder->setRenderer(mRenderer); 1508 } 1509 if (mAudioDecoder != NULL) { 1510 mAudioDecoder->setRenderer(mRenderer); 1511 } 1512 1513 mLastStartedPlayingTimeNs = systemTime(); 1514 1515 postScanSources(); 1516} 1517 1518void NuPlayer::onPause() { 1519 if (mPaused) { 1520 return; 1521 } 1522 mPaused = true; 1523 if (mSource != NULL) { 1524 mSource->pause(); 1525 } else { 1526 ALOGW("pause called when source is gone or not set"); 1527 } 1528 if (mRenderer != NULL) { 1529 mRenderer->pause(); 1530 } else { 1531 ALOGW("pause called when renderer is gone or not set"); 1532 } 1533 1534 sp<NuPlayerDriver> driver = mDriver.promote(); 1535 if (driver != NULL) { 1536 int64_t now = systemTime(); 1537 int64_t played = now - mLastStartedPlayingTimeNs; 1538 ALOGD("played from %" PRId64 " to %" PRId64 " = %" PRId64 , 1539 mLastStartedPlayingTimeNs, now, played); 1540 1541 driver->notifyMorePlayingTimeUs((played+500)/1000); 1542 } 1543} 1544 1545bool NuPlayer::audioDecoderStillNeeded() { 1546 // Audio decoder is no longer needed if it's in shut/shutting down status. 1547 return ((mFlushingAudio != SHUT_DOWN) && (mFlushingAudio != SHUTTING_DOWN_DECODER)); 1548} 1549 1550void NuPlayer::handleFlushComplete(bool audio, bool isDecoder) { 1551 // We wait for both the decoder flush and the renderer flush to complete 1552 // before entering either the FLUSHED or the SHUTTING_DOWN_DECODER state. 1553 1554 mFlushComplete[audio][isDecoder] = true; 1555 if (!mFlushComplete[audio][!isDecoder]) { 1556 return; 1557 } 1558 1559 FlushStatus *state = audio ? &mFlushingAudio : &mFlushingVideo; 1560 switch (*state) { 1561 case FLUSHING_DECODER: 1562 { 1563 *state = FLUSHED; 1564 break; 1565 } 1566 1567 case FLUSHING_DECODER_SHUTDOWN: 1568 { 1569 *state = SHUTTING_DOWN_DECODER; 1570 1571 ALOGV("initiating %s decoder shutdown", audio ? "audio" : "video"); 1572 getDecoder(audio)->initiateShutdown(); 1573 break; 1574 } 1575 1576 default: 1577 // decoder flush completes only occur in a flushing state. 1578 LOG_ALWAYS_FATAL_IF(isDecoder, "decoder flush in invalid state %d", *state); 1579 break; 1580 } 1581} 1582 1583void NuPlayer::finishFlushIfPossible() { 1584 if (mFlushingAudio != NONE && mFlushingAudio != FLUSHED 1585 && mFlushingAudio != SHUT_DOWN) { 1586 return; 1587 } 1588 1589 if (mFlushingVideo != NONE && mFlushingVideo != FLUSHED 1590 && mFlushingVideo != SHUT_DOWN) { 1591 return; 1592 } 1593 1594 ALOGV("both audio and video are flushed now."); 1595 1596 mFlushingAudio = NONE; 1597 mFlushingVideo = NONE; 1598 1599 clearFlushComplete(); 1600 1601 processDeferredActions(); 1602} 1603 1604void NuPlayer::postScanSources() { 1605 if (mScanSourcesPending) { 1606 return; 1607 } 1608 1609 sp<AMessage> msg = new AMessage(kWhatScanSources, this); 1610 msg->setInt32("generation", mScanSourcesGeneration); 1611 msg->post(); 1612 1613 mScanSourcesPending = true; 1614} 1615 1616void NuPlayer::tryOpenAudioSinkForOffload( 1617 const sp<AMessage> &format, const sp<MetaData> &audioMeta, bool hasVideo) { 1618 // Note: This is called early in NuPlayer to determine whether offloading 1619 // is possible; otherwise the decoders call the renderer openAudioSink directly. 1620 1621 status_t err = mRenderer->openAudioSink( 1622 format, true /* offloadOnly */, hasVideo, 1623 AUDIO_OUTPUT_FLAG_NONE, &mOffloadAudio, mSource->isStreaming()); 1624 if (err != OK) { 1625 // Any failure we turn off mOffloadAudio. 1626 mOffloadAudio = false; 1627 } else if (mOffloadAudio) { 1628 sendMetaDataToHal(mAudioSink, audioMeta); 1629 } 1630} 1631 1632void NuPlayer::closeAudioSink() { 1633 mRenderer->closeAudioSink(); 1634} 1635 1636void NuPlayer::restartAudio( 1637 int64_t currentPositionUs, bool forceNonOffload, bool needsToCreateAudioDecoder) { 1638 if (mAudioDecoder != NULL) { 1639 mAudioDecoder->pause(); 1640 mAudioDecoder.clear(); 1641 ++mAudioDecoderGeneration; 1642 } 1643 if (mFlushingAudio == FLUSHING_DECODER) { 1644 mFlushComplete[1 /* audio */][1 /* isDecoder */] = true; 1645 mFlushingAudio = FLUSHED; 1646 finishFlushIfPossible(); 1647 } else if (mFlushingAudio == FLUSHING_DECODER_SHUTDOWN 1648 || mFlushingAudio == SHUTTING_DOWN_DECODER) { 1649 mFlushComplete[1 /* audio */][1 /* isDecoder */] = true; 1650 mFlushingAudio = SHUT_DOWN; 1651 finishFlushIfPossible(); 1652 needsToCreateAudioDecoder = false; 1653 } 1654 if (mRenderer == NULL) { 1655 return; 1656 } 1657 closeAudioSink(); 1658 mRenderer->flush(true /* audio */, false /* notifyComplete */); 1659 if (mVideoDecoder != NULL) { 1660 mRenderer->flush(false /* audio */, false /* notifyComplete */); 1661 } 1662 1663 performSeek(currentPositionUs, MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC /* mode */); 1664 1665 if (forceNonOffload) { 1666 mRenderer->signalDisableOffloadAudio(); 1667 mOffloadAudio = false; 1668 } 1669 if (needsToCreateAudioDecoder) { 1670 instantiateDecoder(true /* audio */, &mAudioDecoder, !forceNonOffload); 1671 } 1672} 1673 1674void NuPlayer::determineAudioModeChange(const sp<AMessage> &audioFormat) { 1675 if (mSource == NULL || mAudioSink == NULL) { 1676 return; 1677 } 1678 1679 if (mRenderer == NULL) { 1680 ALOGW("No renderer can be used to determine audio mode. Use non-offload for safety."); 1681 mOffloadAudio = false; 1682 return; 1683 } 1684 1685 sp<MetaData> audioMeta = mSource->getFormatMeta(true /* audio */); 1686 sp<AMessage> videoFormat = mSource->getFormat(false /* audio */); 1687 audio_stream_type_t streamType = mAudioSink->getAudioStreamType(); 1688 const bool hasVideo = (videoFormat != NULL); 1689 bool canOffload = canOffloadStream( 1690 audioMeta, hasVideo, mSource->isStreaming(), streamType) 1691 && (mPlaybackSettings.mSpeed == 1.f && mPlaybackSettings.mPitch == 1.f); 1692 1693 // Modular DRM: Disabling audio offload if the source is protected 1694 if (canOffload && mIsDrmProtected) { 1695 canOffload = false; 1696 ALOGV("determineAudioModeChange: Disabling mOffloadAudio b/c the source is protected."); 1697 } 1698 1699 if (canOffload) { 1700 if (!mOffloadAudio) { 1701 mRenderer->signalEnableOffloadAudio(); 1702 } 1703 // open audio sink early under offload mode. 1704 tryOpenAudioSinkForOffload(audioFormat, audioMeta, hasVideo); 1705 } else { 1706 if (mOffloadAudio) { 1707 mRenderer->signalDisableOffloadAudio(); 1708 mOffloadAudio = false; 1709 } 1710 } 1711} 1712 1713status_t NuPlayer::instantiateDecoder( 1714 bool audio, sp<DecoderBase> *decoder, bool checkAudioModeChange) { 1715 // The audio decoder could be cleared by tear down. If still in shut down 1716 // process, no need to create a new audio decoder. 1717 if (*decoder != NULL || (audio && mFlushingAudio == SHUT_DOWN)) { 1718 return OK; 1719 } 1720 1721 sp<AMessage> format = mSource->getFormat(audio); 1722 1723 if (format == NULL) { 1724 return UNKNOWN_ERROR; 1725 } else { 1726 status_t err; 1727 if (format->findInt32("err", &err) && err) { 1728 return err; 1729 } 1730 } 1731 1732 format->setInt32("priority", 0 /* realtime */); 1733 1734 if (!audio) { 1735 AString mime; 1736 CHECK(format->findString("mime", &mime)); 1737 1738 sp<AMessage> ccNotify = new AMessage(kWhatClosedCaptionNotify, this); 1739 if (mCCDecoder == NULL) { 1740 mCCDecoder = new CCDecoder(ccNotify); 1741 } 1742 1743 if (mSourceFlags & Source::FLAG_SECURE) { 1744 format->setInt32("secure", true); 1745 } 1746 1747 if (mSourceFlags & Source::FLAG_PROTECTED) { 1748 format->setInt32("protected", true); 1749 } 1750 1751 float rate = getFrameRate(); 1752 if (rate > 0) { 1753 format->setFloat("operating-rate", rate * mPlaybackSettings.mSpeed); 1754 } 1755 } 1756 1757 if (audio) { 1758 sp<AMessage> notify = new AMessage(kWhatAudioNotify, this); 1759 ++mAudioDecoderGeneration; 1760 notify->setInt32("generation", mAudioDecoderGeneration); 1761 1762 if (checkAudioModeChange) { 1763 determineAudioModeChange(format); 1764 } 1765 if (mOffloadAudio) { 1766 mSource->setOffloadAudio(true /* offload */); 1767 1768 const bool hasVideo = (mSource->getFormat(false /*audio */) != NULL); 1769 format->setInt32("has-video", hasVideo); 1770 *decoder = new DecoderPassThrough(notify, mSource, mRenderer); 1771 ALOGV("instantiateDecoder audio DecoderPassThrough hasVideo: %d", hasVideo); 1772 } else { 1773 mSource->setOffloadAudio(false /* offload */); 1774 1775 *decoder = new Decoder(notify, mSource, mPID, mUID, mRenderer); 1776 ALOGV("instantiateDecoder audio Decoder"); 1777 } 1778 } else { 1779 sp<AMessage> notify = new AMessage(kWhatVideoNotify, this); 1780 ++mVideoDecoderGeneration; 1781 notify->setInt32("generation", mVideoDecoderGeneration); 1782 1783 *decoder = new Decoder( 1784 notify, mSource, mPID, mUID, mRenderer, mSurface, mCCDecoder); 1785 1786 // enable FRC if high-quality AV sync is requested, even if not 1787 // directly queuing to display, as this will even improve textureview 1788 // playback. 1789 { 1790 if (property_get_bool("persist.sys.media.avsync", false)) { 1791 format->setInt32("auto-frc", 1); 1792 } 1793 } 1794 } 1795 (*decoder)->init(); 1796 1797 // Modular DRM 1798 if (mIsDrmProtected) { 1799 format->setPointer("crypto", mCrypto.get()); 1800 ALOGV("instantiateDecoder: mCrypto: %p (%d) isSecure: %d", mCrypto.get(), 1801 (mCrypto != NULL ? mCrypto->getStrongCount() : 0), 1802 (mSourceFlags & Source::FLAG_SECURE) != 0); 1803 } 1804 1805 (*decoder)->configure(format); 1806 1807 if (!audio) { 1808 sp<AMessage> params = new AMessage(); 1809 float rate = getFrameRate(); 1810 if (rate > 0) { 1811 params->setFloat("frame-rate-total", rate); 1812 } 1813 1814 sp<MetaData> fileMeta = getFileMeta(); 1815 if (fileMeta != NULL) { 1816 int32_t videoTemporalLayerCount; 1817 if (fileMeta->findInt32(kKeyTemporalLayerCount, &videoTemporalLayerCount) 1818 && videoTemporalLayerCount > 0) { 1819 params->setInt32("temporal-layer-count", videoTemporalLayerCount); 1820 } 1821 } 1822 1823 if (params->countEntries() > 0) { 1824 (*decoder)->setParameters(params); 1825 } 1826 } 1827 return OK; 1828} 1829 1830void NuPlayer::updateVideoSize( 1831 const sp<AMessage> &inputFormat, 1832 const sp<AMessage> &outputFormat) { 1833 if (inputFormat == NULL) { 1834 ALOGW("Unknown video size, reporting 0x0!"); 1835 notifyListener(MEDIA_SET_VIDEO_SIZE, 0, 0); 1836 return; 1837 } 1838 int32_t err = OK; 1839 inputFormat->findInt32("err", &err); 1840 if (err == -EWOULDBLOCK) { 1841 ALOGW("Video meta is not available yet!"); 1842 return; 1843 } 1844 if (err != OK) { 1845 ALOGW("Something is wrong with video meta!"); 1846 return; 1847 } 1848 1849 int32_t displayWidth, displayHeight; 1850 if (outputFormat != NULL) { 1851 int32_t width, height; 1852 CHECK(outputFormat->findInt32("width", &width)); 1853 CHECK(outputFormat->findInt32("height", &height)); 1854 1855 int32_t cropLeft, cropTop, cropRight, cropBottom; 1856 CHECK(outputFormat->findRect( 1857 "crop", 1858 &cropLeft, &cropTop, &cropRight, &cropBottom)); 1859 1860 displayWidth = cropRight - cropLeft + 1; 1861 displayHeight = cropBottom - cropTop + 1; 1862 1863 ALOGV("Video output format changed to %d x %d " 1864 "(crop: %d x %d @ (%d, %d))", 1865 width, height, 1866 displayWidth, 1867 displayHeight, 1868 cropLeft, cropTop); 1869 } else { 1870 CHECK(inputFormat->findInt32("width", &displayWidth)); 1871 CHECK(inputFormat->findInt32("height", &displayHeight)); 1872 1873 ALOGV("Video input format %d x %d", displayWidth, displayHeight); 1874 } 1875 1876 // Take into account sample aspect ratio if necessary: 1877 int32_t sarWidth, sarHeight; 1878 if (inputFormat->findInt32("sar-width", &sarWidth) 1879 && inputFormat->findInt32("sar-height", &sarHeight) 1880 && sarWidth > 0 && sarHeight > 0) { 1881 ALOGV("Sample aspect ratio %d : %d", sarWidth, sarHeight); 1882 1883 displayWidth = (displayWidth * sarWidth) / sarHeight; 1884 1885 ALOGV("display dimensions %d x %d", displayWidth, displayHeight); 1886 } else { 1887 int32_t width, height; 1888 if (inputFormat->findInt32("display-width", &width) 1889 && inputFormat->findInt32("display-height", &height) 1890 && width > 0 && height > 0 1891 && displayWidth > 0 && displayHeight > 0) { 1892 if (displayHeight * (int64_t)width / height > (int64_t)displayWidth) { 1893 displayHeight = (int32_t)(displayWidth * (int64_t)height / width); 1894 } else { 1895 displayWidth = (int32_t)(displayHeight * (int64_t)width / height); 1896 } 1897 ALOGV("Video display width and height are overridden to %d x %d", 1898 displayWidth, displayHeight); 1899 } 1900 } 1901 1902 int32_t rotationDegrees; 1903 if (!inputFormat->findInt32("rotation-degrees", &rotationDegrees)) { 1904 rotationDegrees = 0; 1905 } 1906 1907 if (rotationDegrees == 90 || rotationDegrees == 270) { 1908 int32_t tmp = displayWidth; 1909 displayWidth = displayHeight; 1910 displayHeight = tmp; 1911 } 1912 1913 notifyListener( 1914 MEDIA_SET_VIDEO_SIZE, 1915 displayWidth, 1916 displayHeight); 1917} 1918 1919void NuPlayer::notifyListener(int msg, int ext1, int ext2, const Parcel *in) { 1920 if (mDriver == NULL) { 1921 return; 1922 } 1923 1924 sp<NuPlayerDriver> driver = mDriver.promote(); 1925 1926 if (driver == NULL) { 1927 return; 1928 } 1929 1930 driver->notifyListener(msg, ext1, ext2, in); 1931} 1932 1933void NuPlayer::flushDecoder(bool audio, bool needShutdown) { 1934 ALOGV("[%s] flushDecoder needShutdown=%d", 1935 audio ? "audio" : "video", needShutdown); 1936 1937 const sp<DecoderBase> &decoder = getDecoder(audio); 1938 if (decoder == NULL) { 1939 ALOGI("flushDecoder %s without decoder present", 1940 audio ? "audio" : "video"); 1941 return; 1942 } 1943 1944 // Make sure we don't continue to scan sources until we finish flushing. 1945 ++mScanSourcesGeneration; 1946 if (mScanSourcesPending) { 1947 if (!needShutdown) { 1948 mDeferredActions.push_back( 1949 new SimpleAction(&NuPlayer::performScanSources)); 1950 } 1951 mScanSourcesPending = false; 1952 } 1953 1954 decoder->signalFlush(); 1955 1956 FlushStatus newStatus = 1957 needShutdown ? FLUSHING_DECODER_SHUTDOWN : FLUSHING_DECODER; 1958 1959 mFlushComplete[audio][false /* isDecoder */] = (mRenderer == NULL); 1960 mFlushComplete[audio][true /* isDecoder */] = false; 1961 if (audio) { 1962 ALOGE_IF(mFlushingAudio != NONE, 1963 "audio flushDecoder() is called in state %d", mFlushingAudio); 1964 mFlushingAudio = newStatus; 1965 } else { 1966 ALOGE_IF(mFlushingVideo != NONE, 1967 "video flushDecoder() is called in state %d", mFlushingVideo); 1968 mFlushingVideo = newStatus; 1969 } 1970} 1971 1972void NuPlayer::queueDecoderShutdown( 1973 bool audio, bool video, const sp<AMessage> &reply) { 1974 ALOGI("queueDecoderShutdown audio=%d, video=%d", audio, video); 1975 1976 mDeferredActions.push_back( 1977 new FlushDecoderAction( 1978 audio ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE, 1979 video ? FLUSH_CMD_SHUTDOWN : FLUSH_CMD_NONE)); 1980 1981 mDeferredActions.push_back( 1982 new SimpleAction(&NuPlayer::performScanSources)); 1983 1984 mDeferredActions.push_back(new PostMessageAction(reply)); 1985 1986 processDeferredActions(); 1987} 1988 1989status_t NuPlayer::setVideoScalingMode(int32_t mode) { 1990 mVideoScalingMode = mode; 1991 if (mSurface != NULL) { 1992 status_t ret = native_window_set_scaling_mode(mSurface.get(), mVideoScalingMode); 1993 if (ret != OK) { 1994 ALOGE("Failed to set scaling mode (%d): %s", 1995 -ret, strerror(-ret)); 1996 return ret; 1997 } 1998 } 1999 return OK; 2000} 2001 2002status_t NuPlayer::getTrackInfo(Parcel* reply) const { 2003 sp<AMessage> msg = new AMessage(kWhatGetTrackInfo, this); 2004 msg->setPointer("reply", reply); 2005 2006 sp<AMessage> response; 2007 status_t err = msg->postAndAwaitResponse(&response); 2008 return err; 2009} 2010 2011status_t NuPlayer::getSelectedTrack(int32_t type, Parcel* reply) const { 2012 sp<AMessage> msg = new AMessage(kWhatGetSelectedTrack, this); 2013 msg->setPointer("reply", reply); 2014 msg->setInt32("type", type); 2015 2016 sp<AMessage> response; 2017 status_t err = msg->postAndAwaitResponse(&response); 2018 if (err == OK && response != NULL) { 2019 CHECK(response->findInt32("err", &err)); 2020 } 2021 return err; 2022} 2023 2024status_t NuPlayer::selectTrack(size_t trackIndex, bool select, int64_t timeUs) { 2025 sp<AMessage> msg = new AMessage(kWhatSelectTrack, this); 2026 msg->setSize("trackIndex", trackIndex); 2027 msg->setInt32("select", select); 2028 msg->setInt64("timeUs", timeUs); 2029 2030 sp<AMessage> response; 2031 status_t err = msg->postAndAwaitResponse(&response); 2032 2033 if (err != OK) { 2034 return err; 2035 } 2036 2037 if (!response->findInt32("err", &err)) { 2038 err = OK; 2039 } 2040 2041 return err; 2042} 2043 2044status_t NuPlayer::getCurrentPosition(int64_t *mediaUs) { 2045 sp<Renderer> renderer = mRenderer; 2046 if (renderer == NULL) { 2047 return NO_INIT; 2048 } 2049 2050 return renderer->getCurrentPosition(mediaUs); 2051} 2052 2053void NuPlayer::getStats(Vector<sp<AMessage> > *mTrackStats) { 2054 CHECK(mTrackStats != NULL); 2055 2056 mTrackStats->clear(); 2057 if (mVideoDecoder != NULL) { 2058 mTrackStats->push_back(mVideoDecoder->getStats()); 2059 } 2060 if (mAudioDecoder != NULL) { 2061 mTrackStats->push_back(mAudioDecoder->getStats()); 2062 } 2063} 2064 2065sp<MetaData> NuPlayer::getFileMeta() { 2066 return mSource->getFileFormatMeta(); 2067} 2068 2069float NuPlayer::getFrameRate() { 2070 sp<MetaData> meta = mSource->getFormatMeta(false /* audio */); 2071 if (meta == NULL) { 2072 return 0; 2073 } 2074 int32_t rate; 2075 if (!meta->findInt32(kKeyFrameRate, &rate)) { 2076 // fall back to try file meta 2077 sp<MetaData> fileMeta = getFileMeta(); 2078 if (fileMeta == NULL) { 2079 ALOGW("source has video meta but not file meta"); 2080 return -1; 2081 } 2082 int32_t fileMetaRate; 2083 if (!fileMeta->findInt32(kKeyFrameRate, &fileMetaRate)) { 2084 return -1; 2085 } 2086 return fileMetaRate; 2087 } 2088 return rate; 2089} 2090 2091void NuPlayer::schedulePollDuration() { 2092 sp<AMessage> msg = new AMessage(kWhatPollDuration, this); 2093 msg->setInt32("generation", mPollDurationGeneration); 2094 msg->post(); 2095} 2096 2097void NuPlayer::cancelPollDuration() { 2098 ++mPollDurationGeneration; 2099} 2100 2101void NuPlayer::processDeferredActions() { 2102 while (!mDeferredActions.empty()) { 2103 // We won't execute any deferred actions until we're no longer in 2104 // an intermediate state, i.e. one more more decoders are currently 2105 // flushing or shutting down. 2106 2107 if (mFlushingAudio != NONE || mFlushingVideo != NONE) { 2108 // We're currently flushing, postpone the reset until that's 2109 // completed. 2110 2111 ALOGV("postponing action mFlushingAudio=%d, mFlushingVideo=%d", 2112 mFlushingAudio, mFlushingVideo); 2113 2114 break; 2115 } 2116 2117 sp<Action> action = *mDeferredActions.begin(); 2118 mDeferredActions.erase(mDeferredActions.begin()); 2119 2120 action->execute(this); 2121 } 2122} 2123 2124void NuPlayer::performSeek(int64_t seekTimeUs, MediaPlayerSeekMode mode) { 2125 ALOGV("performSeek seekTimeUs=%lld us (%.2f secs), mode=%d", 2126 (long long)seekTimeUs, seekTimeUs / 1E6, mode); 2127 2128 if (mSource == NULL) { 2129 // This happens when reset occurs right before the loop mode 2130 // asynchronously seeks to the start of the stream. 2131 LOG_ALWAYS_FATAL_IF(mAudioDecoder != NULL || mVideoDecoder != NULL, 2132 "mSource is NULL and decoders not NULL audio(%p) video(%p)", 2133 mAudioDecoder.get(), mVideoDecoder.get()); 2134 return; 2135 } 2136 mPreviousSeekTimeUs = seekTimeUs; 2137 mSource->seekTo(seekTimeUs, mode); 2138 ++mTimedTextGeneration; 2139 2140 // everything's flushed, continue playback. 2141} 2142 2143void NuPlayer::performDecoderFlush(FlushCommand audio, FlushCommand video) { 2144 ALOGV("performDecoderFlush audio=%d, video=%d", audio, video); 2145 2146 if ((audio == FLUSH_CMD_NONE || mAudioDecoder == NULL) 2147 && (video == FLUSH_CMD_NONE || mVideoDecoder == NULL)) { 2148 return; 2149 } 2150 2151 if (audio != FLUSH_CMD_NONE && mAudioDecoder != NULL) { 2152 flushDecoder(true /* audio */, (audio == FLUSH_CMD_SHUTDOWN)); 2153 } 2154 2155 if (video != FLUSH_CMD_NONE && mVideoDecoder != NULL) { 2156 flushDecoder(false /* audio */, (video == FLUSH_CMD_SHUTDOWN)); 2157 } 2158} 2159 2160void NuPlayer::performReset() { 2161 ALOGV("performReset"); 2162 2163 CHECK(mAudioDecoder == NULL); 2164 CHECK(mVideoDecoder == NULL); 2165 2166 cancelPollDuration(); 2167 2168 ++mScanSourcesGeneration; 2169 mScanSourcesPending = false; 2170 2171 if (mRendererLooper != NULL) { 2172 if (mRenderer != NULL) { 2173 mRendererLooper->unregisterHandler(mRenderer->id()); 2174 } 2175 mRendererLooper->stop(); 2176 mRendererLooper.clear(); 2177 } 2178 mRenderer.clear(); 2179 ++mRendererGeneration; 2180 2181 if (mSource != NULL) { 2182 mSource->stop(); 2183 2184 Mutex::Autolock autoLock(mSourceLock); 2185 mSource.clear(); 2186 } 2187 2188 if (mDriver != NULL) { 2189 sp<NuPlayerDriver> driver = mDriver.promote(); 2190 if (driver != NULL) { 2191 driver->notifyResetComplete(); 2192 } 2193 } 2194 2195 mStarted = false; 2196 mPrepared = false; 2197 mResetting = false; 2198 mSourceStarted = false; 2199 2200 // Modular DRM 2201 if (mCrypto != NULL) { 2202 // decoders will be flushed before this so their mCrypto would go away on their own 2203 // TODO change to ALOGV 2204 ALOGD("performReset mCrypto: %p (%d)", mCrypto.get(), 2205 (mCrypto != NULL ? mCrypto->getStrongCount() : 0)); 2206 mCrypto.clear(); 2207 } 2208 mIsDrmProtected = false; 2209} 2210 2211void NuPlayer::performScanSources() { 2212 ALOGV("performScanSources"); 2213 2214 if (!mStarted) { 2215 return; 2216 } 2217 2218 if (mAudioDecoder == NULL || mVideoDecoder == NULL) { 2219 postScanSources(); 2220 } 2221} 2222 2223void NuPlayer::performSetSurface(const sp<Surface> &surface) { 2224 ALOGV("performSetSurface"); 2225 2226 mSurface = surface; 2227 2228 // XXX - ignore error from setVideoScalingMode for now 2229 setVideoScalingMode(mVideoScalingMode); 2230 2231 if (mDriver != NULL) { 2232 sp<NuPlayerDriver> driver = mDriver.promote(); 2233 if (driver != NULL) { 2234 driver->notifySetSurfaceComplete(); 2235 } 2236 } 2237} 2238 2239void NuPlayer::performResumeDecoders(bool needNotify) { 2240 if (needNotify) { 2241 mResumePending = true; 2242 if (mVideoDecoder == NULL) { 2243 // if audio-only, we can notify seek complete now, 2244 // as the resume operation will be relatively fast. 2245 finishResume(); 2246 } 2247 } 2248 2249 if (mVideoDecoder != NULL) { 2250 // When there is continuous seek, MediaPlayer will cache the seek 2251 // position, and send down new seek request when previous seek is 2252 // complete. Let's wait for at least one video output frame before 2253 // notifying seek complete, so that the video thumbnail gets updated 2254 // when seekbar is dragged. 2255 mVideoDecoder->signalResume(needNotify); 2256 } 2257 2258 if (mAudioDecoder != NULL) { 2259 mAudioDecoder->signalResume(false /* needNotify */); 2260 } 2261} 2262 2263void NuPlayer::finishResume() { 2264 if (mResumePending) { 2265 mResumePending = false; 2266 notifyDriverSeekComplete(); 2267 } 2268} 2269 2270void NuPlayer::notifyDriverSeekComplete() { 2271 if (mDriver != NULL) { 2272 sp<NuPlayerDriver> driver = mDriver.promote(); 2273 if (driver != NULL) { 2274 driver->notifySeekComplete(); 2275 } 2276 } 2277} 2278 2279void NuPlayer::onSourceNotify(const sp<AMessage> &msg) { 2280 int32_t what; 2281 CHECK(msg->findInt32("what", &what)); 2282 2283 switch (what) { 2284 case Source::kWhatInstantiateSecureDecoders: 2285 { 2286 if (mSource == NULL) { 2287 // This is a stale notification from a source that was 2288 // asynchronously preparing when the client called reset(). 2289 // We handled the reset, the source is gone. 2290 break; 2291 } 2292 2293 sp<AMessage> reply; 2294 CHECK(msg->findMessage("reply", &reply)); 2295 status_t err = onInstantiateSecureDecoders(); 2296 reply->setInt32("err", err); 2297 reply->post(); 2298 break; 2299 } 2300 2301 case Source::kWhatPrepared: 2302 { 2303 ALOGV("NuPlayer::onSourceNotify Source::kWhatPrepared source: %p", mSource.get()); 2304 if (mSource == NULL) { 2305 // This is a stale notification from a source that was 2306 // asynchronously preparing when the client called reset(). 2307 // We handled the reset, the source is gone. 2308 break; 2309 } 2310 2311 int32_t err; 2312 CHECK(msg->findInt32("err", &err)); 2313 2314 if (err != OK) { 2315 // shut down potential secure codecs in case client never calls reset 2316 mDeferredActions.push_back( 2317 new FlushDecoderAction(FLUSH_CMD_SHUTDOWN /* audio */, 2318 FLUSH_CMD_SHUTDOWN /* video */)); 2319 processDeferredActions(); 2320 } else { 2321 mPrepared = true; 2322 } 2323 2324 sp<NuPlayerDriver> driver = mDriver.promote(); 2325 if (driver != NULL) { 2326 // notify duration first, so that it's definitely set when 2327 // the app received the "prepare complete" callback. 2328 int64_t durationUs; 2329 if (mSource->getDuration(&durationUs) == OK) { 2330 driver->notifyDuration(durationUs); 2331 } 2332 driver->notifyPrepareCompleted(err); 2333 } 2334 2335 break; 2336 } 2337 2338 // Modular DRM 2339 case Source::kWhatDrmInfo: 2340 { 2341 Parcel parcel; 2342 sp<ABuffer> drmInfo; 2343 CHECK(msg->findBuffer("drmInfo", &drmInfo)); 2344 parcel.setData(drmInfo->data(), drmInfo->size()); 2345 2346 ALOGV("onSourceNotify() kWhatDrmInfo MEDIA_DRM_INFO drmInfo: %p parcel size: %zu", 2347 drmInfo.get(), parcel.dataSize()); 2348 2349 notifyListener(MEDIA_DRM_INFO, 0 /* ext1 */, 0 /* ext2 */, &parcel); 2350 2351 break; 2352 } 2353 2354 case Source::kWhatFlagsChanged: 2355 { 2356 uint32_t flags; 2357 CHECK(msg->findInt32("flags", (int32_t *)&flags)); 2358 2359 sp<NuPlayerDriver> driver = mDriver.promote(); 2360 if (driver != NULL) { 2361 2362 ALOGV("onSourceNotify() kWhatFlagsChanged FLAG_CAN_PAUSE: %d " 2363 "FLAG_CAN_SEEK_BACKWARD: %d \n\t\t\t\t FLAG_CAN_SEEK_FORWARD: %d " 2364 "FLAG_CAN_SEEK: %d FLAG_DYNAMIC_DURATION: %d \n" 2365 "\t\t\t\t FLAG_SECURE: %d FLAG_PROTECTED: %d", 2366 (flags & Source::FLAG_CAN_PAUSE) != 0, 2367 (flags & Source::FLAG_CAN_SEEK_BACKWARD) != 0, 2368 (flags & Source::FLAG_CAN_SEEK_FORWARD) != 0, 2369 (flags & Source::FLAG_CAN_SEEK) != 0, 2370 (flags & Source::FLAG_DYNAMIC_DURATION) != 0, 2371 (flags & Source::FLAG_SECURE) != 0, 2372 (flags & Source::FLAG_PROTECTED) != 0); 2373 2374 if ((flags & NuPlayer::Source::FLAG_CAN_SEEK) == 0) { 2375 driver->notifyListener( 2376 MEDIA_INFO, MEDIA_INFO_NOT_SEEKABLE, 0); 2377 } 2378 driver->notifyFlagsChanged(flags); 2379 } 2380 2381 if ((mSourceFlags & Source::FLAG_DYNAMIC_DURATION) 2382 && (!(flags & Source::FLAG_DYNAMIC_DURATION))) { 2383 cancelPollDuration(); 2384 } else if (!(mSourceFlags & Source::FLAG_DYNAMIC_DURATION) 2385 && (flags & Source::FLAG_DYNAMIC_DURATION) 2386 && (mAudioDecoder != NULL || mVideoDecoder != NULL)) { 2387 schedulePollDuration(); 2388 } 2389 2390 mSourceFlags = flags; 2391 break; 2392 } 2393 2394 case Source::kWhatVideoSizeChanged: 2395 { 2396 sp<AMessage> format; 2397 CHECK(msg->findMessage("format", &format)); 2398 2399 updateVideoSize(format); 2400 break; 2401 } 2402 2403 case Source::kWhatBufferingUpdate: 2404 { 2405 int32_t percentage; 2406 CHECK(msg->findInt32("percentage", &percentage)); 2407 2408 notifyListener(MEDIA_BUFFERING_UPDATE, percentage, 0); 2409 break; 2410 } 2411 2412 case Source::kWhatPauseOnBufferingStart: 2413 { 2414 // ignore if not playing 2415 if (mStarted) { 2416 ALOGI("buffer low, pausing..."); 2417 2418 mPausedForBuffering = true; 2419 onPause(); 2420 } 2421 notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_START, 0); 2422 break; 2423 } 2424 2425 case Source::kWhatResumeOnBufferingEnd: 2426 { 2427 // ignore if not playing 2428 if (mStarted) { 2429 ALOGI("buffer ready, resuming..."); 2430 2431 mPausedForBuffering = false; 2432 2433 // do not resume yet if client didn't unpause 2434 if (!mPausedByClient) { 2435 onResume(); 2436 } 2437 } 2438 notifyListener(MEDIA_INFO, MEDIA_INFO_BUFFERING_END, 0); 2439 break; 2440 } 2441 2442 case Source::kWhatCacheStats: 2443 { 2444 int32_t kbps; 2445 CHECK(msg->findInt32("bandwidth", &kbps)); 2446 2447 notifyListener(MEDIA_INFO, MEDIA_INFO_NETWORK_BANDWIDTH, kbps); 2448 break; 2449 } 2450 2451 case Source::kWhatSubtitleData: 2452 { 2453 sp<ABuffer> buffer; 2454 CHECK(msg->findBuffer("buffer", &buffer)); 2455 2456 sendSubtitleData(buffer, 0 /* baseIndex */); 2457 break; 2458 } 2459 2460 case Source::kWhatTimedMetaData: 2461 { 2462 sp<ABuffer> buffer; 2463 if (!msg->findBuffer("buffer", &buffer)) { 2464 notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0); 2465 } else { 2466 sendTimedMetaData(buffer); 2467 } 2468 break; 2469 } 2470 2471 case Source::kWhatTimedTextData: 2472 { 2473 int32_t generation; 2474 if (msg->findInt32("generation", &generation) 2475 && generation != mTimedTextGeneration) { 2476 break; 2477 } 2478 2479 sp<ABuffer> buffer; 2480 CHECK(msg->findBuffer("buffer", &buffer)); 2481 2482 sp<NuPlayerDriver> driver = mDriver.promote(); 2483 if (driver == NULL) { 2484 break; 2485 } 2486 2487 int posMs; 2488 int64_t timeUs, posUs; 2489 driver->getCurrentPosition(&posMs); 2490 posUs = (int64_t) posMs * 1000ll; 2491 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2492 2493 if (posUs < timeUs) { 2494 if (!msg->findInt32("generation", &generation)) { 2495 msg->setInt32("generation", mTimedTextGeneration); 2496 } 2497 msg->post(timeUs - posUs); 2498 } else { 2499 sendTimedTextData(buffer); 2500 } 2501 break; 2502 } 2503 2504 case Source::kWhatQueueDecoderShutdown: 2505 { 2506 int32_t audio, video; 2507 CHECK(msg->findInt32("audio", &audio)); 2508 CHECK(msg->findInt32("video", &video)); 2509 2510 sp<AMessage> reply; 2511 CHECK(msg->findMessage("reply", &reply)); 2512 2513 queueDecoderShutdown(audio, video, reply); 2514 break; 2515 } 2516 2517 case Source::kWhatDrmNoLicense: 2518 { 2519 notifyListener(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN, ERROR_DRM_NO_LICENSE); 2520 break; 2521 } 2522 2523 default: 2524 TRESPASS(); 2525 } 2526} 2527 2528void NuPlayer::onClosedCaptionNotify(const sp<AMessage> &msg) { 2529 int32_t what; 2530 CHECK(msg->findInt32("what", &what)); 2531 2532 switch (what) { 2533 case NuPlayer::CCDecoder::kWhatClosedCaptionData: 2534 { 2535 sp<ABuffer> buffer; 2536 CHECK(msg->findBuffer("buffer", &buffer)); 2537 2538 size_t inbandTracks = 0; 2539 if (mSource != NULL) { 2540 inbandTracks = mSource->getTrackCount(); 2541 } 2542 2543 sendSubtitleData(buffer, inbandTracks); 2544 break; 2545 } 2546 2547 case NuPlayer::CCDecoder::kWhatTrackAdded: 2548 { 2549 notifyListener(MEDIA_INFO, MEDIA_INFO_METADATA_UPDATE, 0); 2550 2551 break; 2552 } 2553 2554 default: 2555 TRESPASS(); 2556 } 2557 2558 2559} 2560 2561void NuPlayer::sendSubtitleData(const sp<ABuffer> &buffer, int32_t baseIndex) { 2562 int32_t trackIndex; 2563 int64_t timeUs, durationUs; 2564 CHECK(buffer->meta()->findInt32("trackIndex", &trackIndex)); 2565 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2566 CHECK(buffer->meta()->findInt64("durationUs", &durationUs)); 2567 2568 Parcel in; 2569 in.writeInt32(trackIndex + baseIndex); 2570 in.writeInt64(timeUs); 2571 in.writeInt64(durationUs); 2572 in.writeInt32(buffer->size()); 2573 in.writeInt32(buffer->size()); 2574 in.write(buffer->data(), buffer->size()); 2575 2576 notifyListener(MEDIA_SUBTITLE_DATA, 0, 0, &in); 2577} 2578 2579void NuPlayer::sendTimedMetaData(const sp<ABuffer> &buffer) { 2580 int64_t timeUs; 2581 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2582 2583 Parcel in; 2584 in.writeInt64(timeUs); 2585 in.writeInt32(buffer->size()); 2586 in.writeInt32(buffer->size()); 2587 in.write(buffer->data(), buffer->size()); 2588 2589 notifyListener(MEDIA_META_DATA, 0, 0, &in); 2590} 2591 2592void NuPlayer::sendTimedTextData(const sp<ABuffer> &buffer) { 2593 const void *data; 2594 size_t size = 0; 2595 int64_t timeUs; 2596 int32_t flag = TextDescriptions::IN_BAND_TEXT_3GPP; 2597 2598 AString mime; 2599 CHECK(buffer->meta()->findString("mime", &mime)); 2600 CHECK(strcasecmp(mime.c_str(), MEDIA_MIMETYPE_TEXT_3GPP) == 0); 2601 2602 data = buffer->data(); 2603 size = buffer->size(); 2604 2605 Parcel parcel; 2606 if (size > 0) { 2607 CHECK(buffer->meta()->findInt64("timeUs", &timeUs)); 2608 int32_t global = 0; 2609 if (buffer->meta()->findInt32("global", &global) && global) { 2610 flag |= TextDescriptions::GLOBAL_DESCRIPTIONS; 2611 } else { 2612 flag |= TextDescriptions::LOCAL_DESCRIPTIONS; 2613 } 2614 TextDescriptions::getParcelOfDescriptions( 2615 (const uint8_t *)data, size, flag, timeUs / 1000, &parcel); 2616 } 2617 2618 if ((parcel.dataSize() > 0)) { 2619 notifyListener(MEDIA_TIMED_TEXT, 0, 0, &parcel); 2620 } else { // send an empty timed text 2621 notifyListener(MEDIA_TIMED_TEXT, 0, 0); 2622 } 2623} 2624 2625// Modular DRM begin 2626status_t NuPlayer::prepareDrm(const uint8_t uuid[16], const Vector<uint8_t> &drmSessionId) 2627{ 2628 ALOGV("prepareDrm "); 2629 2630 // Passing to the looper anyway; called in a pre-config prepared state so no race on mCrypto 2631 sp<AMessage> msg = new AMessage(kWhatPrepareDrm, this); 2632 // synchronous call so just passing the address but with local copies of "const" args 2633 uint8_t UUID[16]; 2634 memcpy(UUID, uuid, sizeof(UUID)); 2635 Vector<uint8_t> sessionId = drmSessionId; 2636 msg->setPointer("uuid", (void*)UUID); 2637 msg->setPointer("drmSessionId", (void*)&sessionId); 2638 2639 sp<AMessage> response; 2640 status_t status = msg->postAndAwaitResponse(&response); 2641 2642 if (status == OK && response != NULL) { 2643 CHECK(response->findInt32("status", &status)); 2644 ALOGV("prepareDrm ret: %d ", status); 2645 } else { 2646 ALOGE("prepareDrm err: %d", status); 2647 } 2648 2649 return status; 2650} 2651 2652status_t NuPlayer::releaseDrm() 2653{ 2654 ALOGV("releaseDrm "); 2655 2656 sp<AMessage> msg = new AMessage(kWhatReleaseDrm, this); 2657 2658 sp<AMessage> response; 2659 status_t status = msg->postAndAwaitResponse(&response); 2660 2661 if (status == OK && response != NULL) { 2662 CHECK(response->findInt32("status", &status)); 2663 ALOGV("releaseDrm ret: %d ", status); 2664 } else { 2665 ALOGE("releaseDrm err: %d", status); 2666 } 2667 2668 return status; 2669} 2670 2671status_t NuPlayer::onPrepareDrm(const sp<AMessage> &msg) 2672{ 2673 // TODO change to ALOGV 2674 ALOGD("onPrepareDrm "); 2675 2676 status_t status = INVALID_OPERATION; 2677 if (mSource == NULL) { 2678 ALOGE("onPrepareDrm: No source. onPrepareDrm failed with %d.", status); 2679 return status; 2680 } 2681 2682 uint8_t *uuid; 2683 Vector<uint8_t> *drmSessionId; 2684 CHECK(msg->findPointer("uuid", (void**)&uuid)); 2685 CHECK(msg->findPointer("drmSessionId", (void**)&drmSessionId)); 2686 2687 status = OK; 2688 sp<ICrypto> crypto = NULL; 2689 2690 status = mSource->prepareDrm(uuid, *drmSessionId, &crypto); 2691 if (crypto == NULL) { 2692 ALOGE("onPrepareDrm: mSource->prepareDrm failed. status: %d", status); 2693 return status; 2694 } 2695 ALOGV("onPrepareDrm: mSource->prepareDrm succeeded"); 2696 2697 if (mCrypto != NULL) { 2698 ALOGE("onPrepareDrm: Unexpected. Already having mCrypto: %p (%d)", 2699 mCrypto.get(), mCrypto->getStrongCount()); 2700 mCrypto.clear(); 2701 } 2702 2703 mCrypto = crypto; 2704 mIsDrmProtected = true; 2705 // TODO change to ALOGV 2706 ALOGD("onPrepareDrm: mCrypto: %p (%d)", mCrypto.get(), 2707 (mCrypto != NULL ? mCrypto->getStrongCount() : 0)); 2708 2709 return status; 2710} 2711 2712status_t NuPlayer::onReleaseDrm() 2713{ 2714 // TODO change to ALOGV 2715 ALOGD("onReleaseDrm "); 2716 2717 if (!mIsDrmProtected) { 2718 ALOGW("onReleaseDrm: Unexpected. mIsDrmProtected is already false."); 2719 } 2720 2721 mIsDrmProtected = false; 2722 2723 status_t status; 2724 if (mCrypto != NULL) { 2725 status=OK; 2726 // first making sure the codecs have released their crypto reference 2727 const sp<DecoderBase> &videoDecoder = getDecoder(false/*audio*/); 2728 if (videoDecoder != NULL) { 2729 status = videoDecoder->releaseCrypto(); 2730 ALOGV("onReleaseDrm: video decoder ret: %d", status); 2731 } 2732 2733 const sp<DecoderBase> &audioDecoder = getDecoder(true/*audio*/); 2734 if (audioDecoder != NULL) { 2735 status_t status_audio = audioDecoder->releaseCrypto(); 2736 if (status == OK) { // otherwise, returning the first error 2737 status = status_audio; 2738 } 2739 ALOGV("onReleaseDrm: audio decoder ret: %d", status_audio); 2740 } 2741 2742 // TODO change to ALOGV 2743 ALOGD("onReleaseDrm: mCrypto: %p (%d)", mCrypto.get(), 2744 (mCrypto != NULL ? mCrypto->getStrongCount() : 0)); 2745 mCrypto.clear(); 2746 } else { // mCrypto == NULL 2747 ALOGE("onReleaseDrm: Unexpected. There is no crypto."); 2748 status = INVALID_OPERATION; 2749 } 2750 2751 return status; 2752} 2753// Modular DRM end 2754//////////////////////////////////////////////////////////////////////////////// 2755 2756sp<AMessage> NuPlayer::Source::getFormat(bool audio) { 2757 sp<MetaData> meta = getFormatMeta(audio); 2758 2759 if (meta == NULL) { 2760 return NULL; 2761 } 2762 2763 sp<AMessage> msg = new AMessage; 2764 2765 if(convertMetaDataToMessage(meta, &msg) == OK) { 2766 return msg; 2767 } 2768 return NULL; 2769} 2770 2771void NuPlayer::Source::notifyFlagsChanged(uint32_t flags) { 2772 sp<AMessage> notify = dupNotify(); 2773 notify->setInt32("what", kWhatFlagsChanged); 2774 notify->setInt32("flags", flags); 2775 notify->post(); 2776} 2777 2778void NuPlayer::Source::notifyVideoSizeChanged(const sp<AMessage> &format) { 2779 sp<AMessage> notify = dupNotify(); 2780 notify->setInt32("what", kWhatVideoSizeChanged); 2781 notify->setMessage("format", format); 2782 notify->post(); 2783} 2784 2785void NuPlayer::Source::notifyPrepared(status_t err) { 2786 ALOGV("Source::notifyPrepared %d", err); 2787 sp<AMessage> notify = dupNotify(); 2788 notify->setInt32("what", kWhatPrepared); 2789 notify->setInt32("err", err); 2790 notify->post(); 2791} 2792 2793void NuPlayer::Source::notifyDrmInfo(const sp<ABuffer> &drmInfoBuffer) 2794{ 2795 ALOGV("Source::notifyDrmInfo"); 2796 2797 sp<AMessage> notify = dupNotify(); 2798 notify->setInt32("what", kWhatDrmInfo); 2799 notify->setBuffer("drmInfo", drmInfoBuffer); 2800 2801 notify->post(); 2802} 2803 2804void NuPlayer::Source::notifyInstantiateSecureDecoders(const sp<AMessage> &reply) { 2805 sp<AMessage> notify = dupNotify(); 2806 notify->setInt32("what", kWhatInstantiateSecureDecoders); 2807 notify->setMessage("reply", reply); 2808 notify->post(); 2809} 2810 2811void NuPlayer::Source::onMessageReceived(const sp<AMessage> & /* msg */) { 2812 TRESPASS(); 2813} 2814 2815} // namespace android 2816