/* 
 * SICMA AERO SEAT
 * code@ife-sit.info
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <sys/types.h>
#include <unistd.h>
#include <Evas.h>
#ifdef HAVE_EVAS_SOFWARE_X11
# include <Evas_Engine_Software_X11.h>
#endif
#ifdef HAVE_EVAS_OPENGL_X11
# include <Evas_Engine_GL_X11.h>
#endif

#include "Emotion.h"
#include "emotion_private.h"
#include "emotion_vlc.h"

/* internal util calls */
static void *_em_lock          (void *par);
static void  _em_unlock        (void *par);
static void  _em_event         (const libvlc_event_t *event, void* data);
static void  _em_resize        (Emotion_Vlc_Video *ev, int x,  int y);
static Eina_Bool _em_fd_active (Emotion_Vlc_Video *ev, Ecore_Fd_Handler *fdh);
static int   _em_reload_vlc    (Emotion_Vlc_Video *ev);
void*	     _em_slave_thread  (void * t);

void * _em_slave_thread(void * t)
{
	int event;
	pthread_detach(pthread_self());
	Emotion_Vlc_Video *ev=  (Emotion_Vlc_Video*)t;
	while(read(ev->fd_slave_read, &event,  sizeof(int)) > 0)	{
		switch(event)	{
			case VLC_RESIZE:
				_em_resize(ev, -1, -1);
			break;
			case VLC_CHANGE_VOL:
				_emotion_audio_level_change(ev->obj);
			break;
			default:
			break;
		}
	}
	fprintf(stderr,"BYE BYE");
	return NULL;
}

static unsigned char em_init(Evas_Object *obj, void **emotion_video, Emotion_Module_Options *opt)
{
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *ef;
	int fds[2], x, y;
	int event = VLC_NEW_FRAME;
	pthread_t t_id;
	x = WIDTH;
	y = HEIGHT;


	if (!emotion_video) return 0;

	ev = (Emotion_Vlc_Video*)calloc(1, sizeof(Emotion_Vlc_Video));
	ASSERT_EV(ev) return 0;
	memset(ev, 0, sizeof(Emotion_Vlc_Video));

	ef = (Emotion_Vlc_Video_Frame*)calloc(1, sizeof(Emotion_Vlc_Video_Frame));
	if (!ef) return 0;
	memset(ef, 0, sizeof(Emotion_Vlc_Video_Frame));

	/* init internal frames */
	if(ef->frame_A)	{
		free(ef->frame_A);
	}
	if(ef->frame_B)	{
		free(ef->frame_B);
	}
	ef->frame_A = (char*)malloc(x*y*sizeof(char)*4);
	ef->frame_B = (char*)malloc(x*y*sizeof(char)*4);
	memset(ef->frame_A, 0x00, x*y*sizeof(char)*4);
	memset(ef->frame_B, 0x00, x*y*sizeof(char)*4);
	ef->frame = ef->frame_A;

	/* update size in object */
	ev->w = x;
	ev->h = y;
	ev->ratio = (double)x/(double)y;

	ev->cur_frame = ef;

	if(pipe(fds) == 0)
	{
		ev->fd_read = fds[0];
		ev->fd_write = fds[1];
		fcntl(ev->fd_read, F_SETFL, O_NONBLOCK);
		ev->fd_handler = ecore_main_fd_handler_add(ev->fd_read, ECORE_FD_READ, (Ecore_Fd_Cb)_em_fd_active, ev, NULL, NULL);
		ecore_main_fd_handler_active_set(ev->fd_handler, ECORE_FD_READ);
	}

	if (pipe(fds) == 0)
	{
		ev->fd_slave_read = fds[0];
		ev->fd_slave_write = fds[1];
		fcntl(ev->fd_slave_write, F_SETFL, O_NONBLOCK);
	}
	ev->obj = obj;

	ev->delete_me = 0;
	ev->opening = 1;
	ev->play_ok = 0;
	ev->video_mute = 1;

	if (opt)
	{
		ev->opt_no_audio = opt->no_audio;
		ev->opt_no_video = opt->no_video;
	}


	/* init libvlc */
	int vlc_argc = 0;
	char const *vlc_argv[] =
	{
		"-q",
		//"-vvvvv",
		"--ignore-config"
	};
	vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
	sprintf(ev->clock, "%lld", (long long int)(intptr_t)_em_lock);
	sprintf(ev->cunlock, "%lld", (long long int)(intptr_t)_em_unlock);
	sprintf(ev->cdata, "%lld", (long long int)(intptr_t)ev);
	sprintf(ev->width, "%d", WIDTH);
	sprintf(ev->height, "%d", HEIGHT);
	sprintf(ev->pitch, "%d", 4*WIDTH);

	ev->vlc_player = libvlc_new(vlc_argc, vlc_argv);

	if(ev->vlc_player)	{
		ev->play_ok = 1;
	}

	pthread_mutex_init(&ef->frame_copy_lock, NULL);
	pthread_create(&t_id, NULL, _em_slave_thread, ev);

	ev->opening = 0;
	write(ev->fd_write, &event, sizeof(void *));

	*emotion_video = ev;
	return 1;
}

