JNIEXPORT void JNICALL NAME(nativeSetDataSource)(JNIEnv *env, jobject thiz, jstring path)
{
libvlc_instance_t *instance = (libvlc_instance_t *) getIntValue(env, thiz, "mLibVlcInstance");
libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
const char *str = (*env)->GetStringUTFChars(env, path, 0);
if (!str)
{
/* XXX: throw */
return;
}
libvlc_media_t *media = (*str == '/') ? libvlc_media_new_path(instance, str) : libvlc_media_new_location(instance, str);
if (media)
{
libvlc_event_manager_t *em = libvlc_media_event_manager(media);
for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++)
{
libvlc_event_attach(em, md_listening[i], vlc_event_callback, thiz);
}
/* this will cancel current input and start a new one */
libvlc_media_player_set_media(mp, media);
setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
}
(*env)->ReleaseStringUTFChars(env, path, str);
setIntValue(env, thiz, "mLibVlcMedia", (jint) media);
}
bool ExpressionItem::setValue(void* value_str,const data_type type) {
switch(type) {
case t_int: {
setIntValue(*(int *)value_str);
break;
}
case t_float: {
setFloatValue(*(float *)value_str);
break;
}
case t_smallInt:
{
setSmallIntValue(*(short *)value_str);
break;
}
case t_double: {
setDoubleValue(*(double *)value_str);
break;
}
case t_u_long: {
setULongValue(*(unsigned long*)value_str);
break;
}
case t_string: {
setStringValue(string((char *)value_str));
break;
}
case t_decimal: {
setDecimalValue((const char *)value_str);
break;
}
case t_datetime: {
setDatetimeValue((const char *)value_str);
break;
}
case t_date: {
setDateValue((const char *)value_str);
break;
}
case t_time: {
setTimeValue((const char *)value_str);
break;
}
case t_boolean: {
setBooleanValue(*(bool *)value_str);
break;
}
default: {
cout<<"no matching operator exists!!!"<<endl;
/*
* In the debug phase, it's better to show the assert failure in case of unexpected input.
* The bug can be found much more easily in such a way.
*/
assert(false);
break;
}
}
return true;
}
void IntVariableInfo::setToBlendedLinear(UniversalObjectInterface *aObject, UniversalObjectInterface *bObject, real t, real blendRatio, ObjectRefInstance *blendedRefInstance)
{
int tempValue = value;
aObject->setObjectToLinear(bObject, t, this);
setIntValue(linear(tempValue, value, blendRatio));
}
JNIEXPORT void JNICALL NAME(nativeCreate)(JNIEnv *env, jobject thiz)
{
initClasses(env, thiz);
vlc_mutex_t *parse_lock = calloc(1, sizeof(vlc_mutex_t));
vlc_mutex_init(parse_lock);
setIntValue(env, thiz, "mNativeMediaParseLock", (jint) parse_lock);
vlc_cond_t *parse_cond = calloc(1, sizeof(vlc_cond_t));
vlc_cond_init(parse_cond);
setIntValue(env, thiz, "mNativeMediaParseCond", (jint) parse_cond);
setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
const char *argv[] = {"-I", "dummy", "-vvv", "--no-plugins-cache", "--no-drop-late-frames", "--input-timeshift-path", "/data/local/tmp"};
libvlc_instance_t *instance = libvlc_new_with_builtins(sizeof(argv) / sizeof(*argv), argv, vlc_builtins_modules);
setIntValue(env, thiz, "mLibVlcInstance", (jint) instance);
libvlc_media_player_t *mp = libvlc_media_player_new(instance);
setIntValue(env, thiz, "mLibVlcMediaPlayer", (jint) mp);
/* throw? */
libvlc_event_manager_t *em = libvlc_media_player_event_manager(mp);
for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++)
{
libvlc_event_attach(em, mp_listening[i], vlc_event_callback, thiz);
}
}
void PropertyManager::setValue(QtProperty *prop, const QVariant &value)
{
QtAbstractPropertyManager *mngr = prop->propertyManager();
if (mngr == m_boolManager)
setBoolValue(prop, value.toBool());
else if (mngr == m_stringManager)
setStringValue(prop, value.toString());
else if (mngr == m_intManager)
setIntValue(prop, value.toInt());
else if (mngr == m_scriptManager)
setScriptValue(prop, value.toString());
else if (mngr == m_labelManager)
setLabelValue(prop, value.toString());
}
Var::Var(VarType type, const string& name) :
_type(type) {
_name = string(name);
switch (type) {
case VT_DOUBLE:
setDoubleValue(0.0);
break;
case VT_INT:
setIntValue(0);
break;
case VT_STRING:
setStringValue(0);
break;
default:
assert(false);
}
}
void hexString::operator = (const std::string Right){
std::string temp = "";
//strip out any illegal characters and whitespace
for (int j = 0; j < Right.length(); j++){
if (isLegalChar(Right[j])) {
temp += Right[j];
}
//Convert lowercase characters to uppercase ASCII a-f
if (Right[j] > 96 && Right[j] < 103){
char tempchar = Right[j] - 32;
temp += tempchar;
}
}
hexValue = temp;
setIntValue();;
}
void hexString::operator = (const char Right[]){
std::string temp = "";
std::string newHexString(Right);
//strip out any illegal characters and whitespace
for (int j = 0; j < newHexString.length(); j++){
if (isLegalChar(newHexString[j])) {
temp += newHexString[j];
}
//Convert lowercase characters to uppercase ASCII a-f
if (newHexString[j] > 96 && newHexString[j] < 103){
newHexString[j] -= 32;
temp += newHexString[j];
}
}
hexValue = temp;
setIntValue();
}
hexString::hexString(const std::string newHexString){
//Constructor from a string value.
std::string temp = "";
//strip out any illegal characters and whitespace
for (int j = 0; j < newHexString.length(); j++){
if (isLegalChar(newHexString[j])) {
temp += newHexString[j];
}
//Convert lowercase characters to uppercase ASCII a-f
if (newHexString[j] > 96 && newHexString[j] < 103){
char tempchar = newHexString[j] - 32;
temp += tempchar;
}
}
hexValue = temp;
setIntValue();
}
JNIEXPORT void JNICALL NAME(nativeRelease)(JNIEnv *env, jobject thiz)
{
vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, thiz, "mNativeMediaParseLock");
vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, thiz, "mNativeMediaParseCond");
/* wake up threads that waiting on prepare */
vlc_mutex_lock(parse_lock);
setIntValue(env, thiz, "mNativeMediaParsed", 4);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
jint mLibVlcMediaPlayer = getIntValue(env, thiz, "mLibVlcMediaPlayer");
if (mLibVlcMediaPlayer != 0)
{
libvlc_event_manager_t *em;
libvlc_media_player_t *mp = (libvlc_media_player_t*) mLibVlcMediaPlayer;
libvlc_media_t *md = libvlc_media_player_get_media(mp);
if (md) {
em = libvlc_media_event_manager(md);
for (int i = 0; i < sizeof(md_listening) / sizeof(*md_listening); i++)
{
libvlc_event_detach(em, md_listening[i], vlc_event_callback, thiz);
}
}
em = libvlc_media_player_event_manager(mp);
for (int i = 0; i < sizeof(mp_listening) / sizeof(*mp_listening); i++)
{
libvlc_event_detach(em, mp_listening[i], vlc_event_callback, thiz);
}
libvlc_media_player_stop(mp);
libvlc_media_player_release(mp);
setIntValue(env, thiz, "mLibVlcMediaPlayer", 0);
}
jint mLibVlcInstance = getIntValue(env, thiz, "mLibVlcInstance");
if (mLibVlcInstance != 0)
{
libvlc_instance_t *instance = (libvlc_instance_t*) mLibVlcInstance;
libvlc_release(instance);
setIntValue(env, thiz, "mLibVlcInstance", 0);
}
setIntValue(env, thiz, "mNativeMediaBufferingCount", 0);
vlc_mutex_destroy(parse_lock);
free(parse_lock);
setIntValue(env, thiz, "mNativeMediaParseLock", 0);
vlc_cond_destroy(parse_cond);
free(parse_cond);
setIntValue(env, thiz, "mNativeMediaParseCond", 0);
freeClasses(env, thiz);
}
bool FGPropertyManager::SetInt (const string &name, int val)
{
return setIntValue(name.c_str(), val);
}
static void vlc_event_callback(const libvlc_event_t *ev, void *data)
{
JNIEnv *env;
jobject obj_VlcMediaPlayer = g_obj_VlcMediaPlayer;
jobject obj_VlcEvent;
int trigger = 1;
if ((*gJVM)->AttachCurrentThread(gJVM, &env, 0) < 0)
return;
obj_VlcEvent = (*env)->AllocObject(env, clz_VlcEvent);
if (!obj_VlcEvent)
return;
libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMedia");
char *mrl = libvlc_media_get_mrl(media);
libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, obj_VlcMediaPlayer, "mLibVlcMediaPlayer");
vlc_mutex_t *parse_lock = (vlc_mutex_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseLock");
vlc_cond_t *parse_cond = (vlc_cond_t *) getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParseCond");
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, ev->type);
switch (ev->type) {
case libvlc_MediaDurationChanged: {
int64_t duration = ev->u.media_duration_changed.new_duration;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) duration);
break;
}
case libvlc_MediaStateChanged: {
int state = ev->u.media_state_changed.new_state;
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, state);
/* wake up if there is an error */
if (state == libvlc_MediaPlayerEncounteredError) {
vlc_mutex_lock(parse_lock);
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 2);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
}
break;
}
case libvlc_MediaParsedChanged: {
libvlc_media_player_play(mp);
trigger = 0;
break;
}
case libvlc_MediaPlayerBuffering: {
float cache = ev->u.media_player_buffering.new_cache;
(*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, cache);
int count = getIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount");
if ((int) cache == 100) {
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaBufferingCount", count + 1);
/* if it's the first time */
if (count == 0) {
/* send buffering update event now */
(*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent);
libvlc_media_player_set_pause(mp, 1);
/* asynchonous preparing is done */
vlc_mutex_lock(parse_lock);
setIntValue(env, obj_VlcMediaPlayer, "mNativeMediaParsed", 1);
vlc_cond_broadcast(parse_cond);
vlc_mutex_unlock(parse_lock);
/* simulate a media prepared event */
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_eventType, libvlc_MediaParsedChanged);
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, 1);
}
}
break;
}
case libvlc_MediaPlayerTimeChanged: {
int64_t time = ev->u.media_player_time_changed.new_time;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) time);
break;
}
case libvlc_MediaPlayerPositionChanged: {
float position = ev->u.media_player_position_changed.new_position;
(*env)->SetFloatField(env, obj_VlcEvent, f_VlcEvent_floatValue, position);
break;
}
case libvlc_MediaPlayerSeekableChanged: {
int seekable = ev->u.media_player_seekable_changed.new_seekable;
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, seekable > 0);
break;
}
case libvlc_MediaPlayerPausableChanged: {
int pausable = ev->u.media_player_pausable_changed.new_pausable;
(*env)->SetBooleanField(env, obj_VlcEvent, f_VlcEvent_booleanValue, pausable > 0);
break;
}
case libvlc_MediaPlayerTitleChanged: {
int title = ev->u.media_player_title_changed.new_title;
(*env)->SetIntField(env, obj_VlcEvent, f_VlcEvent_intValue, title);
break;
}
case libvlc_MediaPlayerSnapshotTaken: {
char *p = ev->u.media_player_snapshot_taken.psz_filename;
jstring path = (*env)->NewStringUTF(env, p);
(*env)->SetObjectField(env, obj_VlcEvent, f_VlcEvent_stringValue, path);
break;
}
case libvlc_MediaPlayerLengthChanged: {
int64_t length = ev->u.media_player_length_changed.new_length;
(*env)->SetLongField(env, obj_VlcEvent, f_VlcEvent_longValue, (jlong) length);
break;
}
default:
break;
}
if (trigger)
(*env)->CallVoidMethod(env, obj_VlcMediaPlayer, m_VlcMediaPlayer_onVlcEvent, obj_VlcEvent);
(*env)->DeleteLocalRef(env, obj_VlcEvent);
free(mrl);
/* EXPLAIN: this is called in pthread wrapper routines */
// (*gJVM)->DetachCurrentThread(gJVM);
}
Color::Color(unsigned int value) {
setIntValue(value);
}
Color::Color() {
setIntValue(0);
}
