XineEngine::~XineEngine()
{
// Wait until the fader thread is done
if( s_fader ) {
m_stopFader = true;
s_fader->resume(); // safety call if the engine is in the pause state
s_fader->wait();
}
delete s_fader;
delete s_outfader;
if( PanaConfig::fadeoutOnExit() ) {
bool terminateFader = false;
fadeOut( PanaConfig::fadeoutLength(), &terminateFader, true ); // true == exiting
}
if( m_xine ) xine_config_save( m_xine, configPath() );
if( m_stream ) xine_close( m_stream );
if( m_eventQueue ) xine_event_dispose_queue( m_eventQueue );
if( m_stream ) xine_dispose( m_stream );
if( m_audioPort ) xine_close_audio_driver( m_xine, m_audioPort );
if( m_post ) xine_post_dispose( m_xine, m_post );
if( m_xine ) xine_exit( m_xine );
debug() << "xine closed\n";
debug() << "Scope statistics:\n"
<< " Average list size: " << Log::bufferCount / Log::scopeCallCount << endl
<< " Buffer failure: " << double(Log::noSuitableBuffer*100) / Log::scopeCallCount << "%\n";
}
static void xine_open_and_play(char * file)
{
int tmp;
if(file == NULL){
return;
}
char * tmp3 = malloc(((sizeof(char) * strlen(file) * 3)) + 1);
char * tmp2 = malloc(((sizeof(char) * strlen(file) * 3)) + 7);
if(file[0] == '/'){
url_encode(file, tmp3);
sprintf(tmp2, "file:/%s", tmp3);
}else{
sprintf(tmp2, "%s", file);
}
xine_close ( stream );
log_debug(tmp2);
free(tmp3);
if(!xine_open ( stream, tmp2)){
return;
}
free(tmp2);
if(!xine_play ( stream, 0, 0 )){
return;
}
int count = 0;
while ( !xine_get_pos_length ( stream, &tmp, &tmp, &length ) ) // The header file states: "probably because it's not known yet... try again later"
{
sleepTS.tv_sec = 0;
sleepTS.tv_nsec = 10000000;
nanosleep(&sleepTS,NULL); //Just try until you get some usefull info
count++;
if(count>5) break;
//log_debug("Sleeping");
}
}
//***************************************************
//Engine playback controls.
//
void engine_stop ( void )
{
xine_stop ( stream );
xine_close ( stream );
length = 0;
engine_state = engine_stoped;
}
void Xine::collect_info(const std::string &f){
if (quitting)
return;
pthread_mutex_lock(&stream_mutex);
if (!playing || file.path != f){
/* Exceptionally we don't let the loop handle this */
playing = false;
if(!validate_stream()){
pthread_mutex_unlock(&stream_mutex);
return;
}
xine_close(stream); /* you never know */
xine_event_dispose_queue(event_queue);
event_queue = NULL;
if(!xine_open(stream, f.c_str())){
pthread_mutex_unlock(&stream_mutex);
return;
}
const bool has_audio = xine_get_stream_info( stream, XINE_STREAM_INFO_HAS_AUDIO );
const bool audio_handled = xine_get_stream_info( stream, XINE_STREAM_INFO_AUDIO_HANDLED );
if (has_audio && audio_handled && xine_play(stream, 0, 0)){
gather_info_internal();
xine_close(stream);
}
else{
pthread_mutex_unlock(&stream_mutex);
return;
}
}
else{
if(!validate_stream()){
pthread_mutex_unlock(&stream_mutex);
return;
}
gather_info_internal();
}
title = _title;
album = _album;
artist = _artist;
cur_time = _cur_time;
total_time = _total_time;
pthread_mutex_unlock(&stream_mutex);
}
void engine_jump_to ( char * current)
{
xine_stop ( stream );
xine_close ( stream );
xine_open_and_play(current);
current_song = current;
engine_state = engine_playing;
}
static void
IDirectFBVideoProvider_Xine_Destruct( IDirectFBVideoProvider *thiz )
{
IDirectFBVideoProvider_Xine_data *data = thiz->priv;
if (data->xine) {
if (data->stream) {
xine_stop( data->stream );
xine_close( data->stream );
if (data->queue)
xine_event_dispose_queue( data->queue );
xine_dispose( data->stream );
}
if (data->post)
xine_post_dispose( data->xine, data->post );
if (data->vo)
xine_close_video_driver( data->xine, data->vo );
if (data->ao)
xine_close_audio_driver( data->xine, data->ao );
if (data->cfg) {
xine_config_save( data->xine, data->cfg );
D_FREE( data->cfg );
}
xine_exit( data->xine );
}
if (data->buffer_thread) {
direct_thread_cancel( data->buffer_thread );
direct_thread_join( data->buffer_thread );
direct_thread_destroy( data->buffer_thread );
}
if (data->buffer)
data->buffer->Release( data->buffer );
if (data->pipe) {
unlink( data->pipe );
D_FREE( data->pipe );
}
if (data->events)
data->events->Release( data->events );
D_FREE( data->mrl );
pthread_mutex_destroy( &data->lock );
DIRECT_DEALLOCATE_INTERFACE( thiz );
}
void framecatcher::close(){
if(stream != NULL){
xine_close(stream);
xine_dispose(stream);
stream = NULL;
}
}
void engine_shutdown ( void )
{
// Stop playing and close down the stream
xine_stop( stream );
xine_stop( meta_stream );
xine_event_dispose_queue(queue);
xine_close(stream);
xine_close(meta_stream);
xine_dispose(stream);
xine_dispose(meta_stream);
// Now shut down cleanly
xine_close_audio_driver ( engine, ap );
// Now shut down cleanly
xine_exit ( engine );
}
void
music_stop ()
{
int state;
state = xine_get_status (stream);
if (state != XINE_STATUS_IDLE)
xine_close (stream);
stream_pos = 0;
music_playing = FALSE;
music_notify_stopped ();
}
static void icvCloseAVI_XINE( CvCaptureAVI_XINE* capture )
{
xine_free_video_frame( capture->vo_port, &capture->xine_frame );
if ( capture->yuv_frame ) cvReleaseImage( &capture->yuv_frame );
if ( capture->bgr_frame ) cvReleaseImage( &capture->bgr_frame );
xine_close( capture->stream );
// xine_dispose( capture->stream );
if ( capture->vo_port ) xine_close_video_driver( capture->xine, capture->vo_port );
xine_exit( capture->xine );
}
void engine_load_meta_info(songdata_song * file){
if(file->fullpath[0] != '/'){
return;
}
char * tmp3 = calloc((strlen(file->fullpath) * 3) + 1, sizeof(char));
url_encode(file->fullpath, tmp3);
char * tmp2 = calloc(strlen(tmp3) + 7, sizeof(char));
sprintf(tmp2, "file:/%s", tmp3);
free(tmp3);
if(!xine_open ( meta_stream, tmp2)){
free(tmp2);
return;
}
engine_load_meta_info_from_stream(file, meta_stream);
xine_close(meta_stream);
free(tmp2);
}
void
music_pause ()
{
int state;
state = xine_get_status (stream);
if (state != XINE_STATUS_IDLE) {
int pos, time, length;
/* length = 0 for streams */
if (!(xine_get_pos_length (stream, &pos, &time, &length) && length))
pos = 0;
stream_pos = pos;
g_message ("stream_pos: %d", pos);
xine_close (stream);
}
music_playing = FALSE;
music_notify_paused ();
}
static void xine_open_and_play(char * file)
{
if(file == NULL)
{
return;
}
char * file_uri = malloc(((sizeof(char) * strlen(file) * 3)) + 7);
if(file[0] == '/')
{
char * file_encoded = malloc(((sizeof(char) * strlen(file) * 3)) + 1);
url_encode(file, file_encoded);
sprintf(file_uri, "file:/%s", file_encoded);
free(file_encoded);
}
else
{
sprintf(file_uri, "%s", file);
}
xine_close ( stream );
log_debug_format("engine: %s\n", file_uri);
if(!xine_open ( stream, file_uri)){
return;
}
free(file_uri);
if(!xine_play ( stream, 0, 0 )){
return;
}
int count = 0;
int dummy1, dummy2;
// The header file states: "probably because it's not known yet... try again later"
while ( !xine_get_pos_length ( stream, &dummy1, &dummy2, &length ) )
{
sleepTS.tv_sec = 0;
sleepTS.tv_nsec = 10000000;
nanosleep(&sleepTS,NULL); //Just try until you get some usefull info
count++;
if(count>5) break;
}
}
void close()
{
OSG_INFO<<"XineImageStream::close()"<<std::endl;
if (_stream)
{
OSG_INFO<<" Closing stream"<<std::endl;
xine_close(_stream);
OSG_INFO<<" Disposing stream"<<std::endl;
xine_dispose(_stream);
_stream = 0;
}
if (_event_queue)
{
_event_queue = 0;
}
if (_ao)
{
OSG_INFO<<" Closing audio driver"<<std::endl;
xine_close_audio_driver(_xine, _ao);
_ao = 0;
}
if (_vo)
{
OSG_INFO<<" Closing video driver"<<std::endl;
xine_close_video_driver(_xine, _vo);
_vo = 0;
}
OSG_INFO<<"closed XineImageStream "<<std::endl;
}
XineEngine::~XineEngine()
{
// Wait until the fader thread is done
if( s_fader ) {
m_stopFader = true;
s_fader->wait();
delete s_fader;
}
// NOTE The fadeout gets stuck when the EQ is active, so we skip it then
if( !m_equalizerEnabled && m_stream && state() == Engine::Playing )
{
const int volume = xine_get_param( m_stream, XINE_PARAM_AUDIO_AMP_LEVEL );
const double D = 300000 * std::pow( (double)volume, -0.4951 );
debug() << "Sleeping: " << D << ", " << volume << endl;
for( int v = volume - 1; v >= 1; v-- ) {
xine_set_param( m_stream, XINE_PARAM_AUDIO_AMP_LEVEL, v );
const int sleep = int(D * (-log10( v + 1 ) + 2));
::usleep( sleep );
}
xine_stop( m_stream );
}
if( m_xine ) xine_config_save( m_xine, configPath() );
if( m_stream ) xine_close( m_stream );
if( m_eventQueue ) xine_event_dispose_queue( m_eventQueue );
if( m_stream ) xine_dispose( m_stream );
if( m_audioPort ) xine_close_audio_driver( m_xine, m_audioPort );
if( m_post ) xine_post_dispose( m_xine, m_post );
if( m_xine ) xine_exit( m_xine );
debug() << "xine closed\n";
debug() << "Scope statistics:\n"
<< " Average list size: " << Log::bufferCount / Log::scopeCallCount << endl
<< " Buffer failure: " << double(Log::noSuitableBuffer*100) / Log::scopeCallCount << "%\n";
}
void
music_play ()
{
PlaylistItem *item;
gint state, pos;
gchar *path;
state = xine_get_status (stream);
if (!music_playing && playlist_current) {
item = LISTITEM (playlist_current);
if (!(path = g_filename_from_utf8 (PATH (item), -1,
NULL, NULL, NULL))) {
g_critical (_("Skipping '%s'. Could not convert from UTF-8. "
"Bug?"), PATH (item));
playlist_fail ();
return;
}
if (state != XINE_STATUS_IDLE)
xine_close (stream);
music_notify_current_song (g_list_position
(playlist, playlist_current));
if (!xine_open (stream, path)) {
playlist_fail ();
return;
}
pos = stream_pos;
stream_pos = 0;
if (xine_play (stream, pos, 0)) {
music_playing = TRUE;
music_notify_playing ();
} else {
music_playing = FALSE;
playlist_fail ();
}
}
}
eServiceXine::~eServiceXine()
{
if (m_state == stRunning)
stop();
eDebug("close stream");
if (stream)
xine_close(stream);
eDebug("dispose queue");
if (event_queue)
xine_event_dispose_queue(event_queue);
eDebug("dispose stream");
if (stream)
xine_dispose(stream);
eDebug("dispose ao_port");
if (ao_port)
xine_close_audio_driver(xine, ao_port);
eDebug("dispose vo port");
if (vo_port)
xine_close_video_driver(xine, vo_port);
eDebug("done.");
}
Xine::~Xine(){
pthread_mutex_lock(&stream_mutex);
quitting = true;
pthread_cond_broadcast(&stream_switch);
pthread_mutex_unlock(&stream_mutex);
if (!initted)
return;
pthread_join(thread_loop, NULL);
pthread_mutex_lock(&stream_mutex);
if(stream){
xine_close(stream);
xine_event_dispose_queue(event_queue);
event_queue = NULL;
xine_dispose(stream);
stream = NULL;
}
if (ao_port)
xine_close_audio_driver(xine, ao_port);
ao_port = NULL;
xine_exit(xine);
/* booo bye */
}
static Epsilon_Image *
epsilon_generate_thumb (Epsilon * e)
{
int ret = XINE_THUMB_SUCCESS;
Epsilon_Image *img = NULL;
unsigned char *buf = NULL;
int cnt, attempts = 0, length = -1, pos_perc, pos_time, new_perc, new_time,
req_perc = 500, req_time = 500;
static int old_length = -1;
char cfg[PATH_MAX];
epsilon_xine_param *param;
param = calloc (1, sizeof (epsilon_xine_param));
if (!(param->xine = xine_new ()))
{
return NULL;
}
snprintf (cfg, PATH_MAX, "%s%s", xine_get_homedir (), ".xine/config");
xine_config_load (param->xine, cfg);
xine_init (param->xine);
/* opening xine output ports */
if (!
(param->vo_port =
xine_open_video_driver (param->xine, "none", XINE_VISUAL_TYPE_NONE,
(void *) NULL)))
{
goto done;
}
param->ao_port = xine_open_audio_driver (param->xine, "none", NULL);
/* open a xine stream connected to these ports */
if (!
(param->stream =
xine_stream_new (param->xine, param->ao_port, param->vo_port)))
{
goto done;
}
if (!xine_open (param->stream, e->src))
{
ret = XINE_THUMB_FAIL;
goto done;
}
if (XINE_THUMBNAILER_DEBUG) printf("Starting xine thumbnail process..\n");
try_get_chance:
new_perc = -1;
new_time = req_time;
if (!xine_play (param->stream, 0, new_time))
{
new_time = -1;
new_perc = req_perc; /* 0..65535 */
if (!xine_play (param->stream, new_perc, 0))
{
ret = XINE_THUMB_FAIL;
if (XINE_THUMBNAILER_DEBUG) printf("Coudln't play video %s..\n", e->src);
goto close_stream;
}
}
/* get position */
for (cnt = 0; ((cnt < 50) &&
(!xine_get_pos_length
(param->stream, &pos_perc, &pos_time, &length)
|| (length == old_length))); cnt++)
usleep (1000);
if (length < 0)
{
if (XINE_THUMBNAILER_DEBUG) printf("Video is 0 length!..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
/* wait till position changes */
for (cnt = 0;
(cnt < 50) &&
(!xine_get_pos_length (param->stream, &new_perc, &new_time, &length) ||
((new_perc == pos_perc) && (new_time == pos_time))); cnt++)
{
usleep (1000);
}
/* get snapshot */
int w, h, ratio, format;
old_length = length;
/* ask what size a snapshot would be (if we can make one) */
if (!xine_get_current_frame (param->stream, &w, &h, &ratio, &format, NULL))
{
attempts++;
if (attempts < 10)
{
if (req_time < 10000)
req_time += 1000;
if (req_perc < 10000)
req_perc += 1000;
goto try_get_chance;
}
else
{
if (XINE_THUMBNAILER_DEBUG) printf("Exhausted attempts to thumbnail..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
}
else if ((w <= 0) || (h <= 0))
{
if (XINE_THUMBNAILER_DEBUG) printf("Width/Height of video invalid: %d:%d..\n", w,h);
ret = XINE_THUMB_FAIL;
goto close_stream;
}
else
{
/* know we know the size, get a buffer for the snapshot */
if (!(buf = malloc (w * h * 2)))
{
if (XINE_THUMBNAILER_DEBUG) printf("Couldn't allocate memory for thumbnail buffer..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
/* make a snapshot! */
if (!xine_get_current_frame
(param->stream, &w, &h, &ratio, &format, buf))
{
if (XINE_THUMBNAILER_DEBUG) printf("Couldn't retrieve current video frame..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
else if ((w <= 0) || (h <= 0))
{
if (XINE_THUMBNAILER_DEBUG) printf("Width/height of video invalid: %d:%d..\n",w,h);
ret = XINE_THUMB_FAIL;
goto close_stream;
}
if (format == XINE_IMGFMT_YUY2)
{
unsigned char *buf2 = malloc (w * h * 2);
unsigned char *tmp = buf;
i_yuy2_to_yv12 (buf, buf2, w, h);
buf = buf2;
free (tmp);
format = XINE_IMGFMT_YV12;
}
if (format == XINE_IMGFMT_YV12)
{
ret = yv12_to_rgb (e->src, w, h, &buf, &img);
if (ret != XINE_THUMB_SUCCESS)
{
if (img)
{
if (++attempts > 10)
goto close_stream;
free(img->data);
free(img);
img = NULL;
if (ret == XINE_THUMB_RETRY)
{
if (buf)
{
free (buf);
buf = NULL;
if ((req_perc += (attempts * 1000)) > 65535)
req_perc = 1000;
if ((req_time += (attempts * 2500)) > length)
req_time = 3000;
goto try_get_chance;
}
if (XINE_THUMBNAILER_DEBUG) printf("Exhausted attempts to thumbnail pos 2..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
}
else
{
if (XINE_THUMBNAILER_DEBUG) printf("Couldn't complete yv12_to_rgb..\n");
ret = XINE_THUMB_FAIL;
goto close_stream;
}
}
}
ret = XINE_THUMB_SUCCESS;
close_stream:
if (buf)
{
free (buf);
buf = NULL;
}
xine_close (param->stream);
done:
if (ret != XINE_THUMB_SUCCESS)
{
if (img)
{
free(img->data);
free(img);
img = NULL;
}
}
if (param->stream)
{
xine_dispose (param->stream);
param->stream = NULL;
}
if (param->ao_port)
{
xine_close_audio_driver (param->xine, param->ao_port);
param->ao_port = NULL;
}
if (param->vo_port)
{
xine_close_video_driver (param->xine, param->vo_port);
param->vo_port = NULL;
}
free (param);
return img;
}
return NULL;
}
/* this is a slave controller thread for the xine module - libxine loves
* to deadlock, internally stall and otherwise have unpredictable behavior
* if we use the main process thread for many things - so a lot will be
* farmed off to this slave. its job is to handle opening, closing, file
* opening, recoder init etc. and all sorts of things can that often block.
* anything this thread needs to return, it will return via the event pipe.
*/
static void *
_em_slave(void *par)
{
Emotion_Xine_Video *ev;
void *buf[2];
int len;
ev = (Emotion_Xine_Video *)par;
while ((len = read(ev->fd_slave_read, buf, sizeof(buf))) > 0)
{
if (len == sizeof(buf))
{
Emotion_Xine_Event *eev;
ev = buf[0];
eev = buf[1];
switch (eev->mtype)
{
case 0: /* noop */
break;
case 1: /* init */
{
ev->decoder = xine_new();
xine_init(ev->decoder);
xine_register_plugins(ev->decoder, emotion_xine_plugin_info);
if (1)
{
xine_cfg_entry_t cf;
if (xine_config_lookup_entry(ev->decoder, "input.dvd_use_readahead", &cf))
{
cf.num_value = 1; // 0 or 1
xine_config_update_entry(ev->decoder, &cf);
}
}
DBG("OPEN VIDEO PLUGIN...");
if (!ev->opt_no_video)
ev->video = xine_open_video_driver(ev->decoder, "emotion",
XINE_VISUAL_TYPE_NONE, ev);
DBG("RESULT: xine_open_video_driver() = %p", ev->video);
// Let xine autodetect the best audio output driver
if (!ev->opt_no_audio)
ev->audio = xine_open_audio_driver(ev->decoder, NULL, ev);
// ev->audio = xine_open_audio_driver(ev->decoder, "oss", ev);
// dont use alsa - alsa has oss emulation.
// ev->audio = xine_open_audio_driver(ev->decoder, "alsa", ev);
// ev->audio = xine_open_audio_driver(ev->decoder, "arts", ev);
// ev->audio = xine_open_audio_driver(ev->decoder, "esd", ev);
ev->stream = xine_stream_new(ev->decoder, ev->audio, ev->video);
ev->queue = xine_event_new_queue(ev->stream);
xine_event_create_listener_thread(ev->queue, _em_event, ev);
ev->opening = 0;
ev->play_ok = 1;
_em_module_event(ev, 1); /* event - open done */
}
break;
case 3: /* shutdown */
{
_em_module_event(ev, 3);
DBG("shutdown stop");
xine_stop(ev->stream);
// pthread_mutex_lock(&(ev->get_pos_len_mutex));
if (!ev->get_pos_thread_deleted)
{
DBG("closing get_pos thread, %p", ev);
pthread_mutex_lock(&(ev->get_pos_len_mutex));
pthread_cond_broadcast(&(ev->get_pos_len_cond));
pthread_mutex_unlock(&(ev->get_pos_len_mutex));
while (ev->get_poslen);
}
DBG("dispose %p", ev);
xine_dispose(ev->stream);
DBG("dispose evq %p", ev);
xine_event_dispose_queue(ev->queue);
DBG("close video drv %p", ev);
if (ev->video) xine_close_video_driver(ev->decoder, ev->video);
DBG("wait for vo to go");
while (ev->have_vo);
DBG("vo gone");
DBG("close audio drv %p", ev);
if (ev->audio) xine_close_audio_driver(ev->decoder, ev->audio);
DBG("xine exit %p", ev);
xine_exit(ev->decoder);
DBG("DONE %p", ev);
close(ev->fd_write);
close(ev->fd_read);
close(ev->fd_ev_write);
close(ev->fd_ev_read);
close(ev->fd_slave_write);
close(ev->fd_slave_read);
ev->closing = 0;
if (eev->xine_event) free(eev->xine_event);
free(eev);
free(ev);
return NULL;
}
break;
case 2: /* file open */
{
int pos_stream = 0;
int pos_time = 0;
int length_time = 0;
uint32_t v;
char *file;
file = eev->xine_event;
DBG("OPEN STREAM %s", file);
if (xine_open(ev->stream, file))
{
if (xine_get_pos_length(ev->stream, &pos_stream, &pos_time, &length_time))
{
if (length_time == 0)
{
ev->pos = (double)pos_stream / 65535;
ev->len = 1.0;
ev->no_time = 1;
}
else
{
ev->pos = 0.0;
ev->len = (double)length_time / 1000.0;
}
}
else
{
ev->pos = 0.0;
ev->len = 1.0;
}
v = xine_get_stream_info(ev->stream, XINE_STREAM_INFO_FRAME_DURATION);
if (v > 0) ev->fps = 90000.0 / (double)v;
v = xine_get_stream_info(ev->stream, XINE_STREAM_INFO_VIDEO_WIDTH);
ev->w = v;
v = xine_get_stream_info(ev->stream, XINE_STREAM_INFO_VIDEO_HEIGHT);
ev->h = v;
v = xine_get_stream_info(ev->stream, XINE_STREAM_INFO_VIDEO_RATIO);
ev->ratio = (double)v / 10000.0;
ev->just_loaded = 1;
ev->get_poslen = 0;
xine_set_param(ev->stream, XINE_PARAM_AUDIO_VOLUME, ev->volume * 100);
}
_em_module_event(ev, 2); /* event - open done */
}
break;
case 11: /* file close */
{
DBG("done %p", ev);
em_frame_done(ev);
DBG("stop %p", ev);
xine_stop(ev->stream);
DBG("close %p", ev);
xine_close(ev->stream);
DBG("close done %p", ev);
_em_module_event(ev, 11);
}
break;
case 4: /* play */
{
double pos;
int pos_stream, pos_time, length_time;
pos = *((double *)eev->xine_event);
if ((xine_get_param(ev->stream, XINE_PARAM_SPEED) == XINE_SPEED_PAUSE) &&
(pos == ev->pos) &&
(!ev->just_loaded))
{
xine_set_param(ev->stream, XINE_PARAM_SPEED, XINE_SPEED_NORMAL);
}
else
{
if (ev->no_time)
xine_play(ev->stream, pos * 65535, 0);
else
xine_play(ev->stream, 0, pos * 1000);
}
ev->just_loaded = 0;
if (xine_get_pos_length(ev->stream,
&pos_stream,
&pos_time,
&length_time))
{
if (length_time == 0)
{
ev->pos = (double)pos_stream / 65535;
ev->len = 1.0;
ev->no_time = 1;
}
else
{
ev->pos = (double)pos_time / 1000.0;
ev->len = (double)length_time / 1000.0;
}
}
_em_module_event(ev, 4);
}
break;
case 5: /* stop */
{
xine_set_param(ev->stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE);
_em_module_event(ev, 5);
}
break;
case 6: /* seek */
{
double pos;
pos = *((double *)eev->xine_event);
if (ev->no_time)
xine_play(ev->stream, pos * 65535, 0);
else
xine_play(ev->stream, 0, pos * 1000);
if (!ev->play)
xine_set_param(ev->stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE);
_em_module_event(ev, 6);
}
break;
case 7: /* eject */
{
xine_eject(ev->stream);
_em_module_event(ev, 7);
}
break;
case 8: /* spu mute */
{
xine_set_param(ev->stream, XINE_PARAM_IGNORE_SPU, ev->spu_mute);
_em_module_event(ev, 8);
}
break;
case 9: /* channel */
{
xine_set_param(ev->stream, XINE_PARAM_SPU_CHANNEL, ev->spu_channel);
_em_module_event(ev, 9);
}
break;
case 10: /* vol */
{
xine_set_param(ev->stream, XINE_PARAM_AUDIO_VOLUME, ev->volume * 100);
_em_module_event(ev, 10);
}
break;
case 12: /* audio mute */
{
xine_set_param(ev->stream, XINE_PARAM_AUDIO_MUTE, ev->audio_mute);
}
break;
case 13: /* audio mute */
{
xine_set_param(ev->stream, XINE_PARAM_AUDIO_CHANNEL_LOGICAL, ev->audio_channel);
}
break;
case 14: /* audio mute */
{
xine_set_param(ev->stream, XINE_PARAM_VIDEO_CHANNEL, ev->video_channel);
}
break;
default:
break;
}
if (eev->xine_event) free(eev->xine_event);
free(eev);
}
}
return NULL;
}
void Xine::run(){
/* this is the main thread */
playing = false;
seamless = false;
pthread_mutex_lock(&stream_mutex);
struct timespec ts = time_helper::compute_interval(5000);
Audio_s *audio_state = S_Audio_s::get_instance();
volume = 0;
if(validate_stream())
volume = xine_get_param(stream, XINE_PARAM_AUDIO_VOLUME);
old_volume = volume;
while(!quitting){
xine_request = _XINE_REQUEST_NONE;
int ret = pthread_cond_timedwait(&stream_switch, &stream_mutex, &ts);
if (!running || quitting){
ts = time_helper::compute_interval(5000);
continue;
}
if (ret != ETIMEDOUT && xine_request == _XINE_REQUEST_NONE)
continue; /* we're not done waiting */
/*
if (xine_request != _XINE_REQUEST_NONE)
fprintf (stderr, "Loop received event request (%d)\n", xine_request);
*/
switch(xine_request){
case _XINE_REQUEST_PLAY_AT:
case _XINE_REQUEST_PLAY:{
retry_track = false;
if(!validate_stream())
break;
#ifdef XINE_PARAM_EARLY_FINISHED_EVENT
if (seamless && xine_check_version(1,1,1) && oldfile.type != "web" && file.type != "web"){
xine_set_param(stream, XINE_PARAM_GAPLESS_SWITCH, 1);
}
// else{
// xine_close(stream);
// }
seamless = false;
#endif
oldfile = file;
/* fprintf(stderr, "file.path %s\n", file.path.c_str()); */
std::string _str = file.path;
if (file.type == "media-track"){
std::string _path = "cdda:/" + cd_device + "/";
_str = regex_tools::regex_replace(_str, _path.c_str(), "^cdda:/", false, false);
/* fprintf(stderr, "%s\n", _str.c_str()); */
}
else {
vector<string> urls = PlaylistParser::resolve_playlist(_str);
if (!urls.empty())
_str = urls[0]; /* TODO: Handle multiple playlist entries here */
}
if(!xine_open(stream, _str.c_str())){
#ifdef XINE_PARAM_GAPLESS_SWITCH
if (xine_check_version(1,1,1))
xine_set_param(stream, XINE_PARAM_GAPLESS_SWITCH, 0);
#endif
break;
}
int len = 0;
off_t play_at = 0;
const bool has_audio = xine_get_stream_info( stream, XINE_STREAM_INFO_HAS_AUDIO );
const bool audio_handled = xine_get_stream_info( stream, XINE_STREAM_INFO_AUDIO_HANDLED );
if (xine_request == _XINE_REQUEST_PLAY_AT){
xine_get_pos_length(stream, 0, 0, &len);
play_at = len > 0 ? static_cast<double>(cur_time*65535)/(len/1000) : 0;
}
else
cur_time = 0;
_cur_time = cur_time;
total_time = 0;
_total_time = 0;
if ((has_audio || file.type == "web") && audio_handled && xine_play(stream, play_at, cur_time * 1000)){
playing = true;
//gather_info_internal();
audio_state->set_playing(true);
buffering_state = 0;
}
else{
playing = false;
audio_state->set_playing(false);
xine_close(stream);
}
audio_state->get_audio()->update_playlist_view();
#ifdef XINE_PARAM_EARLY_FINISHED_EVENT
#ifdef XINE_PARAM_GAPLESS_SWITCH
if (xine_check_version(1,1,1)){
if (!audio_state->get_audio()->next_helper(false).path.empty()){
xine_set_param(stream, XINE_PARAM_EARLY_FINISHED_EVENT, 1);
/* fprintf(stderr, "Not last track\n"); */
#ifdef XINE_PARAM_DELAY_FINISHED_EVENT
xine_set_param(stream, XINE_PARAM_DELAY_FINISHED_EVENT, 0);
#endif
}
else {
/* If we don't disable XINE_PARAM_DELAY_FINISHED_EVENT for the last track in the playlist,
* xine won't play the last couple of seconds of it */
xine_set_param(stream, XINE_PARAM_EARLY_FINISHED_EVENT, 0);
/* fprintf(stderr, "Last track\n"); */
}
}
#endif
#endif
if (start_paused){
start_paused = false;
audio_state->set_pause(true);
}
else
audio_state->set_pause(false);
break;
}
case _XINE_REQUEST_STOP:
case _XINE_REQUEST_RELEASE_DEVICE:
retry_track = false;
seamless = false;
if(stream){
xine_close(stream);
xine_event_dispose_queue(event_queue);
event_queue = NULL;
xine_dispose(stream);
stream = NULL;
}
playing = false;
audio_state->set_playing(false);
if (xine_request == _XINE_REQUEST_RELEASE_DEVICE){
xine_close_audio_driver(xine, ao_port);
ao_port = NULL;
}
break;
case _XINE_REQUEST_PAUSE:
if(!validate_stream()||!playing)
break;
if(xine_get_param(stream, XINE_PARAM_SPEED) != XINE_SPEED_PAUSE) {
xine_set_param(stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE);
audio_state->set_pause(true);
}
else {
xine_set_param(stream, XINE_PARAM_SPEED, XINE_SPEED_NORMAL);
audio_state->set_pause(false);
}
break;
case _XINE_REQUEST_FF:{
if(!playing || !validate_stream())
break;
gather_info_internal();
if (_cur_time + 5 > _total_time)
break;
_cur_time +=5;
off_t pos = _total_time > 0 ? static_cast<double>(_cur_time*65535)/_total_time : 0;
xine_play(stream, pos, _cur_time*1000);
audio_state->set_pause(false);
break;
}
case _XINE_REQUEST_FB:{
if(!playing || !validate_stream())
break;
gather_info_internal();
if (static_cast<int>(_cur_time) - 5 < 0)
break;
_cur_time -=5;
off_t pos = _total_time > 0 ? static_cast<double>(_cur_time*65535)/_total_time : 0;
xine_play(stream, pos, _cur_time*1000);
audio_state->set_pause(false);
break;
}
default:
break;
}
if (ret == ETIMEDOUT && playing)
gather_info_internal();
if (playing)
ts = time_helper::compute_interval(500);
else
ts = time_helper::compute_interval(5000);
}
if(stream){
xine_close(stream);
xine_event_dispose_queue(event_queue);
event_queue = NULL;
xine_dispose(stream);
stream = NULL;
}
playing = false;
if (ao_port)
xine_close_audio_driver(xine, ao_port);
ao_port = NULL;
pthread_mutex_unlock(&stream_mutex);
/* bye */
}