static int em_shutdown(void *ef)
{
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *evvf;

	ev = (Emotion_Vlc_Video *)ef;
	evvf = ev->cur_frame;

	ASSERT_EV_VLC(ev) return 0;
	libvlc_release(ev->vlc_player);
	ev->vlc_player = NULL;

	ev->closing = 0;

	ecore_main_fd_handler_del(ev->fd_handler);

	if(evvf)	{
		if(evvf->frame_A)	{
			free(evvf->frame_A);
		}
		if(evvf->frame_B)	{
			free(evvf->frame_B);
		}
		pthread_mutex_destroy(&(evvf->frame_copy_lock));
		free(evvf);
	}
	close(ev->fd_write);
	close(ev->fd_read);
	close(ev->fd_slave_write);
	close(ev->fd_slave_read);

	return 1;
}

static unsigned char em_file_open(const char *file, Evas_Object *obj, void *ef)
{
	Emotion_Vlc_Video *ev;
	int i, method;
 Evas *e;
 Eina_List *methods, *l;
 char *name;
#ifndef _WIN32
 uint32_t xid;
#endif
	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_VLC(ev) return 0;

	ev->vlc_m = libvlc_media_new_path(ev->vlc_player, file);
	ASSERT_EV_M(ev) return 0;
	ev->vlc_mp = libvlc_media_player_new_from_media(ev->vlc_m);
	libvlc_media_release(ev->vlc_m); 
	ev->vlc_m = NULL;
	ASSERT_EV_MP(ev) return 0;

   e = evas_object_evas_get(obj);
   method = evas_output_method_get(e);
   methods = evas_render_method_list();
   EINA_LIST_FOREACH(methods, l, name)
     if (evas_render_method_lookup(name) == method) break;

#ifdef _WIN32 /* NOT IMPLEMENTED YET */
  libvlc_media_player_set_hwnd(ev->vlc_mp, (void*)xid);
#else
#ifdef HAVE_EVAS_SOFWARE_X11
   if (!strcmp(name, "software_x11"))
     {
        Evas_Engine_Info_Software_X11 *einfo;
        einfo = (Evas_Engine_Info_Software_X11*)evas_engine_info_get(e);
        xid = einfo->info.drawable;
     }
#endif
#ifdef HAVE_EVAS_OPENGL_X11
   if (!strcmp(name, "gl_x11"))
     {
        Evas_Engine_Info_GL_X11 *einfo;
        einfo = (Evas_Engine_Info_GL_X11*)evas_engine_info_get(e);
        xid = einfo->info.drawable;
     }
#endif
   if (strcmp(name, "software_x11") && strcmp(name, "gl_x11")) /* FIXME */
     {
        fprintf(stderr, "FATAL: engine unsupported!\n");
        exit(1);
     }
  libvlc_media_player_set_xwindow(ev->vlc_mp, xid);
#endif

	ev->vlc_evtmngr = libvlc_media_player_event_manager (ev->vlc_mp);

	for(i = EVENT_BEG_ID; i<EVENT_BEG_ID+NB_EVENTS; i++)	{
		libvlc_event_attach(ev->vlc_evtmngr, (libvlc_event_type_t)i, _em_event, ev);
	}

	if(ev->filename)	{
		free(ev->filename);
		ev->filename = NULL;
	}
	ev->filename = strdup(file);

	/* set properties to video object */
	ev->just_loaded = 1;
   evas_render_method_list_free(methods);
	return 1;
}

