void engine_pause_playback(void){ if(engine_state == engine_playing && xine_get_param(stream, XINE_PARAM_SPEED) == XINE_SPEED_NORMAL){ xine_set_param ( stream, XINE_PARAM_SPEED, XINE_SPEED_PAUSE ); engine_state = engine_paused; }else if(engine_state == engine_playing && xine_get_param(stream, XINE_PARAM_SPEED) == XINE_SPEED_PAUSE){ engine_state = engine_paused; } }
void engine_resume_playback(void){ if(engine_state == engine_paused && xine_get_param(stream, XINE_PARAM_SPEED) == XINE_SPEED_PAUSE){ xine_set_param ( stream, XINE_PARAM_SPEED, XINE_SPEED_NORMAL ); engine_state = engine_playing; }else if(engine_state == engine_paused && xine_get_param(stream, XINE_PARAM_SPEED) == XINE_SPEED_NORMAL){ engine_state = engine_stoped; //TODO klopt deze aanname?? } }
void engine_init ( Config * init_conf) { conf = init_conf; // Create our libxine engine, and initialise it engine = xine_new(); xine_init ( engine ); // Automatically choose an audio driver ap = xine_open_audio_driver ( engine, NULL, NULL ); // Create a new stream object stream = xine_stream_new ( engine, ap, NULL ); meta_stream = xine_stream_new ( engine, NULL, NULL ); //TODO in CFG zetten?? xine_set_param ( stream, XINE_PARAM_EARLY_FINISHED_EVENT, 1 ); queue = xine_event_new_queue ( stream ); xine_event_create_listener_thread ( queue, event_callback, NULL ); volume = xine_get_param ( stream, XINE_PARAM_AUDIO_VOLUME ); engine_state = engine_stoped; }
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"; }
gint get_status (MediaModule *module) { RfMediaXine *media = RF_MEDIA_XINE(module->widget); switch (xine_get_status (media->stream)) { case XINE_STATUS_IDLE: return RF_STATUS_EMPTY; case XINE_STATUS_STOP: return RF_STATUS_STOP; case XINE_STATUS_PLAY: switch (xine_get_param (media->stream, XINE_PARAM_SPEED)) { case XINE_SPEED_PAUSE: return RF_STATUS_PAUSE; case XINE_SPEED_NORMAL: return RF_STATUS_PLAY; } case XINE_STATUS_QUIT: return RF_STATUS_QUIT; } return (-1); }
bool open(xine_t* xine, const std::string& filename) { if (filename==getFileName()) return true; _xine = xine; // create visual rgbout_visual_info_t* visual = new rgbout_visual_info_t; visual->levels = PXLEVEL_ALL; visual->format = PX_RGB32; visual->user_data = this; visual->callback = my_render_frame; // set up video driver _vo = xine_open_video_driver(_xine, "rgb", XINE_VISUAL_TYPE_RGBOUT, (void*)visual); // set up audio driver char* audio_driver = getenv("OSG_XINE_AUDIO_DRIVER"); _ao = audio_driver ? xine_open_audio_driver(_xine, audio_driver, NULL) : xine_open_audio_driver(_xine, "auto", NULL); if (!_vo) { OSG_NOTICE<<"XineImageStream::open() : Failed to create video driver"<<std::endl; return false; } // set up stream _stream = xine_stream_new(_xine, _ao, _vo); if (_stream) { if (_volume < 0.0) { _volume = static_cast<float>(xine_get_param(_stream, XINE_PARAM_AUDIO_VOLUME))/100.0f; } else { setVolume(_volume); } } _event_queue = xine_event_new_queue(_stream); xine_event_create_listener_thread(_event_queue, event_listener, this); int result = xine_open(_stream, filename.c_str()); if (result==0) { OSG_INFO<<"XineImageStream::open() : Could not ready movie file."<<std::endl; close(); return false; } _ready = false; int width = xine_get_stream_info(_stream,XINE_STREAM_INFO_VIDEO_WIDTH); int height = xine_get_stream_info(_stream,XINE_STREAM_INFO_VIDEO_HEIGHT); allocateImage(width,height,1,GL_RGB,GL_UNSIGNED_BYTE,1); OSG_INFO<<"XineImageStream::open() size "<<width<<" "<<height<<std::endl; // play(); return true; }
bool Xine::make_new_stream(){ if (stream) xine_dispose(stream); std::string ao_driver = "auto"; GlobalOptions * go = S_GlobalOptions::get_instance(); global_audio_device gad = go->get_audio_device_audio(); if (gad.dev_output != ""){ ao_driver = gad.dev_output; } if (ao_port) xine_close_audio_driver(xine, ao_port); /* fprintf(stderr, "Audio driver: %s (%d)\n", ao_driver.c_str(), gad.pos); */ ao_port = xine_open_audio_driver(xine, ao_driver.c_str(), NULL); if (ao_port == NULL){ DialogWaitPrint pdialog(4000); pdialog.add_line(dgettext("mms-audio-xine", "Audio device unavailable: ") + ao_driver); pdialog.print(); return false; } /* Xine uses its own config file for a lot of stuff */ xine_cfg_entry_t config; /* for some reason this doesn't work for someone if (!xine_config_lookup_entry(xine, "input.cdda_device", &config)) { fprintf(stderr, "Xine: Can't set cdda device\n"); } else{ std::string str = S_Cd::get_instance()->get_device(); config.str_value = const_cast<char*>(str.c_str()); xine_config_update_entry(xine, &config); } */ /* Disable CDDB, we have our own CDDB library */ if (xine_config_lookup_entry(xine, "media.audio_cd.use_cddb", &config)){ config.num_value = 0; xine_config_update_entry(xine, &config); } stream = xine_stream_new(xine, ao_port, NULL); if (stream == NULL){ xine_close_audio_driver(xine, ao_port); ao_port = NULL; return false; } /* xine_set_param(stream, XINE_PARAM_VERBOSITY, XINE_VERBOSITY_DEBUG); */ if (event_queue) xine_event_dispose_queue(event_queue); xine_set_param( stream, XINE_PARAM_METRONOM_PREBUFFER, 6000 ); xine_set_param( stream, XINE_PARAM_IGNORE_VIDEO, 1 ); #ifdef XINE_PARAM_EARLY_FINISHED_EVENT #ifdef XINE_PARAM_GAPLESS_SWITCH if (xine_check_version(1,1,1)) xine_set_param(stream, XINE_PARAM_EARLY_FINISHED_EVENT, 1); #ifdef XINE_PARAM_DELAY_FINISHED_EVENT xine_set_param(stream, XINE_PARAM_DELAY_FINISHED_EVENT, 0); #endif #endif #endif event_queue = xine_event_new_queue(stream); mixer_cap = false; is_muted = xine_get_param(stream, XINE_PARAM_AUDIO_MUTE); if (is_muted == -1){ is_muted = xine_get_param(stream, XINE_PARAM_AUDIO_AMP_MUTE); mixer_cap = true; } xine_event_create_listener_thread(event_queue, &Xine::event_listener, reinterpret_cast<void*>(this)); return true; }
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 */ }
/* 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; }