eServiceXine::eServiceXine(const char *filename): m_filename(filename), m_pump(eApp, 1) { m_state = stError; stream = 0; event_queue = 0; ao_port = 0; vo_port = 0; // if ((vo_port = xine_open_video_driver(xine, "fb", XINE_VISUAL_TYPE_FB, NULL)) == NULL) if ((vo_port = xine_open_video_driver(xine, "none", XINE_VISUAL_TYPE_NONE, NULL)) == NULL) { eWarning("cannot open xine video driver"); } if ((ao_port = xine_open_audio_driver(xine , "alsa", NULL)) == NULL) { eWarning("cannot open xine audio driver"); } stream = xine_stream_new(xine, ao_port, vo_port); event_queue = xine_event_new_queue(stream); xine_event_create_listener_thread(event_queue, eventListenerWrap, this); // CONNECT(m_pump.recv_msg, eServiceXine::gstPoll); m_state = stIdle; }
framecatcher::framecatcher(): xine(NULL), stream(NULL), vo_port(NULL) , length(0){ // start up drivers std::string vo_driver = "auto"; xine= xine_new(); xine_init(xine); if((vo_port=xine_open_video_driver(xine,vo_driver.c_str(),XINE_VISUAL_TYPE_NONE, NULL))==NULL) std::cerr << "framecatcher::framecatcher() " << "ERROR OPENING VIDEO DRIVER"; }
xine_video_port_t *VideoDataOutputXT::videoPort() const { #ifdef XINE_VISUAL_TYPE_RAW if (m_needNewPort) { VideoDataOutputXT *that = const_cast<VideoDataOutputXT *>(this); that->m_needNewPort = false; that->m_visual.user_data = static_cast<void *>(that); that->m_visual.supported_formats = m_supported_formats; that->m_visual.raw_output_cb = &Phonon::Xine::VideoDataOutputXT::raw_output_cb; that->m_visual.raw_overlay_cb = &Phonon::Xine::VideoDataOutputXT::raw_overlay_cb; debug() << Q_FUNC_INFO << "create new raw video port with supported_formats =" << that->m_visual.supported_formats; xine_video_port_t *newVideoPort = xine_open_video_driver(m_xine, "auto", XINE_VISUAL_TYPE_RAW, static_cast<void *>(&that->m_visual)); if (m_videoPort) { // TODO delayed destruction of m_videoPort } that->m_videoPort = newVideoPort; return newVideoPort; } #endif return m_videoPort; }
void music_init () { char *configfile; if (!xine_check_version (XINE_MAJOR_VERSION, XINE_MINOR_VERSION, XINE_SUB_VERSION)) { g_critical (_("Incompatible version of Xine-lib found.")); exit (EXIT_FAILURE); } xine = xine_new (); configfile = g_build_filename (g_get_home_dir (), ".xine", "config", NULL); xine_config_load (xine, configfile); g_free (configfile); xine_init (xine); if (!(ao = xine_open_audio_driver (xine, NULL, NULL))) { g_critical (_("Unable to open audio driver from Xine.")); exit (EXIT_FAILURE); } if (!(vo = xine_open_video_driver (xine, NULL, XINE_VISUAL_TYPE_NONE, NULL))) { g_critical (_("Unable to open video driver from Xine.")); exit (EXIT_FAILURE); } if (!(stream = xine_stream_new (xine, ao, vo))) { g_critical (_("Unable to open a Xine stream.")); exit (EXIT_FAILURE); } events = xine_event_new_queue (stream); xine_event_create_listener_thread (events, music_events, NULL); }
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; }
static xine_vo_driver_t * _xine_create_video_driver (GstXine * xine) { return xine_open_video_driver (GST_XINE_GET_CLASS (xine)->xine, "none", XINE_VISUAL_TYPE_NONE, 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; }
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; }