static void em_file_close(void *ef)
{
	Emotion_Vlc_Video *ev;
	int i;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;

	for(i = EVENT_BEG_ID; i<EVENT_BEG_ID+NB_EVENTS; i++)	{
		libvlc_event_detach(ev->vlc_evtmngr, (libvlc_event_type_t)i, _em_event, ev);
	}
	libvlc_media_player_stop(ev->vlc_mp);
	libvlc_media_player_release(ev->vlc_mp);
	ev->vlc_mp = NULL;
	if(ev->filename)	{
		free(ev->filename);
		ev->filename = NULL;
	}
}

static void em_play(void *ef, double pos)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;

	ev->play = 1;
	ev->play_ok = 0;

	if(pos != ev->pos)	{
		libvlc_media_player_set_time(ev->vlc_mp, (libvlc_time_t)(pos*1000));
	}
	
	libvlc_media_player_play(ev->vlc_mp);

	ev->just_loaded = 0;
}

static void em_stop(void *ef)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;

	ev->play = 0;
	ev->play_ok = 0;
	libvlc_media_player_pause(ev->vlc_mp);
}

static void em_size_get(void *ef, int *w, int *h)
{
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *fr;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	fr = ev->cur_frame;

	pthread_mutex_lock(&fr->frame_copy_lock);
	if(w) *w = ev->w;
	if(h) *h = ev->h;
	pthread_mutex_unlock(&fr->frame_copy_lock);
}

static void em_pos_set(void *ef, double pos)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;
	libvlc_media_player_set_time(ev->vlc_mp, (libvlc_time_t)(pos*1000));
}

static double em_len_get(void *ef)
{
	Emotion_Vlc_Video *ev;
	ASSERT_EV(ev) return 0;

	ev = (Emotion_Vlc_Video *)ef;
	return ev->len;
}

static int em_fps_num_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	ASSERT_EV(ev) return 0;
	ev = (Emotion_Vlc_Video *)ef;
	return (int)(ev->fps * 1000.0);
}

static int em_fps_den_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	return 1000;
}

static double em_fps_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	ASSERT_EV(ev) return 0;
	ev = (Emotion_Vlc_Video *)ef;
	return ev->fps;
}

static double em_pos_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	ASSERT_EV(ev) return 0;
	ev = (Emotion_Vlc_Video *)ef;
	return ev->pos;
}

static void em_vis_set(void *ef, Emotion_Vis vis)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	if (ev->vis == vis) return;
	ev->vis = vis;
}

static Emotion_Vis em_vis_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	return ev->vis;
}

static Eina_Bool em_vis_supported(void *ef, Emotion_Vis vis)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	return EINA_FALSE;
}

static double em_ratio_get(void *ef)
{
	double ratio;
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *fr;

	ASSERT_EV(ev) return 0;
	ev = (Emotion_Vlc_Video *)ef;
	fr = ev->cur_frame;
	pthread_mutex_lock(&fr->frame_copy_lock);
	ratio = ev->ratio;
	pthread_mutex_unlock(&fr->frame_copy_lock);
	return ratio;
}

static int em_video_handled(void *ef)
{
	int ret = 0;
	Emotion_Vlc_Video *ev;

	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	ev = (Emotion_Vlc_Video *)ef;
	if (ev->opening || (!ev->play_ok)) return 0;

	ret = libvlc_media_player_has_vout(ev->vlc_mp);
	return ret;
}

static int em_audio_handled(void *ef)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	return 1;
}

static int em_seekable(void *ef)
{
	int ret = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	ret = libvlc_media_player_is_seekable(ev->vlc_mp);
	return ret;
}

static void em_frame_done(void *ef)
{
	return;
}

