void
_mp_app_media_key_event_cb(media_key_e key, media_key_event_e event, void *user_data)
{
struct appdata *ad = (struct appdata *)user_data;
MP_CHECK(ad);
mp_debug("key [%d], event [%d]", key, event);
bool released = false;
if (event == MEDIA_KEY_STATUS_RELEASED)
released = true;
if (event == MEDIA_KEY_STATUS_UNKNOWN) {
mp_debug("unknown key status");
return;
}
const char *signal = NULL;
switch (key) {
case MEDIA_KEY_PLAY:
if (released) {
if (ad->player_state != PLAY_STATE_PLAYING)
mp_play_control_play_pause(ad, true);
else
DEBUG_TRACE("Already playing state. skip event");
}
break;
case MEDIA_KEY_PAUSE:
if (released) {
if (ad->player_state == PLAY_STATE_PLAYING)
mp_play_control_play_pause(ad, false);
else
DEBUG_TRACE("Already pause state. skip event");
}
break;
case MEDIA_KEY_PREVIOUS:
case MEDIA_KEY_REWIND:
signal = (released) ? "rew_btn_up" : "rew_btn_down";
mp_play_control_rew_cb(ad, NULL, signal, CTR_EDJ_SIG_SRC);
break;
case MEDIA_KEY_NEXT:
case MEDIA_KEY_FASTFORWARD:
signal = (released) ? "ff_btn_up" : "ff_btn_down";
mp_play_control_ff_cb(ad, NULL, signal, CTR_EDJ_SIG_SRC);
break;
case MEDIA_KEY_STOP:
mp_player_control_stop(ad);
break;
default:
mp_debug("Undefined key");
break;
}
}
void mps_share_preconds_em(int *smooth) {
int ivals[4];
int ovals[4];
ivals[0] = 0;
ivals[1] = num_goals;
ivals[2] = failure_observed;
ivals[3] = 0;
MPI_Allreduce(ivals, ovals, 4, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
sw_msg_size = ovals[0];
num_goals = ovals[1];
failure_observed = ovals[2];
*smooth = ovals[3];
mp_debug("msgsize=%d, #goals=%d, failure=%s, smooth = %s",
sw_msg_size, num_goals, failure_observed ? "on" : "off", *smooth ? "on" : "off");
alloc_sw_msg_buffers();
mps_bcast_fixed();
if (*smooth) {
mps_bcast_smooth();
}
}
void mps_bcast_inside(void)
{
SW_INS_PTR sw_ins_ptr;
double *meg_ptr;
int i;
MPI_Bcast(sw_msg_recv, sw_msg_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);
mp_debug("mps_bcast_inside");
for (i = 0; i < occ_switch_tab_size; i++) {
meg_ptr = sw_msg_recv;
meg_ptr += occ_position[i];
for (sw_ins_ptr = occ_switches[i]; sw_ins_ptr != NULL; sw_ins_ptr = sw_ins_ptr->next) {
sw_ins_ptr->inside = *(meg_ptr++);
}
}
}
void mpm_bcast_inside(void)
{
SW_INS_PTR sw_ins_ptr;
double *meg_ptr;
int i;
meg_ptr = sw_msg_send;
for (i = 0; i < occ_switch_tab_size; i++) {
for (sw_ins_ptr = occ_switches[i]; sw_ins_ptr != NULL; sw_ins_ptr = sw_ins_ptr->next) {
*(meg_ptr++) = sw_ins_ptr->inside;
}
}
MPI_Bcast(sw_msg_send, sw_msg_size, MPI_DOUBLE, 0, MPI_COMM_WORLD);
mp_debug("mpm_bcast_inside");
}
void mpm_bcast_fixed(void)
{
SW_INS_PTR sw_ins_ptr;
char *meg_ptr;
int i;
meg_ptr = sw_msg_send;
for (i = 0; i < occ_switch_tab_size; i++) {
for (sw_ins_ptr = occ_switches[i]; sw_ins_ptr != NULL; sw_ins_ptr = sw_ins_ptr->next) {
*(meg_ptr++) = (!!sw_ins_ptr->fixed) | ((!!sw_ins_ptr->fixed_h) << 1);
}
}
MPI_Bcast(sw_msg_send, sw_msg_size, MPI_CHAR, 0, MPI_COMM_WORLD);
mp_debug("mpm_bcast_fixed");
}
int pc_mp_recv_swlayout_0(void)
{
occ_position = MALLOC(sizeof(int) * occ_switch_tab_size);
MPI_Recv(occ_position, occ_switch_tab_size, MPI_INT, 0, TAG_SWITCH_RES, MPI_COMM_WORLD, NULL);
/* debug */
{
int i;
TERM msw;
for (i = 0; i < occ_switch_tab_size; i++) {
msw = bpx_get_arg(1, prism_sw_ins_term(occ_switches[i]->id));
mp_debug("%s -> %d", bpx_term_2_string(msw), occ_position[i]);
}
}
return BP_TRUE;
}
void mps_bcast_fixed(void)
{
SW_INS_PTR sw_ins_ptr;
char *meg_ptr;
int i;
MPI_Bcast(sw_msg_recv, sw_msg_size, MPI_CHAR, 0, MPI_COMM_WORLD);
mp_debug("mps_bcast_fixed");
for (i = 0; i < occ_switch_tab_size; i++) {
meg_ptr = sw_msg_recv;
meg_ptr += occ_position[i];
for (sw_ins_ptr = occ_switches[i]; sw_ins_ptr != NULL; sw_ins_ptr = sw_ins_ptr->next) {
sw_ins_ptr->fixed = !!(*meg_ptr & 1);
sw_ins_ptr->fixed_h = !!(*meg_ptr & 2);
meg_ptr++;
}
}
}
NPError
NP_Initialize (NPNetscapeFuncs *mozilla_funcs, NPPluginFuncs *plugin_funcs)
{
MoonlightPlugin *moon_host = MMP_HANDLE ();
gsize mozilla_funcs_size;
MOON_CHECK_LOAD_PLUGIN ();
mp_debug ("NP_Initialize (%p, %p)", mozilla_funcs, plugin_funcs);
// Copy the Mozilla function table
mozilla_funcs_size = sizeof (NPNetscapeFuncs);
memset (&moon_host->mozilla_funcs, 0, mozilla_funcs_size);
mozilla_funcs_size = mozilla_funcs->size < mozilla_funcs_size
? mozilla_funcs->size
: mozilla_funcs_size;
memcpy (&moon_host->mozilla_funcs, mozilla_funcs, mozilla_funcs_size);
moon_host->mozilla_funcs.size = sizeof (moon_host->mozilla_funcs);
// Proxy NP_Initialize to Moonlight
if (MMP_HANDLE ()->np_initialize != NULL) {
NPError result = MMP_HANDLE ()->np_initialize (&moon_host->mozilla_funcs, plugin_funcs);
if (result == NPERR_NO_ERROR) {
// Override some Moonlight NPP functions
moon_host->moon_npp_new = plugin_funcs->newp;
plugin_funcs->newp = mmp_binder_npp_new;
moon_host->moon_npp_destroy = plugin_funcs->destroy;
plugin_funcs->destroy = mmp_binder_npp_destroy;
moon_host->moon_npp_stream_as_file = plugin_funcs->asfile;
plugin_funcs->asfile = mmp_binder_npp_stream_as_file;
} else {
mp_error ("Unknown error in libmoonloader's NP_Initialize: %d", result);
}
return result;
}
mp_error ("Could not call NP_Initialize from libmoonloader (NULL)");
return NPERR_GENERIC_ERROR;
}
static gboolean
mmp_plugin_proxy_load_module (gchar *prefix)
{
MoonlightPlugin *plugin_host = MMP_HANDLE ();
// Moonlight's loader is named libmoonloader if it is installed as a
// package, and libmoonloaderxpi if it is installed as an XPI
gchar *path = g_module_build_path (prefix, "moonloader");
if (!g_file_test (path, G_FILE_TEST_EXISTS)) {
g_free (path);
path = g_module_build_path (prefix, "moonloaderxpi");
if (!g_file_test (path, G_FILE_TEST_EXISTS)) {
g_free (path);
return FALSE;
}
}
plugin_host->module = g_module_open (path, G_MODULE_BIND_LOCAL | G_MODULE_BIND_LAZY);
if (plugin_host->module != NULL
&& mmp_plugin_proxy_load_symbol ("NP_Initialize", (gpointer *)&plugin_host->np_initialize)
&& mmp_plugin_proxy_load_symbol ("NP_Shutdown", (gpointer *)&plugin_host->np_shutdown)
&& mmp_plugin_proxy_load_symbol ("NP_GetValue", (gpointer *)&plugin_host->np_getvalue)) {
mp_debug ("Loaded Moonlight plugin: %s", path);
g_free (path);
return TRUE;
} else if (plugin_host->module != NULL) {
if (!g_module_close (plugin_host->module)) {
mp_error ("Could not unload library that was loaded but had invalid symbols: %s (%s)",
path, g_module_error ());
}
plugin_host->module = NULL;
}
mp_error ("Could not load Moonlight plugin: %s (%s)", path, g_module_error ());
g_free (path);
return FALSE;
}
NPError
NP_Shutdown ()
{
MoonlightPlugin *plugin_host = MMP_HANDLE ();
mp_debug ("NP_Shutdown");
if (plugin_host->np_shutdown != NULL) {
plugin_host->np_shutdown ();
}
if (plugin_host->module != NULL) {
g_module_close (plugin_host->module);
}
g_free (plugin_host->mime_description);
memset (plugin_host, 0, sizeof (MoonlightPlugin));
moon_module_load_attempted = FALSE;
return NPERR_NO_ERROR;
}
static Eina_Bool
_mp_app_inotify_timer_cb(void *data)
{
bool b_invalid_playing_file = false;
struct appdata *ad = (struct appdata *)data;
MP_CHECK_FALSE(ad);
if (ad->edit_in_progress)
{
DEBUG_TRACE("editing in progress. not refresh list...");
return false;
}
DEBUG_TRACE("update view");
mp_plst_item * current_item = mp_playlist_mgr_get_current(ad->playlist_mgr);
if (current_item)
{
if (mp_util_check_uri_available(current_item->uri))
{
mp_debug("http uri path");
}
else if (!g_file_test(current_item->uri, G_FILE_TEST_EXISTS))
{
mp_play_stop_and_updateview(ad, FALSE);
b_invalid_playing_file = true;
}
}
#ifndef MP_SOUND_PLAYER
mp_library_update_view(ad);
#endif
_g_inotyfy_timer = NULL;
return EINA_FALSE;
}
int main(int argc,char* argv[]){
//FILE* f=fopen("edgar.avi","rb"); // readonly (report errors)
//FILE* f=fopen("edgar.avi","rb+"); // fix mode (fix chunk sizes)
unsigned int lastgood=0;
unsigned int fixat=0;
unsigned int offset=0;
int fix_flag=0;
FILE* f;
if(argc<=1){
printf("Usage: %s [-fix] badfile.avi\n",argv[0]);
exit(1);
}
if(!strcmp(argv[1],"-fix")){
fix_flag=1;
f=fopen(argv[argc-1],"rb+");
} else
f=fopen(argv[argc-1],"rb");
if(!f){
perror("error");
printf("couldnt open '%s'\n",argv[argc-1]);
exit(2);
}
while(1){
unsigned int id,len;
again:
id=fgetc(f);
id=(id<<8)|fgetc(f);
id=(id<<8)|fgetc(f);
faszom:
if(feof(f)) break;
// if(!lastgood && feof(f)) break;
id=(id<<8)|fgetc(f);
// lastgood=ftell(f);
mp_debug("%08X: %c%c%c%c\n",(int)ftell(f)-4,xx(id>>24),xx(id>>16),xx(id>>8),xx(id));
switch(id){
case FCC('R','I','F','F'):
fread(&len,4,1,f); // filesize
id=getid(f); // AVI
mp_debug("RIFF header, filesize=0x%X format=%c%c%c%c\n",len,xx(id>>24),xx(id>>16),xx(id>>8),xx(id));
break;
case FCC('L','I','S','T'):
fread(&len,4,1,f); // size
id=getid(f); // AVI
mp_debug("LIST size=0x%X format=%c%c%c%c\n",len,xx(id>>24),xx(id>>16),xx(id>>8),xx(id));
//case FCC('h','d','r','l'):
//case FCC('s','t','r','l'):
//case FCC('o','d','m','l'):
//case FCC('m','o','v','i'):
break;
// legal chunk IDs:
case FCC('a','v','i','h'): // avi header
case FCC('s','t','r','h'): // stream header
case FCC('s','t','r','f'): // stream format
case FCC('J','U','N','K'): // official shit
// index:
case FCC('i','d','x','1'): // main index??
case FCC('d','m','l','h'): // opendml header
case FCC('i','n','d','x'): // opendml main index??
case FCC('i','x','0','0'): // opendml sub index??
case FCC('i','x','0','1'): // opendml sub index??
// data:
case FCC('0','1','w','b'): // audio track #1
case FCC('0','2','w','b'): // audio track #2
case FCC('0','3','w','b'): // audio track #3
case FCC('0','0','d','b'): // uncompressed video
case FCC('0','0','d','c'): // compressed video
case FCC('0','0','_','_'): // A-V interleaved (type2 DV file)
// info:
case FCC('I','S','F','T'): // INFO: software
case FCC('I','S','R','C'): // INFO: source
case FCC('I','N','A','M'): // INFO: name
case FCC('I','S','B','J'): // INFO: subject
case FCC('I','A','R','T'): // INFO: artist
case FCC('I','C','O','P'): // INFO: copyright
case FCC('I','C','M','T'): // INFO: comment
lastgood=ftell(f);
if(fixat && fix_flag){
// fix last chunk's size field:
fseek(f,fixat,SEEK_SET);
len=lastgood-fixat-8;
mp_debug("Correct len to 0x%X\n",len);
fwrite(&len,4,1,f);
fseek(f,lastgood,SEEK_SET);
fixat=0;
}
fread(&len,4,1,f); // size
mp_debug("ID ok, chunk len=0x%X\n",len);
len+=len&1; // align at 2
fseek(f,len,SEEK_CUR); // skip data
break;
default:
if(!lastgood){
++offset;
mp_debug("invalid ID, trying %d byte offset\n",offset);
goto faszom; // try again @ next post
}
mp_debug("invalid ID, parsing next chunk's data at 0x%X\n",lastgood);
fseek(f,lastgood,SEEK_SET);
fixat=lastgood;
lastgood=0;
goto again;
}
offset=0;
}
}
int mpm_run_em(EM_ENG_PTR emptr) {
int r, iterate, old_valid, converged, saved=0;
double likelihood, log_prior;
double lambda, old_lambda=0.0;
config_em(emptr);
for (r = 0; r < num_restart; r++) {
SHOW_PROGRESS_HEAD("#em-iters", r);
initialize_params();
mpm_bcast_inside();
clear_sw_msg_send();
itemp = daem ? itemp_init : 1.0;
iterate = 0;
while (1) {
if (daem) {
SHOW_PROGRESS_TEMP(itemp);
}
old_valid = 0;
while (1) {
if (CTRLC_PRESSED) {
SHOW_PROGRESS_INTR();
RET_ERR(err_ctrl_c_pressed);
}
if (failure_observed) {
inside_failure = mp_sum_value(0.0);
}
log_prior = emptr->smooth ? emptr->compute_log_prior() : 0.0;
lambda = mp_sum_value(log_prior);
likelihood = lambda - log_prior;
mp_debug("local lambda = %.9f, lambda = %.9f", log_prior, lambda);
if (verb_em) {
if (emptr->smooth) {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\tlog_prior=%.9f\tlog_post=%.9f\n", iterate, likelihood, log_prior, lambda);
} else {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\n", iterate, likelihood);
}
}
if (!isfinite(lambda)) {
emit_internal_error("invalid log likelihood or log post: %s (at iterateion #%d)",
isnan(lambda) ? "NaN" : "infinity", iterate);
RET_ERR(ierr_invalid_likelihood);
}
if (old_valid && old_lambda - lambda > prism_epsilon) {
emit_error("log likelihood or log post decreased [old: %.9f, new: %.9f] (at iteration #%d)",
old_lambda, lambda, iterate);
RET_ERR(err_invalid_likelihood);
}
if (itemp == 1.0 && likelihood > 0.0) {
emit_error("log likelihood greater than zero [value: %.9f] (at iteration #%d)",
likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}
converged = (old_valid && lambda - old_lambda <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_lambda = lambda;
old_valid = 1;
mpm_share_expectation();
SHOW_PROGRESS(iterate);
RET_ON_ERR(emptr->update_params());
iterate++;
}
if (itemp == 1.0) {
break;
}
itemp *= itemp_rate;
if (itemp >= 1.0) {
itemp = 1.0;
}
}
SHOW_PROGRESS_TAIL(converged, iterate, lambda);
if (r == 0 || lambda > emptr->lambda) {
emptr->lambda = lambda;
emptr->likelihood = likelihood;
emptr->iterate = iterate;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (saved) {
restore_params();
}
emptr->bic = compute_bic(emptr->likelihood);
emptr->cs = emptr->smooth ? compute_cs(emptr->likelihood) : 0.0;
return BP_TRUE;
}
int mps_run_em(EM_ENG_PTR emptr) {
int r, iterate, old_valid, converged, saved=0;
double likelihood;
double lambda, old_lambda=0.0;
config_em(emptr);
for (r = 0; r < num_restart; r++) {
mps_bcast_inside();
clear_sw_msg_send();
itemp = daem ? itemp_init : 1.0;
iterate = 0;
while (1) {
old_valid = 0;
while (1) {
RET_ON_ERR(emptr->compute_inside());
RET_ON_ERR(emptr->examine_inside());
if (failure_observed) {
inside_failure = mp_sum_value(inside_failure);
}
likelihood = emptr->compute_likelihood();
lambda = mp_sum_value(likelihood);
mp_debug("local lambda = %.9f, lambda = %.9f", likelihood, lambda);
converged = (old_valid && lambda - old_lambda <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_lambda = lambda;
old_valid = 1;
RET_ON_ERR(emptr->compute_expectation());
mps_share_expectation();
RET_ON_ERR(emptr->update_params());
iterate++;
}
if (itemp == 1.0) {
break;
}
itemp *= itemp_rate;
if (itemp >= 1.0) {
itemp = 1.0;
}
}
if (r == 0 || lambda > emptr->lambda) {
emptr->lambda = lambda;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (saved) {
restore_params();
}
return BP_TRUE;
}
