/*
* Start the Android runtime. This involves starting the virtual machine
* and calling the "static void main(String[] args)" method in the class
* named by "className".
*
* Passes the main function two arguments, the class name and the specified
* options string.
*/
void AndroidRuntime::start(const char* className, const char* options)
{
ALOGD("\n>>>>>> AndroidRuntime START %s <<<<<<\n",
className != NULL ? className : "(unknown)");
/*
* 'startSystemServer == true' means runtime is obsolete and not run from
* init.rc anymore, so we print out the boot start event here.
*/
if (strcmp(options, "start-system-server") == 0) {
/* track our progress through the boot sequence */
const int LOG_BOOT_PROGRESS_START = 3000;
LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START,
ns2ms(systemTime(SYSTEM_TIME_MONOTONIC)));
}
const char* rootDir = getenv("ANDROID_ROOT");
if (rootDir == NULL) {
rootDir = "/system";
if (!hasDir("/system")) {
LOG_FATAL("No root directory specified, and /android does not exist.");
return;
}
setenv("ANDROID_ROOT", rootDir, 1);
}
//const char* kernelHack = getenv("LD_ASSUME_KERNEL");
//ALOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack);
/* start the virtual machine */
JniInvocation jni_invocation;
jni_invocation.Init(NULL);
JNIEnv* env;
if (startVm(&mJavaVM, &env) != 0) {
return;
}
onVmCreated(env);
/*
* Register android functions.
*/
if (startReg(env) < 0) {
ALOGE("Unable to register all android natives\n");
return;
}
/*
* We want to call main() with a String array with arguments in it.
* At present we have two arguments, the class name and an option string.
* Create an array to hold them.
*/
jclass stringClass;
jobjectArray strArray;
jstring classNameStr;
jstring optionsStr;
stringClass = env->FindClass("java/lang/String");
assert(stringClass != NULL);
strArray = env->NewObjectArray(2, stringClass, NULL);
assert(strArray != NULL);
classNameStr = env->NewStringUTF(className);
assert(classNameStr != NULL);
env->SetObjectArrayElement(strArray, 0, classNameStr);
optionsStr = env->NewStringUTF(options);
env->SetObjectArrayElement(strArray, 1, optionsStr);
/*
* Start VM. This thread becomes the main thread of the VM, and will
* not return until the VM exits.
*/
char* slashClassName = toSlashClassName(className);
jclass startClass = env->FindClass(slashClassName);
if (startClass == NULL) {
ALOGE("JavaVM unable to locate class '%s'\n", slashClassName);
/* keep going */
} else {
jmethodID startMeth = env->GetStaticMethodID(startClass, "main",
"([Ljava/lang/String;)V");
if (startMeth == NULL) {
ALOGE("JavaVM unable to find main() in '%s'\n", className);
/* keep going */
} else {
env->CallStaticVoidMethod(startClass, startMeth, strArray);
#if 0
if (env->ExceptionCheck())
threadExitUncaughtException(env);
#endif
}
}
free(slashClassName);
ALOGD("Shutting down VM\n");
if (mJavaVM->DetachCurrentThread() != JNI_OK)
ALOGW("Warning: unable to detach main thread\n");
if (mJavaVM->DestroyJavaVM() != 0)
ALOGW("Warning: VM did not shut down cleanly\n");
}
void AudioSystem::AudioFlingerClient::ioConfigChanged(int event, int ioHandle, void *param2) {
ALOGV("ioConfigChanged() event %d", event);
OutputDescriptor *desc;
uint32_t stream;
if (ioHandle == 0) return;
Mutex::Autolock _l(AudioSystem::gLock);
switch (event) {
case STREAM_CONFIG_CHANGED:
if (param2 == 0) break;
stream = *(uint32_t *)param2;
ALOGV("ioConfigChanged() STREAM_CONFIG_CHANGED stream %d, output %d", stream, ioHandle);
if (gStreamOutputMap.indexOfKey(stream) >= 0) {
gStreamOutputMap.replaceValueFor(stream, ioHandle);
}
break;
case OUTPUT_OPENED: {
if (gOutputs.indexOfKey(ioHandle) >= 0) {
ALOGV("ioConfigChanged() opening already existing output! %d", ioHandle);
break;
}
if (param2 == 0) break;
desc = (OutputDescriptor *)param2;
OutputDescriptor *outputDesc = new OutputDescriptor(*desc);
gOutputs.add(ioHandle, outputDesc);
ALOGV("ioConfigChanged() new output samplingRate %d, format %d channels %d frameCount %d latency %d",
outputDesc->samplingRate, outputDesc->format, outputDesc->channels, outputDesc->frameCount, outputDesc->latency);
} break;
case OUTPUT_CLOSED: {
if (gOutputs.indexOfKey(ioHandle) < 0) {
ALOGW("ioConfigChanged() closing unknow output! %d", ioHandle);
break;
}
ALOGV("ioConfigChanged() output %d closed", ioHandle);
gOutputs.removeItem(ioHandle);
for (int i = gStreamOutputMap.size() - 1; i >= 0 ; i--) {
if (gStreamOutputMap.valueAt(i) == ioHandle) {
gStreamOutputMap.removeItemsAt(i);
}
}
} break;
case OUTPUT_CONFIG_CHANGED: {
int index = gOutputs.indexOfKey(ioHandle);
if (index < 0) {
ALOGW("ioConfigChanged() modifying unknow output! %d", ioHandle);
break;
}
if (param2 == 0) break;
desc = (OutputDescriptor *)param2;
ALOGV("ioConfigChanged() new config for output %d samplingRate %d, format %d channels %d frameCount %d latency %d",
ioHandle, desc->samplingRate, desc->format,
desc->channels, desc->frameCount, desc->latency);
OutputDescriptor *outputDesc = gOutputs.valueAt(index);
delete outputDesc;
outputDesc = new OutputDescriptor(*desc);
gOutputs.replaceValueFor(ioHandle, outputDesc);
} break;
case INPUT_OPENED:
case INPUT_CLOSED:
case INPUT_CONFIG_CHANGED:
break;
}
}
void MediaPlayer::notify(int msg, int ext1, int ext2, const Parcel *obj)
{
ALOGV("message received msg=%d, ext1=%d, ext2=%d", 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
// and seekTo 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 == MEDIA_ERROR && mCurrentState == MEDIA_PLAYER_IDLE) && mPlayer == 0) {
ALOGV("notify(%d, %d, %d) callback on disconnected mediaplayer", msg, ext1, ext2);
if (locked) mLock.unlock(); // release the lock when done.
return;
}
switch (msg) {
case MEDIA_NOP: // interface test message
break;
case MEDIA_PREPARED:
ALOGV("prepared");
mCurrentState = MEDIA_PLAYER_PREPARED;
if (mPrepareSync) {
ALOGV("signal application thread");
mPrepareSync = false;
mPrepareStatus = NO_ERROR;
mSignal.signal();
}
break;
case MEDIA_PLAYBACK_COMPLETE:
ALOGV("playback complete");
if (mCurrentState == MEDIA_PLAYER_IDLE) {
ALOGE("playback complete in idle state");
}
if (!mLoop) {
mCurrentState = MEDIA_PLAYER_PLAYBACK_COMPLETE;
}
break;
case MEDIA_ERROR:
// Always log errors.
// ext1: Media framework error code.
// ext2: Implementation dependant error code.
ALOGE("error (%d, %d)", ext1, ext2);
mCurrentState = MEDIA_PLAYER_STATE_ERROR;
if (mPrepareSync)
{
ALOGV("signal application thread");
mPrepareSync = false;
mPrepareStatus = ext1;
mSignal.signal();
send = false;
}
break;
case MEDIA_INFO:
// ext1: Media framework error code.
// ext2: Implementation dependant error code.
if (ext1 != MEDIA_INFO_VIDEO_TRACK_LAGGING) {
ALOGW("info/warning (%d, %d)", ext1, ext2);
}
break;
case MEDIA_SEEK_COMPLETE:
ALOGV("Received seek complete");
if (mSeekPosition != mCurrentPosition) {
ALOGV("Executing queued seekTo(%d)", mSeekPosition);
mSeekPosition = -1;
seekTo_l(mCurrentPosition);
}
else {
ALOGV("All seeks complete - return to regularly scheduled program");
mCurrentPosition = mSeekPosition = -1;
}
break;
case MEDIA_BUFFERING_UPDATE:
ALOGV("buffering %d", ext1);
break;
case MEDIA_SET_VIDEO_SIZE:
ALOGV("New video size %d x %d", ext1, ext2);
mVideoWidth = ext1;
mVideoHeight = ext2;
break;
case MEDIA_TIMED_TEXT:
ALOGV("Received timed text message");
break;
case MEDIA_SUBTITLE_DATA:
ALOGV("Received subtitle data message");
break;
default:
ALOGV("unrecognized message: (%d, %d, %d)", msg, ext1, ext2);
break;
}
sp<MediaPlayerListener> 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(msg, ext1, ext2, obj);
ALOGV("back from callback");
}
}
// IBinder::DeathRecipient
virtual void binderDied(const wp<IBinder>& who){
c_plus_plus_releaseWakeLock();
gPowerManager.clear();
ALOGW("power manager service died !!!");
}
/*
* Function : libaroma_stream_file
* Return Value: LIBAROMA_STREAMP
* Descriptions: new stream from file
*/
LIBAROMA_STREAMP libaroma_stream_file(
char * path) {
#ifdef LIBAROMA_SYSCAL_HAVE_MMAP
if (!path) {
ALOGW("libaroma_stream_file path is invalid");
return NULL;
}
LIBAROMA_STREAMP ret;
/* Read File Stat */
int filesize=libaroma_filesize(path);
if (filesize < 0) {
ALOGI("libaroma_stream_file (%s) not found", path);
return NULL;
}
/* Open File */
int fd = open(path, O_RDONLY, 0);
if (fd < 0) {
ALOGW("libaroma_stream_file unable to open (%s)", path);
return NULL;
}
/* MAP */
bytep mem = (bytep) mmap(NULL, filesize,
PROT_READ, MAP_FILE | MAP_SHARED, fd, 0);
/* Close FD */
close(fd);
if (mem == MAP_FAILED) {
ALOGW("libaroma_stream_file unable to mmap (%s)", path);
return NULL;
}
/* Return */
ret = (LIBAROMA_STREAMP) malloc(sizeof(LIBAROMA_STREAM));
ret->data = mem;
ret->size = filesize;
ret->ismmap = 1;
snprintf(ret->uri,
LIBAROMA_STREAM_URI_LENGTH, "file://%s", path);
return ret;
#else
if (!path) {
ALOGW("libaroma_stream_file path is invalid");
return 0;
}
LIBAROMA_STREAMP ret;
/* Read File Stat */
int filesize=libaroma_filesize(path);
if (filesize < 0) {
ALOGI("libaroma_stream_file (%s) not found", path);
return NULL;
}
/* Allocating Memory */
bytep mem = malloc(filesize);
FILE * f = fopen(path, "rb");
if (f == NULL) {
ALOGW("libaroma_stream_file fopen error (%s)", path);
goto error;
}
if (((int) fread(mem, 1, filesize, f)) != filesize) {
ALOGW("libaroma_stream_file fread error (%s)", path);
fclose(f);
goto error;
}
fclose(f);
goto done;
error:
free(mem);
return NULL;
done:
ret = (LIBAROMA_STREAMP) malloc(sizeof(LIBAROMA_STREAM));
ret->data = mem;
ret->size = filesize;
ret->ismmap = 0;
snprintf(ret->uri,
LIBAROMA_STREAM_URI_LENGTH, "file://%s", path);
return ret;
#endif
} /* End of libaroma_stream_file */
/*
* Function : libaroma_shmem
* Return Value: LIBAROMA_SHMEMP
* Descriptions: new/open shared memory
*/
LIBAROMA_SHMEMP libaroma_shmem(
const char * name,
int sz) {
#ifdef LIBAROMA_SYSCAL_HAVE_SHMEM
/* Copy Name */
char nm[LIBAROMA_STREAM_URI_LENGTH];
if (name[0]=='@'){
snprintf(nm, LIBAROMA_STREAM_URI_LENGTH,
"%s%s", LIBAROMA_CONFIG_SHMEM_PREFIX, name+1);
}
else{
snprintf(nm, LIBAROMA_STREAM_URI_LENGTH,
"%s", name);
}
/* Open Shared Memory */
int fd;
if (sz < 1) {
fd = shm_open(nm, O_RDWR, 0666);
if (fd < 0) {
ALOGW("libaroma_shmem shm_open failed (%s)", nm);
return 0;
}
int filesize=libaroma_filesize_fd(fd);
if (sz< 0) {
ALOGW("libaroma_shmem stat is invalid (%s)", nm);
close(fd);
return 0;
}
sz=filesize;
if (sz < 1) {
ALOGW("libaroma_shmem exiting shmem not found (%s)", nm);
close(fd);
return 0;
}
ALOGV("libaroma_shmem reopen shmem - %ibyte (%s)", sz, nm);
}
else {
fd = shm_open(nm, O_CREAT | O_TRUNC | O_RDWR, 0666);
if (fd < 0) {
ALOGW("libaroma_shmem shm_open failed (%s)", nm);
return 0;
}
/* Truncate */
if (ftruncate(fd, sz) != 0) {
ALOGW("libaroma_shmem ftruncate error (%s)", nm);
close(fd);
return 0;
}
ALOGV("libaroma_shmem new - %ibyte (%s)", sz, nm);
}
/* mmap */
bytep mem = (bytep) mmap(0, sz, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
close(fd);
/* check memory */
if (mem == MAP_FAILED) {
ALOGW("libaroma_shmem unable to mmap (%s)", name);
return 0;
}
/* return data */
LIBAROMA_SHMEMP ret = (LIBAROMA_SHMEMP) malloc(sizeof(LIBAROMA_SHMEM));
ret->data = mem;
ret->size = sz;
snprintf(ret->name, LIBAROMA_STREAM_URI_LENGTH, "%s", nm);
return ret;
#else
return NULL;
#endif
} /* End of libaroma_shmem */
status_t FFMPEGSoftCodec::setSupportedRole(
const sp<IOMX> &omx, IOMX::node_id node,
bool isEncoder, const char *mime) {
ALOGV("setSupportedRole Called %s", mime);
struct MimeToRole {
const char *mime;
const char *decoderRole;
const char *encoderRole;
};
static const MimeToRole kFFMPEGMimeToRole[] = {
{ MEDIA_MIMETYPE_AUDIO_AAC,
"audio_decoder.aac", NULL },
{ MEDIA_MIMETYPE_AUDIO_MPEG,
"audio_decoder.mp3", NULL },
{ MEDIA_MIMETYPE_AUDIO_VORBIS,
"audio_decoder.vorbis", NULL },
{ MEDIA_MIMETYPE_AUDIO_WMA,
"audio_decoder.wma", NULL },
{ MEDIA_MIMETYPE_AUDIO_RA,
"audio_decoder.ra" , NULL },
{ MEDIA_MIMETYPE_AUDIO_FLAC,
"audio_decoder.flac", NULL },
{ MEDIA_MIMETYPE_AUDIO_MPEG_LAYER_II,
"audio_decoder.mp2", NULL },
{ MEDIA_MIMETYPE_AUDIO_AC3,
"audio_decoder.ac3", NULL },
{ MEDIA_MIMETYPE_AUDIO_APE,
"audio_decoder.ape", NULL },
{ MEDIA_MIMETYPE_AUDIO_DTS,
"audio_decoder.dts", NULL },
{ MEDIA_MIMETYPE_VIDEO_MPEG2,
"video_decoder.mpeg2", NULL },
{ MEDIA_MIMETYPE_VIDEO_DIVX,
"video_decoder.divx", NULL },
{ MEDIA_MIMETYPE_VIDEO_DIVX4,
"video_decoder.divx", NULL },
{ MEDIA_MIMETYPE_VIDEO_DIVX311,
"video_decoder.divx", NULL },
{ MEDIA_MIMETYPE_VIDEO_WMV,
"video_decoder.wmv", NULL },
{ MEDIA_MIMETYPE_VIDEO_RV,
"video_decoder.rv", NULL },
{ MEDIA_MIMETYPE_VIDEO_FLV1,
"video_decoder.flv1", NULL },
{ MEDIA_MIMETYPE_VIDEO_HEVC,
"video_decoder.hevc", NULL },
{ MEDIA_MIMETYPE_AUDIO_FFMPEG,
"audio_decoder.trial", NULL },
{ MEDIA_MIMETYPE_VIDEO_FFMPEG,
"video_decoder.trial", NULL },
};
static const size_t kNumMimeToRole =
sizeof(kFFMPEGMimeToRole) / sizeof(kFFMPEGMimeToRole[0]);
size_t i;
for (i = 0; i < kNumMimeToRole; ++i) {
if (!strcasecmp(mime, kFFMPEGMimeToRole[i].mime)) {
break;
}
}
if (i == kNumMimeToRole) {
return ERROR_UNSUPPORTED;
}
const char *role =
isEncoder ? kFFMPEGMimeToRole[i].encoderRole
: kFFMPEGMimeToRole[i].decoderRole;
if (role != NULL) {
OMX_PARAM_COMPONENTROLETYPE roleParams;
InitOMXParams(&roleParams);
strncpy((char *)roleParams.cRole,
role, OMX_MAX_STRINGNAME_SIZE - 1);
roleParams.cRole[OMX_MAX_STRINGNAME_SIZE - 1] = '\0';
status_t err = omx->setParameter(
node, OMX_IndexParamStandardComponentRole,
&roleParams, sizeof(roleParams));
if (err != OK) {
ALOGW("Failed to set standard component role '%s'.", role);
return err;
}
}
return OK;
}