static Emotion_Format em_format_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	return EMOTION_FORMAT_BGRA;
}

static void em_video_data_size_get(void *ef, int *w, int *h)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	if (w) *w = ev->w;
	if (h) *h = ev->h;
}

static int em_yuv_rows_get(void *ef, int w, int h, unsigned char **yrows, unsigned char **urows, unsigned char **vrows)
{
   Emotion_Vlc_Video *ev;
   volatile Emotion_Vlc_Video_Frame *fr;
   
   ev = (Emotion_Vlc_Video *)ef;
   fr = ev->cur_frame;
   if (!fr) return 0;
   if (fr->frame_A)
     {
	int i;
	
	// FIXME: this is wrong. see xine/gst modules
	for (i = 0; i < h; i++) yrows[i] = fr->frame_A + (i * w);
	for (i = 0; i < (h / 2); i++) urows[i] = fr->frame_A + (i * w);
	for (i = 0; i < (h / 2); i++) vrows[i] = fr->frame_A + (i * w);
	return 1;
     }
   return 0;
}

static int em_bgra_data_get(void *ef, unsigned char **bgra_data)
{
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *fr;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	fr = ev->cur_frame;
	if (!fr) return 0;
	if (fr->frame)
	{
		/* wait for frame to be ready */
		pthread_mutex_lock(&fr->frame_copy_lock);
		/* send cur frame to emotion */
		*bgra_data = fr->frame;

		/* switch frames */
		if(fr->frame == fr->frame_A)	{
			fr->frame = fr->frame_B;
		} else {
			fr->frame = fr->frame_A;
		}

		/* unlock both frames */
		pthread_mutex_unlock(&fr->frame_copy_lock);
		return 1;
	}
	return 0;
}

static void _em_resize(Emotion_Vlc_Video *ev, int x,  int y)
{
	int i;
	int event;
	int vlc_argc = 0;
	unsigned int tmp;
	char const *vlc_argv[] =
	{
		"-q",
		//"-vvvvv",
		"--ignore-config",
		"--vout", "vmem",
		"--vmem-width", ev->width,
		"--vmem-height", ev->height,
		"--vmem-pitch", ev->pitch,
		"--vmem-chroma", "RV32",
		"--vmem-lock", ev->clock,
		"--vmem-unlock", ev->cunlock,
		"--vmem-data", ev->cdata,
	};
	Emotion_Vlc_Video_Frame *fr;

	ASSERT_EV(ev)	return;
	ASSERT_EV_VLC(ev) return;
	fr = ev->cur_frame;

	/* We look for new size if not specified */
	if ((x == -1) || (y == -1))
	  if (!libvlc_video_get_size(ev->vlc_mp, tmp, &x, &y)) return;

	/* stop vlc if necessary */
	if(ev->filename)	{	
		libvlc_media_player_stop(ev->vlc_mp);
		libvlc_media_player_release(ev->vlc_mp);
	}

	/* update size in object */
	ev->w = x;
	ev->h = y;
	ev->ratio = (double)x/(double)y;

	/* we need to restart vlc */
	libvlc_release(ev->vlc_player);
	vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
	sprintf(ev->clock, "%lld", (long long int)(intptr_t)_em_lock);
	sprintf(ev->cunlock, "%lld", (long long int)(intptr_t)_em_unlock);
	sprintf(ev->cdata, "%lld", (long long int)(intptr_t)ev);
	sprintf(ev->width, "%d", ev->w);
	sprintf(ev->height, "%d", ev->h);
	sprintf(ev->pitch, "%d", 4*ev->w);
	ev->vlc_player = libvlc_new(vlc_argc, vlc_argv);

	pthread_mutex_lock(&fr->frame_copy_lock);

	if(ev->filename)	{	
		/* relaunch media and mediaplayer */
		ev->vlc_m = libvlc_media_new_path(ev->vlc_player, ev->filename);
		ASSERT_EV_M(ev) return;
		ev->vlc_mp = libvlc_media_player_new_from_media(ev->vlc_m);
		libvlc_media_release(ev->vlc_m); 
		ev->vlc_m = NULL;
		ASSERT_EV_MP(ev) return;

		ev->vlc_evtmngr = libvlc_media_player_event_manager (ev->vlc_mp);

		for(i = EVENT_BEG_ID; i<EVENT_BEG_ID+NB_EVENTS; i++)	{
			libvlc_event_attach(ev->vlc_evtmngr, (libvlc_event_type_t)i, _em_event, ev);
		}
	}

	/* resize frames */
	if(fr->frame_A)	{
		free(fr->frame_A);
	}
	if(fr->frame_B)	{
		free(fr->frame_B);
	}
	fr->frame_A = malloc(ev->w*ev->h*sizeof(char)*4);
	fr->frame_B = malloc(ev->w*ev->h*sizeof(char)*4);
	memset(fr->frame_A, 0xFF, x*y*sizeof(char)*4);
	memset(fr->frame_B, 0xFF, x*y*sizeof(char)*4);
	fr->frame = fr->frame_A;

	/* notify a new frame is available */
	event = VLC_RESIZE;
	write(ev->fd_write, &event, sizeof(void *));

	pthread_mutex_unlock(&fr->frame_copy_lock);

	/* unlock both frames */
	if(ev->filename)	{	
		libvlc_media_player_play(ev->vlc_mp);
	}

	/* activate display */
	ev->video_mute = 0;
}

