void __mm_player_streaming_set_content_bitrate(mm_player_streaming_t* streamer, guint max_bitrate, guint avg_bitrate) { debug_fenter(); return_if_fail(streamer); /* Note : Update buffering criterion bytes * 1. maximum bitrate is considered first. * 2. average bitrage * 3 is next. * 3. if there are no updated bitrate, use default buffering limit. */ if (max_bitrate > 0 && streamer->buffer_max_bitrate != max_bitrate) { debug_log("set maximum bitrate(%dbps).\n", max_bitrate); streamer->buffer_max_bitrate = max_bitrate; streamer->need_update = TRUE; } if (avg_bitrate > 0 && streamer->buffer_avg_bitrate != avg_bitrate) { debug_log("set averate bitrate(%dbps).\n", avg_bitrate); streamer->buffer_avg_bitrate = avg_bitrate; streamer->need_update = TRUE; } debug_fleave(); return; }
static void streaming_set_buffering_time(mm_player_streaming_t* streamer, gdouble buffering_time) { gdouble buffer_buffering_time = DEFAULT_BUFFERING_TIME; debug_fenter(); return_if_fail(streamer); if (buffering_time < MIN_BUFFERING_TIME) buffer_buffering_time = MIN_BUFFERING_TIME; else if (buffering_time > MAX_BUFFERING_TIME) buffer_buffering_time = MAX_BUFFERING_TIME; else buffer_buffering_time = buffering_time; if (streamer->buffering_time != buffer_buffering_time) { debug_log("set buffer buffering time from %2.1f to %2.1f.", streamer->buffering_time, buffer_buffering_time); streamer->buffering_time = buffer_buffering_time; } debug_fleave(); return; }
void __mm_player_streaming_set_buffer(mm_player_streaming_t* streamer, GstElement * buffer, gboolean use_buffering, guint buffer_size, gdouble low_percent, gdouble high_percent, gdouble buffering_time, gboolean use_file, gchar * file_path, guint64 content_size) { debug_fenter(); return_if_fail(streamer); if (buffer) { streamer->buffer = buffer; debug_log("buffer element is %s.", GST_ELEMENT_NAME(buffer)); g_object_set ( G_OBJECT (streamer->buffer), "use-buffering", use_buffering, NULL ); } streaming_set_buffer_size(streamer, buffer_size); streaming_set_buffer_percent(streamer, low_percent, high_percent); streaming_set_buffer_type (streamer, use_file, file_path, content_size); streaming_set_buffering_time(streamer, buffering_time); debug_fleave(); return; }
void test_pthread(void) { pthread_t consumer_t = 0; pthread_t producer_t = 0; Locker *wrlock = locker_pthread_create(); Locker *nest_lock = locker_pthread_nest_create(wrlock, (ReadSelfId)pthread_self); #ifdef RW_LOCK Locker *rdlock = locker_pthread_create(); RWLock *rwlock = rwlock_create(wrlock, rdlock); #endif DList *head = NULL; #ifdef RW_LOCK head = dlist_create(rwlock); #else head = dlist_create(wrlock); #endif return_if_fail(head != NULL); pthread_create(&producer_t, NULL, producer_thread, head); pthread_create(&consumer_t, NULL, consumer_thread, head); pthread_join(consumer_t, NULL); pthread_join(producer_t, NULL); }
/* * mowgli_object_unref * * Decrement the reference counter on an object. * * Inputs: * - the object to refcount * * Outputs: * - none * * Side Effects: * - if the refcount is 0, the object is destroyed. */ void mowgli_object_unref(void *object) { mowgli_object_t *obj = mowgli_object(object); return_if_fail(object != NULL); obj->refcount--; if (obj->refcount <= 0) { mowgli_object_message_broadcast(obj, "destroy"); if (obj->name != NULL) free(obj->name); if (obj->klass != NULL) { mowgli_destructor_t destructor = obj->klass->destructor; if (obj->klass->dynamic == TRUE) mowgli_object_class_destroy(obj->klass); if (destructor != NULL) destructor(obj); else free(obj); } else { mowgli_log_warning("invalid object class"); } } }
void CMediaSession::unregister_fd_cb(sgs_connection *conn, int fd, short events) { sgs_context *ctx = sgs_connection_get_context(conn); CMediaSession *thiz = (CMediaSession *) sgs_context_get_priv(ctx); return_if_fail(thiz); thiz->unregisterFdCB(conn, fd, events); }
PRIVATE void add_polygon_path(SvgPolygonRenderObject* render_object, GraphicsPath* path){ ARRAY point_array = {0}; return_if_fail(render_object && path); point_array = svg_polygon_render_object_get_point_array(render_object); path->AddPolygon((PointF*)point_array.data, point_array.length); }
static void ini_parser_error(INIParser* thiz, int line, int row, char* message) { return_if_fail(thiz != NULL && thiz->builder != NULL); ini_builder_on_error(thiz->builder, line, row, message); return; }
void ftk_widget_set_type(FtkWidget* thiz, int type) { return_if_fail(thiz != NULL && thiz->priv != NULL); thiz->priv->type = type; return; }
static void ini_parser_subkey(INIParser* thiz) { return_if_fail(thiz != NULL && thiz->builder != NULL); ini_builder_on_subkey(thiz->builder, thiz->subkey_start); return; }
static void ini_parser_value(INIParser* thiz) { return_if_fail(thiz != NULL && thiz->builder != NULL); ini_builder_on_value(thiz->builder, thiz->value_start); return; }
void db_close(database_handle_t *db) { return_if_fail(db_mod != NULL); return db_mod->db_close(db); }
void ini_parser_set_builder(INIParser* thiz, INIBuilder* builder) { return_if_fail(thiz != NULL && builder != NULL); thiz->builder = builder; return; }
static void opensex_db_close(database_handle_t *db) { opensex_t *rs; int errno1; char oldpath[BUFSIZE], newpath[BUFSIZE]; return_if_fail(db != NULL); rs = db->priv; mowgli_strlcpy(oldpath, db->file, sizeof oldpath); mowgli_strlcat(oldpath, ".new", sizeof oldpath); mowgli_strlcpy(newpath, db->file, sizeof newpath); fclose(rs->f); if (db->txn == DB_WRITE) { /* now, replace the old database with the new one, using an atomic rename */ if (srename(oldpath, newpath) < 0) { errno1 = errno; slog(LG_ERROR, "db_save(): cannot rename services.db.new to services.db: %s", strerror(errno1)); wallops(_("\2DATABASE ERROR\2: db_save(): cannot rename services.db.new to services.db: %s"), strerror(errno1)); } hook_call_db_saved(); } free(rs->buf); free(rs); free(db->file); free(db); }
/* * mowgli_object_init * * Populates the object manager part of an object. * * Inputs: * - pointer to object manager area * - (optional) name of object * - (optional) class of object * - (optional) custom destructor * * Outputs: * - none * * Side Effects: * - none */ void mowgli_object_init(mowgli_object_t *obj, const char *name, mowgli_object_class_t *klass, mowgli_destructor_t des) { return_if_fail(obj != NULL); if (name != NULL) obj->name = mowgli_strdup(name); if (klass != NULL) { obj->klass = klass; } else { mowgli_object_class_t *tmp = mowgli_alloc(sizeof *tmp); mowgli_object_class_init(tmp, name, des, TRUE); obj->klass = tmp; } obj->refcount = 1; obj->message_handlers.head = NULL; obj->message_handlers.tail = NULL; obj->message_handlers.count = 0; obj->metadata.head = NULL; obj->metadata.tail = NULL; obj->metadata.count = 0; mowgli_object_message_broadcast(obj, "create"); }
static void on_channel_mode(hook_channel_mode_t *data) { mychan_t *mc; return_if_fail(data != NULL); return_if_fail(data->c != NULL); mc = mychan_from(data->c); if (mc == NULL || mc->flags & MC_NOSYNC) return; if (do_channel_sync != NULL) do_channel_sync(mc, NULL); }
void ftk_widget_ref_self(FtkWidget* thiz) { return_if_fail(thiz != NULL); thiz->ref++; return; }
static void ini_parser_comment(INIParser* thiz) { return_if_fail(thiz != NULL && thiz->builder != NULL); ini_builder_on_comment(thiz->builder, thiz->comment_start); return; }
void ftk_widget_show(FtkWidget* thiz, int visible) { FtkEvent event = {0}; return_if_fail(thiz != NULL && thiz->priv != NULL); if(thiz->priv->visible == visible) return; thiz->priv->visible = visible; event.type = visible ? FTK_EVT_SHOW : FTK_EVT_HIDE; ftk_widget_event(thiz, &event); if(!ftk_widget_is_parent_visible(thiz)) { return; } if(visible) { ftk_widget_paint(thiz); } else { /*FIXME: now, as ftk not support clip, repaint the whole parent surface.*/ ftk_widget_paint(ftk_widget_parent(thiz)); } return; }
void fl_xml_free_context(fl_xml_ctx_t *ctx) { return_if_fail(ctx); xml_ctx_free(ctx->xml); fclose(ctx->fp); free(ctx); }
/* protocol-specific stuff to do on login */ static void asuka_on_login(user_t *u, myuser_t *account, const char *wantedhost) { return_if_fail(u != NULL); sts("%s AC %s %s %lu", me.numeric, u->uid, entity(u->myuser)->name, (unsigned long)account->registered); check_hidehost(u); }
void ftk_widget_set_canvas(FtkWidget* thiz, FtkCanvas* canvas) { return_if_fail(thiz != NULL && thiz->priv != NULL); thiz->priv->canvas = canvas; return; }
ret_t cherokee_vrule_configure (cherokee_vrule_t *vrule, cherokee_config_node_t *conf, void *vsrv) { ret_t ret; return_if_fail (vrule, ret_error); return_if_fail (vrule->configure, ret_error); ret = configure_base (vrule, conf); if (ret != ret_ok) return ret; /* Call the real method */ return vrule->configure (vrule, conf, VSERVER(vsrv)); }
void ftk_widget_set_gc(FtkWidget* thiz, FtkWidgetState state, FtkGc* gc) { return_if_fail(thiz != NULL && state < FTK_WIDGET_STATE_NR && gc != NULL); ftk_gc_copy(thiz->priv->gc+state, gc); return; }
void mowgli_mutex_destroy(mowgli_mutex_t *mutex) { return_if_fail(mutex != NULL); mowgli_mutex_uninit(mutex); mowgli_free(mutex); }
void ftk_widget_set_id(FtkWidget* thiz, int id) { return_if_fail(thiz != NULL && thiz->priv != NULL); thiz->priv->id = id; return; }
PRIVATE void add_circle_path(SvgCircleRenderObject* render_object, GraphicsPath* path){ NUMBER cx, cy, radius; return_if_fail(render_object && path); cx = svg_circle_render_object_get_center_x(render_object); cy = svg_circle_render_object_get_center_y(render_object); radius = svg_circle_render_object_get_radius(render_object); path->AddEllipse(cx - radius, cy - radius, radius * 2, radius * 2); }
void ftk_widget_set_insensitive(FtkWidget* thiz, int insensitive) { return_if_fail(thiz != NULL && thiz->priv != NULL); thiz->priv->state = insensitive ? FTK_WIDGET_INSENSITIVE : FTK_WIDGET_NORMAL; return; }
void set_value(const k3d::double_t Value) { return_if_fail(m_writable_data); k3d::rectangle value = boost::any_cast<k3d::rectangle>(m_readable_data.property_internal_value()); value.*m_value = Value; m_writable_data->property_set_value(value); }
static void streaming_set_buffer_type (mm_player_streaming_t* streamer, gboolean use_file, gchar * file_path, guint64 content_size) { guint64 storage_available_size = 0L; //bytes guint64 file_buffer_size = 0L; //bytes gchar file_buffer_name[MAX_FILE_BUFFER_NAME_LEN] = {0}; struct statfs buf = {0}; debug_fenter(); return_if_fail(streamer && streamer->buffer); if (!use_file) { debug_log("use memory for buffering. streaming is played on push-based. \n" "buffering position would not be updated.\n" "buffered data would be flushed after played.\n" "seeking and getting duration could be failed due to file format."); return; } debug_log("use file for buffering. streaming is played on pull-based. \n"); if (!file_path || strlen(file_path) <= 0) file_path = g_strdup(DEFAULT_FILE_BUFFER_PATH); sprintf( file_buffer_name, "%s/XXXXXX", file_path ); debug_log("the buffering file name is %s.\n", file_buffer_name); if (statfs((const char *)file_path, &buf) < 0) { debug_warning ("fail to get availabe storage capacity. just use file buffer.\n"); file_buffer_size = 0L; } else { storage_available_size = (guint64)buf.f_bavail * (guint64)buf.f_bsize; //bytes debug_log ("the number of available blocks : %"G_GUINT64_FORMAT", the block size is %"G_GUINT64_FORMAT".\n", (guint64)buf.f_bavail, (guint64)buf.f_bsize); debug_log ("calculated availabe storage size is %"G_GUINT64_FORMAT" Bytes.\n", storage_available_size); if (content_size <= 0 || content_size >= storage_available_size) file_buffer_size = storage_available_size; else file_buffer_size = 0L; } if (file_buffer_size>0) debug_log("use file ring buffer for buffering."); g_object_set (G_OBJECT(streamer->buffer), "temp-template", file_buffer_name, NULL); g_object_set (G_OBJECT(streamer->buffer), "file-buffer-max-size", file_buffer_size, NULL); debug_fleave(); return; }