Пример #1
0
conn_pool_t* conn_pool_new(int size,int lazy_init,conn_cb_t* cbs, void* args)
{
	int i;
	assert(size > 0);
	conn_pool_t* pool = (conn_pool_t*)PCALLOC(sizeof(conn_pool_t));
	pool->conns = (void**)PCALLOC(sizeof(void*)*size);
	pool->size = size;
	pool->args = args;
	pool->curconns = 0;
	pool->cbs = (conn_cb_t*)PCALLOC(sizeof(conn_cb_t));
	memcpy(pool->cbs, cbs, sizeof(conn_cb_t));

	if(lazy_init == 0){
		pool->start = pool->end = 0;
		for(i=0;i<size; i++){
			pool->conns[i] = new_and_connect(cbs, args,&pool->statis);
			if(pool->conns[i]) sync_inc(&pool->curconns);
		}
	}else{
		pool->start = 0;
		pool->end = 0;
	}
	

	pthread_spin_init(&pool->spin, 0);
	return pool;
}
Пример #2
0
mrl_metadata_t *
mrl_metadata_new (mrl_resource_t res)
{
  mrl_metadata_t *meta;

  meta = PCALLOC (mrl_metadata_t, 1);
  if (!meta)
    return NULL;

  switch (res)
  {
  case MRL_RESOURCE_CDDA:
  case MRL_RESOURCE_CDDB:
    meta->priv = mrl_metadata_cd_new ();
    break;

  case MRL_RESOURCE_DVD:
  case MRL_RESOURCE_DVDNAV:
    meta->priv = mrl_metadata_dvd_new ();
    break;

  default:
    break;
  }

  return meta;
}
Пример #3
0
mrl_properties_video_t *
mrl_properties_video_new (void)
{
  mrl_properties_video_t *video;

  video = PCALLOC (mrl_properties_video_t, 1);

  return video;
}
Пример #4
0
mrl_properties_audio_t *
mrl_properties_audio_new (void)
{
  mrl_properties_audio_t *audio;

  audio = PCALLOC (mrl_properties_audio_t, 1);

  return audio;
}
Пример #5
0
static mrl_metadata_audio_t *
mrl_metadata_audio_new (void)
{
  mrl_metadata_audio_t *audio;

  audio = PCALLOC (mrl_metadata_audio_t, 1);

  return audio;
}
Пример #6
0
static mrl_metadata_dvd_t *
mrl_metadata_dvd_new (void)
{
  mrl_metadata_dvd_t *dvd;

  dvd = PCALLOC (mrl_metadata_dvd_t, 1);

  return dvd;
}
Пример #7
0
static mrl_metadata_sub_t *
mrl_metadata_sub_new (void)
{
  mrl_metadata_sub_t *sub;

  sub = PCALLOC (mrl_metadata_sub_t, 1);

  return sub;
}
Пример #8
0
mrl_metadata_dvd_title_t *
mrl_metadata_dvd_title_new (void)
{
  mrl_metadata_dvd_title_t *title;

  title = PCALLOC (mrl_metadata_dvd_title_t, 1);

  return title;
}
Пример #9
0
static mrl_metadata_cd_t *
mrl_metadata_cd_new (void)
{
  mrl_metadata_cd_t *cd;

  cd = PCALLOC (mrl_metadata_cd_t, 1);

  return cd;
}
Пример #10
0
mrl_metadata_cd_track_t *
mrl_metadata_cd_track_new (void)
{
  mrl_metadata_cd_track_t *track;

  track = PCALLOC (mrl_metadata_cd_track_t, 1);

  return track;
}
Пример #11
0
mrl_properties_t *
mrl_properties_new (void)
{
  mrl_properties_t *prop;

  prop = PCALLOC (mrl_properties_t, 1);

  return prop;
}
Пример #12
0
playlist_t *
pl_playlist_new (int shuffle, int loop, player_loop_t loop_mode)
{
  playlist_t *playlist;

  playlist = PCALLOC (playlist_t, 1);
  if (!playlist)
    return NULL;

  pl_playlist_set_shuffle (playlist, shuffle);
  pl_playlist_set_loop (playlist, loop, loop_mode);

  return playlist;
}
Пример #13
0
void 
kcdb_credset_buf_assert_size(kcdb_credset * cs, khm_int32 nclist)
{
    if(cs->nc_clist < nclist) {
        kcdb_credset_credref * new_clist;
        
        /* nclist had better be greater than KCDB_CREDSET_INITIAL_SIZE */
        nclist = KCDB_CREDSET_INITIAL_SIZE + 
            (((nclist - (KCDB_CREDSET_INITIAL_SIZE + 1)) / KCDB_CREDSET_GROWTH_FACTOR) + 1) *
            KCDB_CREDSET_GROWTH_FACTOR;

        new_clist = PCALLOC(nclist, sizeof(kcdb_credset_credref));

        memcpy(new_clist, cs->clist, cs->nclist * sizeof(kcdb_credset_credref));

        PFREE(cs->clist);

        cs->clist = new_clist;
    }
}
Пример #14
0
static int _init(T *thiz)
{
    RWLOCK_INIT(LOCK);

    thiz->hdr = PCALLOC(SUPER->mpool, sizeof(hdr_block_t));
#if 1
    thiz->hdr->fend_off = BTR_HEADER_BLK_SIZE;
#else
    thiz->hdr->fend_off = BTR_HEADER_BLK_SIZE;
    thiz->hdr->version = DB_FILE_VERSION;
    thiz->hdr->blktype = BTR_HEADER_BLK;
    strncpy(thiz->hdr->magic, DB_MAGIC_NUM, sizeof(thiz->hdr->magic));
#endif

    thiz->rfd = -1;
    thiz->wfd = -1;

    ADD_METHOD(destroy);
    ADD_METHOD(store);
    ADD_METHOD(restore);
    ADD_METHOD(merge_start);
    ADD_METHOD(merge);
    ADD_METHOD(merge_flush);
    ADD_METHOD(merge_hdr);
    ADD_METHOD(merge_fin);
    ADD_METHOD(find);
    ADD_METHOD(exist);
    ADD_METHOD(find_in_index);
    ADD_METHOD(range_cmp);
    ADD_METHOD(krange_cmp);
    ADD_METHOD(pkrange_cmp);
    ADD_METHOD(split);
    ADD_METHOD(shrink);
    ADD_METHOD(invalid);
    ADD_METHOD(get_iter);

    return 0;
}
Пример #15
0
mrl_t *
mrl_sv_new (player_t *player, mrl_resource_t res, void *args)
{
  mrl_t *mrl = NULL;
  int support = 0;

  pl_log (player, PLAYER_MSG_VERBOSE, MODULE_NAME, __FUNCTION__);

  if (!player || !args)
    return NULL;

  /* ensure we provide a valid resource type */
  if (res == MRL_RESOURCE_UNKNOWN)
    return NULL;

  /* ensure player support this resource type */
  support = libplayer_wrapper_supported_res (player->type, res);

  if (!support)
  {
    pl_log (player, PLAYER_MSG_WARNING, MODULE_NAME,
          "Unsupported resource type (%d)", res);
    return NULL;
  }

  mrl = PCALLOC (mrl_t, 1);
  if (!mrl)
    return NULL;

  mrl->resource = res;
  mrl->priv = args;

  mrl_retrieve_properties (player, mrl);

  mrl->type = mrl_guess_type (mrl);   /* can guess only if properties exist */

  return mrl;
}
Пример #16
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;
}