static Eina_Bool _em_fd_active(Emotion_Vlc_Video *ev, Ecore_Fd_Handler *fdh)
{
	/* this only used for ecore notification */
	/* every other internal event should be done in _em_slave_thread */
	int event;
	int fd, len;
	Emotion_Vlc_Video_Frame *fr;

	fd = ecore_main_fd_handler_fd_get(fdh);
	while((len = read(fd, &event, sizeof(int))) > 0) {
		if(len == sizeof(int)) {
			switch(event)	{
				case VLC_NEW_FRAME:
					ASSERT_EV(ev)	return EINA_TRUE;
					_emotion_frame_new(ev->obj);
				break;
				case VLC_RESIZE:
					ASSERT_EV(ev)	return EINA_TRUE;
					_emotion_frame_resize(ev->obj, ev->w, ev->h, ev->ratio);
				break;
				default:
				break;
			}
		}
	}
	return EINA_TRUE;
}


/* STUB */
static void em_event_feed(void *ef, int event)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	if ((ev->opening) || (!ev->play_ok)) return;

	switch (event)
	{
		case EMOTION_EVENT_MENU1:
			break;
		case EMOTION_EVENT_MENU2:
			break;
		case EMOTION_EVENT_MENU3:
			break;
		case EMOTION_EVENT_MENU4:
			break;
		case EMOTION_EVENT_MENU5:
			break;
		case EMOTION_EVENT_MENU6:
			break;
		case EMOTION_EVENT_MENU7:
			break;
		case EMOTION_EVENT_UP:
			break;
		case EMOTION_EVENT_DOWN:
			break;
		case EMOTION_EVENT_LEFT:
			break;
		case EMOTION_EVENT_RIGHT:
			break;
		case EMOTION_EVENT_SELECT:
			break;
		case EMOTION_EVENT_NEXT:
			break;
		case EMOTION_EVENT_PREV:
			break;
		case EMOTION_EVENT_ANGLE_NEXT:
			break;
		case EMOTION_EVENT_ANGLE_PREV:
			break;
		case EMOTION_EVENT_FORCE:
			break;
		case EMOTION_EVENT_0:
			break;
		case EMOTION_EVENT_1:
			break;
		case EMOTION_EVENT_2:
			break;
		case EMOTION_EVENT_3:
			break;
		case EMOTION_EVENT_4:
			break;
		case EMOTION_EVENT_5:
			break;
		case EMOTION_EVENT_6:
			break;
		case EMOTION_EVENT_7:
			break;
		case EMOTION_EVENT_8:
			break;
		case EMOTION_EVENT_9:
			break;
		case EMOTION_EVENT_10:
			break;
		default:
			return;
			break;
	}
}

/* STUB */
static void em_event_mouse_button_feed(void *ef, int button, int x, int y)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	if ((ev->opening) || (!ev->play_ok)) return;
}

