/*
**
** Copyright 2017, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaPlayer2Native"
#include <android/binder_ibinder.h>
#include <media/AudioSystem.h>
#include <media/DataSourceDesc.h>
#include <media/MemoryLeakTrackUtil.h>
#include <media/NdkWrapper.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/foundation/ALooperRoster.h>
#include <mediaplayer2/MediaPlayer2AudioOutput.h>
#include <mediaplayer2/mediaplayer2.h>
#include <utils/Log.h>
#include <utils/SortedVector.h>
#include <utils/String8.h>
#include <system/audio.h>
#include <system/window.h>
#include <nuplayer2/NuPlayer2Driver.h>
#include <dirent.h>
#include <sys/stat.h>
namespace android {
extern ALooperRoster gLooperRoster;
namespace {
const int kDumpLockRetries = 50;
const int kDumpLockSleepUs = 20000;
class proxyListener : public MediaPlayer2InterfaceListener {
public:
proxyListener(const wp<MediaPlayer2> &player)
: mPlayer(player) { }
~proxyListener() { };
virtual void notify(int64_t srcId, int msg, int ext1, int ext2,
const PlayerMessage *obj) override {
sp<MediaPlayer2> player = mPlayer.promote();
if (player != NULL) {
player->notify(srcId, msg, ext1, ext2, obj);
}
}
private:
wp<MediaPlayer2> mPlayer;
};
Mutex sRecordLock;
SortedVector<wp<MediaPlayer2> > *sPlayers;
void ensureInit_l() {
if (sPlayers == NULL) {
sPlayers = new SortedVector<wp<MediaPlayer2> >();
}
}
void addPlayer(const wp<MediaPlayer2>& player) {
Mutex::Autolock lock(sRecordLock);
ensureInit_l();
sPlayers->add(player);
}
void removePlayer(const wp<MediaPlayer2>& player) {
Mutex::Autolock lock(sRecordLock);
ensureInit_l();
sPlayers->remove(player);
}
/**
* The only arguments this understands right now are -c, -von and -voff,
* which are parsed by ALooperRoster::dump()
*/
status_t dumpPlayers(int fd, const Vector<String16>& args) {
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
SortedVector< sp<MediaPlayer2> > players; //to serialise the mutex unlock & client destruction.
{
Mutex::Autolock lock(sRecordLock);
ensureInit_l();
for (int i = 0, n = sPlayers->size(); i < n; ++i) {
sp<MediaPlayer2> p = (*sPlayers)[i].promote();
if (p != 0) {
p->dump(fd, args);
}
players.add(p);
}
}
result.append(" Files opened and/or mapped:\n");
snprintf(buffer, SIZE, "/proc/%d/maps", getpid());
FILE *f = fopen(buffer, "r");
if (f) {
while (!feof(f)) {
fgets(buffer, SIZE, f);
if (strstr(buffer, " /storage/") ||
strstr(buffer, " /system/sounds/") ||
strstr(buffer, " /data/") ||
strstr(buffer, " /system/media/")) {
result.append(" ");
result.append(buffer);
}
}
fclose(f);
} else {
result.append("couldn't open ");
result.append(buffer);
result.append("\n");
}
snprintf(buffer, SIZE, "/proc/%d/fd", getpid());
DIR *d = opendir(buffer);
if (d) {
struct dirent *ent;
while((ent = readdir(d)) != NULL) {
if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
snprintf(buffer, SIZE, "/proc/%d/fd/%s", getpid(), ent->d_name);
struct stat s;
if (lstat(buffer, &s) == 0) {
if ((s.st_mode & S_IFMT) == S_IFLNK) {
char linkto[256];
int len = readlink(buffer, linkto, sizeof(linkto));
if(len > 0) {
if(len > 255) {
linkto[252] = '.';
linkto[253] = '.';
linkto[254] = '.';
linkto[255] = 0;
} else {
linkto[len] = 0;
}
if (strstr(linkto, "/storage/") == linkto ||
strstr(linkto, "/system/sounds/") == linkto ||
strstr(linkto, "/data/") == linkto ||
strstr(linkto, "/system/media/") == linkto) {
result.append(" ");
result.append(buffer);
result.append(" -> ");
result.append(linkto);
result.append("\n");
}
}
} else {
result.append(" unexpected type for ");
result.append(buffer);
result.append("\n");
}
}
}
}
closedir(d);
} else {
result.append("couldn't open ");
result.append(buffer);
result.append("\n");
}
gLooperRoster.dump(fd, args);
bool dumpMem = false;
bool unreachableMemory = false;
for (size_t i = 0; i < args.size(); i++) {
if (args[i] == String16("-m")) {
dumpMem = true;
} else if (args[i] == String16("--unreachable")) {
unreachableMemory = true;
}
}
if (dumpMem) {
result.append("\nDumping memory:\n");
std::string s = dumpMemoryAddresses(100 /* limit */);
result.append(s.c_str(), s.size());
}
if (unreachableMemory) {
result.append("\nDumping unreachable memory:\n");
// TODO - should limit be an argument parameter?
// TODO: enable GetUnreachableMemoryString if it's part of stable API
//std::string s = GetUnreachableMemoryString(true /* contents */, 10000 /* limit */);
//result.append(s.c_str(), s.size());
}
write(fd, result.string(), result.size());
return NO_ERROR;
}
} // anonymous namespace
//static
sp<MediaPlayer2> MediaPlayer2::Create(int32_t sessionId, jobject context) {
sp<MediaPlayer2> player = new MediaPlayer2(sessionId, context);
if (!player->init()) {
return NULL;
}
ALOGV("Create new player(%p)", player.get());
addPlayer(player);
return player;
}
// static
status_t MediaPlayer2::DumpAll(int fd, const Vector<String16>& args) {
return dumpPlayers(fd, args);
}
MediaPlayer2::MediaPlayer2(int32_t sessionId, jobject context) {
ALOGV("constructor");
mSrcId = 0;
mLockThreadId = 0;
mListener = NULL;
mStreamType = AUDIO_STREAM_MUSIC;
mAudioAttributes = NULL;
mContext = new JObjectHolder(context);
mCurrentPosition = -1;
mCurrentSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
mSeekPosition = -1;
mSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
mCurrentState = MEDIA_PLAYER2_IDLE;
mTransitionToNext = false;
mLoop = false;
mVolume = 1.0;
mVideoWidth = mVideoHeight = 0;
mSendLevel = 0;
mPid = AIBinder_getCallingPid();
mUid = AIBinder_getCallingUid();
mAudioOutput = new MediaPlayer2AudioOutput(sessionId, mUid, mPid, NULL /*attributes*/);
}
MediaPlayer2::~MediaPlayer2() {
ALOGV("destructor");
disconnect();
removePlayer(this);
}
bool MediaPlayer2::init() {
// TODO: after merge with NuPlayer2Driver, MediaPlayer2 will have its own
// looper for notification.
return true;
}
void MediaPlayer2::disconnect() {
ALOGV("disconnect");
sp<MediaPlayer2Interface> p;
{
Mutex::Autolock _l(mLock);
p = mPlayer;
mPlayer.clear();
}
if (p != 0) {
p->setListener(NULL);
p->reset();
}
{
Mutex::Autolock _l(mLock);
disconnectNativeWindow_l();
}
}
void MediaPlayer2::clear_l() {
mCurrentPosition = -1;
mCurrentSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
mSeekPosition = -1;
mSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
mVideoWidth = mVideoHeight = 0;
}
status_t MediaPlayer2::setListener(const sp<MediaPlayer2Listener>& listener) {
ALOGV("setListener");
Mutex::Autolock _l(mLock);
mListener = listener;
return NO_ERROR;
}
status_t MediaPlayer2::getSrcId(int64_t *srcId) {
if (srcId == NULL) {
return BAD_VALUE;
}
Mutex::Autolock _l(mLock);
*srcId = mSrcId;
return OK;
}
status_t MediaPlayer2::setDataSource(const sp<DataSourceDesc> &dsd) {
if (dsd == NULL) {
return BAD_VALUE;
}
// Microsecond is used in NuPlayer2.
if (dsd->mStartPositionMs > DataSourceDesc::kMaxTimeMs) {
dsd->mStartPositionMs = DataSourceDesc::kMaxTimeMs;
ALOGW("setDataSource, start poistion clamped to %lld ms", (long long)dsd->mStartPositionMs);
}
if (dsd->mEndPositionMs > DataSourceDesc::kMaxTimeMs) {
dsd->mEndPositionMs = DataSourceDesc::kMaxTimeMs;
ALOGW("setDataSource, end poistion clamped to %lld ms", (long long)dsd->mStartPositionMs);
}
ALOGV("setDataSource type(%d), srcId(%lld)", dsd->mType, (long long)dsd->mId);
sp<MediaPlayer2Interface> oldPlayer;
{
Mutex::Autolock _l(mLock);
if (!((mCurrentState & MEDIA_PLAYER2_IDLE)
|| mCurrentState == MEDIA_PLAYER2_STATE_ERROR)) {
ALOGE("setDataSource called in wrong state %d", mCurrentState);
return INVALID_OPERATION;
}
sp<MediaPlayer2Interface> player = new NuPlayer2Driver(mPid, mUid, mContext);
status_t err = player->initCheck();
if (err != NO_ERROR) {
ALOGE("Failed to create player object, initCheck failed(%d)", err);
return err;
}
clear_l();
player->setListener(new proxyListener(this));
player->setAudioSink(mAudioOutput);
err = player->setDataSource(dsd);
if (err != OK) {
ALOGE("setDataSource error: %d", err);
return err;
}
sp<MediaPlayer2Interface> oldPlayer = mPlayer;
mPlayer = player;
mSrcId = dsd->mId;
mCurrentState = MEDIA_PLAYER2_INITIALIZED;
}
if (oldPlayer != NULL) {
oldPlayer->setListener(NULL);
oldPlayer->reset();
}
return OK;
}
status_t MediaPlayer2::prepareNextDataSource(const sp<DataSourceDesc> &dsd) {
if (dsd == NULL) {
return BAD_VALUE;
}
ALOGV("prepareNextDataSource type(%d), srcId(%lld)", dsd->mType, (long long)dsd->mId);
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
ALOGE("prepareNextDataSource failed: state %X, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
return mPlayer->prepareNextDataSource(dsd);
}
status_t MediaPlayer2::playNextDataSource(int64_t srcId) {
ALOGV("playNextDataSource srcId(%lld)", (long long)srcId);
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
ALOGE("playNextDataSource failed: state %X, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
mSrcId = srcId;
mTransitionToNext = true;
return mPlayer->playNextDataSource(srcId);
}
status_t MediaPlayer2::invoke(const PlayerMessage &request, PlayerMessage *reply) {
Mutex::Autolock _l(mLock);
const bool hasBeenInitialized =
(mCurrentState != MEDIA_PLAYER2_STATE_ERROR) &&
((mCurrentState & MEDIA_PLAYER2_IDLE) != MEDIA_PLAYER2_IDLE);
if ((mPlayer == NULL) || !hasBeenInitialized) {
ALOGE("invoke() failed: wrong state %X, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
return mPlayer->invoke(request, reply);
}
void MediaPlayer2::disconnectNativeWindow_l() {
if (mConnectedWindow != NULL && mConnectedWindow->getANativeWindow() != NULL) {
status_t err = native_window_api_disconnect(
mConnectedWindow->getANativeWindow(), NATIVE_WINDOW_API_MEDIA);
if (err != OK) {
ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
strerror(-err), err);
}
}
mConnectedWindow.clear();
}
status_t MediaPlayer2::setVideoSurfaceTexture(const sp<ANativeWindowWrapper>& nww) {
ANativeWindow *anw = (nww == NULL ? NULL : nww->getANativeWindow());
ALOGV("setVideoSurfaceTexture(%p)", anw);
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return NO_INIT;
}
if (anw != NULL) {
if (mConnectedWindow != NULL
&& mConnectedWindow->getANativeWindow() == anw) {
return OK;
}
status_t err = native_window_api_connect(anw, NATIVE_WINDOW_API_MEDIA);
if (err != OK) {
ALOGE("setVideoSurfaceTexture failed: %d", err);
// Note that we must do the reset before disconnecting from the ANW.
// Otherwise queue/dequeue calls could be made on the disconnected
// ANW, which may result in errors.
mPlayer->reset();
disconnectNativeWindow_l();
return err;
}
}
// Note that we must set the player's new GraphicBufferProducer before
// disconnecting the old one. Otherwise queue/dequeue calls could be made
// on the disconnected ANW, which may result in errors.
status_t err = mPlayer->setVideoSurfaceTexture(nww);
disconnectNativeWindow_l();
if (err == OK) {
mConnectedWindow = nww;
mLock.unlock();
} else if (anw != NULL) {
mLock.unlock();
status_t err = native_window_api_disconnect(anw, NATIVE_WINDOW_API_MEDIA);
if (err != OK) {
ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
strerror(-err), err);
}
}
return err;
}
status_t MediaPlayer2::getBufferingSettings(BufferingSettings* buffering /* nonnull */) {
ALOGV("getBufferingSettings");
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return NO_INIT;
}
status_t ret = mPlayer->getBufferingSettings(buffering);
if (ret == NO_ERROR) {
ALOGV("getBufferingSettings{%s}", buffering->toString().string());
} else {
ALOGE("getBufferingSettings returned %d", ret);
}
return ret;
}
status_t MediaPlayer2::setBufferingSettings(const BufferingSettings& buffering) {
ALOGV("setBufferingSettings{%s}", buffering.toString().string());
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return NO_INIT;
}
return mPlayer->setBufferingSettings(buffering);
}
status_t MediaPlayer2::setAudioAttributes_l(const jobject attributes) {
if (mAudioOutput != NULL) {
mAudioOutput->setAudioAttributes(attributes);
}
return NO_ERROR;
}
status_t MediaPlayer2::prepareAsync() {
ALOGV("prepareAsync");
Mutex::Autolock _l(mLock);
if ((mPlayer != 0) && (mCurrentState & MEDIA_PLAYER2_INITIALIZED)) {
if (mAudioAttributes != NULL) {
status_t err = setAudioAttributes_l(mAudioAttributes->getJObject());
if (err != OK) {
return err;
}
}
mCurrentState = MEDIA_PLAYER2_PREPARING;
return mPlayer->prepareAsync();
}
ALOGE("prepareAsync called in state %d, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
status_t MediaPlayer2::start() {
ALOGV("start");
status_t ret = NO_ERROR;
Mutex::Autolock _l(mLock);
mLockThreadId = getThreadId();
if (mCurrentState & MEDIA_PLAYER2_STARTED) {
ret = NO_ERROR;
} else if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER2_PREPARED |
MEDIA_PLAYER2_PLAYBACK_COMPLETE | MEDIA_PLAYER2_PAUSED ) ) ) {
mPlayer->setLooping(mLoop);
if (mAudioOutput != 0) {
mAudioOutput->setVolume(mVolume);
}
if (mAudioOutput != 0) {
mAudioOutput->setAuxEffectSendLevel(mSendLevel);
}
mCurrentState = MEDIA_PLAYER2_STARTED;
ret = mPlayer->start();
if (ret != NO_ERROR) {
mCurrentState = MEDIA_PLAYER2_STATE_ERROR;
} else {
if (mCurrentState == MEDIA_PLAYER2_PLAYBACK_COMPLETE) {
ALOGV("playback completed immediately following start()");
}
}
} else {
ALOGE("start called in state %d, mPlayer(%p)", mCurrentState, mPlayer.get());
ret = INVALID_OPERATION;
}
mLockThreadId = 0;
return ret;
}
status_t MediaPlayer2::pause() {
ALOGV("pause");
Mutex::Autolock _l(mLock);
if (mCurrentState & (MEDIA_PLAYER2_PAUSED|MEDIA_PLAYER2_PLAYBACK_COMPLETE))
return NO_ERROR;
if ((mPlayer != 0) && (mCurrentState & (MEDIA_PLAYER2_STARTED | MEDIA_PLAYER2_PREPARED))) {
status_t ret = mPlayer->pause();
if (ret != NO_ERROR) {
mCurrentState = MEDIA_PLAYER2_STATE_ERROR;
} else {
mCurrentState = MEDIA_PLAYER2_PAUSED;
mTransitionToNext = false;
}
return ret;
}
ALOGE("pause called in state %d, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
bool MediaPlayer2::isPlaying() {
Mutex::Autolock _l(mLock);
if (mPlayer != 0) {
bool temp = mPlayer->isPlaying();
ALOGV("isPlaying: %d", temp);
if ((mCurrentState & MEDIA_PLAYER2_STARTED) && ! temp) {
ALOGE("internal/external state mismatch corrected");
mCurrentState = MEDIA_PLAYER2_PAUSED;
} else if ((mCurrentState & MEDIA_PLAYER2_PAUSED) && temp) {
ALOGE("internal/external state mismatch corrected");
mCurrentState = MEDIA_PLAYER2_STARTED;
}
return temp;
}
ALOGV("isPlaying: no active player");
return false;
}
mediaplayer2_states MediaPlayer2::getState() {
Mutex::Autolock _l(mLock);
if (mCurrentState & MEDIA_PLAYER2_STATE_ERROR) {
return MEDIAPLAYER2_STATE_ERROR;
}
if (mPlayer == 0
|| (mCurrentState &
(MEDIA_PLAYER2_IDLE | MEDIA_PLAYER2_INITIALIZED | MEDIA_PLAYER2_PREPARING))) {
return MEDIAPLAYER2_STATE_IDLE;
}
if (mCurrentState & MEDIA_PLAYER2_STARTED) {
return MEDIAPLAYER2_STATE_PLAYING;
}
if (mCurrentState & (MEDIA_PLAYER2_PAUSED | MEDIA_PLAYER2_PLAYBACK_COMPLETE)) {
return MEDIAPLAYER2_STATE_PAUSED;
}
// now only mCurrentState & MEDIA_PLAYER2_PREPARED is true
return MEDIAPLAYER2_STATE_PREPARED;
}
status_t MediaPlayer2::setPlaybackSettings(const AudioPlaybackRate& rate) {
ALOGV("setPlaybackSettings: %f %f %d %d",
rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
// Negative speed and pitch does not make sense. Further validation will
// be done by the respective mediaplayers.
if (rate.mSpeed <= 0.f || rate.mPitch < 0.f) {
return BAD_VALUE;
}
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
status_t err = mPlayer->setPlaybackSettings(rate);
return err;
}
status_t MediaPlayer2::getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */) {
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
status_t ret = mPlayer->getPlaybackSettings(rate);
if (ret == NO_ERROR) {
ALOGV("getPlaybackSettings(%f, %f, %d, %d)",
rate->mSpeed, rate->mPitch, rate->mFallbackMode, rate->mStretchMode);
} else {
ALOGV("getPlaybackSettings returned %d", ret);
}
return ret;
}
status_t MediaPlayer2::setSyncSettings(const AVSyncSettings& sync, float videoFpsHint) {
ALOGV("setSyncSettings: %u %u %f %f",
sync.mSource, sync.mAudioAdjustMode, sync.mTolerance, videoFpsHint);
Mutex::Autolock _l(mLock);
if (mPlayer == 0) return INVALID_OPERATION;
return mPlayer->setSyncSettings(sync, videoFpsHint);
}
status_t MediaPlayer2::getSyncSettings(
AVSyncSettings* sync /* nonnull */, float* videoFps /* nonnull */) {
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
status_t ret = mPlayer->getSyncSettings(sync, videoFps);
if (ret == NO_ERROR) {
ALOGV("getSyncSettings(%u, %u, %f, %f)",
sync->mSource, sync->mAudioAdjustMode, sync->mTolerance, *videoFps);
} else {
ALOGV("getSyncSettings returned %d", ret);
}
return ret;
}
status_t MediaPlayer2::getVideoWidth(int *w) {
ALOGV("getVideoWidth");
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
*w = mVideoWidth;
return NO_ERROR;
}
status_t MediaPlayer2::getVideoHeight(int *h) {
ALOGV("getVideoHeight");
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
*h = mVideoHeight;
return NO_ERROR;
}
status_t MediaPlayer2::getCurrentPosition(int64_t *msec) {
ALOGV("getCurrentPosition");
Mutex::Autolock _l(mLock);
if (mPlayer == 0) {
return INVALID_OPERATION;
}
if (mCurrentPosition >= 0) {
ALOGV("Using cached seek position: %lld", (long long)mCurrentPosition);
*msec = mCurrentPosition;
return NO_ERROR;
}
status_t ret = mPlayer->getCurrentPosition(msec);
if (ret == NO_ERROR) {
ALOGV("getCurrentPosition = %lld", (long long)*msec);
} else {
ALOGE("getCurrentPosition returned %d", ret);
}
return ret;
}
status_t MediaPlayer2::getDuration(int64_t srcId, int64_t *msec) {
Mutex::Autolock _l(mLock);
// TODO: cache duration for currentSrcId and nextSrcId, and return correct
// value for nextSrcId.
if (srcId != mSrcId) {
*msec = -1;
return OK;
}
ALOGV("getDuration_l");
bool isValidState = (mCurrentState & (MEDIA_PLAYER2_PREPARED | MEDIA_PLAYER2_STARTED |
MEDIA_PLAYER2_PAUSED | MEDIA_PLAYER2_PLAYBACK_COMPLETE));
if (mPlayer == 0 || !isValidState) {
ALOGE("Attempt to call getDuration in wrong state: mPlayer=%p, mCurrentState=%u",
mPlayer.get(), mCurrentState);
return INVALID_OPERATION;
}
int64_t durationMs;
status_t ret = mPlayer->getDuration(&durationMs);
if (ret == NO_ERROR) {
ALOGV("getDuration = %lld", (long long)durationMs);
} else {
ALOGE("getDuration returned %d", ret);
// Do not enter error state just because no duration was available.
durationMs = -1;
}
if (msec) {
*msec = durationMs;
}
return OK;
}
status_t MediaPlayer2::seekTo_l(int64_t msec, MediaPlayer2SeekMode mode) {
ALOGV("seekTo (%lld, %d)", (long long)msec, mode);
if ((mPlayer == 0) || !(mCurrentState & (MEDIA_PLAYER2_STARTED | MEDIA_PLAYER2_PREPARED |
MEDIA_PLAYER2_PAUSED | MEDIA_PLAYER2_PLAYBACK_COMPLETE))) {
ALOGE("Attempt to perform seekTo in wrong state: mPlayer=%p, mCurrentState=%u",
mPlayer.get(), mCurrentState);
return INVALID_OPERATION;
}
if (msec < 0) {
ALOGW("Attempt to seek to invalid position: %lld", (long long)msec);
msec = 0;
}
int64_t durationMs;
status_t err = mPlayer->getDuration(&durationMs);
if (err != OK) {
ALOGW("Stream has no duration and is therefore not seekable.");
return err;
}
if (msec > durationMs) {
ALOGW("Attempt to seek to past end of file: request = %lld, durationMs = %lld",
(long long)msec, (long long)durationMs);
msec = durationMs;
}
// cache duration
mCurrentPosition = msec;
mCurrentSeekMode = mode;
if (mSeekPosition < 0) {
mSeekPosition = msec;
mSeekMode = mode;
return mPlayer->seekTo(msec, mode);
}
ALOGV("Seek in progress - queue up seekTo[%lld, %d]", (long long)msec, mode);
return NO_ERROR;
}
status_t MediaPlayer2::seekTo(int64_t msec, MediaPlayer2SeekMode mode) {
mLockThreadId = getThreadId();
Mutex::Autolock _l(mLock);
status_t result = seekTo_l(msec, mode);
mLockThreadId = 0;
return result;
}
status_t MediaPlayer2::notifyAt(int64_t mediaTimeUs) {
Mutex::Autolock _l(mLock);
if (mPlayer != 0) {
return INVALID_OPERATION;
}
return mPlayer->notifyAt(mediaTimeUs);
}
status_t MediaPlayer2::reset_l() {
mLoop = false;
if (mCurrentState == MEDIA_PLAYER2_IDLE) {
return NO_ERROR;
}
if (mPlayer != 0) {
status_t ret = mPlayer->reset();
if (ret != NO_ERROR) {
ALOGE("reset() failed with return code (%d)", ret);
mCurrentState = MEDIA_PLAYER2_STATE_ERROR;
} else {
mPlayer->setListener(NULL);
mCurrentState = MEDIA_PLAYER2_IDLE;
mTransitionToNext = false;
}
// setDataSource has to be called again to create a
// new mediaplayer.
mPlayer = 0;
return ret;
}
clear_l();
return NO_ERROR;
}
status_t MediaPlayer2::reset() {
ALOGV("reset");
mLockThreadId = getThreadId();
Mutex::Autolock _l(mLock);
status_t result = reset_l();
mLockThreadId = 0;
return result;
}
status_t MediaPlayer2::setAudioStreamType(audio_stream_type_t type) {
ALOGV("MediaPlayer2::setAudioStreamType");
Mutex::Autolock _l(mLock);
if (mStreamType == type) return NO_ERROR;
if (mCurrentState & ( MEDIA_PLAYER2_PREPARED | MEDIA_PLAYER2_STARTED |
MEDIA_PLAYER2_PAUSED | MEDIA_PLAYER2_PLAYBACK_COMPLETE ) ) {
// Can't change the stream type after prepare
ALOGE("setAudioStream called in state %d", mCurrentState);
return INVALID_OPERATION;
}
// cache
mStreamType = type;
return OK;
}
status_t MediaPlayer2::getAudioStreamType(audio_stream_type_t *type) {
ALOGV("getAudioStreamType");
Mutex::Autolock _l(mLock);
*type = mStreamType;
return OK;
}
status_t MediaPlayer2::setLooping(int loop) {
ALOGV("MediaPlayer2::setLooping");
Mutex::Autolock _l(mLock);
mLoop = (loop != 0);
if (mPlayer != 0) {
return mPlayer->setLooping(loop);
}
return OK;
}
bool MediaPlayer2::isLooping() {
ALOGV("isLooping");
Mutex::Autolock _l(mLock);
if (mPlayer != 0) {
return mLoop;
}
ALOGV("isLooping: no active player");
return false;
}
status_t MediaPlayer2::setVolume(float volume) {
ALOGV("MediaPlayer2::setVolume(%f)", volume);
Mutex::Autolock _l(mLock);
mVolume = volume;
if (mAudioOutput != 0) {
mAudioOutput->setVolume(volume);
}
return OK;
}
status_t MediaPlayer2::setAudioSessionId(int32_t sessionId) {
ALOGV("MediaPlayer2::setAudioSessionId(%d)", sessionId);
Mutex::Autolock _l(mLock);
if (!(mCurrentState & MEDIA_PLAYER2_IDLE)) {
ALOGE("setAudioSessionId called in state %d", mCurrentState);
return INVALID_OPERATION;
}
if (sessionId < 0) {
return BAD_VALUE;
}
if (mAudioOutput != NULL && sessionId != mAudioOutput->getSessionId()) {
mAudioOutput->setSessionId(sessionId);
}
return NO_ERROR;
}
int32_t MediaPlayer2::getAudioSessionId() {
Mutex::Autolock _l(mLock);
if (mAudioOutput != NULL) {
return mAudioOutput->getSessionId();
}
return 0;
}
status_t MediaPlayer2::setAuxEffectSendLevel(float level) {
ALOGV("MediaPlayer2::setAuxEffectSendLevel(%f)", level);
Mutex::Autolock _l(mLock);
mSendLevel = level;
if (mAudioOutput != 0) {
return mAudioOutput->setAuxEffectSendLevel(level);
}
return OK;
}
status_t MediaPlayer2::attachAuxEffect(int effectId) {
ALOGV("MediaPlayer2::attachAuxEffect(%d)", effectId);
Mutex::Autolock _l(mLock);
if (mAudioOutput == 0 ||
(mCurrentState & MEDIA_PLAYER2_IDLE) ||
(mCurrentState == MEDIA_PLAYER2_STATE_ERROR )) {
ALOGE("attachAuxEffect called in state %d, mPlayer(%p)", mCurrentState, mPlayer.get());
return INVALID_OPERATION;
}
return mAudioOutput->attachAuxEffect(effectId);
}
// always call with lock held
status_t MediaPlayer2::checkState_l() {
if (mCurrentState & ( MEDIA_PLAYER2_PREPARED | MEDIA_PLAYER2_STARTED |
MEDIA_PLAYER2_PAUSED | MEDIA_PLAYER2_PLAYBACK_COMPLETE) ) {
// Can't change the audio attributes after prepare
ALOGE("trying to set audio attributes called in state %d", mCurrentState);
return INVALID_OPERATION;
}
return OK;
}
status_t MediaPlayer2::setAudioAttributes(const jobject attributes) {
ALOGV("MediaPlayer2::setAudioAttributes");
status_t status = INVALID_OPERATION;
Mutex::Autolock _l(mLock);
if (checkState_l() != OK) {
return status;
}
mAudioAttributes = new JObjectHolder(attributes);
status = setAudioAttributes_l(attributes);
return status;
}
jobject MediaPlayer2::getAudioAttributes() {
ALOGV("MediaPlayer2::getAudioAttributes)");
Mutex::Autolock _l(mLock);
return mAudioAttributes != NULL ? mAudioAttributes->getJObject() : NULL;
}
status_t MediaPlayer2::getParameter(int key, Parcel *reply) {
ALOGV("MediaPlayer2::getParameter(%d)", key);
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
ALOGV("getParameter: no active player");
return INVALID_OPERATION;
}
status_t status = mPlayer->getParameter(key, reply);
if (status != OK) {
ALOGD("getParameter returns %d", status);
}
return status;
}
// for mediametrics
status_t MediaPlayer2::getMetrics(char **buffer, size_t *length) {
ALOGD("MediaPlayer2::getMetrics()");
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
ALOGV("getMetrics: no active player");
return INVALID_OPERATION;
}
status_t status = mPlayer->getMetrics(buffer, length);
if (status != OK) {
ALOGD("getMetrics returns %d", status);
}
return status;
}
void MediaPlayer2::notify(int64_t srcId, int msg, int ext1, int ext2, const PlayerMessage *obj) {
ALOGV("message received srcId=%lld, msg=%d, ext1=%d, ext2=%d",
(long long)srcId, msg, ext1, ext2);
bool send = true;
bool locked = false;
// TODO: In the future, we might be on the same thread if the app is
// running in the same process as the media server. In that case,
// this will deadlock.
//
// The threadId hack below works around this for the care of prepare,
// seekTo, start, and reset within the same process.
// FIXME: Remember, this is a hack, it's not even a hack that is applied
// consistently for all use-cases, this needs to be revisited.
if (mLockThreadId != getThreadId()) {
mLock.lock();
locked = true;
}
// Allows calls from JNI in idle state to notify errors
if (!(msg == MEDIA2_ERROR && mCurrentState == MEDIA_PLAYER2_IDLE) && mPlayer == 0) {
ALOGV("notify(%lld, %d, %d, %d) callback on disconnected mediaplayer",
(long long)srcId, msg, ext1, ext2);
if (locked) mLock.unlock(); // release the lock when done.
return;
}
switch (msg) {
case MEDIA2_NOP: // interface test message
break;
case MEDIA2_PREPARED:
ALOGV("MediaPlayer2::notify() prepared, srcId=%lld", (long long)srcId);
if (srcId == mSrcId) {
mCurrentState = MEDIA_PLAYER2_PREPARED;
}
break;
case MEDIA2_DRM_INFO:
ALOGV("MediaPlayer2::notify() MEDIA2_DRM_INFO(%lld, %d, %d, %d, %p)",
(long long)srcId, msg, ext1, ext2, obj);
break;
case MEDIA2_PLAYBACK_COMPLETE:
ALOGV("playback complete");
if (mCurrentState == MEDIA_PLAYER2_IDLE) {
ALOGE("playback complete in idle state");
}
if (!mLoop && srcId == mSrcId) {
mCurrentState = MEDIA_PLAYER2_PLAYBACK_COMPLETE;
}
break;
case MEDIA2_ERROR:
// Always log errors.
// ext1: Media framework error code.
// ext2: Implementation dependant error code.
ALOGE("error (%d, %d)", ext1, ext2);
mCurrentState = MEDIA_PLAYER2_STATE_ERROR;
break;
case MEDIA2_INFO:
// ext1: Media framework error code.
// ext2: Implementation dependant error code.
if (ext1 != MEDIA2_INFO_VIDEO_TRACK_LAGGING) {
ALOGW("info/warning (%d, %d)", ext1, ext2);
if (ext1 == MEDIA2_INFO_DATA_SOURCE_START && srcId == mSrcId && mTransitionToNext) {
mCurrentState = MEDIA_PLAYER2_STARTED;
mTransitionToNext = false;
}
}
break;
case MEDIA2_SEEK_COMPLETE:
ALOGV("Received seek complete");
if (mSeekPosition != mCurrentPosition || (mSeekMode != mCurrentSeekMode)) {
ALOGV("Executing queued seekTo(%lld, %d)",
(long long)mCurrentPosition, mCurrentSeekMode);
mSeekPosition = -1;
mSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
seekTo_l(mCurrentPosition, mCurrentSeekMode);
}
else {
ALOGV("All seeks complete - return to regularly scheduled program");
mCurrentPosition = mSeekPosition = -1;
mCurrentSeekMode = mSeekMode = MediaPlayer2SeekMode::SEEK_PREVIOUS_SYNC;
}
break;
case MEDIA2_BUFFERING_UPDATE:
ALOGV("buffering %d", ext1);
break;
case MEDIA2_SET_VIDEO_SIZE:
ALOGV("New video size %d x %d", ext1, ext2);
mVideoWidth = ext1;
mVideoHeight = ext2;
break;
case MEDIA2_NOTIFY_TIME:
ALOGV("Received notify time message");
break;
case MEDIA2_TIMED_TEXT:
ALOGV("Received timed text message");
break;
case MEDIA2_SUBTITLE_DATA:
ALOGV("Received subtitle data message");
break;
case MEDIA2_META_DATA:
ALOGV("Received timed metadata message");
break;
default:
ALOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2);
break;
}
sp<MediaPlayer2Listener> listener = mListener;
if (locked) mLock.unlock();
// this prevents re-entrant calls into client code
if ((listener != 0) && send) {
Mutex::Autolock _l(mNotifyLock);
ALOGV("callback application");
listener->notify(srcId, msg, ext1, ext2, obj);
ALOGV("back from callback");
}
}
// Modular DRM
status_t MediaPlayer2::prepareDrm(
int64_t srcId, const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId) {
// TODO change to ALOGV
ALOGD("prepareDrm: uuid: %p drmSessionId: %p(%zu)", uuid,
drmSessionId.array(), drmSessionId.size());
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
return NO_INIT;
}
// Only allowed it in player's preparing/prepared state.
// We get here only if MEDIA_DRM_INFO has already arrived (e.g., prepare is half-way through or
// completed) so the state change to "prepared" might not have happened yet (e.g., buffering).
// Still, we can allow prepareDrm for the use case of being called in OnDrmInfoListener.
if (!(mCurrentState & (MEDIA_PLAYER2_PREPARING | MEDIA_PLAYER2_PREPARED))) {
ALOGW("prepareDrm(%lld) called in non-prepare state(%d)", (long long)srcId, mCurrentState);
if (srcId == mSrcId) {
return INVALID_OPERATION;
}
}
if (drmSessionId.isEmpty()) {
ALOGE("prepareDrm: Unexpected. Can't proceed with crypto. Empty drmSessionId.");
return INVALID_OPERATION;
}
// Passing down to mediaserver mainly for creating the crypto
status_t status = mPlayer->prepareDrm(srcId, uuid, drmSessionId);
ALOGE_IF(status != OK, "prepareDrm: Failed at mediaserver with ret: %d", status);
// TODO change to ALOGV
ALOGD("prepareDrm: mediaserver::prepareDrm ret=%d", status);
return status;
}
status_t MediaPlayer2::releaseDrm(int64_t srcId) {
Mutex::Autolock _l(mLock);
if (mPlayer == NULL) {
return NO_INIT;
}
// Not allowing releaseDrm in an active/resumable state
if (mCurrentState & (MEDIA_PLAYER2_STARTED |
MEDIA_PLAYER2_PAUSED |
MEDIA_PLAYER2_PLAYBACK_COMPLETE |
MEDIA_PLAYER2_STATE_ERROR)) {
ALOGE("releaseDrm Unexpected state %d. Can only be called in stopped/idle.", mCurrentState);
return INVALID_OPERATION;
}
status_t status = mPlayer->releaseDrm(srcId);
// TODO change to ALOGV
ALOGD("releaseDrm: mediaserver::releaseDrm ret: %d", status);
if (status != OK) {
ALOGE("releaseDrm: Failed at mediaserver with ret: %d", status);
// Overriding to OK so the client proceed with its own cleanup
// Client can't do more cleanup. mediaserver release its crypto at end of session anyway.
status = OK;
}
return status;
}
status_t MediaPlayer2::setPreferredDevice(jobject device) {
Mutex::Autolock _l(mLock);
if (mAudioOutput == NULL) {
ALOGV("setPreferredDevice: audio sink not init");
return NO_INIT;
}
return mAudioOutput->setPreferredDevice(device);
}
jobject MediaPlayer2::getRoutedDevice() {
Mutex::Autolock _l(mLock);
if (mAudioOutput == NULL) {
ALOGV("getRoutedDevice: audio sink not init");
return nullptr;
}
return mAudioOutput->getRoutedDevice();
}
status_t MediaPlayer2::addAudioDeviceCallback(jobject routingDelegate) {
Mutex::Autolock _l(mLock);
if (mAudioOutput == NULL) {
ALOGV("addAudioDeviceCallback: player not init");
return NO_INIT;
}
return mAudioOutput->addAudioDeviceCallback(routingDelegate);
}
status_t MediaPlayer2::removeAudioDeviceCallback(jobject listener) {
Mutex::Autolock _l(mLock);
if (mAudioOutput == NULL) {
ALOGV("addAudioDeviceCallback: player not init");
return NO_INIT;
}
return mAudioOutput->removeAudioDeviceCallback(listener);
}
status_t MediaPlayer2::dump(int fd, const Vector<String16>& args) {
const size_t SIZE = 256;
char buffer[SIZE];
String8 result;
result.append(" MediaPlayer2\n");
snprintf(buffer, 255, " pid(%d), looping(%s)\n", mPid, mLoop?"true": "false");
result.append(buffer);
sp<MediaPlayer2Interface> player;
sp<MediaPlayer2AudioOutput> audioOutput;
bool locked = false;
for (int i = 0; i < kDumpLockRetries; ++i) {
if (mLock.tryLock() == NO_ERROR) {
locked = true;
break;
}
usleep(kDumpLockSleepUs);
}
if (locked) {
player = mPlayer;
audioOutput = mAudioOutput;
mLock.unlock();
} else {
result.append(" lock is taken, no dump from player and audio output\n");
}
write(fd, result.string(), result.size());
if (player != NULL) {
player->dump(fd, args);
}
if (audioOutput != 0) {
audioOutput->dump(fd, args);
}
write(fd, "\n", 1);
return NO_ERROR;
}
} // namespace android