JNIEXPORT jint Java_com_farcore_playerservice_AmPlayer_setglobalalpha(JNIEnv *env, jclass clazz, jint alpha){
int ret = -1;
ret = SYS_set_global_alpha(alpha);
ALOGI("set global alpha is %d",alpha);
return ret;
}
// must be called with mLock held
status_t AudioRecord::openRecord_l(const Modulo<uint32_t> &epoch, const String16& opPackageName)
{
const sp<IAudioFlinger>& audioFlinger = AudioSystem::get_audio_flinger();
if (audioFlinger == 0) {
ALOGE("Could not get audioflinger");
return NO_INIT;
}
if (mDeviceCallback != 0 && mInput != AUDIO_IO_HANDLE_NONE) {
AudioSystem::removeAudioDeviceCallback(mDeviceCallback, mInput);
}
audio_io_handle_t input;
// mFlags (not mOrigFlags) is modified depending on whether fast request is accepted.
// After fast request is denied, we will request again if IAudioRecord is re-created.
status_t status;
// Not a conventional loop, but a retry loop for at most two iterations total.
// Try first maybe with FAST flag then try again without FAST flag if that fails.
// Exits loop normally via a return at the bottom, or with error via a break.
// The sp<> references will be dropped when re-entering scope.
// The lack of indentation is deliberate, to reduce code churn and ease merges.
for (;;) {
status = AudioSystem::getInputForAttr(&mAttributes, &input,
mSessionId,
// FIXME compare to AudioTrack
mClientPid,
mClientUid,
mSampleRate, mFormat, mChannelMask,
mFlags, mSelectedDeviceId);
if (status != NO_ERROR || input == AUDIO_IO_HANDLE_NONE) {
ALOGE("Could not get audio input for session %d, record source %d, sample rate %u, "
"format %#x, channel mask %#x, flags %#x",
mSessionId, mAttributes.source, mSampleRate, mFormat, mChannelMask, mFlags);
return BAD_VALUE;
}
// Now that we have a reference to an I/O handle and have not yet handed it off to AudioFlinger,
// we must release it ourselves if anything goes wrong.
#if 0
size_t afFrameCount;
status = AudioSystem::getFrameCount(input, &afFrameCount);
if (status != NO_ERROR) {
ALOGE("getFrameCount(input=%d) status %d", input, status);
break;
}
#endif
uint32_t afSampleRate;
status = AudioSystem::getSamplingRate(input, &afSampleRate);
if (status != NO_ERROR) {
ALOGE("getSamplingRate(input=%d) status %d", input, status);
break;
}
if (mSampleRate == 0) {
mSampleRate = afSampleRate;
}
// Client can only express a preference for FAST. Server will perform additional tests.
if (mFlags & AUDIO_INPUT_FLAG_FAST) {
bool useCaseAllowed =
// either of these use cases:
// use case 1: callback transfer mode
(mTransfer == TRANSFER_CALLBACK) ||
// use case 2: obtain/release mode
(mTransfer == TRANSFER_OBTAIN);
// sample rates must also match
bool fastAllowed = useCaseAllowed && (mSampleRate == afSampleRate);
if (!fastAllowed) {
ALOGW("AUDIO_INPUT_FLAG_FAST denied by client; transfer %d, "
"track %u Hz, input %u Hz",
mTransfer, mSampleRate, afSampleRate);
mFlags = (audio_input_flags_t) (mFlags & ~(AUDIO_INPUT_FLAG_FAST |
AUDIO_INPUT_FLAG_RAW));
AudioSystem::releaseInput(input, mSessionId);
continue; // retry
}
}
// The notification frame count is the period between callbacks, as suggested by the client
// but moderated by the server. For record, the calculations are done entirely on server side.
size_t notificationFrames = mNotificationFramesReq;
size_t frameCount = mReqFrameCount;
audio_input_flags_t flags = mFlags;
pid_t tid = -1;
if (mFlags & AUDIO_INPUT_FLAG_FAST) {
if (mAudioRecordThread != 0) {
tid = mAudioRecordThread->getTid();
}
}
size_t temp = frameCount; // temp may be replaced by a revised value of frameCount,
// but we will still need the original value also
audio_session_t originalSessionId = mSessionId;
sp<IMemory> iMem; // for cblk
sp<IMemory> bufferMem;
sp<IAudioRecord> record = audioFlinger->openRecord(input,
mSampleRate,
mFormat,
mChannelMask,
opPackageName,
&temp,
&flags,
mClientPid,
tid,
mClientUid,
&mSessionId,
¬ificationFrames,
iMem,
bufferMem,
&status);
ALOGE_IF(originalSessionId != AUDIO_SESSION_ALLOCATE && mSessionId != originalSessionId,
"session ID changed from %d to %d", originalSessionId, mSessionId);
if (status != NO_ERROR) {
ALOGE("AudioFlinger could not create record track, status: %d", status);
break;
}
ALOG_ASSERT(record != 0);
// AudioFlinger now owns the reference to the I/O handle,
// so we are no longer responsible for releasing it.
mAwaitBoost = false;
if (mFlags & AUDIO_INPUT_FLAG_FAST) {
if (flags & AUDIO_INPUT_FLAG_FAST) {
ALOGI("AUDIO_INPUT_FLAG_FAST successful; frameCount %zu", frameCount);
mAwaitBoost = true;
} else {
ALOGW("AUDIO_INPUT_FLAG_FAST denied by server; frameCount %zu", frameCount);
mFlags = (audio_input_flags_t) (mFlags & ~(AUDIO_INPUT_FLAG_FAST |
AUDIO_INPUT_FLAG_RAW));
continue; // retry
}
}
mFlags = flags;
if (iMem == 0) {
ALOGE("Could not get control block");
return NO_INIT;
}
void *iMemPointer = iMem->pointer();
if (iMemPointer == NULL) {
ALOGE("Could not get control block pointer");
return NO_INIT;
}
audio_track_cblk_t* cblk = static_cast<audio_track_cblk_t*>(iMemPointer);
// Starting address of buffers in shared memory.
// The buffers are either immediately after the control block,
// or in a separate area at discretion of server.
void *buffers;
if (bufferMem == 0) {
buffers = cblk + 1;
} else {
buffers = bufferMem->pointer();
if (buffers == NULL) {
ALOGE("Could not get buffer pointer");
return NO_INIT;
}
}
// invariant that mAudioRecord != 0 is true only after set() returns successfully
if (mAudioRecord != 0) {
IInterface::asBinder(mAudioRecord)->unlinkToDeath(mDeathNotifier, this);
mDeathNotifier.clear();
}
mAudioRecord = record;
mCblkMemory = iMem;
mBufferMemory = bufferMem;
IPCThreadState::self()->flushCommands();
mCblk = cblk;
// note that temp is the (possibly revised) value of frameCount
if (temp < frameCount || (frameCount == 0 && temp == 0)) {
ALOGW("Requested frameCount %zu but received frameCount %zu", frameCount, temp);
}
frameCount = temp;
// Make sure that application is notified with sufficient margin before overrun.
// The computation is done on server side.
if (mNotificationFramesReq > 0 && notificationFrames != mNotificationFramesReq) {
ALOGW("Server adjusted notificationFrames from %u to %zu for frameCount %zu",
mNotificationFramesReq, notificationFrames, frameCount);
}
mNotificationFramesAct = (uint32_t) notificationFrames;
// We retain a copy of the I/O handle, but don't own the reference
mInput = input;
mRefreshRemaining = true;
mFrameCount = frameCount;
// If IAudioRecord is re-created, don't let the requested frameCount
// decrease. This can confuse clients that cache frameCount().
if (frameCount > mReqFrameCount) {
mReqFrameCount = frameCount;
}
// update proxy
mProxy = new AudioRecordClientProxy(cblk, buffers, mFrameCount, mFrameSize);
mProxy->setEpoch(epoch);
mProxy->setMinimum(mNotificationFramesAct);
mDeathNotifier = new DeathNotifier(this);
IInterface::asBinder(mAudioRecord)->linkToDeath(mDeathNotifier, this);
if (mDeviceCallback != 0) {
AudioSystem::addAudioDeviceCallback(mDeviceCallback, mInput);
}
return NO_ERROR;
// End of retry loop.
// The lack of indentation is deliberate, to reduce code churn and ease merges.
}
// Arrive here on error, via a break
AudioSystem::releaseInput(input, mSessionId);
if (status == NO_ERROR) {
status = NO_INIT;
}
return status;
}
int wifi_get_status(char *sPattern)
{
int irtn = 0;
FILE *pf = NULL;
char lbuffer[512]={0};
char *pPtr=NULL;
#if defined(REALTEK_WFDISPLAY_SIGMA)
return 1;
#endif
/*
//if want to use ETHERNET test,
return 1;
*/
//1. check role
int irole = 0;
ALOGI("[%s:%d]:%s()- \n", __FILE__, __LINE__, __func__);
irole = wifi_get_role();
if (irole ==2) {//client
sprintf(lbuffer, "/usr/local/bin/IMS_Modules/Wfdisplay/scripts/wpa_cli status|grep wpa_state= > /tmp/p2pPeer.txt");
system(lbuffer);
pf = fopen( "/tmp/p2pPeer.txt", "r" );
if (pf!=NULL) {
memset(lbuffer,0,sizeof(lbuffer));
fread(lbuffer,1,sizeof(lbuffer),pf);
ALOGI("[%s:%d]:%s()- wpa status=%s\n", __FILE__, __LINE__, __func__, lbuffer);
if (strstr(lbuffer,"wpa_state=")!=NULL) {
pPtr = lbuffer+strlen("wpa_state=");
//ALOGI("[%s:%d]:%s()- pPtr=%s,sPattern=%s\n", __FILE__, __LINE__, __func__, pPtr,sPattern);
if (strncmp(pPtr,sPattern,strlen(sPattern))==0) {
//ALOGI("[%s:%d]:%s()- pPtr=%s\n", __FILE__, __LINE__, __func__, pPtr);
irtn = 1;
}
}
fclose(pf);
}
}
else if (irole==3) {
memset(lbuffer,0,sizeof(lbuffer));
if (1) {
sprintf(lbuffer, "/usr/local/bin/IMS_Modules/Wfdisplay/scripts/hostapd_cli all_sta |grep dot11RSNAStatsSTAAddress= > /tmp/p2pPeer.txt");
system(lbuffer);
NP("tandy:[%s:%d]:%s()- System cmd:%s\n", __FILE__, __LINE__, __func__, lbuffer);
pf = fopen( "/tmp/p2pPeer.txt", "r" );
if (pf!=NULL) {
memset(lbuffer,0,sizeof(lbuffer));
fread(lbuffer,1,sizeof(lbuffer),pf);
ALOGI("[%s:%d]:%s()- lbuffer=%s\n", __FILE__, __LINE__, __func__, lbuffer);
pPtr = strstr(lbuffer,"dot11RSNAStatsSTAAddress=");
if (pPtr!=NULL) {
pPtr += strlen("dot11RSNAStatsSTAAddress=");
if (*pPtr !=0 && *pPtr!='\n') {
irtn = 1;
}
}
fclose(pf);
}
else {
NP("tandy:[%s:%d]:%s()\n", __FILE__, __LINE__, __func__);
}
}
}
else {//unlnown role
}
remove("/tmp/p2pPeer.txt");
return irtn;
}
HelloWorldService::~HelloWorldService()
{
ALOGI("HelloWorldService is destroyed");
}
MediaScanResult StagefrightMediaScanner::processFileInternal(
const char *path, const char * /* mimeType */,
MediaScannerClient &client) {
const char *extension = strrchr(path, '.');
if (!extension) {
return MEDIA_SCAN_RESULT_SKIPPED;
}
if (!FileHasAcceptableExtension(extension)) {
return MEDIA_SCAN_RESULT_SKIPPED;
}
#ifdef MTK_AOSP_ENHANCEMENT
#ifdef MTK_DRM_APP
// add dcf meta data for dcf file
// check extension first
ALOGV("processFileInternal() : the extension: %s", extension);
bool isOMADrmDcf = false;
if (0 == strcasecmp(extension, ".dcf")) {
String8 tmp(path);
DrmManagerClient* drmManagerClient = new DrmManagerClient();
DrmMetadata* dcfMetadata = drmManagerClient->getMetadata(&tmp);
if (dcfMetadata == NULL) {
ALOGW("scan: OMA DRM v1: failed to get drm metadata, not scanned into db.");
delete drmManagerClient;
client.setMimeType("bad mime type");
return MEDIA_SCAN_RESULT_SKIPPED;
}
struct Map {
const char* from;
int to;
};
static const Map kMap[] = {
{DrmMetaKey::META_KEY_IS_DRM,
METADATA_KEY_IS_DRM}, // "is_drm"
{DrmMetaKey::META_KEY_CONTENT_URI,
METADATA_KEY_DRM_CONTENT_URI},
{DrmMetaKey::META_KEY_OFFSET,
METADATA_KEY_DRM_OFFSET},
{DrmMetaKey::META_KEY_DATALEN,
METADATA_KEY_DRM_DATALEN},
{DrmMetaKey::META_KEY_RIGHTS_ISSUER,
METADATA_KEY_DRM_RIGHTS_ISSUER},
{DrmMetaKey::META_KEY_CONTENT_NAME,
METADATA_KEY_DRM_CONTENT_NAME},
{DrmMetaKey::META_KEY_CONTENT_DESCRIPTION,
METADATA_KEY_DRM_CONTENT_DES},
{DrmMetaKey::META_KEY_CONTENT_VENDOR,
METADATA_KEY_DRM_CONTENT_VENDOR},
{DrmMetaKey::META_KEY_ICON_URI,
METADATA_KEY_DRM_ICON_URI} ,
{DrmMetaKey::META_KEY_METHOD,
METADATA_KEY_DRM_METHOD},
{DrmMetaKey::META_KEY_MIME,
METADATA_KEY_DRM_MIME}
};
static const size_t kNumMapEntries = sizeof(kMap) / sizeof(kMap[0]);
int action = Action::PLAY;
String8 type;
for (size_t i = 0; i < kNumMapEntries; ++i) {
String8 value = dcfMetadata->get(String8(kMap[i].from));
if (value.length() != 0)
{
if (kMap[i].to == METADATA_KEY_DRM_MIME) {
value = DrmMtkUtil::toCommonMime(value.string());
// not audio/video/image -> not scan into db
type.setTo(value.string(), 6);
if (0 != strcasecmp(type.string(), "audio/")
&& 0 != strcasecmp(type.string(), "video/")
&& 0 != strcasecmp(type.string(), "image/")) {
ALOGW("scan: OMA DRM v1: invalid drm media file mime type[%s], not added into db.",
value.string());
delete dcfMetadata;
delete drmManagerClient;
client.setMimeType("bad mime type");
return MEDIA_SCAN_RESULT_SKIPPED;
}
client.setMimeType(value.string());
ALOGD("scan: OMA DRM v1: drm original mime type[%s].",
value.string());
// determine the Action it shall used.
if ((0 == strcasecmp(type.string(), "audio/"))
|| (0 == strcasecmp(type.string(), "video/"))) {
action = Action::PLAY;
} else if ((0 == strcasecmp(type.string(), "image/"))) {
action = Action::DISPLAY;
}
}
if (kMap[i].to == METADATA_KEY_IS_DRM) {
isOMADrmDcf = (value == String8("1"));
}
client.addStringTag(kMap[i].from, value.string());
ALOGD("scan: OMA DRM v1: client.addString tag[%s] value[%s].",
kMap[i].from, value.string());
}
}
// if there's no valid rights for this file currently, just return OK
// to make sure it can be scanned into db.
if (isOMADrmDcf
&& RightsStatus::RIGHTS_VALID != drmManagerClient->checkRightsStatus(tmp, action)) {
ALOGD("scan: OMA DRM v1: current no valid rights, return OK so that it can be added into db.");
delete dcfMetadata;
delete drmManagerClient;
return MEDIA_SCAN_RESULT_OK;
}
// when there's valid rights, should contine to add extra metadata
ALOGD("scan: OMA DRM v1: current valid rights, continue to add extra info.");
delete dcfMetadata; dcfMetadata = NULL;
delete drmManagerClient; drmManagerClient = NULL;
// if picture then we need not to scan with extractors.
if (isOMADrmDcf && 0 == strcasecmp(type.string(), "image/")) {
ALOGD("scan: OMA DRM v1: for DRM image we do not sniff with extractors.");
return MEDIA_SCAN_RESULT_OK;
}
}
#endif
#endif // #ifdef MTK_AOSP_ENHANCEMENT
if (!strcasecmp(extension, ".mid")
|| !strcasecmp(extension, ".smf")
|| !strcasecmp(extension, ".imy")
|| !strcasecmp(extension, ".midi")
|| !strcasecmp(extension, ".xmf")
|| !strcasecmp(extension, ".rtttl")
|| !strcasecmp(extension, ".rtx")
|| !strcasecmp(extension, ".ota")
|| !strcasecmp(extension, ".mxmf")) {
return HandleMIDI(path, &client);
}
sp<MediaMetadataRetriever> mRetriever(new MediaMetadataRetriever);
int fd = open(path, O_RDONLY | O_LARGEFILE);
status_t status;
if (fd < 0) {
// couldn't open it locally, maybe the media server can?
status = mRetriever->setDataSource(NULL /* httpService */, path);
} else {
status = mRetriever->setDataSource(fd, 0, 0x7ffffffffffffffL);
//why close fd so fast???--haizhen
close(fd);
}
if (status) {
#ifdef MTK_AOSP_ENHANCEMENT
//if this still need on ICS
// set mime type to "bad mime type" for unsupported format, otherwise the file will be included in Gallery/Music
ALOGE("processFile '%s' - not supported", path);
client.setMimeType("bad mime type");
return MEDIA_SCAN_RESULT_SKIPPED;
#else
return MEDIA_SCAN_RESULT_ERROR;
#endif
}
const char *value;
if ((value = mRetriever->extractMetadata(
METADATA_KEY_MIMETYPE)) != NULL) {
status = client.setMimeType(value);
if (status) {
return MEDIA_SCAN_RESULT_ERROR;
}
}
struct KeyMap {
const char *tag;
int key;
};
static const KeyMap kKeyMap[] = {
{ "tracknumber", METADATA_KEY_CD_TRACK_NUMBER },
{ "discnumber", METADATA_KEY_DISC_NUMBER },
{ "album", METADATA_KEY_ALBUM },
{ "artist", METADATA_KEY_ARTIST },
{ "albumartist", METADATA_KEY_ALBUMARTIST },
{ "composer", METADATA_KEY_COMPOSER },
{ "genre", METADATA_KEY_GENRE },
{ "title", METADATA_KEY_TITLE },
{ "year", METADATA_KEY_YEAR },
{ "duration", METADATA_KEY_DURATION },
{ "writer", METADATA_KEY_WRITER },
{ "compilation", METADATA_KEY_COMPILATION },
{ "isdrm", METADATA_KEY_IS_DRM },
{ "width", METADATA_KEY_VIDEO_WIDTH },
{ "height", METADATA_KEY_VIDEO_HEIGHT },
/// M: add for the Gallery 6595 new feature -- fancy layout
{ "rotation", METADATA_KEY_VIDEO_ROTATION },
#ifdef MTK_AOSP_ENHANCEMENT
/*
#ifdef MTK_S3D_SUPPORT
{"stereotype",METADATA_KEY_STEREO_3D}, //stereo 3d info
#endif
*/
#ifdef MTK_SLOW_MOTION_VIDEO_SUPPORT
{"slowMotion_Speed_value",METADATA_KEY_SlowMotion_SpeedValue},
#endif
{"is_live_photo",METADATA_KEY_Is_LivePhoto},
#endif
};
static const size_t kNumEntries = sizeof(kKeyMap) / sizeof(kKeyMap[0]);
for (size_t i = 0; i < kNumEntries; ++i) {
const char *value;
if ((value = mRetriever->extractMetadata(kKeyMap[i].key)) != NULL) {
#ifdef MTK_AOSP_ENHANCEMENT
#ifdef MTK_DRM_APP
if (kKeyMap[i].key == METADATA_KEY_IS_DRM) {
if (isOMADrmDcf) {
ALOGD("set METADATA_KEY_IS_DRM to 1 for OMA DRM v1.");
value = "1";
}
}
#endif
#endif // #ifdef MTK_AOSP_ENHANCEMENT
status = client.addStringTag(kKeyMap[i].tag, value);
ALOGD("processFileInternal() : client.addString tag[%s] value[%s]",
kKeyMap[i].tag, value);
if (status != OK) {
return MEDIA_SCAN_RESULT_ERROR;
}
#ifdef MTK_AOSP_ENHANCEMENT
if (kKeyMap[i].key == METADATA_KEY_DURATION) {
if (!strcasecmp(extension, ".mp3")
|| !strcasecmp(extension, ".aac")
|| !strcasecmp(extension, ".amr")
|| !strcasecmp(extension, ".awb")) {
client.addStringTag("isAccurateDuration", "0");
} else if (!strcasecmp(extension, ".wav")
|| !strcasecmp(extension, ".ogg")
|| !strcasecmp(extension, ".oga")) {
client.addStringTag("isAccurateDuration", "1");
}
}
#endif // #ifdef MTK_AOSP_ENHANCEMENT
}
}
#ifdef MTK_AOSP_ENHANCEMENT
ALOGI("processFileInternal '%s' - return OK", path);
#endif
return MEDIA_SCAN_RESULT_OK;
}
/*===========================================================================
* FUNCTION : init
*
* DESCRIPTION: initialize stream obj
*
* PARAMETERS :
* @streamInfoBuf: ptr to buf that contains stream info
* @stream_cb : stream data notify callback. Can be NULL if not needed
* @userdata : user data ptr
*
* RETURN : int32_t type of status
* NO_ERROR -- success
* none-zero failure code
*==========================================================================*/
int32_t QCamera3Stream::init(cam_stream_type_t streamType,
cam_format_t streamFormat,
cam_dimension_t streamDim,
uint8_t minNumBuffers,
stream_cb_routine stream_cb,
void *userdata)
{
int32_t rc = OK;
mm_camera_stream_config_t stream_config;
mHandle = mCamOps->add_stream(mCamHandle, mChannelHandle);
if (!mHandle) {
ALOGE("add_stream failed");
rc = UNKNOWN_ERROR;
goto done;
}
// allocate and map stream info memory
mStreamInfoBuf = new QCamera3HeapMemory();
if (mStreamInfoBuf == NULL) {
ALOGE("%s: no memory for stream info buf obj", __func__);
rc = -ENOMEM;
goto err1;
}
rc = mStreamInfoBuf->allocate(1, sizeof(cam_stream_info_t), false);
if (rc < 0) {
ALOGE("%s: no memory for stream info", __func__);
rc = -ENOMEM;
goto err2;
}
mStreamInfo =
reinterpret_cast<cam_stream_info_t *>(mStreamInfoBuf->getPtr(0));
memset(mStreamInfo, 0, sizeof(cam_stream_info_t));
mStreamInfo->stream_type = streamType;
mStreamInfo->fmt = streamFormat;
mStreamInfo->dim = streamDim;
mStreamInfo->streaming_mode = CAM_STREAMING_MODE_CONTINUOUS;
mNumBufs = minNumBuffers;
rc = mCamOps->map_stream_buf(mCamHandle,
mChannelHandle, mHandle, CAM_MAPPING_BUF_TYPE_STREAM_INFO,
0, -1, mStreamInfoBuf->getFd(0), mStreamInfoBuf->getSize(0));
if (rc < 0) {
ALOGE("Failed to map stream info buffer");
goto err3;
}
// Configure the stream
stream_config.stream_info = mStreamInfo;
stream_config.mem_vtbl = mMemVtbl;
stream_config.padding_info = mPaddingInfo;
stream_config.userdata = this;
switch(streamType) {
case CAM_STREAM_TYPE_SNAPSHOT:
stream_config.stream_cb = NULL;
ALOGI("%s: disabling stream_cb for snapshot", __func__);
break;
default:
stream_config.stream_cb = dataNotifyCB;
break;
}
rc = mCamOps->config_stream(mCamHandle,
mChannelHandle, mHandle, &stream_config);
if (rc < 0) {
ALOGE("Failed to config stream, rc = %d", rc);
goto err4;
}
mDataCB = stream_cb;
mUserData = userdata;
return 0;
err4:
mCamOps->unmap_stream_buf(mCamHandle,
mChannelHandle, mHandle, CAM_MAPPING_BUF_TYPE_STREAM_INFO, 0, -1);
err3:
mStreamInfoBuf->deallocate();
err2:
delete mStreamInfoBuf;
mStreamInfoBuf = NULL;
mStreamInfo = NULL;
err1:
mCamOps->delete_stream(mCamHandle, mChannelHandle, mHandle);
mHandle = 0;
mNumBufs = 0;
done:
return rc;
}
status_t HelloWorldService::helloWorld(const char* str)
{
ALOGI("%s\n",str);
printf("%s\n",str);
return NO_ERROR;
}
JNIEXPORT jint JNICALL Java_com_farcore_playerservice_AmPlayer_playMedia
(JNIEnv *env, jobject obj,jstring url, jint isloop, jint pMode,jint st){
int pid = -1;
jclass clazz = (*env)->GetObjectClass(env, obj);
gMplayerClazz =(*env)->NewGlobalRef(env,clazz);
if(gMplayerClazz){
ALOGI("get mediaplayer class");
}else{
ALOGE("can't get mediaplayer class");
return -100;
}
gPostMid = (*env)->GetStaticMethodID(env, gMplayerClazz, "onUpdateState", "(IIIIIII)V");
if(gPostMid){
ALOGI("get update state object id");
}else{
ALOGE("failed to get update object id");
return -101;
}
const char * pname = (*env)->GetStringUTFChars(env,url, NULL);
if(NULL == pname)
{
ALOGE("failed to change jstring to standard string");
return -1;
}
if(_plCtrl.file_name != NULL){
free(_plCtrl.file_name);
}
memset((void*)&_plCtrl,0,sizeof(play_control_t));
player_register_update_callback(&_plCtrl.callback_fn,&update_player_info,PLAYER_INFO_POP_INTERVAL);
_plCtrl.file_name = strndup(pname,FILENAME_LENGTH_MAX);
_plCtrl.video_index = -1;//MUST
_plCtrl.audio_index = -1;//MUST
_plCtrl.hassub = 1;
if(pMode == 1){
_plCtrl.nosound = 1;
SYS_set_tsync_enable(0);//if no sound,can set to be 0
ALOGI("disable sound");
}else if(pMode ==2){
_plCtrl.novideo = 1;
ALOGI("disable video");
}
SYS_set_tsync_enable(1);//if no sound,can set to be 0
if(isloop>0){
_plCtrl.loop_mode =1;
ALOGI("set loop mode");
}
if(st>0){
ALOGI("play start position:%d",st);
_plCtrl.t_pos = st;
}
ALOGI("add a media file to play");
pid=player_start(&_plCtrl,0);
if(pid<0)
{
ALOGI("player start failed!error=%d\n",pid);
return -1;
}
(*env)->ReleaseStringUTFChars(env,url, pname);
return pid;
}
/*
* Class: com_farcore_playerservice_MediaPlayer
* Method: resume
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_com_farcore_playerservice_AmPlayer_resume
(JNIEnv *env, jobject obj, jint pid){
ALOGI("player resume");
player_resume(pid);
return 0;
}
jobject MediaInfoContext_create(JNIEnv *env,media_info_t *msgt){
int index = 0;
jclass meta_cls = MediaInfo_getClass(env);
if(NULL == meta_cls){
ALOGE("failed to get MediaInfo class");
return NULL;
}
if(NULL==msgt){
ALOGE("set invalid msg info");
return NULL;
}
//set file info
jmethodID constructor = (*env)->GetMethodID(env, meta_cls, "<init>", "()V");
jobject meta_obj = (*env)->NewObject(env,meta_cls,constructor);
(*env)->SetIntField(env,meta_obj,\
(*env)->GetFieldID(env, meta_cls, "seekable", "I"), (int)(msgt->stream_info.seekable));
jfieldID id_filetype = (*env)->GetFieldID(env, meta_cls, "filetype", "I");
(*env)->SetIntField(env, meta_obj, id_filetype, (int)(msgt->stream_info.type));
(*env)->SetLongField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "filesize", "J"), msgt->stream_info.file_size);
(*env)->SetIntField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "duration", "I"), msgt->stream_info.duration);
(*env)->SetIntField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "drm_check", "I"), msgt->stream_info.drm_check);
if (msgt->stream_info.has_video && msgt->stream_info.total_video_num>0) {
(*env)->SetIntField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "width", "I"), msgt->video_info[0]->width);
(*env)->SetIntField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "height", "I"), msgt->video_info[0]->height);
(*env)->SetIntField(env,meta_obj, (*env)->GetFieldID(env, meta_cls, "vformat", "I"), msgt->video_info[0]->format);
}
if(msgt->stream_info.has_audio>0 && msgt->stream_info.total_audio_num>0){
jclass ainfo_cls = AudioMediaInfo_getClass(env);
jmethodID amid = (*env)->GetMethodID(env,ainfo_cls, "<init>", "()V");
if(!amid){
ALOGE("failed to get audio info constructor");
return meta_obj;
}
jobjectArray ainfoArray = (*env)->NewObjectArray(env,msgt->stream_info.total_audio_num,ainfo_cls, NULL);
if(NULL == ainfoArray){
ALOGE("failed to get audio info object");
return meta_obj;
}
for(index = 0;index<msgt->stream_info.total_audio_num;index++){
jobject aobj = (*env)->NewObject(env,ainfo_cls, amid);
if(NULL ==aobj){
(*env)->DeleteLocalRef(env,ainfoArray);
ALOGE("failed to get audio info object");
return meta_obj;
}
(*env)->SetIntField(env,aobj,\
(*env)->GetFieldID(env, ainfo_cls, "audio_format", "I"), (int)(msgt->audio_info[index]->aformat));
/*(*env)->SetIntField(env,aobj,\
(*env)->GetFieldID(env, ainfo_cls, "audio_channel", "I"), (int)(msgt->audio_info[index]->channel));
(*env)->SetIntField(env,aobj,\
(*env)->GetFieldID(env, ainfo_cls, "audio_samplerate", "I"), (int)(msgt->audio_info[index]->sample_rate));
(*env)->SetIntField(env,aobj,\
(*env)->GetFieldID(env, ainfo_cls, "bit_rate", "I"), (int)(msgt->audio_info[index]->bit_rate));*/
(*env)->SetIntField(env,aobj,\
(*env)->GetFieldID(env, ainfo_cls, "uid", "I"), (int)(msgt->audio_info[index]->id));
(*env)->SetObjectArrayElement(env,ainfoArray,index, aobj);
}
(*env)->SetObjectField(env,meta_obj,(*env)->GetFieldID(env, meta_cls, "ainfo", "[Lcom/farcore/playerservice/AudioMediaInfo;"),ainfoArray);
}
//for insub num;
if(msgt->stream_info.total_sub_num>0)
{
ALOGI("================== 'in internal subtitle num:%d\n", msgt->stream_info.total_sub_num);
jclass sub_cls =Intersub_getClass(env);
(*env)->SetStaticIntField(env,sub_cls,(*env)->GetStaticFieldID(env, sub_cls, "insub_num", "I"),(int)(msgt->stream_info.total_sub_num));
}
#if 0
if(msgt->audio_info[0]->audio_tag!=NULL){
jclass tag_cls = AudioTagInfo_getClass(env);
jmethodID tagmid = (*env)->GetMethodID(env,tag_cls, "<init>", "()V");
if(NULL == tagmid){
ALOGE("failed to get tag info constructor");
return meta_obj;
}
jobject tagobj = (*env)->NewObject(env,tag_cls, tagmid);
if(NULL ==tagobj){
ALOGE("failed to get tag info object");
return meta_obj;
}
jstring title = (*env)->NewStringUTF(env,msgt->audio_info[0]->audio_tag->title);
(*env)->SetObjectField(env,tagobj,
(*env)->GetFieldID(env, tag_cls, "title", "Ljava/lang/String;"), title);
jstring album = (*env)->NewStringUTF(env,msgt->audio_info[0]->audio_tag->album);
(*env)->SetObjectField(env,tagobj,
(*env)->GetFieldID(env, tag_cls, "album", "Ljava/lang/String;"),album);
jstring author = (*env)->NewStringUTF(env,msgt->audio_info[0]->audio_tag->author);
(*env)->SetObjectField(env,tagobj,
(*env)->GetFieldID(env, tag_cls, "author", "Ljava/lang/String;"), author);
(*env)->SetObjectField(env,meta_obj,
(*env)->GetFieldID(env, meta_cls, "taginfo", "Lcom/farcore/playerservice/AudioTagInfo;"),tagobj);
}
if(msgt->stream_info.total_sub_num>0) {
jclass sub_cls =Intersub_getClass(env);
jmethodID submid = (*env)->GetMethodID(env,sub_cls, "<init>", "()V");
if(NULL == submid){
ALOGE("failed to get sub info constructor");
return meta_obj;
}
jobjectArray subArray = (*env)->NewObjectArray(env,msgt->stream_info.total_sub_num,sub_cls, NULL);
if(NULL == subArray){
ALOGI("failed to get audio info object");
return meta_obj;
}
for(index = 0;index<msgt->stream_info.total_sub_num;index++) {
jobject subobj = (*env)->NewObject(env,sub_cls, submid);
if(NULL ==subobj){
ALOGE("failed to get sub info object");
return meta_obj;
}
(*env)->SetIntField(env,subobj,
(*env)->GetFieldID(env, sub_cls, "sub_uid", "I"),(int) (msgt->sub_info[index]->id));
(*env)->SetObjectArrayElement(env,subArray,index, subobj);
}
(*env)->SetObjectField(env,meta_obj,(*env)->GetFieldID(env, meta_cls, "sinfo", "[Lcom/farcore/playerservice/InternalSubtitleInfo;"),subArray);
}
#endif
return meta_obj;
}
/*
* Class: com_farcore_playerservice_MediaPlayer
* Method: addMediaSource
* Signature: (Ljava/lang/String;III)I
*/
JNIEXPORT jint JNICALL Java_com_farcore_playerservice_AmPlayer_setMediaFd
(JNIEnv *env, jobject obj, jobject fileDescriptor,jint isloop, jint pMode,jint st,jlong offset, jlong length){
int pid = -1;
char * file=NULL;
jclass clazz = (*env)->GetObjectClass(env, obj);
gMplayerClazz =(*env)->NewGlobalRef(env,clazz);
if(gMplayerClazz){
ALOGI("get mediaplayer class");
}else{
ALOGE("can't get mediaplayer class");
return -100;
}
gPostMid = (*env)->GetStaticMethodID(env, gMplayerClazz, "onUpdateState", "(IIIIIII)V");
if(gPostMid){
ALOGI("get update state object id");
}else{
ALOGE("failed to get update object id");
return -101;
}
URLProtocol *prot=&android_protocol;
prot->name="android";
prot->url_open=(int (*)(URLContext *, const char *, int ))vp_open;
prot->url_read=(int (*)(URLContext *, unsigned char *, int))vp_read;
prot->url_write=(int (*)(URLContext *, unsigned char *, int))vp_write;
prot->url_seek=(int64_t (*)(URLContext *, int64_t , int))vp_seek;
prot->url_close=(int (*)(URLContext *))vp_close;
prot->url_get_file_handle = (int (*)(URLContext *))vp_get_file_handle;
av_register_protocol(prot);
if (fileDescriptor == NULL) {
return -1;
}
int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
if(fd<0 || offset<0)
return -1;
file=(char *)malloc(128);
if(file==NULL)
return -1;
mAmlogicFile.oldfd=fd;
mAmlogicFile.fd = dup(fd);
mAmlogicFile.fd_valid=1;
mAmlogicFile.mOffset=offset;
mAmlogicFile.mLength=length;
_plCtrl.t_pos=-1;/*don't seek to 0*/
//mPlay_ctl.t_pos=0;/*don't seek to 0*/
sprintf(file,"android:AmlogicPlayer=[%x:%x],AmlogicPlayer_fd=[%x:%x]",
NULL,NULL,
(unsigned int)&mAmlogicFile,(~(unsigned int)&mAmlogicFile));
if(_plCtrl.file_name != NULL){
free(_plCtrl.file_name);
}
memset((void*)&_plCtrl,0,sizeof(play_control_t));
player_register_update_callback(&_plCtrl.callback_fn,&update_player_info,PLAYER_INFO_POP_INTERVAL);
//_plCtrl.file_name = strndup(pname,FILENAME_LENGTH_MAX);
mAmlogicFile.datasource=file;
_plCtrl.file_name=(char*)mAmlogicFile.datasource;
_plCtrl.video_index = -1;//MUST
_plCtrl.audio_index = -1;//MUST
_plCtrl.hassub = 1; //enable subtitle
if(pMode == 1){
_plCtrl.nosound = 1;
SYS_set_tsync_enable(0);//if no sound,can set to be 0
ALOGI("disable sound");
}else if(pMode ==2){
_plCtrl.novideo = 1;
ALOGI("disable video");
}
if(st>0){
ALOGI("play start position:%d",st);
_plCtrl.t_pos = st;
}
SYS_set_tsync_enable(1);//if no sound,can set to be 0
if(isloop>0){
_plCtrl.loop_mode =1;
ALOGI("set loop mode");
}
_plCtrl.need_start = 1;
ALOGI("set a media file to play,but need start it using start interface");
pid=player_start(&_plCtrl,0);
if(pid<0)
{
ALOGI("player start failed!error=%d\n",pid);
return -1;
}
//(*env)->ReleaseStringUTFChars(env,url, pname);
return pid;
}
int _media_info_dump(media_info_t* minfo)
{
int i = 0;
ALOGI("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
ALOGI("======||file size:%lld\n",minfo->stream_info.file_size);
ALOGI("======||file type:%d\n",minfo->stream_info.type);
ALOGI("======||has internal subtitle?:%s\n",minfo->stream_info.has_sub>0?"YES!":"NO!");
ALOGI("======||internal subtile counts:%d\n",minfo->stream_info.total_sub_num);
ALOGI("======||has video track?:%s\n",minfo->stream_info.has_video>0?"YES!":"NO!");
ALOGI("======||has audio track?:%s\n",minfo->stream_info.has_audio>0?"YES!":"NO!");
ALOGI("======||duration:%d\n",minfo->stream_info.duration);
ALOGI("======||seekable:%d\n",minfo->stream_info.seekable);
if(minfo->stream_info.has_video && minfo->stream_info.total_video_num>0)
{
ALOGI("======||video counts:%d\n",minfo->stream_info.total_video_num);
ALOGI("======||video width:%d\n",minfo->video_info[0]->width);
ALOGI("======||video height:%d\n",minfo->video_info[0]->height);
ALOGI("======||video bitrate:%d\n",minfo->video_info[0]->bit_rate);
ALOGI("======||video format:%d\n",minfo->video_info[0]->format);
}
if(minfo->stream_info.has_audio &&minfo->stream_info.total_audio_num> 0)
{
ALOGI("======||audio counts:%d\n",minfo->stream_info.total_audio_num);
if(NULL !=minfo->audio_info[0]->audio_tag)
{
ALOGI("======||track title:%s",minfo->audio_info[0]->audio_tag->title!=NULL?minfo->audio_info[0]->audio_tag->title:"unknow");
ALOGI("\n======||track album:%s",minfo->audio_info[0]->audio_tag->album!=NULL?minfo->audio_info[0]->audio_tag->album:"unknow");
ALOGI("\n======||track author:%s\n",minfo->audio_info[0]->audio_tag->author!=NULL?minfo->audio_info[0]->audio_tag->author:"unknow");
ALOGI("\n======||track year:%s\n",minfo->audio_info[0]->audio_tag->year!=NULL?minfo->audio_info[0]->audio_tag->year:"unknow");
ALOGI("\n======||track comment:%s\n",minfo->audio_info[0]->audio_tag->comment!=NULL?minfo->audio_info[0]->audio_tag->comment:"unknow");
ALOGI("\n======||track genre:%s\n",minfo->audio_info[0]->audio_tag->genre!=NULL?minfo->audio_info[0]->audio_tag->genre:"unknow");
ALOGI("\n======||track copyright:%s\n",minfo->audio_info[0]->audio_tag->copyright!=NULL?minfo->audio_info[0]->audio_tag->copyright:"unknow");
ALOGI("\n======||track track:%d\n",minfo->audio_info[0]->audio_tag->track);
}
for(i = 0;i<minfo->stream_info.total_audio_num;i++)
{
ALOGI("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
ALOGI("======||%d 'st audio track codec type:%d\n",i,minfo->audio_info[i]->aformat);
ALOGI("======||%d 'st audio track audio_channel:%d\n",i,minfo->audio_info[i]->channel);
ALOGI("======||%d 'st audio track bit_rate:%d\n",i,minfo->audio_info[i]->bit_rate);
ALOGI("======||%d 'st audio track audio_samplerate:%d\n",i,minfo->audio_info[i]->sample_rate);
ALOGI("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
}
}
if(minfo->stream_info.has_sub &&minfo->stream_info.total_sub_num>0){
for(i = 0;i<minfo->stream_info.total_sub_num;i++)
{
if(0 == minfo->sub_info[i]->internal_external){
ALOGI("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
ALOGI("======||%d 'st internal subtitle pid:%d\n",i,minfo->sub_info[i]->id);
ALOGI("======||%d 'st internal subtitle language:%s\n",i,minfo->sub_info[i]->sub_language?minfo->sub_info[i]->sub_language:"unknow");
ALOGI("======||%d 'st internal subtitle width:%d\n",i,minfo->sub_info[i]->width);
ALOGI("======||%d 'st internal subtitle height:%d\n",i,minfo->sub_info[i]->height);
ALOGI("======||%d 'st internal subtitle resolution:%d\n",i,minfo->sub_info[i]->resolution);
ALOGI("======||%d 'st internal subtitle subtitle size:%lld\n",i,minfo->sub_info[i]->subtitle_size);
ALOGI("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n");
}
}
}
ALOGI("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n");
return 0;
}
int vp_get_file_handle(URLContext *h)
{
ALOGI("%s\n",__FUNCTION__);
return (intptr_t) h->priv_data;
}
JNIEXPORT jint Java_com_farcore_playerservice_AmPlayer_getosdbpp(JNIEnv *env, jclass clazz){
jint ret = -1;
ret = SYS_get_osdbpp();
ALOGI("get osd bpp:%d",ret);
return ret;
}
sp<ICamera> CameraService::connect(
const sp<ICameraClient>& cameraClient, int cameraId) {
int callingPid = getCallingPid();
LOG1("CameraService::connect E (pid %d, id %d)", callingPid, cameraId);
if (!mModule) {
ALOGE("Camera HAL module not loaded");
return NULL;
}
sp<Client> client;
if (cameraId < 0 || cameraId >= mNumberOfCameras) {
ALOGE("CameraService::connect X (pid %d) rejected (invalid cameraId %d).",
callingPid, cameraId);
return NULL;
}
char value[PROPERTY_VALUE_MAX];
property_get("sys.secpolicy.camera.disabled", value, "0");
if (strcmp(value, "1") == 0) {
// Camera is disabled by DevicePolicyManager.
ALOGI("Camera is disabled. connect X (pid %d) rejected", callingPid);
return NULL;
}
#if defined(BOARD_HAVE_HTC_FFC)
htcCameraSwitch(cameraId);
#endif
Mutex::Autolock lock(mServiceLock);
if (mClient[cameraId] != 0) {
client = mClient[cameraId].promote();
if (client != 0) {
if (cameraClient->asBinder() == client->getCameraClient()->asBinder()) {
LOG1("CameraService::connect X (pid %d) (the same client)",
callingPid);
return client;
} else {
ALOGW("CameraService::connect X (pid %d) rejected (existing client).",
callingPid);
return NULL;
}
}
mClient[cameraId].clear();
}
if (mBusy[cameraId]) {
ALOGW("CameraService::connect X (pid %d) rejected"
" (camera %d is still busy).", callingPid, cameraId);
return NULL;
}
struct camera_info info;
if (mModule->get_camera_info(cameraId, &info) != OK) {
ALOGE("Invalid camera id %d", cameraId);
return NULL;
}
int deviceVersion;
if (mModule->common.module_api_version == CAMERA_MODULE_API_VERSION_2_0) {
deviceVersion = info.device_version;
} else {
deviceVersion = CAMERA_DEVICE_API_VERSION_1_0;
}
switch(deviceVersion) {
case CAMERA_DEVICE_API_VERSION_1_0:
client = new CameraClient(this, cameraClient, cameraId,
info.facing, callingPid, getpid());
break;
case CAMERA_DEVICE_API_VERSION_2_0:
client = new Camera2Client(this, cameraClient, cameraId,
info.facing, callingPid, getpid());
break;
default:
ALOGE("Unknown camera device HAL version: %d", deviceVersion);
return NULL;
}
if (client->initialize(mModule) != OK) {
return NULL;
}
cameraClient->asBinder()->linkToDeath(this);
mClient[cameraId] = client;
LOG1("CameraService::connect X (id %d, this pid is %d)", cameraId, getpid());
return client;
}
/*
* Class: com_farcore_playerservice_MediaPlayer
* Method: set3Dmode
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_com_farcore_playerservice_AmPlayer_set3Dmode
(JNIEnv *env, jobject obj, jint pid, jint mode){
ALOGI("JNI Set 3D mode:%d,player pid:%d\n",mode,pid);
int ret = SYS_set_3D_mode((SYS_3D_MODE_SET)mode);
return ret;
}
CameraService::CameraService()
:mSoundRef(0), mModule(0)
{
ALOGI("CameraService started (pid=%d)", getpid());
gCameraService = this;
}
int vp_write(URLContext *h, unsigned char *buf, int size)
{
AmlogicPlayer_File* af= (AmlogicPlayer_File*)h->priv_data;
ALOGI("%s\n",__FUNCTION__);
return -1;
}
int wcnss_qmi_get_wlan_address(unsigned char *pBdAddr)
{
int i = 0;
struct stat mac_stat;
int success = 0;
while (stat(MAC_ADDR_PATH, &mac_stat) && i < MAX_WAIT_COUNT) {
usleep(WAIT_TIME);
i++;
}
if (i == MAX_WAIT_COUNT) {
ALOGE("Failed to obtain MAC address from NV\n");
} else {
int fd = open(MAC_ADDR_PATH, O_RDONLY);
if (fd < 0) {
ALOGE("Failure opening MAC path: %d\n", errno);
} else {
char mac_buf[MAC_ADDR_SIZE];
int ret = read(fd, mac_buf, MAC_ADDR_SIZE);
if (ret < 0) {
ALOGE("Failure to read MAC data: %d\n", errno);
} else {
/* swap bytes */
for (i = 0; i < MAC_ADDR_SIZE; i++) {
pBdAddr[i] = mac_buf[MAC_ADDR_SIZE - 1 - i];
}
ALOGI("Successfully read MAC from NV data");
success = 1;
}
close(fd);
}
}
// Use a previously stored value on failure (if it exists)
if (!success && !stat(GENMAC_FILE, &mac_stat)) {
FILE *genmac = fopen(GENMAC_FILE,"r");
if (fscanf(genmac, "%c%c%c%c%c%c",
&pBdAddr[0], &pBdAddr[1], &pBdAddr[2],
&pBdAddr[3], &pBdAddr[4], &pBdAddr[5]) == 6) {
ALOGE("Successfully read local MAC address");
success = 1;
}
fclose(genmac);
}
// If that fails as well, randomize a MAC
if (!success) {
memcpy(pBdAddr, oneplus_mac_prefix, sizeof(oneplus_mac_prefix));
// We don't need strong randomness, and if the NV is corrupted
// any hardware values are suspect, so just seed it with the
// current time
srand(time(NULL));
for (i = sizeof(oneplus_mac_prefix) / sizeof(oneplus_mac_prefix[0]); i < MAC_ADDR_SIZE; i++) {
pBdAddr[i] = rand() % 255;
}
ALOGI("Using randomized MAC address");
// Store for reuse
FILE *genmac = fopen(GENMAC_FILE, "w");
fwrite(pBdAddr, 1, MAC_ADDR_SIZE, genmac);
fclose(genmac);
}
ALOGI("Using MAC address: %02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n",
pBdAddr[0], pBdAddr[1], pBdAddr[2],
pBdAddr[3], pBdAddr[4], pBdAddr[5]);
return SUCCESS;
}
// This function is used as an alternative to opening the char device directly.
// It is needed as libbt-vendor does the power up/down control for us when we open/close the file descriptor.
int init_transport_bdroid(int on) {
void *so_handle;
unsigned char bdaddr[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
int fd[CH_MAX], powerstate, ret;
if (on) {
so_handle = dlopen("libbt-vendor.so", RTLD_NOW);
if (!so_handle)
{
ALOGE("Failed to load vendor component");
return -1;
}
vendor_interface = (bt_vendor_interface_t *) dlsym(so_handle, "BLUETOOTH_VENDOR_LIB_INTERFACE");
if (!vendor_interface)
{
ALOGE("Failed to accesst bt vendor interface");
return -1;
}
vendor_interface->init(&vendor_callbacks, bdaddr);
ALOGI("Turn On BT power");
powerstate = BT_VND_PWR_ON;
ret = vendor_interface->op(BT_VND_OP_POWER_CTRL, &powerstate);
if (ret < 0)
{
ALOGE("Failed to turn on power from bt vendor interface");
return -1;
}
/*call ANT_USERIAL_OPEN to get ANT handle*/
#ifdef BT_SOC_TYPE_ROME
ret = vendor_interface->op(BT_VND_OP_ANT_USERIAL_OPEN, fd);
#endif
ALOGE("ret value: %d", ret);
if (ret != 1)
{
ALOGE("Failed to get fd from bt vendor interface");
return -1;
} else {
ALOGE("FD: %x", fd[0]);
return fd[0];
}
} else {
if (vendor_interface) {
ALOGE("Close and cleanup the interfaces");
#ifdef BT_SOC_TYPE_ROME
int ret = vendor_interface->op(BT_VND_OP_ANT_USERIAL_CLOSE, NULL);
#endif
ALOGE("ret value: %d", ret);
ALOGI("Turn off BT power");
powerstate = BT_VND_PWR_OFF;
ret = vendor_interface->op(BT_VND_OP_POWER_CTRL, &powerstate);
if (ret < 0)
{
ALOGE("Failed to turn off power from bt vendor interface");
return -1;
}
vendor_interface->cleanup();
vendor_interface = NULL;
return 0;
} else {
ALOGE("Not able to find vendor interface handle");
return -1;
}
}
}
HelloWorldService::HelloWorldService()
{
ALOGI("HelloWorldService is created");
}
int wcnss_write_cal_data(int fd_dev)
{
int rcount = 0;
int size = 0;
int rc = 0;
int wcount = 0;
int fd_file;
struct stat st;
char buf[WCNSS_CAL_CHUNK];
ALOGI("wcnss_write_cal_data trying to write cal");
rc = stat(WCNSS_CAL_FILE, &st);
if (rc < 0) {
ALOGE("Failed to stat cal file : %s",
strerror(errno));
goto exit;
}
size = st.st_size;
fd_file = open(WCNSS_CAL_FILE, O_RDONLY);
if (fd_file < 0) {
ALOGE("cal file doesn't exist: %s",
strerror(errno));
rc = fd_file;
goto exit;
}
/* write the file size first, so that platform driver knows
* when it recieves the full data */
wcount = write(fd_dev, (void *)&size, 4);
if (wcount != 4) {
ALOGE("Failed to write to wcnss device : %s",
strerror(errno));
rc = wcount;
goto exit_close;
}
do {
rcount = read(fd_file, (void *)buf, sizeof(buf));
if (rcount < 0) {
ALOGE("Failed to read from cal file ; %s",
strerror(errno));
rc = rcount;
goto exit_remove;
}
if (!rcount)
break;
wcount = write(fd_dev, buf, rcount);
if (wcount < 0) {
ALOGE("Failed to write to wcnss device : %s",
strerror(errno));
rc = wcount;
goto exit_close;
}
} while (rcount);
close(fd_file);
return SUCCESS;
exit_remove:
close(fd_file);
remove("WCNSS_CAL_FILE");
return rc;
exit_close:
close(fd_file);
exit:
return rc;
}
/*
* Start the Dalvik Virtual Machine.
*
* Various arguments, most determined by system properties, are passed in.
* The "mOptions" vector is updated.
*
* Returns 0 on success.
*/
int AndroidRuntime::startVm(JavaVM** pJavaVM, JNIEnv** pEnv)
{
int result = -1;
JavaVMInitArgs initArgs;
JavaVMOption opt;
char propBuf[PROPERTY_VALUE_MAX];
char stackTraceFileBuf[PROPERTY_VALUE_MAX];
char dexoptFlagsBuf[PROPERTY_VALUE_MAX];
char enableAssertBuf[sizeof("-ea:")-1 + PROPERTY_VALUE_MAX];
char jniOptsBuf[sizeof("-Xjniopts:")-1 + PROPERTY_VALUE_MAX];
char heapstartsizeOptsBuf[sizeof("-Xms")-1 + PROPERTY_VALUE_MAX];
char heapsizeOptsBuf[sizeof("-Xmx")-1 + PROPERTY_VALUE_MAX];
char heapgrowthlimitOptsBuf[sizeof("-XX:HeapGrowthLimit=")-1 + PROPERTY_VALUE_MAX];
char heapminfreeOptsBuf[sizeof("-XX:HeapMinFree=")-1 + PROPERTY_VALUE_MAX];
char heapmaxfreeOptsBuf[sizeof("-XX:HeapMaxFree=")-1 + PROPERTY_VALUE_MAX];
char heaptargetutilizationOptsBuf[sizeof("-XX:HeapTargetUtilization=")-1 + PROPERTY_VALUE_MAX];
char extraOptsBuf[PROPERTY_VALUE_MAX];
char* stackTraceFile = NULL;
bool checkJni = false;
bool checkDexSum = false;
bool logStdio = false;
enum {
kEMDefault,
kEMIntPortable,
kEMIntFast,
#if defined(WITH_JIT)
kEMJitCompiler,
#endif
} executionMode = kEMDefault;
property_get("dalvik.vm.checkjni", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
checkJni = true;
} else if (strcmp(propBuf, "false") != 0) {
/* property is neither true nor false; fall back on kernel parameter */
property_get("ro.kernel.android.checkjni", propBuf, "");
if (propBuf[0] == '1') {
checkJni = true;
}
}
property_get("dalvik.vm.execution-mode", propBuf, "");
if (strcmp(propBuf, "int:portable") == 0) {
executionMode = kEMIntPortable;
} else if (strcmp(propBuf, "int:fast") == 0) {
executionMode = kEMIntFast;
#if defined(WITH_JIT)
} else if (strcmp(propBuf, "int:jit") == 0) {
executionMode = kEMJitCompiler;
#endif
}
property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, "");
property_get("dalvik.vm.check-dex-sum", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
checkDexSum = true;
}
property_get("log.redirect-stdio", propBuf, "");
if (strcmp(propBuf, "true") == 0) {
logStdio = true;
}
strcpy(enableAssertBuf, "-ea:");
property_get("dalvik.vm.enableassertions", enableAssertBuf+4, "");
strcpy(jniOptsBuf, "-Xjniopts:");
property_get("dalvik.vm.jniopts", jniOptsBuf+10, "");
/* route exit() to our handler */
opt.extraInfo = (void*) runtime_exit;
opt.optionString = "exit";
mOptions.add(opt);
/* route fprintf() to our handler */
opt.extraInfo = (void*) runtime_vfprintf;
opt.optionString = "vfprintf";
mOptions.add(opt);
/* register the framework-specific "is sensitive thread" hook */
opt.extraInfo = (void*) runtime_isSensitiveThread;
opt.optionString = "sensitiveThread";
mOptions.add(opt);
opt.extraInfo = NULL;
/* enable verbose; standard options are { jni, gc, class } */
//options[curOpt++].optionString = "-verbose:jni";
opt.optionString = "-verbose:gc";
mOptions.add(opt);
//options[curOpt++].optionString = "-verbose:class";
/*
* The default starting and maximum size of the heap. Larger
* values should be specified in a product property override.
*/
strcpy(heapstartsizeOptsBuf, "-Xms");
property_get("dalvik.vm.heapstartsize", heapstartsizeOptsBuf+4, "4m");
opt.optionString = heapstartsizeOptsBuf;
mOptions.add(opt);
strcpy(heapsizeOptsBuf, "-Xmx");
property_get("dalvik.vm.heapsize", heapsizeOptsBuf+4, "16m");
opt.optionString = heapsizeOptsBuf;
mOptions.add(opt);
// Increase the main thread's interpreter stack size for bug 6315322.
opt.optionString = "-XX:mainThreadStackSize=24K";
mOptions.add(opt);
strcpy(heapgrowthlimitOptsBuf, "-XX:HeapGrowthLimit=");
property_get("dalvik.vm.heapgrowthlimit", heapgrowthlimitOptsBuf+20, "");
if (heapgrowthlimitOptsBuf[20] != '\0') {
opt.optionString = heapgrowthlimitOptsBuf;
mOptions.add(opt);
}
strcpy(heapminfreeOptsBuf, "-XX:HeapMinFree=");
property_get("dalvik.vm.heapminfree", heapminfreeOptsBuf+16, "");
if (heapminfreeOptsBuf[16] != '\0') {
opt.optionString = heapminfreeOptsBuf;
mOptions.add(opt);
}
strcpy(heapmaxfreeOptsBuf, "-XX:HeapMaxFree=");
property_get("dalvik.vm.heapmaxfree", heapmaxfreeOptsBuf+16, "");
if (heapmaxfreeOptsBuf[16] != '\0') {
opt.optionString = heapmaxfreeOptsBuf;
mOptions.add(opt);
}
strcpy(heaptargetutilizationOptsBuf, "-XX:HeapTargetUtilization=");
property_get("dalvik.vm.heaptargetutilization", heaptargetutilizationOptsBuf+26, "");
if (heaptargetutilizationOptsBuf[26] != '\0') {
opt.optionString = heaptargetutilizationOptsBuf;
mOptions.add(opt);
}
/*
* Enable or disable dexopt features, such as bytecode verification and
* calculation of register maps for precise GC.
*/
property_get("dalvik.vm.dexopt-flags", dexoptFlagsBuf, "");
if (dexoptFlagsBuf[0] != '\0') {
const char* opc;
const char* val;
opc = strstr(dexoptFlagsBuf, "v="); /* verification */
if (opc != NULL) {
switch (*(opc+2)) {
case 'n': val = "-Xverify:none"; break;
case 'r': val = "-Xverify:remote"; break;
case 'a': val = "-Xverify:all"; break;
default: val = NULL; break;
}
if (val != NULL) {
opt.optionString = val;
mOptions.add(opt);
}
}
opc = strstr(dexoptFlagsBuf, "o="); /* optimization */
if (opc != NULL) {
switch (*(opc+2)) {
case 'n': val = "-Xdexopt:none"; break;
case 'v': val = "-Xdexopt:verified"; break;
case 'a': val = "-Xdexopt:all"; break;
case 'f': val = "-Xdexopt:full"; break;
default: val = NULL; break;
}
if (val != NULL) {
opt.optionString = val;
mOptions.add(opt);
}
}
opc = strstr(dexoptFlagsBuf, "m=y"); /* register map */
if (opc != NULL) {
opt.optionString = "-Xgenregmap";
mOptions.add(opt);
/* turn on precise GC while we're at it */
opt.optionString = "-Xgc:precise";
mOptions.add(opt);
}
}
/* enable debugging; set suspend=y to pause during VM init */
/* use android ADB transport */
opt.optionString =
"-agentlib:jdwp=transport=dt_android_adb,suspend=n,server=y";
mOptions.add(opt);
ALOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF");
if (checkJni) {
/* extended JNI checking */
opt.optionString = "-Xcheck:jni";
mOptions.add(opt);
/* set a cap on JNI global references */
opt.optionString = "-Xjnigreflimit:2000";
mOptions.add(opt);
/* with -Xcheck:jni, this provides a JNI function call trace */
//opt.optionString = "-verbose:jni";
//mOptions.add(opt);
}
char lockProfThresholdBuf[sizeof("-Xlockprofthreshold:") + sizeof(propBuf)];
property_get("dalvik.vm.lockprof.threshold", propBuf, "");
if (strlen(propBuf) > 0) {
strcpy(lockProfThresholdBuf, "-Xlockprofthreshold:");
strcat(lockProfThresholdBuf, propBuf);
opt.optionString = lockProfThresholdBuf;
mOptions.add(opt);
}
#if defined(WITH_JIT)
/* Force interpreter-only mode for selected opcodes. Eg "1-0a,3c,f1-ff" */
char jitOpBuf[sizeof("-Xjitop:") + PROPERTY_VALUE_MAX];
property_get("dalvik.vm.jit.op", propBuf, "");
if (strlen(propBuf) > 0) {
strcpy(jitOpBuf, "-Xjitop:");
strcat(jitOpBuf, propBuf);
opt.optionString = jitOpBuf;
mOptions.add(opt);
}
/* Force interpreter-only mode for selected methods */
char jitMethodBuf[sizeof("-Xjitmethod:") + PROPERTY_VALUE_MAX];
property_get("dalvik.vm.jit.method", propBuf, "");
if (strlen(propBuf) > 0) {
strcpy(jitMethodBuf, "-Xjitmethod:");
strcat(jitMethodBuf, propBuf);
opt.optionString = jitMethodBuf;
mOptions.add(opt);
}
#endif
if (executionMode == kEMIntPortable) {
opt.optionString = "-Xint:portable";
mOptions.add(opt);
} else if (executionMode == kEMIntFast) {
opt.optionString = "-Xint:fast";
mOptions.add(opt);
#if defined(WITH_JIT)
} else if (executionMode == kEMJitCompiler) {
opt.optionString = "-Xint:jit";
mOptions.add(opt);
#endif
}
if (checkDexSum) {
/* perform additional DEX checksum tests */
opt.optionString = "-Xcheckdexsum";
mOptions.add(opt);
}
if (logStdio) {
/* convert stdout/stderr to log messages */
opt.optionString = "-Xlog-stdio";
mOptions.add(opt);
}
if (enableAssertBuf[4] != '\0') {
/* accept "all" to mean "all classes and packages" */
if (strcmp(enableAssertBuf+4, "all") == 0)
enableAssertBuf[3] = '\0';
ALOGI("Assertions enabled: '%s'\n", enableAssertBuf);
opt.optionString = enableAssertBuf;
mOptions.add(opt);
} else {
ALOGV("Assertions disabled\n");
}
if (jniOptsBuf[10] != '\0') {
ALOGI("JNI options: '%s'\n", jniOptsBuf);
opt.optionString = jniOptsBuf;
mOptions.add(opt);
}
if (stackTraceFileBuf[0] != '\0') {
static const char* stfOptName = "-Xstacktracefile:";
stackTraceFile = (char*) malloc(strlen(stfOptName) +
strlen(stackTraceFileBuf) +1);
strcpy(stackTraceFile, stfOptName);
strcat(stackTraceFile, stackTraceFileBuf);
opt.optionString = stackTraceFile;
mOptions.add(opt);
}
/* extra options; parse this late so it overrides others */
property_get("dalvik.vm.extra-opts", extraOptsBuf, "");
parseExtraOpts(extraOptsBuf);
/* Set the properties for locale */
{
char langOption[sizeof("-Duser.language=") + 3];
char regionOption[sizeof("-Duser.region=") + 3];
strcpy(langOption, "-Duser.language=");
strcpy(regionOption, "-Duser.region=");
readLocale(langOption, regionOption);
opt.extraInfo = NULL;
opt.optionString = langOption;
mOptions.add(opt);
opt.optionString = regionOption;
mOptions.add(opt);
}
/*
* We don't have /tmp on the device, but we often have an SD card. Apps
* shouldn't use this, but some test suites might want to exercise it.
*/
opt.optionString = "-Djava.io.tmpdir=/sdcard";
mOptions.add(opt);
initArgs.version = JNI_VERSION_1_4;
initArgs.options = mOptions.editArray();
initArgs.nOptions = mOptions.size();
initArgs.ignoreUnrecognized = JNI_FALSE;
/*
* Initialize the VM.
*
* The JavaVM* is essentially per-process, and the JNIEnv* is per-thread.
* If this call succeeds, the VM is ready, and we can start issuing
* JNI calls.
*/
if (JNI_CreateJavaVM(pJavaVM, pEnv, &initArgs) < 0) {
ALOGE("JNI_CreateJavaVM failed\n");
goto bail;
}
result = 0;
bail:
free(stackTraceFile);
return result;
}
int main() {
int l_socket_fd = -1;
int c_socket_fd = -1;
fd_set fds;
l_socket_fd = android_get_control_socket(SOCKET_NAME);
if (l_socket_fd < 0 ){
ALOGE("Unable to open inputdevinfo_socket (%s)\n", strerror(errno));
return -1;
}
if (make_nonblocking (l_socket_fd)) {
ALOGE("Unable to modify inputdevinfo_socket flags. (%s)\n", strerror(errno));
}
if (listen (l_socket_fd, 0) < 0) {
ALOGE("Unable to open inputdevinfo_socket (%s)\n", strerror(errno));
return -1;
}
while(1){
FD_ZERO(&fds);
FD_SET(l_socket_fd, &fds);
if (c_socket_fd >= 0 ) {
// && fcntl(c_socket_fd, F_GETFD) >= 0 ?
FD_SET(c_socket_fd, &fds);
}
int retval = select(get_max(c_socket_fd, l_socket_fd) + 1, &fds, NULL, NULL, NULL);
if(retval <= 0){
ALOGI("Error\n");
// Should I check for EBADR?
break;
}
if(FD_ISSET(l_socket_fd, &fds)) {
ALOGI("Connection attempt\n");
if(c_socket_fd < 0) {
c_socket_fd = accept(l_socket_fd, NULL, NULL);
}
if (make_nonblocking (c_socket_fd)) {
ALOGE("Unable to modify socket flags. (%s)\n", strerror(errno));
}
}
if(c_socket_fd >= 0 && FD_ISSET(c_socket_fd, &fds)){
int unread_bytes_count;
if (ioctl(c_socket_fd, FIONREAD, &unread_bytes_count)){
ALOGE("Attempt to check if client socket is closed resulted in error.\n");
} else if(unread_bytes_count == 0) {
//TODO: Check return code?
close(c_socket_fd);
c_socket_fd = -1;
} else {
process_cmds(c_socket_fd, MAX_COMMAND_LENGTH);
close(c_socket_fd);
c_socket_fd = -1;
}
}
}
return 0;
}
StagefrightMediaScanner::~StagefrightMediaScanner() {
#ifdef MTK_AOSP_ENHANCEMENT
ALOGI("StagefrightMediaScanner destructor");
#endif
}
/*
* Copy the native library if needed.
*
* This function assumes the library and path names passed in are considered safe.
*/
static install_status_t
copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName)
{
jstring* javaNativeLibPath = (jstring*) arg;
ScopedUtfChars nativeLibPath(env, *javaNativeLibPath);
size_t uncompLen;
long when;
long crc;
time_t modTime;
if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, &when, &crc)) {
ALOGD("Couldn't read zip entry info\n");
return INSTALL_FAILED_INVALID_APK;
} else {
struct tm t;
ZipUtils::zipTimeToTimespec(when, &t);
t.tm_isdst=0;
modTime = mktime(&t);
}
// Build local file path
const size_t fileNameLen = strlen(fileName);
char localFileName[nativeLibPath.size() + fileNameLen + 2];
if (strlcpy(localFileName, nativeLibPath.c_str(), sizeof(localFileName)) != nativeLibPath.size()) {
ALOGD("Couldn't allocate local file name for library");
return INSTALL_FAILED_INTERNAL_ERROR;
}
*(localFileName + nativeLibPath.size()) = '/';
if (strlcpy(localFileName + nativeLibPath.size() + 1, fileName, sizeof(localFileName)
- nativeLibPath.size() - 1) != fileNameLen) {
ALOGD("Couldn't allocate local file name for library");
return INSTALL_FAILED_INTERNAL_ERROR;
}
// Only copy out the native file if it's different.
struct stat64 st;
if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) {
return INSTALL_SUCCEEDED;
}
char localTmpFileName[nativeLibPath.size() + TMP_FILE_PATTERN_LEN + 2];
if (strlcpy(localTmpFileName, nativeLibPath.c_str(), sizeof(localTmpFileName))
!= nativeLibPath.size()) {
ALOGD("Couldn't allocate local file name for library");
return INSTALL_FAILED_INTERNAL_ERROR;
}
*(localFileName + nativeLibPath.size()) = '/';
if (strlcpy(localTmpFileName + nativeLibPath.size(), TMP_FILE_PATTERN,
TMP_FILE_PATTERN_LEN - nativeLibPath.size()) != TMP_FILE_PATTERN_LEN) {
ALOGI("Couldn't allocate temporary file name for library");
return INSTALL_FAILED_INTERNAL_ERROR;
}
int fd = mkstemp(localTmpFileName);
if (fd < 0) {
ALOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno));
return INSTALL_FAILED_CONTAINER_ERROR;
}
if (!zipFile->uncompressEntry(zipEntry, fd)) {
ALOGI("Failed uncompressing %s to %s\n", fileName, localTmpFileName);
close(fd);
unlink(localTmpFileName);
return INSTALL_FAILED_CONTAINER_ERROR;
}
close(fd);
// Set the modification time for this file to the ZIP's mod time.
struct timeval times[2];
times[0].tv_sec = st.st_atime;
times[1].tv_sec = modTime;
times[0].tv_usec = times[1].tv_usec = 0;
if (utimes(localTmpFileName, times) < 0) {
ALOGI("Couldn't change modification time on %s: %s\n", localTmpFileName, strerror(errno));
unlink(localTmpFileName);
return INSTALL_FAILED_CONTAINER_ERROR;
}
// Set the mode to 755
static const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
if (chmod(localTmpFileName, mode) < 0) {
ALOGI("Couldn't change permissions on %s: %s\n", localTmpFileName, strerror(errno));
unlink(localTmpFileName);
return INSTALL_FAILED_CONTAINER_ERROR;
}
// Finally, rename it to the final name.
if (rename(localTmpFileName, localFileName) < 0) {
ALOGI("Couldn't rename %s to %s: %s\n", localTmpFileName, localFileName, strerror(errno));
unlink(localTmpFileName);
return INSTALL_FAILED_CONTAINER_ERROR;
}
ALOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName);
return INSTALL_SUCCEEDED;
}
static void printGLString(const char *name, GLenum s) {
const char *v = (const char *) glGetString(s);
ALOGI("GL %s = %s\n", name, v);
}
// static
sp<VBRISeeker> VBRISeeker::CreateFromSource(
const sp<DataSource> &source, off64_t post_id3_pos) {
off64_t pos = post_id3_pos;
uint8_t header[4];
ssize_t n = source->readAt(pos, header, sizeof(header));
if (n < (ssize_t)sizeof(header)) {
return NULL;
}
uint32_t tmp = U32_AT(&header[0]);
size_t frameSize;
int sampleRate;
if (!GetMPEGAudioFrameSize(tmp, &frameSize, &sampleRate)) {
return NULL;
}
// VBRI header follows 32 bytes after the header _ends_.
pos += sizeof(header) + 32;
uint8_t vbriHeader[26];
n = source->readAt(pos, vbriHeader, sizeof(vbriHeader));
if (n < (ssize_t)sizeof(vbriHeader)) {
return NULL;
}
if (memcmp(vbriHeader, "VBRI", 4)) {
return NULL;
}
size_t numFrames = U32_AT(&vbriHeader[14]);
int64_t durationUs =
numFrames * 1000000ll * (sampleRate >= 32000 ? 1152 : 576) / sampleRate;
ALOGV("duration = %.2f secs", durationUs / 1E6);
size_t numEntries = U16_AT(&vbriHeader[18]);
size_t entrySize = U16_AT(&vbriHeader[22]);
size_t scale = U16_AT(&vbriHeader[20]);
ALOGV("%d entries, scale=%d, size_per_entry=%d",
numEntries,
scale,
entrySize);
size_t totalEntrySize = numEntries * entrySize;
uint8_t *buffer = new uint8_t[totalEntrySize];
n = source->readAt(pos + sizeof(vbriHeader), buffer, totalEntrySize);
if (n < (ssize_t)totalEntrySize) {
delete[] buffer;
buffer = NULL;
return NULL;
}
sp<VBRISeeker> seeker = new VBRISeeker;
seeker->mBasePos = post_id3_pos + frameSize;
// only update mDurationUs if the calculated duration is valid (non zero)
// otherwise, leave duration at -1 so that getDuration() and getOffsetForTime()
// return false when called, to indicate that this vbri tag does not have the
// requested information
if (durationUs) {
seeker->mDurationUs = durationUs;
}
off64_t offset = post_id3_pos;
for (size_t i = 0; i < numEntries; ++i) {
uint32_t numBytes;
switch (entrySize) {
case 1:
numBytes = buffer[i];
break;
case 2:
numBytes = U16_AT(buffer + 2 * i);
break;
case 3:
numBytes = U24_AT(buffer + 3 * i);
break;
default:
{
CHECK_EQ(entrySize, 4u);
numBytes = U32_AT(buffer + 4 * i);
break;
}
}
numBytes *= scale;
seeker->mSegments.push(numBytes);
ALOGV("entry #%d: %d offset 0x%08lx", i, numBytes, offset);
offset += numBytes;
}
delete[] buffer;
buffer = NULL;
ALOGI("Found VBRI header.");
return seeker;
}
static void* wifi_hdcp_thread(void * arg)
{
fd_set rfds, efds;
int nfds=0;
static int displayinfo=0;
bool bOut=false;
static int forceSocketDisconnectCount;
ihdcp_thread_run=1;
ALOGI("[LY] wifi_hdcp_thread start\n");
while(1)
{
switch (g_hdcpThreadState)
{
case EM_HDCP_THREAD_STATE_START:
if (displayinfo==0)
{
ALOGI("[LY] HDCP2 listenport=%d, dataport=%d, state=%d\n", sources.hdcp2_listenport, sources.hdcp2_dataport, g_hdcpThreadState);
displayinfo++;
}
nfds=0;
break;
case EM_HDCP_THREAD_STATE_STOP:
ALOGI("[LY] wifi_hdcp_thread stop\n");
if (sources.hdcp2_listenport > 0) {
close(sources.hdcp2_listenport);
sources.hdcp2_listenport = -1;
}
if (sources.hdcp2_dataport > 0) {
close(sources.hdcp2_dataport);
sources.hdcp2_dataport = -1;
}
bOut = true;
break;
case EM_HDCP_THREAD_STATE_PENDING:
default:
continue;
}
if (bOut == true) {
NP("tandy: [%s, %s, %d]\n", __FILE__, __func__, __LINE__);
break;
}
// HDCP2 port handling
nfds = wifi_hdcp_select(&sources, &rfds, &efds, 2000);
if (nfds <= 0)
continue;
if (sources.hdcp2_dataport < 0 && listen(sources.hdcp2_listenport, 1)<0)
{
ALOGI("HDCP2 Rx is waiting for connection..........\n");
continue;
}
if (nfds > 0)
{
if (sources.hdcp2_dataport > 0 )
{
//WiDi_UDHCPC_Enable = false;
if (FD_ISSET(sources.hdcp2_dataport, &rfds)) {
NP("tandylo: [%s:%d:%s] data in\n",__FILE__,__LINE__,__func__);
if (wifi_hdcp2_process_msg(sources.hdcp2_dataport) == false)
{
/*kelly retry auth
if (forceSocketDisconnectCount++ > 30)
{
//sources.WDP_Disonnect = true;
NP("tandylo: [%s:%d:%s] force disconnect hdcp thread\n",__FILE__,__LINE__,__func__);
break;
}kelly retry auth*/
//kelly add for retry auth form source
close(sources.hdcp2_dataport);
sources.hdcp2_dataport = -1;
//kelly add for retry auth form source
NP("tandylo: [%s:%d:%s] read 0 byte in connection\n",__FILE__,__LINE__,__func__);
continue;
}
forceSocketDisconnectCount = 0;
}
else
NP("tandylo: [%s:%d:%s] no data in connection\n",__FILE__,__LINE__,__func__);
if (FD_ISSET(sources.hdcp2_dataport, &efds)) {
NP("tandylo: [%s:%d:%s] error data connection\n",__FILE__,__LINE__,__func__);
close(sources.hdcp2_dataport);
sources.hdcp2_dataport = -1;
}
}
else if (sources.hdcp2_listenport > 0 && sources.hdcp2_dataport <= 0 &&
FD_ISSET(sources.hdcp2_listenport, &rfds)) {
struct sockaddr_in clntAddr;
socklen_t clntLen = sizeof(clntAddr);
int newfd = accept(sources.hdcp2_listenport,
(struct sockaddr*)&clntAddr,
&clntLen);
if (newfd <= 0) {
continue;
}
NP("tandylo: [%s:%d:%s] newfd=%d\n",__FILE__,__LINE__,__func__, newfd);
int nodelay = 1;
setsockopt(newfd, SOL_SOCKET, TCP_NODELAY, &nodelay, sizeof(nodelay));
sources.hdcp2_dataport = newfd;
}
}
}
ALOGI("[LY] wifi_hdcp_thread exit\n");
ihdcp_thread_run=0;
return NULL;
}
/*******************************************************************************
**
** Function userial_vendor_open
**
** Description Open the serial port with the given configuration
**
** Returns device fd
**
*******************************************************************************/
int userial_vendor_open(tUSERIAL_CFG *p_cfg)
{
uint32_t baud;
uint8_t data_bits;
uint16_t parity;
uint8_t stop_bits;
vnd_userial.fd = -1;
if (!userial_to_tcio_baud(p_cfg->baud, &baud))
{
return -1;
}
if(p_cfg->fmt & USERIAL_DATABITS_8)
data_bits = CS8;
else if(p_cfg->fmt & USERIAL_DATABITS_7)
data_bits = CS7;
else if(p_cfg->fmt & USERIAL_DATABITS_6)
data_bits = CS6;
else if(p_cfg->fmt & USERIAL_DATABITS_5)
data_bits = CS5;
else
{
ALOGE("userial vendor open: unsupported data bits");
return -1;
}
if(p_cfg->fmt & USERIAL_PARITY_NONE)
parity = 0;
else if(p_cfg->fmt & USERIAL_PARITY_EVEN)
parity = PARENB;
else if(p_cfg->fmt & USERIAL_PARITY_ODD)
parity = (PARENB | PARODD);
else
{
ALOGE("userial vendor open: unsupported parity bit mode");
return -1;
}
if(p_cfg->fmt & USERIAL_STOPBITS_1)
stop_bits = 0;
else if(p_cfg->fmt & USERIAL_STOPBITS_2)
stop_bits = CSTOPB;
else
{
ALOGE("userial vendor open: unsupported stop bits");
return -1;
}
ALOGI("userial vendor open: opening %s", vnd_userial.port_name);
if ((vnd_userial.fd = open(vnd_userial.port_name, O_RDWR)) == -1)
{
ALOGE("userial vendor open: unable to open %s", vnd_userial.port_name);
return -1;
}
tcflush(vnd_userial.fd, TCIOFLUSH);
tcgetattr(vnd_userial.fd, &vnd_userial.termios);
cfmakeraw(&vnd_userial.termios);
vnd_userial.termios.c_cflag |= (CRTSCTS | stop_bits);
tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
tcflush(vnd_userial.fd, TCIOFLUSH);
tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
tcflush(vnd_userial.fd, TCIOFLUSH);
tcflush(vnd_userial.fd, TCIOFLUSH);
/* set input/output baudrate */
cfsetospeed(&vnd_userial.termios, baud);
cfsetispeed(&vnd_userial.termios, baud);
tcsetattr(vnd_userial.fd, TCSANOW, &vnd_userial.termios);
#if (BT_WAKE_VIA_USERIAL_IOCTL==TRUE)
userial_ioctl_init_bt_wake(vnd_userial.fd);
#endif
ALOGI("device fd = %d open", vnd_userial.fd);
return vnd_userial.fd;
}