/* STUB */
static void em_event_mouse_move_feed(void *ef, int x, int y)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	if ((ev->opening) || (!ev->play_ok)) return;
}

static int em_video_channel_count(void *ef)
{
	int ret  = 0;
	Emotion_Vlc_Video *ev;
	ev = (Emotion_Vlc_Video *)ef; 
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	ret = libvlc_media_player_has_vout(ev->vlc_mp);
	return ret;
}

/* STUB */
static void em_video_channel_set(void *ef, int channel)
{
	return;
}

/* STUB */
static int em_video_channel_get(void *ef)
{
	return 1;
}

/* STUB */
static const char * em_video_channel_name_get(void *ef, int channel)
{
	Emotion_Vlc_Video *ev;
	return NULL;
}

static void em_video_channel_mute_set(void *ef, int mute)
{
	Emotion_Vlc_Video *ev;
	ev = (Emotion_Vlc_Video*)ef;
	ASSERT_EV(ev)	return;
	ev->video_mute = mute;
}

static int em_video_channel_mute_get(void *ef)
{
	Emotion_Vlc_Video *ev;
	ev = (Emotion_Vlc_Video*)ef;
	ASSERT_EV(ev)	return;
	return ev->video_mute;
}

/* STUB */
static int em_audio_channel_count(void *ef)
{
	return -1;
}

static void em_audio_channel_set(void *ef, int channel)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_VLC(ev) return;
	if (channel < -1) channel = -1;
	ev->audio_channel = channel;
	libvlc_audio_set_channel(ev->vlc_mp, channel);
}

static int em_audio_channel_get(void *ef)
{
	int ret = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_VLC(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	ret = libvlc_audio_get_channel(ev->vlc_mp);
	return ret;
}

/* STUB */
static const char * em_audio_channel_name_get(void *ef, int channel)
{
	return NULL;
}

static void em_audio_channel_mute_set(void *ef, int mute)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_VLC(ev) return;
	ev->audio_mute = mute;
	libvlc_audio_set_mute(ev->vlc_mp, (int)(ev->audio_mute));
}

static int em_audio_channel_mute_get(void *ef)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	return ev->audio_mute;
}

static void em_audio_channel_volume_set(void *ef, double vol)
{
	int event = VLC_CHANGE_VOL;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_VLC(ev) return;

	if (vol < 0.0) vol = 0.0;
	if (vol > 1.0) vol = 1.0;
	libvlc_audio_set_volume(ev->vlc_mp, (int)(vol * 200));
	write(ev->fd_slave_write, &event, sizeof(void *));
}

static double em_audio_channel_volume_get(void *ef)
{
	int vol;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_VLC(ev) return;
	if (ev->opening || (!ev->play_ok)) return 0;
	vol = libvlc_audio_get_volume(ev->vlc_mp);
	return (double)(vol/200.0);
}

/* STUB */
static int em_spu_channel_count(void *ef)
{
	return 0;
}

static void em_spu_channel_set(void *ef, int channel)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;
	if (channel < 0) channel = 0;
	ev->spu_channel = channel;
	libvlc_video_set_spu(ev->vlc_mp, ev->spu_channel);
}

static int em_spu_channel_get(void *ef)
{
	int num = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	num = libvlc_video_get_spu(ev->vlc_mp);
	return num;
}

/* STUB */
static const char * em_spu_channel_name_get(void *ef, int channel)
{
	return NULL;
}

/* STUB */
static void em_spu_channel_mute_set(void *ef, int mute)
{
	return;
}

/* STUB */
static int em_spu_channel_mute_get(void *ef)
{
	return 0;
}

static int em_chapter_count(void *ef)
{
	int num = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	if (ev->opening || (!ev->play_ok)) return 0;
	num = libvlc_media_player_get_chapter_count(ev->vlc_mp);
	return num;
}

static void em_chapter_set(void *ef, int chapter)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return ;
	libvlc_media_player_set_chapter(ev->vlc_mp, chapter);
}

static int em_chapter_get(void *ef)
{
	int num = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	num = libvlc_media_player_get_chapter(ev->vlc_mp);
	return num;
}

