Ejemplo n.º 1
0
GF_Err LIBPLAYER_CloseService(GF_InputService *plug)
{
	LibPlayerIn *read = (LibPlayerIn *) plug->priv;

#ifndef TEST_LIBPLAYER
	// only disconnect if
	if (read->player_type == PLAYER_FILE) {
		player_playback_stop(read->player);
		fprintf(stderr, "[LibPlayerIN]player_playback_stop for instance %d\n", read->player_id);
		player_uninit(read->player);
		fprintf(stderr, "[LibPlayerIN]player_uninit for instance %d\n", read->player_id);
		read->player = NULL;
		libplayer_id--;

		read->state = 0;

		gf_service_disconnect_ack(read->service, NULL, GF_OK);
		GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIn] Closing libplayer instance %d\n", read->player_id));



		// channel zapping dvb case, don't disconnect service
	} else {
		GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIn] Don't close service libplayer instance %d, use this instance for channel zapping\n", read->player_id));
	}

	return GF_OK;
#endif
}
Ejemplo n.º 2
0
GF_Err LIBPLAYER_CloseService(GF_InputService *plug)
{
	LibPlayerIn *read = (LibPlayerIn *) plug->priv;
	if(libplayer_id >= 0){
#ifndef TEST_LIBPLAYER
		printf("in do loop\n");
		printf("[LibPlayerIN]read->url: %s\n", read->url);
		player_playback_stop(read->player);
		printf("[LibPlayerIN]player_playback_stop\n");
		player_uninit(read->player);
		printf("[LibPlayerIN]player_uninit\n");
		read->player = NULL;
		libplayer_id--;


#endif
		read->state = 0;
	}
	gf_term_on_disconnect(read->service, NULL, GF_OK);
	GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[LibPlayerIn] Closing libplayer instance %d\n", read->player_id));
	return GF_OK;
}
Ejemplo n.º 3
0
player_t *
player_init (player_type_t type,
             player_verbosity_level_t verbosity, player_init_param_t *param)
{
  player_t *player = NULL;
  init_status_t res = PLAYER_INIT_ERROR;
  supervisor_status_t sv_res;
  int ret;

  int *sv_run;
  pthread_t *sv_job;
  pthread_cond_t *sv_cond;
  pthread_mutex_t *sv_mutex;

  player = PCALLOC (player_t, 1);
  if (!player)
    return NULL;

  player->type        = type;
  player->verbosity   = verbosity;
  player->state       = PLAYER_STATE_IDLE;
  player->playlist    = pl_playlist_new (0, 0, PLAYER_LOOP_DISABLE);

  if (param)
  {
    player->ao          = param->ao;
    player->vo          = param->vo;
    player->winid       = param->winid;
    player->x11_display = param->display;
    player->event_cb    = param->event_cb;
    player->user_data   = param->data;
    player->quality     = param->quality;
  }

  pthread_mutex_init (&player->mutex_verb, NULL);

  switch (player->type)
  {
#ifdef HAVE_XINE
  case PLAYER_TYPE_XINE:
    player->funcs = pl_register_functions_xine ();
    player->priv  = pl_register_private_xine ();
    break;
#endif /* HAVE_XINE */
#ifdef HAVE_MPLAYER
  case PLAYER_TYPE_MPLAYER:
    player->funcs = pl_register_functions_mplayer ();
    player->priv  = pl_register_private_mplayer ();
    break;
#endif /* HAVE_MPLAYER */
#ifdef HAVE_VLC
  case PLAYER_TYPE_VLC:
    player->funcs = pl_register_functions_vlc ();
    player->priv  = pl_register_private_vlc ();
    break;
#endif /* HAVE_VLC */
#ifdef HAVE_GSTREAMER
  case PLAYER_TYPE_GSTREAMER:
    player->funcs = pl_register_functions_gstreamer ();
    player->priv  = pl_register_private_gstreamer ();
    break;
#endif /* HAVE_GSTREAMER */
  case PLAYER_TYPE_DUMMY:
    player->funcs = pl_register_functions_dummy ();
    player->priv  = pl_register_private_dummy ();
    break;
  default:
    break;
  }

  pl_log (player, PLAYER_MSG_VERBOSE, MODULE_NAME, __FUNCTION__);

  if (!player->funcs || !player->priv)
  {
    pl_log (player, PLAYER_MSG_ERROR, MODULE_NAME, "no wrapper registered");
    player_uninit (player);
    return NULL;
  }

  player->supervisor = pl_supervisor_new ();
  if (!player->supervisor)
  {
    player_uninit (player);
    return NULL;
  }

  sv_res = pl_supervisor_init (player, &sv_run, &sv_job, &sv_cond, &sv_mutex);
  if (sv_res != SUPERVISOR_STATUS_OK)
  {
    pl_log (player, PLAYER_MSG_ERROR,
            MODULE_NAME, "failed to init supervisor");
    player_uninit (player);
    return NULL;
  }

  player->event = pl_event_handler_register (player, player_event_cb);
  if (!player->event)
  {
    player_uninit (player);
    return NULL;
  }

  pl_log (player, PLAYER_MSG_INFO, MODULE_NAME, "pl_event_handler_init");
  ret = pl_event_handler_init (player->event,
                               sv_run, sv_job, sv_cond, sv_mutex);
  if (ret)
  {
    pl_log (player, PLAYER_MSG_ERROR,
            MODULE_NAME, "failed to init event handler");
    player_uninit (player);
    return NULL;
  }

  player->window = pl_window_register (player);

  pl_event_handler_enable (player->event);

  player_set_verbosity (player, verbosity);

  pl_supervisor_send (player, SV_MODE_WAIT_FOR_END,
                      SV_FUNC_PLAYER_INIT, NULL, &res);
  if (res != PLAYER_INIT_OK)
  {
    player_uninit (player);
    return NULL;
  }

  return player;
}