/* STUB */
static const char * em_chapter_name_get(void *ef, int chapter)
{
	return NULL;
}

static void em_speed_set(void *ef, double speed)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return;
	ASSERT_EV_MP(ev) return;
	libvlc_media_player_set_rate(ev->vlc_mp, speed);
}

static double em_speed_get(void *ef)
{
	float speed = 0;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev) return 0;
	ASSERT_EV_MP(ev) return 0;
	speed = libvlc_media_player_get_rate(ev->vlc_mp);
	return (double)speed;
}

static int em_eject(void *ef)
{
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	if (system("eject"))
	  fprintf(stderr, "Eject failed!\n");
	return 1;
}

static const char * em_meta_get(void *ef, int meta)
{
	char * meta_data = NULL;
	Emotion_Vlc_Video *ev;

	ev = (Emotion_Vlc_Video *)ef;
	ASSERT_EV(ev)	return NULL;
	ASSERT_EV_M(ev)	return NULL;
	if ((ev->opening) || (!ev->play_ok)) return NULL;
	switch (meta)
	{
		case META_TRACK_TITLE:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Title);
			break;
		case META_TRACK_ARTIST:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Artist);
			break;
		case META_TRACK_GENRE:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Genre);
			break;
		case META_TRACK_COMMENT:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Description);
			break;
		case META_TRACK_ALBUM:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Album);
			break;
		case META_TRACK_YEAR:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_Date);
			break;
		case META_TRACK_DISCID:
			meta_data = libvlc_media_get_meta(ev->vlc_m, libvlc_meta_TrackID);
			break;
		default:
			break;
	}
	return meta_data;
}

static void _em_event(const libvlc_event_t *event, void *data)
{
	Emotion_Vlc_Event *new_ev;
	Emotion_Vlc_Video *ev;

	ev = data;
	ASSERT_EV(ev)	return;
	switch (event->type) {
		case libvlc_MediaPlayerTimeChanged: {
				libvlc_time_t pos = event->u.media_player_time_changed.new_time;
				double time = (pos / 1000000.f);
				_emotion_video_pos_update(ev->obj, time, 0);
				ev->pos = time;
				if(ev->len == 0)	{
					pos = libvlc_media_player_get_length(ev->vlc_mp);
					ev->len = (double)(pos / 1000.0);
				}
			}
		case libvlc_MediaPlayerPlaying: {
				int x, y;
				unsigned int tmp;
				float fps = 0;
				float pos = 0;
				float total_pos = 0;
				libvlc_time_t time = 0;
				libvlc_time_t total_time = 0;

				/* get video properties */
				total_time = libvlc_media_player_get_length(ev->vlc_mp);
				fps = libvlc_media_player_get_fps(ev->vlc_mp);
				libvlc_video_get_size(ev->vlc_mp, tmp, &x, &y);
				/* set them to object */
				if(ev->fps == 0)	{
					ev->fps = fps;
				}
				if(ev->len == 0)	{
					ev->len = (double)(total_time / 1000.0);
				}
				if((x != 0) && (y != 0))	{
					if((ev->w != x)||(ev->h != y))	{
						int event;
						event = VLC_RESIZE;
						write(ev->fd_slave_write, &event, sizeof(void *));
					}
				}
			} break;
		case libvlc_MediaPlayerEndReached: {
				ev->play = 0;
				_emotion_decode_stop(ev->obj);
				_emotion_playback_finished(ev->obj);
			} break;
		default:
			break;
	}
}

static void *_em_lock(void *par)
{
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *evvf; 

	/* get current frame */
	ev = (Emotion_Vlc_Video*)par;
	evvf = ev->cur_frame;

	/* lock current frame */
	pthread_mutex_lock(&(evvf->frame_copy_lock));
	
	/* send current frame address to vlc */
	return evvf->frame;
}

static void  _em_unlock(void *par)
{
	float p = 0;
	int ret;
	int event;
	Emotion_Vlc_Video *ev;
	Emotion_Vlc_Video_Frame *evvf; 

	/* get current frame */
	ev = (Emotion_Vlc_Video*)par;
	evvf = ev->cur_frame;

	/* notify a new frame is available */
	event = VLC_NEW_FRAME;
	
	if(ev->video_mute == 0)	{
		ret = write(ev->fd_write, &event, sizeof(void *));
	}
	pthread_mutex_unlock(&(evvf->frame_copy_lock));

	return;
}

static Emotion_Video_Module em_module =
{
	em_init, /* init */
	em_shutdown, /* shutdown */
	em_file_open, /* file_open */
	em_file_close, /* file_close */
	em_play, /* play */
	em_stop, /* stop */
	em_size_get, /* size_get */
	em_pos_set, /* pos_set */
	em_len_get, /* len_get */
	em_fps_num_get, /* fps_num_get */
	em_fps_den_get, /* fps_den_get */
	em_fps_get, /* fps_get */
	em_pos_get, /* pos_get */
	em_vis_set, /* vis_set */
	em_vis_get, /* vis_get */
        em_vis_supported, /* vis_supported */
	em_ratio_get, /* ratio_get */
	em_video_handled, /* video_handled */
	em_audio_handled, /* audio_handled */
	em_seekable, /* seekable */
	em_frame_done, /* frame_done */
	em_format_get, /* format_get */
	em_video_data_size_get, /* video_data_size_get */
	em_yuv_rows_get, /* yuv_rows_get */
	em_bgra_data_get, /* bgra_data_get */
	em_event_feed, /* event_feed */
	em_event_mouse_button_feed, /* event_mouse_button_feed */
	em_event_mouse_move_feed, /* event_mouse_move_feed */
	em_video_channel_count, /* video_channel_count */
	em_video_channel_set, /* video_channel_set */
	em_video_channel_get, /* video_channel_get */
	em_video_channel_name_get, /* video_channel_name_get */
	em_video_channel_mute_set, /* video_channel_mute_set */
	em_video_channel_mute_get, /* video_channel_mute_get */
	em_audio_channel_count, /* audio_channel_count */
	em_audio_channel_set, /* audio_channel_set */
	em_audio_channel_get, /* audio_channel_get */
	em_audio_channel_name_get, /* audio_channel_name_get */
	em_audio_channel_mute_set, /* audio_channel_mute_set */
	em_audio_channel_mute_get, /* audio_channel_mute_get */
	em_audio_channel_volume_set, /* audio_channel_volume_set */
	em_audio_channel_volume_get, /* audio_channel_volume_get */
	em_spu_channel_count, /* spu_channel_count */
	em_spu_channel_set, /* spu_channel_set */
	em_spu_channel_get, /* spu_channel_get */
	em_spu_channel_name_get, /* spu_channel_name_get */
	em_spu_channel_mute_set, /* spu_channel_mute_set */
	em_spu_channel_mute_get, /* spu_channel_mute_get */
	em_chapter_count, /* chapter_count */
	em_chapter_set, /* chapter_set */
	em_chapter_get, /* chapter_get */
	em_chapter_name_get, /* chapter_name_get */
	em_speed_set, /* speed_set */
	em_speed_get, /* speed_get */
	em_eject, /* eject */
	em_meta_get, /* meta_get */
       _emotion_object_extension_can_play_generic_get, /* can_play_get */

	NULL /* handle */
};

static Eina_Bool module_open(Evas_Object *obj, const Emotion_Video_Module **module, void **video, Emotion_Module_Options *opt)
{
	if (!module)	{
		return EINA_FALSE;
	}

	if (!em_module.init(obj, video, opt))	{
		return EINA_FALSE;
	}

	*module = &em_module;

	return EINA_TRUE;
}

static void module_close(Emotion_Video_Module *module, void *video)
{
	em_module.shutdown(video);
}


Eina_Bool
vlc_module_init(void)
{
   return _emotion_module_register("vlc", module_open, module_close);
}

void
vlc_module_shutdown(void)
{
   _emotion_module_unregister("vlc");
}

#ifndef EMOTION_STATIC_BUILD_VLC

EINA_MODULE_INIT(vlc_module_init);
EINA_MODULE_SHUTDOWN(vlc_module_shutdown);

#endif