static void
gog_object_write_property_sax (GogObject const *obj, GParamSpec *pspec, GsfXMLOut *output)
{
GObject *val_obj;
GType prop_type = G_PARAM_SPEC_VALUE_TYPE (pspec);
GValue value = { 0 };
g_value_init (&value, prop_type);
g_object_get_property (G_OBJECT (obj), pspec->name, &value);
/* No need to save default values */
if (((pspec->flags & GOG_PARAM_POSITION) &&
gog_object_is_default_position_flags (obj, pspec->name)) ||
(!(pspec->flags & GOG_PARAM_FORCE_SAVE) &&
!(pspec->flags & GOG_PARAM_POSITION) &&
g_param_value_defaults (pspec, &value))) {
g_value_unset (&value);
return;
}
switch (G_TYPE_FUNDAMENTAL (prop_type)) {
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
case G_TYPE_BOOLEAN:
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_ENUM:
case G_TYPE_FLAGS: {
GValue str = { 0 };
g_value_init (&str, G_TYPE_STRING);
g_value_transform (&value, &str);
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, g_value_get_string (&str));
gsf_xml_out_end_element (output); /* </property> */
g_value_unset (&str);
break;
}
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
GValue vd = { 0 };
GString *str = g_string_new (NULL);
g_value_init (&vd, G_TYPE_DOUBLE);
g_value_transform (&value, &vd);
go_dtoa (str, "!g", g_value_get_double (&vd));
g_value_unset (&vd);
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, str->str);
gsf_xml_out_end_element (output); /* </property> */
g_string_free (str, TRUE);
break;
}
case G_TYPE_STRING: {
char const *str = g_value_get_string (&value);
if (str != NULL) {
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
gsf_xml_out_add_cstr (output, NULL, str);
gsf_xml_out_end_element (output); /* </property> */
}
break;
}
case G_TYPE_OBJECT:
val_obj = g_value_get_object (&value);
if (val_obj != NULL) {
if (GO_IS_PERSIST (val_obj)) {
gsf_xml_out_start_element (output, "property");
gsf_xml_out_add_cstr_unchecked (output, "name", pspec->name);
go_persist_sax_save (GO_PERSIST (val_obj), output);
gsf_xml_out_end_element (output); /* </property> */
} else
g_warning ("How are we supposed to persist this ??");
}
break;
default:
g_warning ("I could not persist property \"%s\", since type \"%s\" is unhandled.",
g_param_spec_get_name (pspec), g_type_name (G_TYPE_FUNDAMENTAL(prop_type)));
}
g_value_unset (&value);
}
void init_varlist()
{
int i;
GtkTreeViewColumn *col[Num_Columns];
GtkWidget *hbox, *vbox, *buAdd, *buRemove, *buAutoRefresh,
*buImport;
GValue cell_editable;
varlist_auto_update = 0;
iter_stamp = 0xD06FECE5; //unique stamp value (increments)
//Create the window.
winVarList = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW(winVarList), "Variables");
gtk_window_set_default_size( GTK_WINDOW(winVarList), 300, 380);
gtk_container_set_border_width( GTK_CONTAINER(winVarList), 2);
//Create the containers.
hbox = gtk_hbox_new(FALSE, 0); //hbox holds the treeview and hbox.
vbox = gtk_vbox_new(FALSE, 0); //vbox holds the buttons at the right.
//hbox, vbox, no xbox?
//Create the treeview.
store = gtk_tree_store_new(Num_Columns, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
//Create the cell renderers.
memset(&cell_editable, 0, sizeof(cell_editable));
g_value_init(&cell_editable, G_TYPE_BOOLEAN);
g_value_set_boolean(&cell_editable, TRUE);
for(i=0; i<Num_Columns; i++)
{
//cell_renderer[i] = (i == Col_Type) ? gtk_cell_renderer_combo_new() : gtk_cell_renderer_text_new();
cell_renderer[i] = gtk_cell_renderer_text_new();
g_object_set_property(G_OBJECT(cell_renderer[i]), "editable", &cell_editable);
}
//Enable multiple selection for remove button.
tree_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(tree_selection, GTK_SELECTION_MULTIPLE);
//Set up type combo box.
/*g_value_set_boolean(&cell_editable, FALSE);
g_object_set_property(G_OBJECT(cell_renderer[Col_Type]), "has-entry", &cell_editable);
type_list = gtk_tree_store_new(1, G_TYPE_STRING);
memset(&type_val, 0, sizeof(type_val));
g_value_init(&type_val, G_TYPE_STRING);
for(i=0; i<Num_Types; i++)
{
g_value_set_string(&type_val, type_name[i]);
gtk_tree_store_append(type_list, &iter, NULL);
gtk_tree_store_set_value(type_list, &iter, 0, &type_val);
}
memset(&model_val, 0, sizeof(model_val));
g_value_init(&model_val, GTK_TYPE_TREE_MODEL);
g_value_set_???(&model_val, &type_list); //what function goes here?
g_object_set_property(G_OBJECT(cell_renderer[Col_Type]), "model", &model_val);
printf("--------------1------------\n");
memset(&model_col, 0, sizeof(model_col));
g_value_init(&model_val, G_TYPE_INT);
g_value_set_int(&model_col, 0);
g_object_set_property(G_OBJECT(cell_renderer[Col_Type]), "text-column", &model_col);
printf("--------------2------------\n");*/
//Create columns.
for(i=0; i<Num_Columns; i++)
col[i] = gtk_tree_view_column_new_with_attributes(col_name[i], cell_renderer[i], "text", i, NULL);
gtk_tree_view_column_set_cell_data_func(col[Col_Value], cell_renderer[Col_Value], value_data_func, NULL, NULL);
gtk_tree_view_column_set_cell_data_func(col[Col_Address], cell_renderer[Col_Address], address_data_func, NULL, NULL);
gtk_tree_view_column_set_cell_data_func(col[Col_Type], cell_renderer[Col_Type], type_data_func, NULL, NULL);
gtk_tree_view_column_set_cell_data_func(col[Col_Offset], cell_renderer[Col_Offset], offset_data_func, NULL, NULL);
//Add columns.
for(i=0; i<Num_Columns; i++)
{
gtk_tree_view_column_set_resizable(col[i], TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), col[i]);
}
//Add treeview to container.
g_object_unref(G_OBJECT(store));
gtk_box_pack_start(GTK_BOX(hbox), tree, TRUE, TRUE, 0);
//Create buttons and add to container.
buAdd = gtk_button_new_with_label("Add");
gtk_box_pack_start(GTK_BOX(vbox), buAdd, FALSE, FALSE, 0);
buRemove = gtk_button_new_with_label("Remove");
gtk_box_pack_start(GTK_BOX(vbox), buRemove, FALSE, FALSE, 0);
buImport = gtk_button_new_with_label("Import");
gtk_box_pack_start(GTK_BOX(vbox), buImport, FALSE, FALSE, 0);
buAutoRefresh = gtk_check_button_new_with_label("Auto Refresh");
gtk_box_pack_start(GTK_BOX(vbox), buAutoRefresh, FALSE, FALSE, 0);
//Add container to window.
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(winVarList), hbox);
gtk_widget_show_all(winVarList);
//=== Signal Connections ===========================/
gtk_signal_connect(GTK_OBJECT(winVarList), "destroy", (GtkSignalFunc)on_close, NULL);
gtk_signal_connect(GTK_OBJECT(buAdd), "clicked", (GtkSignalFunc)on_add, NULL);
gtk_signal_connect(GTK_OBJECT(buRemove), "clicked", (GtkSignalFunc)on_remove, NULL);
gtk_signal_connect(GTK_OBJECT(buAutoRefresh), "clicked", (GtkSignalFunc)on_auto_refresh_toggle, NULL);
gtk_signal_connect(GTK_OBJECT(buImport), "clicked", (GtkSignalFunc)on_import, NULL);
for(i=0; i<Num_Columns; i++)
gtk_signal_connect(GTK_OBJECT(cell_renderer[i]), "edited", (GtkSignalFunc)on_cell_edit, (gpointer)(long)i);
varlist_opened = 1;
//test values
//add_value("Lives", 0x8033B21D, Type_int8, 0);
//add_value("Health", 0x8033B21E, Type_hex16, 0);
//add_value("Pointer", 0x8033B200, Type_hex32 | Type_pointer, 4);
//add_value("Float", 0x800F6A10, Type_float, 0);
}
static void
gimp_operation_tool_color_picked (GimpImageMapTool *im_tool,
gpointer identifier,
gdouble x,
gdouble y,
const Babl *sample_format,
const GimpRGB *color)
{
GimpOperationTool *tool = GIMP_OPERATION_TOOL (im_tool);
gchar **pspecs;
pspecs = g_strsplit (identifier, ":", 2);
if (pspecs[1])
{
GimpImageMapOptions *options = GIMP_IMAGE_MAP_TOOL_GET_OPTIONS (tool);
GimpDrawable *drawable = GIMP_TOOL (im_tool)->drawable;
GObjectClass *object_class = G_OBJECT_GET_CLASS (tool->config);
GParamSpec *pspec_x;
GParamSpec *pspec_y;
gint width = 1;
gint height = 1;
if (drawable)
{
gint off_x, off_y;
gimp_item_get_offset (GIMP_ITEM (drawable), &off_x, &off_y);
x -= off_x;
y -= off_y;
switch (options->region)
{
case GIMP_IMAGE_MAP_REGION_SELECTION:
if (gimp_item_mask_intersect (GIMP_ITEM (drawable),
&off_x, &off_y, &width, &height))
{
x -= off_x;
y -= off_y;
}
break;
case GIMP_IMAGE_MAP_REGION_DRAWABLE:
width = gimp_item_get_width (GIMP_ITEM (drawable));
height = gimp_item_get_height (GIMP_ITEM (drawable));
break;
}
}
pspec_x = g_object_class_find_property (object_class, pspecs[0]);
pspec_y = g_object_class_find_property (object_class, pspecs[1]);
if (pspec_x && pspec_y &&
G_PARAM_SPEC_TYPE (pspec_x) == G_PARAM_SPEC_TYPE (pspec_y))
{
GValue value_x = G_VALUE_INIT;
GValue value_y = G_VALUE_INIT;
g_value_init (&value_x, G_PARAM_SPEC_VALUE_TYPE (pspec_x));
g_value_init (&value_y, G_PARAM_SPEC_VALUE_TYPE (pspec_y));
#define HAS_KEY(p,k,v) gimp_gegl_param_spec_has_key (p, k, v)
if (HAS_KEY (pspec_x, "unit", "relative-coordinate") &&
HAS_KEY (pspec_y, "unit", "relative-coordinate"))
{
x /= (gdouble) width;
y /= (gdouble) height;
}
if (G_IS_PARAM_SPEC_INT (pspec_x))
{
g_value_set_int (&value_x, x);
g_value_set_int (&value_y, y);
g_param_value_validate (pspec_x, &value_x);
g_param_value_validate (pspec_y, &value_y);
g_object_set (tool->config,
pspecs[0], g_value_get_int (&value_x),
pspecs[1], g_value_get_int (&value_y),
NULL);
}
else if (G_IS_PARAM_SPEC_DOUBLE (pspec_x))
{
g_value_set_double (&value_x, x);
g_value_set_double (&value_y, y);
g_param_value_validate (pspec_x, &value_x);
g_param_value_validate (pspec_y, &value_y);
g_object_set (tool->config,
pspecs[0], g_value_get_double (&value_x),
pspecs[1], g_value_get_double (&value_y),
NULL);
}
else
{
g_warning ("%s: unhandled param spec of type %s",
G_STRFUNC, G_PARAM_SPEC_TYPE_NAME (pspec_x));
}
g_value_unset (&value_x);
g_value_unset (&value_y);
}
}
else
{
g_object_set (tool->config,
pspecs[0], color,
NULL);
}
g_strfreev (pspecs);
}
static void
output_loop (gpointer data)
{
GstPad *pad;
GOmxCore *gomx;
GOmxPort *out_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
pad = data;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
/* do not bother if we have been setup to bail out */
if ((ret = g_atomic_int_get (&self->last_pad_push_return)) != GST_FLOW_OK)
goto leave;
if (!self->ready) {
g_error ("not ready");
return;
}
out_port = self->out_port;
if (G_LIKELY (out_port->enabled)) {
OMX_BUFFERHEADERTYPE *omx_buffer = NULL;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (out_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_UNLIKELY (!omx_buffer)) {
GST_WARNING_OBJECT (self, "null buffer: leaving");
ret = GST_FLOW_WRONG_STATE;
goto leave;
}
log_buffer (self, omx_buffer);
if (G_LIKELY (omx_buffer->nFilledLen > 0)) {
GstBuffer *buf;
#if 1
/** @todo remove this check */
if (G_LIKELY (self->in_port->enabled)) {
GstCaps *caps = NULL;
caps = gst_pad_get_negotiated_caps (self->srcpad);
#ifdef ANDROID
if (!caps || gomx->settings_changed) {
#else
if (!caps) {
#endif
/** @todo We shouldn't be doing this. */
GST_WARNING_OBJECT (self, "faking settings changed notification");
if (gomx->settings_changed_cb)
gomx->settings_changed_cb (gomx);
#ifdef ANDROID
gomx->settings_changed = FALSE;
#endif
} else {
GST_LOG_OBJECT (self, "caps already fixed: %" GST_PTR_FORMAT, caps);
gst_caps_unref (caps);
}
}
#endif
/* buf is always null when the output buffer pointer isn't shared. */
buf = omx_buffer->pAppPrivate;
/** @todo we need to move all the caps handling to one single
* place, in the output loop probably. */
if (G_UNLIKELY (omx_buffer->nFlags & 0x80)) {
GstCaps *caps = NULL;
GstStructure *structure;
GValue value = { 0, {{0}
}
};
caps = gst_pad_get_negotiated_caps (self->srcpad);
caps = gst_caps_make_writable (caps);
structure = gst_caps_get_structure (caps, 0);
g_value_init (&value, GST_TYPE_BUFFER);
buf = gst_buffer_new_and_alloc (omx_buffer->nFilledLen);
memcpy (GST_BUFFER_DATA (buf),
omx_buffer->pBuffer + omx_buffer->nOffset, omx_buffer->nFilledLen);
gst_value_set_buffer (&value, buf);
gst_buffer_unref (buf);
gst_structure_set_value (structure, "codec_data", &value);
g_value_unset (&value);
gst_pad_set_caps (self->srcpad, caps);
} else if (buf && !(omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
GST_BUFFER_SIZE (buf) = omx_buffer->nFilledLen;
if (self->use_timestamps) {
GST_BUFFER_TIMESTAMP (buf) =
gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
OMX_TICKS_PER_SECOND);
}
omx_buffer->pAppPrivate = NULL;
omx_buffer->pBuffer = NULL;
ret = push_buffer (self, buf);
gst_buffer_unref (buf);
} else {
/* This is only meant for the first OpenMAX buffers,
* which need to be pre-allocated. */
/* Also for the very last one. */
ret = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nFilledLen, GST_PAD_CAPS (self->srcpad), &buf);
if (G_LIKELY (buf)) {
memcpy (GST_BUFFER_DATA (buf),
omx_buffer->pBuffer + omx_buffer->nOffset,
omx_buffer->nFilledLen);
if (self->use_timestamps) {
GST_BUFFER_TIMESTAMP (buf) =
gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
OMX_TICKS_PER_SECOND);
}
if (self->share_output_buffer) {
GST_WARNING_OBJECT (self, "couldn't zero-copy");
/* If pAppPrivate is NULL, it means it was a dummy
* allocation, free it. */
if (!omx_buffer->pAppPrivate) {
g_free (omx_buffer->pBuffer);
omx_buffer->pBuffer = NULL;
}
}
ret = push_buffer (self, buf);
} else {
GST_WARNING_OBJECT (self, "couldn't allocate buffer of size %lu",
omx_buffer->nFilledLen);
}
}
} else {
GST_WARNING_OBJECT (self, "empty buffer");
}
if (self->share_output_buffer &&
!omx_buffer->pBuffer && omx_buffer->nOffset == 0) {
GstBuffer *buf;
GstFlowReturn result;
GST_LOG_OBJECT (self, "allocate buffer");
result = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nAllocLen, GST_PAD_CAPS (self->srcpad), &buf);
if (G_LIKELY (result == GST_FLOW_OK)) {
gst_buffer_ref (buf);
omx_buffer->pAppPrivate = buf;
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
} else {
GST_WARNING_OBJECT (self,
"could not pad allocate buffer, using malloc");
omx_buffer->pBuffer = g_malloc (omx_buffer->nAllocLen);
}
}
if (self->share_output_buffer && !omx_buffer->pBuffer) {
GST_ERROR_OBJECT (self, "no input buffer to share");
}
if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
GST_DEBUG_OBJECT (self, "got eos");
gst_pad_push_event (self->srcpad, gst_event_new_eos ());
omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
ret = GST_FLOW_UNEXPECTED;
}
omx_buffer->nFilledLen = 0;
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (out_port, omx_buffer);
}
leave:
self->last_pad_push_return = ret;
if (gomx->omx_error != OMX_ErrorNone)
ret = GST_FLOW_ERROR;
if (ret != GST_FLOW_OK) {
GST_INFO_OBJECT (self, "pause task, reason: %s", gst_flow_get_name (ret));
gst_pad_pause_task (self->srcpad);
}
GST_LOG_OBJECT (self, "end");
gst_object_unref (self);
}
static GstFlowReturn
pad_chain (GstPad * pad, GstBuffer * buf)
{
GOmxCore *gomx;
GOmxPort *in_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
GST_LOG_OBJECT (self, "gst_buffer: size=%u", GST_BUFFER_SIZE (buf));
GST_LOG_OBJECT (self, "state: %d", gomx->omx_state);
if (G_UNLIKELY (gomx->omx_state == OMX_StateLoaded)) {
g_mutex_lock (self->ready_lock);
GST_INFO_OBJECT (self, "omx: prepare");
/** @todo this should probably go after doing preparations. */
if (self->omx_setup) {
self->omx_setup (self);
}
setup_ports (self);
g_omx_core_prepare (self->gomx);
if (gomx->omx_state == OMX_StateIdle) {
self->ready = TRUE;
GST_INFO_OBJECT (self, "start srcpad task");
gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
}
g_mutex_unlock (self->ready_lock);
if (gomx->omx_state != OMX_StateIdle)
goto out_flushing;
}
#ifdef ANDROID
if (gomx->settings_changed) {
GST_DEBUG_OBJECT (self, "settings changed called from streaming thread... Android");
if (gomx->settings_changed_cb)
gomx->settings_changed_cb (gomx);
gomx->settings_changed = FALSE;
}
#endif
in_port = self->in_port;
if (G_LIKELY (in_port->enabled)) {
guint buffer_offset = 0;
if (G_UNLIKELY (gomx->omx_state == OMX_StateIdle)) {
GST_INFO_OBJECT (self, "omx: play");
g_omx_core_start (gomx);
if (gomx->omx_state != OMX_StateExecuting)
goto out_flushing;
/* send buffer with codec data flag */
/** @todo move to util */
if (self->codec_data) {
OMX_BUFFERHEADERTYPE *omx_buffer;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
if (G_LIKELY (omx_buffer)) {
omx_buffer->nFlags |= 0x00000080; /* codec data flag */
omx_buffer->nFilledLen = GST_BUFFER_SIZE (self->codec_data);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
GST_BUFFER_DATA (self->codec_data), omx_buffer->nFilledLen);
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (in_port, omx_buffer);
}
}
}
if (G_UNLIKELY (gomx->omx_state != OMX_StateExecuting)) {
GST_ERROR_OBJECT (self, "Whoa! very wrong");
}
while (G_LIKELY (buffer_offset < GST_BUFFER_SIZE (buf))) {
OMX_BUFFERHEADERTYPE *omx_buffer;
if (self->last_pad_push_return != GST_FLOW_OK ||
!(gomx->omx_state == OMX_StateExecuting ||
gomx->omx_state == OMX_StatePause)) {
goto out_flushing;
}
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_LIKELY (omx_buffer)) {
log_buffer (self, omx_buffer);
if (omx_buffer->nOffset == 0 && self->share_input_buffer) {
{
GstBuffer *old_buf;
old_buf = omx_buffer->pAppPrivate;
if (old_buf) {
gst_buffer_unref (old_buf);
} else if (omx_buffer->pBuffer) {
g_free (omx_buffer->pBuffer);
}
}
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
omx_buffer->nFilledLen = GST_BUFFER_SIZE (buf);
omx_buffer->pAppPrivate = buf;
} else {
omx_buffer->nFilledLen = MIN (GST_BUFFER_SIZE (buf) - buffer_offset,
omx_buffer->nAllocLen - omx_buffer->nOffset);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
GST_BUFFER_DATA (buf) + buffer_offset, omx_buffer->nFilledLen);
}
if (self->use_timestamps) {
GstClockTime timestamp_offset = 0;
if (buffer_offset && GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE) {
timestamp_offset = gst_util_uint64_scale_int (buffer_offset,
GST_BUFFER_DURATION (buf), GST_BUFFER_SIZE (buf));
}
omx_buffer->nTimeStamp =
gst_util_uint64_scale_int (GST_BUFFER_TIMESTAMP (buf) +
timestamp_offset, OMX_TICKS_PER_SECOND, GST_SECOND);
}
buffer_offset += omx_buffer->nFilledLen;
#ifdef ANDROID
omx_buffer->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
log_buffer (self, omx_buffer);
#endif
GST_LOG_OBJECT (self, "release_buffer");
/** @todo untaint buffer */
g_omx_port_release_buffer (in_port, omx_buffer);
} else {
GST_WARNING_OBJECT (self, "null buffer");
ret = GST_FLOW_WRONG_STATE;
goto out_flushing;
}
}
} else {
GST_WARNING_OBJECT (self, "done");
ret = GST_FLOW_UNEXPECTED;
}
if (!self->share_input_buffer) {
gst_buffer_unref (buf);
}
leave:
GST_LOG_OBJECT (self, "end");
return ret;
/* special conditions */
out_flushing:
{
const gchar *error_msg = NULL;
if (gomx->omx_error) {
error_msg = "Error from OpenMAX component";
} else if (gomx->omx_state != OMX_StateExecuting &&
gomx->omx_state != OMX_StatePause) {
error_msg = "OpenMAX component in wrong state";
}
if (error_msg) {
GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
ret = GST_FLOW_ERROR;
}
gst_buffer_unref (buf);
goto leave;
}
}
void
ags_recall_lv2_run_run_init_pre(AgsRecall *recall)
{
AgsRecallLv2 *recall_lv2;
AgsRecallChannelRun *recall_channel_run;
AgsRecallRecycling *recall_recycling;
AgsRecallLv2Run *recall_lv2_run;
AgsAudioSignal *audio_signal;
AgsLv2Plugin *lv2_plugin;
AgsConfig *config;
LV2_Handle *lv2_handle;
float *output, *input;
guint output_lines, input_lines;
guint samplerate;
guint buffer_size;
guint port_count;
guint i, i_stop;
void (*parent_class_run_init_pre)(AgsRecall *recall);
void (*connect_port)(LV2_Handle instance,
uint32_t port,
void *data_location);
void (*activate)(LV2_Handle instance);
pthread_mutex_t *recall_lv2_mutex;
/* get recall mutex */
pthread_mutex_lock(ags_recall_get_class_mutex());
parent_class_run_init_pre = AGS_RECALL_CLASS(ags_recall_lv2_run_parent_class)->run_init_pre;
pthread_mutex_unlock(ags_recall_get_class_mutex());
/* call parent */
parent_class_run_init_pre(recall);
recall_lv2_run = AGS_RECALL_LV2_RUN(recall);
g_object_get(recall,
"parent", &recall_recycling,
NULL);
g_object_get(recall_recycling,
"parent", &recall_channel_run,
NULL);
g_object_get(recall_channel_run,
"recall-channel", &recall_lv2,
NULL);
/* set up buffer */
g_object_get(recall_lv2_run,
"source", &audio_signal,
NULL);
g_object_get(audio_signal,
"samplerate", &samplerate,
"buffer-size", &buffer_size,
NULL);
/* get recall lv2 mutex */
pthread_mutex_lock(ags_recall_get_class_mutex());
recall_lv2_mutex = AGS_RECALL(recall_lv2)->obj_mutex;
pthread_mutex_unlock(ags_recall_get_class_mutex());
/* get some fields */
pthread_mutex_lock(recall_lv2_mutex);
lv2_plugin = recall_lv2->plugin;
output_lines = recall_lv2->output_lines;
input_lines = recall_lv2->input_lines;
connect_port = recall_lv2->plugin_descriptor->connect_port;
activate = recall_lv2->plugin_descriptor->activate;
pthread_mutex_unlock(recall_lv2_mutex);
/* set up buffer */
input = NULL;
output = NULL;
if(input_lines > 0){
input = (float *) malloc(input_lines *
buffer_size *
sizeof(float));
}
output = (float *) malloc(output_lines *
buffer_size *
sizeof(float));
recall_lv2_run->output = output;
recall_lv2_run->input = input;
/* instantiate lv2 */
lv2_handle = (LV2_Handle *) ags_base_plugin_instantiate((AgsBasePlugin *) lv2_plugin,
samplerate, buffer_size);
recall_lv2_run->lv2_handle = lv2_handle;
#ifdef AGS_DEBUG
g_message("instantiate LV2 handle");
#endif
ags_recall_lv2_run_load_ports(recall_lv2_run);
/* can't be done in ags_recall_lv2_run_run_init_inter since possebility of overlapping buffers */
pthread_mutex_lock(recall_lv2_mutex);
/* connect audio port */
for(i = 0; i < input_lines; i++){
#ifdef AGS_DEBUG
g_message("connect in port: %d", recall_lv2->input_port[i]);
#endif
connect_port(recall_lv2_run->lv2_handle[0],
recall_lv2->input_port[i],
recall_lv2_run->input);
}
for(i = 0; i < output_lines; i++){
#ifdef AGS_DEBUG
g_message("connect out port: %d", recall_lv2->output_port[i]);
#endif
connect_port(recall_lv2_run->lv2_handle[0],
recall_lv2->output_port[i],
recall_lv2_run->output);
}
/* connect event port */
if(ags_recall_lv2_test_flags(recall_lv2, AGS_RECALL_LV2_HAS_EVENT_PORT)){
recall_lv2_run->event_port = ags_lv2_plugin_alloc_event_buffer(AGS_RECALL_LV2_DEFAULT_MIDI_LENGHT);
connect_port(recall_lv2_run->lv2_handle[0],
recall_lv2->event_port,
recall_lv2_run->event_port);
}
/* connect atom port */
if(ags_recall_lv2_test_flags(recall_lv2, AGS_RECALL_LV2_HAS_ATOM_PORT)){
recall_lv2_run->atom_port = ags_lv2_plugin_alloc_atom_sequence(AGS_RECALL_LV2_DEFAULT_MIDI_LENGHT);
connect_port(recall_lv2_run->lv2_handle[0],
recall_lv2->atom_port,
recall_lv2_run->atom_port);
}
/* activate */
if(activate != NULL){
activate(recall_lv2_run->lv2_handle[0]);
}
pthread_mutex_unlock(recall_lv2_mutex);
/* set program */
if(ags_lv2_plugin_test_flags(lv2_plugin, AGS_LV2_PLUGIN_HAS_PROGRAM_INTERFACE)){
AgsPort *current_port;
GList *plugin_port_start, *plugin_port;
GList *port;
GList *list;
gchar *specifier, *current_specifier;
float *port_data;
guint bank, program;
guint port_count;
pthread_mutex_t *base_plugin_mutex;
pthread_mutex_lock(recall_lv2_mutex);
port = g_list_copy(AGS_RECALL(recall_lv2)->port);
bank = recall_lv2->bank;
program = recall_lv2->program;
pthread_mutex_unlock(recall_lv2_mutex);
/* get base plugin mutex */
pthread_mutex_lock(ags_base_plugin_get_class_mutex());
base_plugin_mutex = AGS_BASE_PLUGIN(lv2_plugin)->obj_mutex;
pthread_mutex_unlock(ags_base_plugin_get_class_mutex());
/* get plugin port */
pthread_mutex_lock(base_plugin_mutex);
plugin_port_start = g_list_copy(AGS_BASE_PLUGIN(lv2_plugin)->plugin_port);
pthread_mutex_unlock(base_plugin_mutex);
/* create port data */
port_count = g_list_length(plugin_port_start);
port_data = (float *) malloc(port_count * sizeof(float));
plugin_port = plugin_port_start;
for(i = 0; i < port_count && plugin_port != NULL; ){
AgsPluginPort *current_plugin_port;
pthread_mutex_t *plugin_port_mutex;
current_plugin_port = AGS_PLUGIN_PORT(plugin_port->data);
/* get plugin port mutex */
pthread_mutex_lock(ags_plugin_port_get_class_mutex());
plugin_port_mutex = current_plugin_port->obj_mutex;
pthread_mutex_unlock(ags_plugin_port_get_class_mutex());
/* get specifier */
pthread_mutex_lock(plugin_port_mutex);
specifier = g_strdup(current_plugin_port->port_name);
pthread_mutex_unlock(plugin_port_mutex);
list = ags_port_find_specifier(port, specifier);
if(list != NULL){
GValue value = {0,};
current_port = list->data;
g_value_init(&value,
G_TYPE_FLOAT);
ags_port_safe_read(current_port,
&value);
port_data[i] = g_value_get_float(&value);
g_value_unset(&value);
}else{
port_data[i] = 0.0;
}
g_free(specifier);
/* iterate plugin port */
plugin_port = plugin_port->next;
}
ags_lv2_plugin_change_program(lv2_plugin,
recall_lv2_run->lv2_handle[0],
bank,
program);
/* reset port data */
plugin_port = plugin_port_start;
for(i = 0; i < port_count && plugin_port != NULL;){
AgsPluginPort *current_plugin_port;
pthread_mutex_t *plugin_port_mutex;
current_plugin_port = AGS_PLUGIN_PORT(plugin_port->data);
/* get plugin port mutex */
pthread_mutex_lock(ags_plugin_port_get_class_mutex());
plugin_port_mutex = current_plugin_port->obj_mutex;
pthread_mutex_unlock(ags_plugin_port_get_class_mutex());
/* get specifier */
pthread_mutex_lock(plugin_port_mutex);
specifier = g_strdup(current_plugin_port->port_name);
pthread_mutex_unlock(plugin_port_mutex);
list = ags_port_find_specifier(port, specifier);
if(list != NULL){
GValue value = {0,};
current_port = list->data;
g_value_init(&value,
G_TYPE_FLOAT);
g_value_set_float(&value, port_data[i]);
ags_port_safe_write_raw(current_port,
&value);
g_value_unset(&value);
}
/* iterate plugin port */
plugin_port = plugin_port->next;
}
g_free(port_data);
g_list_free(port);
g_list_free(plugin_port_start);
}
g_object_unref(recall_recycling);
g_object_unref(recall_channel_run);
g_object_unref(recall_lv2);
g_object_unref(audio_signal);
}
static gboolean
gimp_procedure_validate_args (GimpProcedure *procedure,
GParamSpec **param_specs,
gint n_param_specs,
GimpValueArray *args,
gboolean return_vals,
GError **error)
{
gint i;
for (i = 0; i < MIN (gimp_value_array_length (args), n_param_specs); i++)
{
GValue *arg = gimp_value_array_index (args, i);
GParamSpec *pspec = param_specs[i];
GType arg_type = G_VALUE_TYPE (arg);
GType spec_type = G_PARAM_SPEC_VALUE_TYPE (pspec);
if (arg_type != spec_type)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_RETURN_VALUE,
_("Procedure '%s' returned a wrong value type "
"for return value '%s' (#%d). "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type),
g_type_name (arg_type));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR, GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with a "
"wrong value type for argument '%s' (#%d). "
"Expected %s, got %s."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type),
g_type_name (arg_type));
}
return FALSE;
}
else if (! (pspec->flags & GIMP_PARAM_NO_VALIDATE))
{
GValue string_value = { 0, };
g_value_init (&string_value, G_TYPE_STRING);
if (g_value_type_transformable (arg_type, G_TYPE_STRING))
g_value_transform (arg, &string_value);
else
g_value_set_static_string (&string_value,
"<not transformable to string>");
if (g_param_value_validate (pspec, arg))
{
if (GIMP_IS_PARAM_SPEC_DRAWABLE_ID (pspec) &&
g_value_get_int (arg) == -1)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_RETURN_VALUE,
_("Procedure '%s' returned an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on a layer that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on a layer that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
}
else if (GIMP_IS_PARAM_SPEC_IMAGE_ID (pspec) &&
g_value_get_int (arg) == -1)
{
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_RETURN_VALUE,
_("Procedure '%s' returned an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on an image that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with an "
"invalid ID for argument '%s'. "
"Most likely a plug-in is trying "
"to work on an image that doesn't "
"exist any longer."),
gimp_object_get_name (procedure),
g_param_spec_get_name (pspec));
}
}
else
{
const gchar *value = g_value_get_string (&string_value);
if (value == NULL)
value = "(null)";
if (return_vals)
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_RETURN_VALUE,
_("Procedure '%s' returned "
"'%s' as return value '%s' "
"(#%d, type %s). "
"This value is out of range."),
gimp_object_get_name (procedure),
value,
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type));
}
else
{
g_set_error (error,
GIMP_PDB_ERROR,
GIMP_PDB_ERROR_INVALID_ARGUMENT,
_("Procedure '%s' has been called with "
"value '%s' for argument '%s' "
"(#%d, type %s). "
"This value is out of range."),
gimp_object_get_name (procedure),
value,
g_param_spec_get_name (pspec),
i + 1, g_type_name (spec_type));
}
}
g_value_unset (&string_value);
return FALSE;
}
g_value_unset (&string_value);
}
}
return TRUE;
}
/* This function calculates the pixel aspect ratio */
static GValue *
gst_vdp_sink_calculate_par (Display * display)
{
static const gint par[][2] = {
{1, 1}, /* regular screen */
{16, 15}, /* PAL TV */
{11, 10}, /* 525 line Rec.601 video */
{54, 59}, /* 625 line Rec.601 video */
{64, 45}, /* 1280x1024 on 16:9 display */
{5, 3}, /* 1280x1024 on 4:3 display */
{4, 3} /* 800x600 on 16:9 display */
};
gint screen_num;
gint width, height;
gint widthmm, heightmm;
gint i;
gint index;
gdouble ratio;
gdouble delta;
GValue *par_value;
#define DELTA(idx) (ABS (ratio - ((gdouble) par[idx][0] / par[idx][1])))
screen_num = DefaultScreen (display);
width = DisplayWidth (display, screen_num);
height = DisplayHeight (display, screen_num);
widthmm = DisplayWidthMM (display, screen_num);
heightmm = DisplayHeightMM (display, screen_num);
/* first calculate the "real" ratio based on the X values;
* which is the "physical" w/h divided by the w/h in pixels of the display */
ratio = (gdouble) (widthmm * height)
/ (heightmm * width);
/* DirectFB's X in 720x576 reports the physical dimensions wrong, so
* override here */
if (width == 720 && height == 576) {
ratio = 4.0 * 576 / (3.0 * 720);
}
GST_DEBUG ("calculated pixel aspect ratio: %f", ratio);
/* now find the one from par[][2] with the lowest delta to the real one */
delta = DELTA (0);
index = 0;
for (i = 1; i < sizeof (par) / (sizeof (gint) * 2); ++i) {
gdouble this_delta = DELTA (i);
if (this_delta < delta) {
index = i;
delta = this_delta;
}
}
GST_DEBUG ("Decided on index %d (%d/%d)", index,
par[index][0], par[index][1]);
par_value = g_new0 (GValue, 1);
g_value_init (par_value, GST_TYPE_FRACTION);
gst_value_set_fraction (par_value, par[index][0], par[index][1]);
GST_DEBUG ("set X11 PAR to %d/%d",
gst_value_get_fraction_numerator (par_value),
gst_value_get_fraction_denominator (par_value));
return par_value;
}
/* this internal thread does nothing else but write samples to the audio device.
* It will write each segment in the ringbuffer and will update the play
* pointer.
* The start/stop methods control the thread.
*/
static void
audioringbuffer_thread_func (GstAudioRingBuffer * buf)
{
GstAudioSink *sink;
GstAudioSinkClass *csink;
GstAudioSinkRingBuffer *abuf = GST_AUDIO_SINK_RING_BUFFER_CAST (buf);
WriteFunc writefunc;
GstMessage *message;
GValue val = { 0 };
sink = GST_AUDIO_SINK (GST_OBJECT_PARENT (buf));
csink = GST_AUDIO_SINK_GET_CLASS (sink);
GST_DEBUG_OBJECT (sink, "enter thread");
GST_OBJECT_LOCK (abuf);
GST_DEBUG_OBJECT (sink, "signal wait");
GST_AUDIO_SINK_RING_BUFFER_SIGNAL (buf);
GST_OBJECT_UNLOCK (abuf);
writefunc = csink->write;
if (writefunc == NULL)
goto no_function;
message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
GST_STREAM_STATUS_TYPE_ENTER, GST_ELEMENT_CAST (sink));
g_value_init (&val, GST_TYPE_G_THREAD);
g_value_set_boxed (&val, g_thread_self ());
gst_message_set_stream_status_object (message, &val);
g_value_unset (&val);
GST_DEBUG_OBJECT (sink, "posting ENTER stream status");
gst_element_post_message (GST_ELEMENT_CAST (sink), message);
while (TRUE) {
gint left, len;
guint8 *readptr;
gint readseg;
/* buffer must be started */
if (gst_audio_ring_buffer_prepare_read (buf, &readseg, &readptr, &len)) {
gint written;
left = len;
do {
written = writefunc (sink, readptr, left);
GST_LOG_OBJECT (sink, "transfered %d bytes of %d from segment %d",
written, left, readseg);
if (written < 0 || written > left) {
/* might not be critical, it e.g. happens when aborting playback */
GST_WARNING_OBJECT (sink,
"error writing data in %s (reason: %s), skipping segment (left: %d, written: %d)",
GST_DEBUG_FUNCPTR_NAME (writefunc),
(errno > 1 ? g_strerror (errno) : "unknown"), left, written);
break;
}
left -= written;
readptr += written;
} while (left > 0);
/* clear written samples */
gst_audio_ring_buffer_clear (buf, readseg);
/* we wrote one segment */
gst_audio_ring_buffer_advance (buf, 1);
} else {
GST_OBJECT_LOCK (abuf);
if (!abuf->running)
goto stop_running;
if (G_UNLIKELY (g_atomic_int_get (&buf->state) ==
GST_AUDIO_RING_BUFFER_STATE_STARTED)) {
GST_OBJECT_UNLOCK (abuf);
continue;
}
GST_DEBUG_OBJECT (sink, "signal wait");
GST_AUDIO_SINK_RING_BUFFER_SIGNAL (buf);
GST_DEBUG_OBJECT (sink, "wait for action");
GST_AUDIO_SINK_RING_BUFFER_WAIT (buf);
GST_DEBUG_OBJECT (sink, "got signal");
if (!abuf->running)
goto stop_running;
GST_DEBUG_OBJECT (sink, "continue running");
GST_OBJECT_UNLOCK (abuf);
}
}
/* Will never be reached */
g_assert_not_reached ();
return;
/* ERROR */
no_function:
{
GST_DEBUG_OBJECT (sink, "no write function, exit thread");
return;
}
stop_running:
{
GST_OBJECT_UNLOCK (abuf);
GST_DEBUG_OBJECT (sink, "stop running, exit thread");
message = gst_message_new_stream_status (GST_OBJECT_CAST (buf),
GST_STREAM_STATUS_TYPE_LEAVE, GST_ELEMENT_CAST (sink));
g_value_init (&val, GST_TYPE_G_THREAD);
g_value_set_boxed (&val, g_thread_self ());
gst_message_set_stream_status_object (message, &val);
g_value_unset (&val);
GST_DEBUG_OBJECT (sink, "posting LEAVE stream status");
gst_element_post_message (GST_ELEMENT_CAST (sink), message);
return;
}
}
void TestRunner::overridePreference(JSStringRef key, JSStringRef value)
{
GOwnPtr<gchar> originalName(JSStringCopyUTF8CString(key));
GOwnPtr<gchar> valueAsString(JSStringCopyUTF8CString(value));
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
ASSERT(view);
// This transformation could be handled by a hash table (and it once was), but
// having it prominent, makes it easier for people from other ports to keep the
// list up to date.
const gchar* propertyName = 0;
if (g_str_equal(originalName.get(), "WebKitJavaScriptEnabled"))
propertyName = "enable-scripts";
else if (g_str_equal(originalName.get(), "WebKitDefaultFontSize"))
propertyName = "default-font-size";
else if (g_str_equal(originalName.get(), "WebKitEnableCaretBrowsing"))
propertyName = "enable-caret-browsing";
else if (g_str_equal(originalName.get(), "WebKitUsesPageCachePreferenceKey"))
propertyName = "enable-page-cache";
else if (g_str_equal(originalName.get(), "WebKitPluginsEnabled"))
propertyName = "enable-plugins";
else if (g_str_equal(originalName.get(), "WebKitHyperlinkAuditingEnabled"))
propertyName = "enable-hyperlink-auditing";
else if (g_str_equal(originalName.get(), "WebKitWebGLEnabled"))
propertyName = "enable-webgl";
else if (g_str_equal(originalName.get(), "WebKitWebAudioEnabled"))
propertyName = "enable-webaudio";
else if (g_str_equal(originalName.get(), "WebKitDisplayImagesKey"))
propertyName = "auto-load-images";
else if (g_str_equal(originalName.get(), "WebKitTabToLinksPreferenceKey")) {
DumpRenderTreeSupportGtk::setLinksIncludedInFocusChain(booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitPageCacheSupportsPluginsPreferenceKey")) {
DumpRenderTreeSupportGtk::setPageCacheSupportsPlugins(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitCSSGridLayoutEnabled")) {
DumpRenderTreeSupportGtk::setCSSGridLayoutEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitCSSRegionsEnabled")) {
DumpRenderTreeSupportGtk::setCSSRegionsEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else if (g_str_equal(originalName.get(), "WebKitCSSCustomFilterEnabled")) {
DumpRenderTreeSupportGtk::setCSSCustomFilterEnabled(webkit_web_frame_get_web_view(mainFrame), booleanFromValue(valueAsString.get()));
return;
} else {
fprintf(stderr, "TestRunner::overridePreference tried to override "
"unknown preference '%s'.\n", originalName.get());
return;
}
WebKitWebSettings* settings = webkit_web_view_get_settings(view);
GParamSpec* pspec = g_object_class_find_property(G_OBJECT_CLASS(
WEBKIT_WEB_SETTINGS_GET_CLASS(settings)), propertyName);
GValue currentPropertyValue = { 0, { { 0 } } };
g_value_init(¤tPropertyValue, pspec->value_type);
if (G_VALUE_HOLDS_STRING(¤tPropertyValue))
g_object_set(settings, propertyName, valueAsString.get(), NULL);
else if (G_VALUE_HOLDS_BOOLEAN(¤tPropertyValue))
g_object_set(G_OBJECT(settings), propertyName, booleanFromValue(valueAsString.get()), NULL);
else if (G_VALUE_HOLDS_INT(¤tPropertyValue))
g_object_set(G_OBJECT(settings), propertyName, atoi(valueAsString.get()), NULL);
else if (G_VALUE_HOLDS_FLOAT(¤tPropertyValue)) {
gfloat newValue = g_ascii_strtod(valueAsString.get(), 0);
g_object_set(G_OBJECT(settings), propertyName, newValue, NULL);
} else
fprintf(stderr, "TestRunner::overridePreference failed to override "
"preference '%s'.\n", originalName.get());
}
/* This function is entirely sick, so is our method of serializing
* units, which we write out as (unit foo bar) instead of
* (unit "foo bar"). The assumption that caused this shit was that a
* unit's "identifier" is really an identifier in the C-ish sense,
* when in fact it's just a random user entered string.
*
* Here, we try to parse at least the default units shipped with gimp,
* and we add code to parse (unit "foo bar") in order to be compatible
* with future correct unit serializing.
*/
static GTokenType
gimp_config_deserialize_unit (GValue *value,
GParamSpec *prop_spec,
GScanner *scanner)
{
gchar *old_cset_skip_characters;
gchar *old_cset_identifier_first;
gchar *old_cset_identifier_nth;
GString *buffer;
GValue src = G_VALUE_INIT;
GTokenType token;
/* parse the next token *before* reconfiguring the scanner, so it
* skips whitespace first
*/
token = g_scanner_peek_next_token (scanner);
if (token == G_TOKEN_STRING)
return gimp_config_deserialize_any (value, prop_spec, scanner);
old_cset_skip_characters = scanner->config->cset_skip_characters;
old_cset_identifier_first = scanner->config->cset_identifier_first;
old_cset_identifier_nth = scanner->config->cset_identifier_nth;
scanner->config->cset_skip_characters = "";
scanner->config->cset_identifier_first = ( G_CSET_a_2_z G_CSET_A_2_Z "." );
scanner->config->cset_identifier_nth = ( G_CSET_a_2_z G_CSET_A_2_Z
G_CSET_DIGITS "-_." );
buffer = g_string_new ("");
while (g_scanner_peek_next_token (scanner) != G_TOKEN_RIGHT_PAREN)
{
token = g_scanner_peek_next_token (scanner);
if (token == G_TOKEN_IDENTIFIER)
{
g_scanner_get_next_token (scanner);
g_string_append (buffer, scanner->value.v_identifier);
}
else if (token == G_TOKEN_CHAR)
{
g_scanner_get_next_token (scanner);
g_string_append_c (buffer, scanner->value.v_char);
}
else if (token == ' ')
{
g_scanner_get_next_token (scanner);
g_string_append_c (buffer, token);
}
else
{
token = G_TOKEN_IDENTIFIER;
goto cleanup;
}
}
g_value_init (&src, G_TYPE_STRING);
g_value_set_static_string (&src, buffer->str);
g_value_transform (&src, value);
g_value_unset (&src);
token = G_TOKEN_RIGHT_PAREN;
cleanup:
g_string_free (buffer, TRUE);
scanner->config->cset_skip_characters = old_cset_skip_characters;
scanner->config->cset_identifier_first = old_cset_identifier_first;
scanner->config->cset_identifier_nth = old_cset_identifier_nth;
return token;
}
/**
* gimp_config_deserialize_property:
* @config: a #GimpConfig.
* @scanner: a #GScanner.
* @nest_level: the nest level
*
* This function deserializes a single property of @config. You
* shouldn't need to call this function directly. If possible, use
* gimp_config_deserialize_properties() instead.
*
* Return value: %G_TOKEN_RIGHT_PAREN on success, otherwise the
* expected #GTokenType or %G_TOKEN_NONE if the expected token was
* found but couldn't be parsed.
*
* Since: GIMP 2.4
**/
GTokenType
gimp_config_deserialize_property (GimpConfig *config,
GScanner *scanner,
gint nest_level)
{
GimpConfigInterface *config_iface = NULL;
GimpConfigInterface *parent_iface = NULL;
GParamSpec *prop_spec;
GTokenType token = G_TOKEN_RIGHT_PAREN;
GValue value = { 0, };
guint old_scope_id;
old_scope_id = g_scanner_set_scope (scanner, 0);
prop_spec = G_PARAM_SPEC (scanner->value.v_symbol);
g_value_init (&value, prop_spec->value_type);
if (G_TYPE_IS_OBJECT (prop_spec->owner_type))
{
GTypeClass *owner_class = g_type_class_peek (prop_spec->owner_type);
config_iface = g_type_interface_peek (owner_class, GIMP_TYPE_CONFIG);
/* We must call deserialize_property() *only* if the *exact* class
* which implements it is param_spec->owner_type's class.
*
* Therefore, we ask param_spec->owner_type's immediate parent class
* for it's GimpConfigInterface and check if we get a different
* pointer.
*
* (if the pointers are the same, param_spec->owner_type's
* GimpConfigInterface is inherited from one of it's parent classes
* and thus not able to handle param_spec->owner_type's properties).
*/
if (config_iface)
{
GTypeClass *owner_parent_class;
owner_parent_class = g_type_class_peek_parent (owner_class);
parent_iface = g_type_interface_peek (owner_parent_class,
GIMP_TYPE_CONFIG);
}
}
if (config_iface &&
config_iface != parent_iface && /* see comment above */
config_iface->deserialize_property &&
config_iface->deserialize_property (config,
prop_spec->param_id,
&value,
prop_spec,
scanner,
&token))
{
/* nop */
}
else
{
if (G_VALUE_HOLDS_OBJECT (&value))
token = gimp_config_deserialize_object (&value,
config, prop_spec,
scanner, nest_level);
else
token = gimp_config_deserialize_value (&value,
config, prop_spec, scanner);
}
if (token == G_TOKEN_RIGHT_PAREN &&
g_scanner_peek_next_token (scanner) == token)
{
if (! (G_VALUE_HOLDS_OBJECT (&value) &&
(prop_spec->flags & GIMP_CONFIG_PARAM_AGGREGATE)))
g_object_set_property (G_OBJECT (config), prop_spec->name, &value);
}
#ifdef CONFIG_DEBUG
else
{
g_warning ("%s: couldn't deserialize property %s::%s of type %s",
G_STRFUNC,
g_type_name (G_TYPE_FROM_INSTANCE (config)),
prop_spec->name,
g_type_name (prop_spec->value_type));
}
#endif
g_value_unset (&value);
g_scanner_set_scope (scanner, old_scope_id);
return token;
}
gboolean
brasero_project_open_project_xml (const gchar *uri,
BraseroBurnSession *session,
gboolean warn_user)
{
xmlNodePtr track_node = NULL;
gchar *label = NULL;
gchar *cover = NULL;
xmlDocPtr project;
xmlNodePtr item;
gboolean retval;
GFile *file;
gchar *path;
file = g_file_new_for_commandline_arg (uri);
path = g_file_get_path (file);
g_object_unref (file);
if (!path)
return FALSE;
/* start parsing xml doc */
project = xmlParseFile (path);
g_free (path);
if (!project) {
if (warn_user)
brasero_project_invalid_project_dialog (_("The project could not be opened"));
return FALSE;
}
/* parses the "header" */
item = xmlDocGetRootElement (project);
if (!item) {
if (warn_user)
brasero_project_invalid_project_dialog (_("The file is empty"));
xmlFreeDoc (project);
return FALSE;
}
if (xmlStrcmp (item->name, (const xmlChar *) "braseroproject")
|| item->next)
goto error;
item = item->children;
while (item) {
if (!xmlStrcmp (item->name, (const xmlChar *) "version")) {
/* simply ignore it */
}
else if (!xmlStrcmp (item->name, (const xmlChar *) "label")) {
label = (gchar *) xmlNodeListGetString (project,
item->xmlChildrenNode,
1);
if (!(label))
goto error;
}
else if (!xmlStrcmp (item->name, (const xmlChar *) "cover")) {
xmlChar *escaped;
escaped = xmlNodeListGetString (project,
item->xmlChildrenNode,
1);
if (!escaped)
goto error;
cover = g_uri_unescape_string ((char *) escaped, NULL);
g_free (escaped);
}
else if (!xmlStrcmp (item->name, (const xmlChar *) "track")) {
if (track_node)
goto error;
track_node = item;
}
else if (item->type == XML_ELEMENT_NODE)
goto error;
item = item->next;
}
retval = _get_tracks (project, track_node, session);
if (!retval)
goto error;
xmlFreeDoc (project);
brasero_burn_session_set_label (session, label);
g_free (label);
if (cover) {
GValue *value;
value = g_new0 (GValue, 1);
g_value_init (value, G_TYPE_STRING);
g_value_set_string (value, cover);
brasero_burn_session_tag_add (session,
BRASERO_COVER_URI,
value);
g_free (cover);
}
return retval;
error:
if (cover)
g_free (cover);
if (label)
g_free (label);
xmlFreeDoc (project);
if (warn_user)
brasero_project_invalid_project_dialog (_("It does not seem to be a valid Brasero project"));
return FALSE;
}
NiceConnection::NiceConnection(MediaType med, const std::string &transport_name,NiceConnectionListener* listener,
unsigned int iceComponents, const IceConfig& iceConfig, std::string username, std::string password)
: mediaType(med), agent_(NULL), listener_(listener), candsDelivered_(0), context_(NULL), iceState_(NICE_INITIAL), iceComponents_(iceComponents) {
localCandidates.reset(new std::vector<CandidateInfo>());
transportName.reset(new std::string(transport_name));
for (unsigned int i = 1; i<=iceComponents_; i++) {
comp_state_list_[i] = NICE_INITIAL;
}
g_type_init();
context_ = g_main_context_new();
g_main_context_set_poll_func(context_,timed_poll);
ELOG_DEBUG("Creating Agent");
nice_debug_enable( FALSE );
// Create a nice agent
agent_ = nice_agent_new(context_, NICE_COMPATIBILITY_RFC5245);
GValue controllingMode = { 0 };
g_value_init(&controllingMode, G_TYPE_BOOLEAN);
g_value_set_boolean(&controllingMode, false);
g_object_set_property(G_OBJECT( agent_ ), "controlling-mode", &controllingMode);
GValue checks = { 0 };
g_value_init(&checks, G_TYPE_UINT);
g_value_set_uint(&checks, 100);
g_object_set_property(G_OBJECT( agent_ ), "max-connectivity-checks", &checks);
if (iceConfig.stunServer.compare("") != 0 && iceConfig.stunPort!=0){
GValue val = { 0 }, val2 = { 0 };
g_value_init(&val, G_TYPE_STRING);
g_value_set_string(&val, iceConfig.stunServer.c_str());
g_object_set_property(G_OBJECT( agent_ ), "stun-server", &val);
g_value_init(&val2, G_TYPE_UINT);
g_value_set_uint(&val2, iceConfig.stunPort);
g_object_set_property(G_OBJECT( agent_ ), "stun-server-port", &val2);
ELOG_DEBUG("Setting STUN server %s:%d", iceConfig.stunServer.c_str(), iceConfig.stunPort);
}
// Connect the signals
g_signal_connect( G_OBJECT( agent_ ), "candidate-gathering-done",
G_CALLBACK( cb_candidate_gathering_done ), this);
g_signal_connect( G_OBJECT( agent_ ), "component-state-changed",
G_CALLBACK( cb_component_state_changed ), this);
g_signal_connect( G_OBJECT( agent_ ), "new-selected-pair",
G_CALLBACK( cb_new_selected_pair ), this);
g_signal_connect( G_OBJECT( agent_ ), "new-candidate",
G_CALLBACK( cb_new_candidate ), this);
// Create a new stream and start gathering candidates
ELOG_DEBUG("Adding Stream... Number of components %d", iceComponents_);
nice_agent_add_stream(agent_, iceComponents_);
gchar *ufrag = NULL, *upass = NULL;
nice_agent_get_local_credentials(agent_, 1, &ufrag, &upass);
ufrag_ = std::string(ufrag); g_free(ufrag);
upass_ = std::string(upass); g_free(upass);
// Set our remote credentials. This must be done *after* we add a stream.
if (username.compare("")!=0 && password.compare("")!=0){
ELOG_DEBUG("Setting remote credentials in constructor");
this->setRemoteCredentials(username, password);
}
// Set Port Range ----> If this doesn't work when linking the file libnice.sym has to be modified to include this call
if (iceConfig.minPort!=0 && iceConfig.maxPort!=0){
ELOG_DEBUG("Setting port range: %d to %d\n", iceConfig.minPort, iceConfig.maxPort);
nice_agent_set_port_range(agent_, (guint)1, (guint)1, (guint)iceConfig.minPort, (guint)iceConfig.maxPort);
}
if (iceConfig.turnServer.compare("") != 0 && iceConfig.turnPort!=0){
ELOG_DEBUG("Setting TURN server %s:%d", iceConfig.turnServer.c_str(), iceConfig.turnPort);
ELOG_DEBUG("Setting TURN credentials %s:%s", iceConfig.turnUsername.c_str(), iceConfig.turnPass.c_str());
for (unsigned int i = 1; i <= iceComponents_ ; i++){
nice_agent_set_relay_info (agent_,
1,
i,
iceConfig.turnServer.c_str(), // TURN Server IP
iceConfig.turnPort, // TURN Server PORT
iceConfig.turnUsername.c_str(), // Username
iceConfig.turnPass.c_str(), // Pass
NICE_RELAY_TYPE_TURN_UDP);
}
}
if(agent_){
for (unsigned int i = 1; i<=iceComponents_; i++){
nice_agent_attach_recv(agent_, 1, i, context_, cb_nice_recv, this);
}
running_ = true;
}
else{
running_=false;
}
m_Thread_ = boost::thread(&NiceConnection::init, this);
}
static GstCaps *
gst_rtp_h263p_pay_sink_getcaps (GstRTPBasePayload * payload, GstPad * pad,
GstCaps * filter)
{
GstRtpH263PPay *rtph263ppay;
GstCaps *caps = NULL, *templ;
GstCaps *peercaps = NULL;
GstCaps *intersect = NULL;
guint i;
rtph263ppay = GST_RTP_H263P_PAY (payload);
peercaps =
gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), filter);
if (!peercaps)
return
gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SINKPAD (payload));
templ = gst_pad_get_pad_template_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload));
intersect = gst_caps_intersect (peercaps, templ);
gst_caps_unref (peercaps);
gst_caps_unref (templ);
if (gst_caps_is_empty (intersect))
return intersect;
caps = gst_caps_new_empty ();
for (i = 0; i < gst_caps_get_size (intersect); i++) {
GstStructure *s = gst_caps_get_structure (intersect, i);
const gchar *encoding_name = gst_structure_get_string (s, "encoding-name");
if (!strcmp (encoding_name, "H263-2000")) {
const gchar *profile_str = gst_structure_get_string (s, "profile");
const gchar *level_str = gst_structure_get_string (s, "level");
int profile = 0;
int level = 0;
if (profile_str && level_str) {
gboolean i = FALSE, j = FALSE, l = FALSE, t = FALSE, f = FALSE,
v = FALSE;
GstStructure *new_s = gst_structure_new ("video/x-h263",
"variant", G_TYPE_STRING, "itu",
NULL);
profile = atoi (profile_str);
level = atoi (level_str);
/* These profiles are defined in the H.263 Annex X */
switch (profile) {
case 0:
/* The Baseline Profile (Profile 0) */
break;
case 1:
/* H.320 Coding Efficiency Version 2 Backward-Compatibility Profile
* (Profile 1)
* Baseline + Annexes I, J, L.4 and T
*/
i = j = l = t = TRUE;
break;
case 2:
/* Version 1 Backward-Compatibility Profile (Profile 2)
* Baseline + Annex F
*/
i = j = l = t = f = TRUE;
break;
case 3:
/* Version 2 Interactive and Streaming Wireless Profile
* Baseline + Annexes I, J, T
*/
i = j = t = TRUE;
break;
case 4:
/* Version 3 Interactive and Streaming Wireless Profile (Profile 4)
* Baseline + Annexes I, J, T, V, W.6.3.8,
*/
/* Missing W.6.3.8 */
i = j = t = v = TRUE;
break;
case 5:
/* Conversational High Compression Profile (Profile 5)
* Baseline + Annexes F, I, J, L.4, T, D, U
*/
/* Missing D, U */
f = i = j = l = t = TRUE;
break;
case 6:
/* Conversational Internet Profile (Profile 6)
* Baseline + Annexes F, I, J, L.4, T, D, U and
* K with arbitratry slice ordering
*/
/* Missing D, U, K with arbitratry slice ordering */
f = i = j = l = t = TRUE;
break;
case 7:
/* Conversational Interlace Profile (Profile 7)
* Baseline + Annexes F, I, J, L.4, T, D, U, W.6.3.11
*/
/* Missing D, U, W.6.3.11 */
f = i = j = l = t = TRUE;
break;
case 8:
/* High Latency Profile (Profile 8)
* Baseline + Annexes F, I, J, L.4, T, D, U, P.5, O.1.1 and
* K with arbitratry slice ordering
*/
/* Missing D, U, P.5, O.1.1 */
f = i = j = l = t = TRUE;
break;
}
if (f || i || j || t || l || v) {
GValue list = { 0 };
GValue vstr = { 0 };
g_value_init (&list, GST_TYPE_LIST);
g_value_init (&vstr, G_TYPE_STRING);
g_value_set_static_string (&vstr, "h263");
gst_value_list_append_value (&list, &vstr);
g_value_set_static_string (&vstr, "h263p");
gst_value_list_append_value (&list, &vstr);
if (l || v) {
g_value_set_static_string (&vstr, "h263pp");
gst_value_list_append_value (&list, &vstr);
}
g_value_unset (&vstr);
gst_structure_set_value (new_s, "h263version", &list);
g_value_unset (&list);
} else {
gst_structure_set (new_s, "h263version", G_TYPE_STRING, "h263", NULL);
}
if (!f)
gst_structure_set (new_s, "annex-f", G_TYPE_BOOLEAN, FALSE, NULL);
if (!i)
gst_structure_set (new_s, "annex-i", G_TYPE_BOOLEAN, FALSE, NULL);
if (!j)
gst_structure_set (new_s, "annex-j", G_TYPE_BOOLEAN, FALSE, NULL);
if (!t)
gst_structure_set (new_s, "annex-t", G_TYPE_BOOLEAN, FALSE, NULL);
if (!l)
gst_structure_set (new_s, "annex-l", G_TYPE_BOOLEAN, FALSE, NULL);
if (!v)
gst_structure_set (new_s, "annex-v", G_TYPE_BOOLEAN, FALSE, NULL);
if (level <= 10 || level == 45) {
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 176,
"height", GST_TYPE_INT_RANGE, 1, 144,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 2002, NULL);
caps = gst_caps_merge_structure (caps, new_s);
} else if (level <= 20) {
GstStructure *s_copy = gst_structure_copy (new_s);
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 352,
"height", GST_TYPE_INT_RANGE, 1, 288,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 2002, NULL);
caps = gst_caps_merge_structure (caps, new_s);
gst_structure_set (s_copy,
"width", GST_TYPE_INT_RANGE, 1, 176,
"height", GST_TYPE_INT_RANGE, 1, 144,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 1001, NULL);
caps = gst_caps_merge_structure (caps, s_copy);
} else if (level <= 40) {
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 352,
"height", GST_TYPE_INT_RANGE, 1, 288,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 30000, 1001, NULL);
caps = gst_caps_merge_structure (caps, new_s);
} else if (level <= 50) {
GstStructure *s_copy = gst_structure_copy (new_s);
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 352,
"height", GST_TYPE_INT_RANGE, 1, 288,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL);
caps = gst_caps_merge_structure (caps, new_s);
gst_structure_set (s_copy,
"width", GST_TYPE_INT_RANGE, 1, 352,
"height", GST_TYPE_INT_RANGE, 1, 240,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL);
caps = gst_caps_merge_structure (caps, s_copy);
} else if (level <= 60) {
GstStructure *s_copy = gst_structure_copy (new_s);
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 720,
"height", GST_TYPE_INT_RANGE, 1, 288,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL);
caps = gst_caps_merge_structure (caps, new_s);
gst_structure_set (s_copy,
"width", GST_TYPE_INT_RANGE, 1, 720,
"height", GST_TYPE_INT_RANGE, 1, 240,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL);
caps = gst_caps_merge_structure (caps, s_copy);
} else if (level <= 70) {
GstStructure *s_copy = gst_structure_copy (new_s);
gst_structure_set (new_s,
"width", GST_TYPE_INT_RANGE, 1, 720,
"height", GST_TYPE_INT_RANGE, 1, 576,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 50, 1, NULL);
caps = gst_caps_merge_structure (caps, new_s);
gst_structure_set (s_copy,
"width", GST_TYPE_INT_RANGE, 1, 720,
"height", GST_TYPE_INT_RANGE, 1, 480,
"framerate", GST_TYPE_FRACTION_RANGE, 0, 1, 60000, 1001, NULL);
caps = gst_caps_merge_structure (caps, s_copy);
} else {
caps = gst_caps_merge_structure (caps, new_s);
}
} else {
GstStructure *new_s = gst_structure_new ("video/x-h263",
"variant", G_TYPE_STRING, "itu",
"h263version", G_TYPE_STRING, "h263",
NULL);
GST_DEBUG_OBJECT (rtph263ppay, "No profile or level specified"
" for H263-2000, defaulting to baseline H263");
caps = gst_caps_merge_structure (caps, new_s);
}
} else {
gboolean f = FALSE, i = FALSE, j = FALSE, t = FALSE;
/* FIXME: ffmpeg support the Appendix K too, how do we express it ?
* guint k;
*/
const gchar *str;
GstStructure *new_s = gst_structure_new ("video/x-h263",
"variant", G_TYPE_STRING, "itu",
NULL);
gboolean added = FALSE;
str = gst_structure_get_string (s, "f");
if (str && !strcmp (str, "1"))
f = TRUE;
str = gst_structure_get_string (s, "i");
if (str && !strcmp (str, "1"))
i = TRUE;
str = gst_structure_get_string (s, "j");
if (str && !strcmp (str, "1"))
j = TRUE;
str = gst_structure_get_string (s, "t");
if (str && !strcmp (str, "1"))
t = TRUE;
if (f || i || j || t) {
GValue list = { 0 };
GValue vstr = { 0 };
g_value_init (&list, GST_TYPE_LIST);
g_value_init (&vstr, G_TYPE_STRING);
g_value_set_static_string (&vstr, "h263");
gst_value_list_append_value (&list, &vstr);
g_value_set_static_string (&vstr, "h263p");
gst_value_list_append_value (&list, &vstr);
g_value_unset (&vstr);
gst_structure_set_value (new_s, "h263version", &list);
g_value_unset (&list);
} else {
gst_structure_set (new_s, "h263version", G_TYPE_STRING, "h263", NULL);
}
if (!f)
gst_structure_set (new_s, "annex-f", G_TYPE_BOOLEAN, FALSE, NULL);
if (!i)
gst_structure_set (new_s, "annex-i", G_TYPE_BOOLEAN, FALSE, NULL);
if (!j)
gst_structure_set (new_s, "annex-j", G_TYPE_BOOLEAN, FALSE, NULL);
if (!t)
gst_structure_set (new_s, "annex-t", G_TYPE_BOOLEAN, FALSE, NULL);
str = gst_structure_get_string (s, "custom");
if (str) {
unsigned int xmax, ymax, mpi;
if (sscanf (str, "%u,%u,%u", &xmax, &ymax, &mpi) == 3) {
if (xmax % 4 && ymax % 4 && mpi >= 1 && mpi <= 32) {
caps = caps_append (caps, new_s, xmax, ymax, mpi);
added = TRUE;
} else {
GST_WARNING_OBJECT (rtph263ppay, "Invalid custom framesize/MPI"
" %u x %u at %u, ignoring", xmax, ymax, mpi);
}
} else {
GST_WARNING_OBJECT (rtph263ppay, "Invalid custom framesize/MPI: %s,"
" ignoring", str);
}
}
str = gst_structure_get_string (s, "16cif");
if (str) {
int mpi = atoi (str);
caps = caps_append (caps, new_s, 1408, 1152, mpi);
added = TRUE;
}
str = gst_structure_get_string (s, "4cif");
if (str) {
int mpi = atoi (str);
caps = caps_append (caps, new_s, 704, 576, mpi);
added = TRUE;
}
str = gst_structure_get_string (s, "cif");
if (str) {
int mpi = atoi (str);
caps = caps_append (caps, new_s, 352, 288, mpi);
added = TRUE;
}
str = gst_structure_get_string (s, "qcif");
if (str) {
int mpi = atoi (str);
caps = caps_append (caps, new_s, 176, 144, mpi);
added = TRUE;
}
str = gst_structure_get_string (s, "sqcif");
if (str) {
int mpi = atoi (str);
caps = caps_append (caps, new_s, 128, 96, mpi);
added = TRUE;
}
if (added)
gst_structure_free (new_s);
else
caps = gst_caps_merge_structure (caps, new_s);
}
}
gst_caps_unref (intersect);
return caps;
}
/**
* clutter_container_child_set:
* @container: a #ClutterContainer
* @actor: a #ClutterActor that is a child of @container.
* @first_prop: name of the first property to be set.
* @...: value for the first property, followed optionally by more name/value
* pairs terminated with NULL.
*
* Sets container specific properties on the child of a container.
*
* Since: 0.8
*/
void
clutter_container_child_set (ClutterContainer *container,
ClutterActor *actor,
const gchar *first_prop,
...)
{
GObjectClass *klass;
const gchar *name;
va_list var_args;
g_return_if_fail (CLUTTER_IS_CONTAINER (container));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
klass = G_OBJECT_GET_CLASS (container);
va_start (var_args, first_prop);
name = first_prop;
while (name)
{
GValue value = { 0, };
gchar *error = NULL;
GParamSpec *pspec;
pspec = clutter_container_class_find_child_property (klass, name);
if (!pspec)
{
g_warning ("%s: Containers of type '%s' have no child "
"property named '%s'",
G_STRLOC, G_OBJECT_TYPE_NAME (container), name);
break;
}
if (!(pspec->flags & G_PARAM_WRITABLE))
{
g_warning ("%s: Child property '%s' of the container '%s' "
"is not writable",
G_STRLOC, pspec->name, G_OBJECT_TYPE_NAME (container));
break;
}
#if GLIB_CHECK_VERSION (2, 23, 2)
G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
var_args, 0,
&error);
#else
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
G_VALUE_COLLECT (&value, var_args, 0, &error);
#endif /* GLIB_CHECK_VERSION (2, 23, 2) */
if (error)
{
/* we intentionally leak the GValue because it might
* be in an undefined state and calling g_value_unset()
* on it might crash
*/
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
break;
}
container_set_child_property (container, actor, &value, pspec);
g_value_unset (&value);
name = va_arg (var_args, gchar*);
}
va_end (var_args);
}
static void
xml_tree_model_get_value ( GtkTreeModel *model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
g_return_if_fail (XML_IS_TREE_MODEL (model));
g_return_if_fail (XML_TREE_MODEL (model)->xmldoc != NULL);
g_return_if_fail (iter != NULL);
g_return_if_fail (iter->user_data != NULL );
g_return_if_fail (column < XML_TREE_MODEL(model)->n_columns);
xmlNodePtr record = iter->user_data;
GType column_type = XML_TREE_MODEL(model)->column_types[column];
//if(g_value_get_gtype(value) != column_type) {
g_value_init (value, column_type);
//}
switch(column)
{
case XML_TREE_MODEL_COL_TYPE:
g_value_set_int(value, record->type);
break;
case XML_TREE_MODEL_COL_NS:
get_value_ns (record, value);
break;
case XML_TREE_MODEL_COL_NAME:
{
switch(record->type)
{
case XML_CDATA_SECTION_NODE:
g_value_set_string(value,"CDATA");
break;
case XML_DOCUMENT_NODE:
case XML_HTML_DOCUMENT_NODE:
{
xmlDocPtr dorec = record;
g_value_set_string(value,(const gchar *)dorec->version);
break;
}
default:
g_value_set_string(value,(gchar *) record->name);
break;
}
break;
}
case XML_TREE_MODEL_COL_CONTENT:
get_value_content(record, value);
break;
case XML_TREE_MODEL_COL_LINE:
g_value_set_int(value, (gint) xmlGetLineNo(record));
break;
case XML_TREE_MODEL_COL_POS:
{
xmlParserNodeInfo *nodeinfo;
gulong pos = NULL;
nodeinfo = xmlParserFindNodeInfo(XML_TREE_MODEL (model)->parser, record);
if(nodeinfo != NULL)
pos = nodeinfo->begin_pos;
g_value_set_ulong(value, pos);
break;
}
case XML_TREE_MODEL_COL_XPATH:
g_value_set_string(value, (const gchar *)xmlGetNodePath(record));
break;
}
}
static gboolean
try_existing_instance (DBusGConnection *bus,
DBusGProxy *proxy,
const char *type,
gboolean create,
gboolean show,
const char *uuid)
{
gboolean has_owner = FALSE;
DBusGProxy *instance;
GHashTable *args;
GValue type_value = { 0, };
GValue create_value = { 0, };
GValue show_value = { 0, };
GValue uuid_value = { 0, };
gboolean success = FALSE;
GError *error = NULL;
if (!dbus_g_proxy_call (proxy, "NameHasOwner", NULL,
G_TYPE_STRING, NM_CE_DBUS_SERVICE_NAME, G_TYPE_INVALID,
G_TYPE_BOOLEAN, &has_owner, G_TYPE_INVALID))
return FALSE;
if (!has_owner)
return FALSE;
/* Send arguments to existing process */
instance = dbus_g_proxy_new_for_name (bus,
NM_CE_DBUS_SERVICE_NAME,
"/",
NM_CE_DBUS_SERVICE_NAME);
if (!instance)
return FALSE;
args = g_hash_table_new (g_str_hash, g_str_equal);
if (type) {
g_value_init (&type_value, G_TYPE_STRING);
g_value_set_static_string (&type_value, type);
g_hash_table_insert (args, ARG_TYPE, &type_value);
}
if (create) {
g_value_init (&create_value, G_TYPE_BOOLEAN);
g_value_set_boolean (&create_value, TRUE);
g_hash_table_insert (args, ARG_CREATE, &create_value);
}
if (show) {
g_value_init (&show_value, G_TYPE_BOOLEAN);
g_value_set_boolean (&show_value, TRUE);
g_hash_table_insert (args, ARG_SHOW, &show_value);
}
if (uuid) {
g_value_init (&uuid_value, G_TYPE_STRING);
g_value_set_static_string (&uuid_value, uuid);
g_hash_table_insert (args, ARG_UUID, &uuid_value);
}
if (dbus_g_proxy_call (instance, "Start", &error,
DBUS_TYPE_G_MAP_OF_VARIANT, args, G_TYPE_INVALID,
G_TYPE_INVALID))
success = TRUE;
else
g_warning ("%s: error calling start: %s", __func__, error->message);
g_hash_table_destroy (args);
g_object_unref (instance);
return success;
}
static void
print_element_properties_info (GstElement * element)
{
GParamSpec **property_specs;
guint num_properties, i;
gboolean readable;
gboolean first_flag;
property_specs = g_object_class_list_properties
(G_OBJECT_GET_CLASS (element), &num_properties);
n_print ("\n");
n_print ("Element Properties:\n");
for (i = 0; i < num_properties; i++) {
GValue value = { 0, };
GParamSpec *param = property_specs[i];
readable = FALSE;
g_value_init (&value, param->value_type);
n_print (" %-20s: %s\n", g_param_spec_get_name (param),
g_param_spec_get_blurb (param));
first_flag = TRUE;
n_print ("%-23.23s flags: ", "");
if (param->flags & G_PARAM_READABLE) {
g_object_get_property (G_OBJECT (element), param->name, &value);
readable = TRUE;
if (!first_flag)
g_print (", ");
else
first_flag = FALSE;
g_print (_("readable"));
}
if (param->flags & G_PARAM_WRITABLE) {
if (!first_flag)
g_print (", ");
else
first_flag = FALSE;
g_print (_("writable"));
}
if (param->flags & GST_PARAM_CONTROLLABLE) {
if (!first_flag)
g_print (", ");
else
first_flag = FALSE;
g_print (_("controllable"));
}
n_print ("\n");
switch (G_VALUE_TYPE (&value)) {
case G_TYPE_STRING:
{
GParamSpecString *pstring = G_PARAM_SPEC_STRING (param);
n_print ("%-23.23s String. ", "");
if (pstring->default_value == NULL)
g_print ("Default: null ");
else
g_print ("Default: \"%s\" ", pstring->default_value);
if (readable) {
const char *string_val = g_value_get_string (&value);
if (string_val == NULL)
g_print ("Current: null");
else
g_print ("Current: \"%s\"", string_val);
}
break;
}
case G_TYPE_BOOLEAN:
{
GParamSpecBoolean *pboolean = G_PARAM_SPEC_BOOLEAN (param);
n_print ("%-23.23s Boolean. ", "");
g_print ("Default: %s ", (pboolean->default_value ? "true" : "false"));
if (readable)
g_print ("Current: %s",
(g_value_get_boolean (&value) ? "true" : "false"));
break;
}
case G_TYPE_ULONG:
{
GParamSpecULong *pulong = G_PARAM_SPEC_ULONG (param);
n_print ("%-23.23s Unsigned Long. ", "");
g_print ("Range: %lu - %lu Default: %lu ",
pulong->minimum, pulong->maximum, pulong->default_value);
if (readable)
g_print ("Current: %lu", g_value_get_ulong (&value));
break;
}
case G_TYPE_LONG:
{
GParamSpecLong *plong = G_PARAM_SPEC_LONG (param);
n_print ("%-23.23s Long. ", "");
g_print ("Range: %ld - %ld Default: %ld ",
plong->minimum, plong->maximum, plong->default_value);
if (readable)
g_print ("Current: %ld", g_value_get_long (&value));
break;
}
case G_TYPE_UINT:
{
GParamSpecUInt *puint = G_PARAM_SPEC_UINT (param);
n_print ("%-23.23s Unsigned Integer. ", "");
g_print ("Range: %u - %u Default: %u ",
puint->minimum, puint->maximum, puint->default_value);
if (readable)
g_print ("Current: %u", g_value_get_uint (&value));
break;
}
case G_TYPE_INT:
{
GParamSpecInt *pint = G_PARAM_SPEC_INT (param);
n_print ("%-23.23s Integer. ", "");
g_print ("Range: %d - %d Default: %d ",
pint->minimum, pint->maximum, pint->default_value);
if (readable)
g_print ("Current: %d", g_value_get_int (&value));
break;
}
case G_TYPE_UINT64:
{
GParamSpecUInt64 *puint64 = G_PARAM_SPEC_UINT64 (param);
n_print ("%-23.23s Unsigned Integer64. ", "");
g_print ("Range: %" G_GUINT64_FORMAT " - %" G_GUINT64_FORMAT
" Default: %" G_GUINT64_FORMAT " ",
puint64->minimum, puint64->maximum, puint64->default_value);
if (readable)
g_print ("Current: %" G_GUINT64_FORMAT, g_value_get_uint64 (&value));
break;
}
case G_TYPE_INT64:
{
GParamSpecInt64 *pint64 = G_PARAM_SPEC_INT64 (param);
n_print ("%-23.23s Integer64. ", "");
g_print ("Range: %" G_GINT64_FORMAT " - %" G_GINT64_FORMAT
" Default: %" G_GINT64_FORMAT " ",
pint64->minimum, pint64->maximum, pint64->default_value);
if (readable)
g_print ("Current: %" G_GINT64_FORMAT, g_value_get_int64 (&value));
break;
}
case G_TYPE_FLOAT:
{
GParamSpecFloat *pfloat = G_PARAM_SPEC_FLOAT (param);
n_print ("%-23.23s Float. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pfloat->minimum, pfloat->maximum, pfloat->default_value);
if (readable)
g_print ("Current: %15.7g", g_value_get_float (&value));
break;
}
case G_TYPE_DOUBLE:
{
GParamSpecDouble *pdouble = G_PARAM_SPEC_DOUBLE (param);
n_print ("%-23.23s Double. ", "");
g_print ("Range: %15.7g - %15.7g Default: %15.7g ",
pdouble->minimum, pdouble->maximum, pdouble->default_value);
if (readable)
g_print ("Current: %15.7g", g_value_get_double (&value));
break;
}
default:
if (param->value_type == GST_TYPE_CAPS) {
const GstCaps *caps = gst_value_get_caps (&value);
if (!caps)
n_print ("%-23.23s Caps (NULL)", "");
else {
print_caps (caps, " ");
}
} else if (G_IS_PARAM_SPEC_ENUM (param)) {
GParamSpecEnum *penum = G_PARAM_SPEC_ENUM (param);
GEnumValue *values;
guint j = 0;
gint enum_value;
const gchar *def_val_nick = "", *cur_val_nick = "";
values = G_ENUM_CLASS (g_type_class_ref (param->value_type))->values;
enum_value = g_value_get_enum (&value);
while (values[j].value_name) {
if (values[j].value == enum_value)
cur_val_nick = values[j].value_nick;
if (values[j].value == penum->default_value)
def_val_nick = values[j].value_nick;
j++;
}
n_print
("%-23.23s Enum \"%s\" Default: %d, \"%s\" Current: %d, \"%s\"",
"", g_type_name (G_VALUE_TYPE (&value)), penum->default_value,
def_val_nick, enum_value, cur_val_nick);
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print (_name);
g_print ("%-23.23s (%d): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
/* g_type_class_unref (ec); */
} else if (G_IS_PARAM_SPEC_FLAGS (param)) {
GParamSpecFlags *pflags = G_PARAM_SPEC_FLAGS (param);
GFlagsValue *values;
guint j = 0;
gint flags_value;
GString *cur_flags = NULL, *def_flags = NULL;
values = G_FLAGS_CLASS (g_type_class_ref (param->value_type))->values;
flags_value = g_value_get_flags (&value);
while (values[j].value_name) {
if (values[j].value & flags_value) {
if (cur_flags) {
g_string_append_printf (cur_flags, " | %s",
values[j].value_nick);
} else {
cur_flags = g_string_new (values[j].value_nick);
}
}
if (values[j].value & pflags->default_value) {
if (def_flags) {
g_string_append_printf (def_flags, " | %s",
values[j].value_nick);
} else {
def_flags = g_string_new (values[j].value_nick);
}
}
j++;
}
n_print
("%-23.23s Flags \"%s\" Default: 0x%08x, \"%s\" Current: 0x%08x, \"%s\"",
"", g_type_name (G_VALUE_TYPE (&value)), pflags->default_value,
(def_flags ? def_flags->str : "(none)"), flags_value,
(cur_flags ? cur_flags->str : "(none)"));
j = 0;
while (values[j].value_name) {
g_print ("\n");
if (_name)
g_print (_name);
g_print ("%-23.23s (0x%08x): %-16s - %s", "",
values[j].value, values[j].value_nick, values[j].value_name);
j++;
}
if (cur_flags)
g_string_free (cur_flags, TRUE);
if (def_flags)
g_string_free (def_flags, TRUE);
} else if (G_IS_PARAM_SPEC_OBJECT (param)) {
n_print ("%-23.23s Object of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_BOXED (param)) {
n_print ("%-23.23s Boxed pointer of type \"%s\"", "",
g_type_name (param->value_type));
} else if (G_IS_PARAM_SPEC_POINTER (param)) {
if (param->value_type != G_TYPE_POINTER) {
n_print ("%-23.23s Pointer of type \"%s\".", "",
g_type_name (param->value_type));
} else {
n_print ("%-23.23s Pointer.", "");
}
} else if (param->value_type == G_TYPE_VALUE_ARRAY) {
n_print ("%-23.23s Array of GValues", "");
} else if (GST_IS_PARAM_SPEC_FRACTION (param)) {
GstParamSpecFraction *pfraction = GST_PARAM_SPEC_FRACTION (param);
n_print ("%-23.23s Fraction. ", "");
g_print ("Range: %d/%d - %d/%d Default: %d/%d ",
pfraction->min_num, pfraction->min_den,
pfraction->max_num, pfraction->max_den,
pfraction->def_num, pfraction->def_den);
if (readable)
g_print ("Current: %d/%d",
gst_value_get_fraction_numerator (&value),
gst_value_get_fraction_denominator (&value));
} else {
n_print ("%-23.23s Unknown type %ld \"%s\"", "", param->value_type,
g_type_name (param->value_type));
}
break;
}
if (!readable)
g_print (" Write only\n");
else
g_print ("\n");
g_value_reset (&value);
}
if (num_properties == 0)
n_print (" none\n");
g_free (property_specs);
}
static GstCaps *
gst_rtp_h265_pay_getcaps (GstRTPBasePayload * payload, GstPad * pad,
GstCaps * filter)
{
GstCaps *template_caps;
GstCaps *allowed_caps;
GstCaps *caps;
GstCaps *icaps;
gboolean append_unrestricted;
guint i;
allowed_caps =
gst_pad_peer_query_caps (GST_RTP_BASE_PAYLOAD_SRCPAD (payload), NULL);
if (allowed_caps == NULL)
return NULL;
template_caps =
gst_static_pad_template_get_caps (&gst_rtp_h265_pay_sink_template);
if (gst_caps_is_any (allowed_caps)) {
caps = gst_caps_ref (template_caps);
goto done;
}
if (gst_caps_is_empty (allowed_caps)) {
caps = gst_caps_ref (allowed_caps);
goto done;
}
caps = gst_caps_new_empty ();
append_unrestricted = FALSE;
for (i = 0; i < gst_caps_get_size (allowed_caps); i++) {
GstStructure *s = gst_caps_get_structure (allowed_caps, i);
GstStructure *new_s = gst_structure_new_empty ("video/x-h265");
const gchar *profile_level_id;
profile_level_id = gst_structure_get_string (s, "profile-level-id");
if (profile_level_id && strlen (profile_level_id) == 6) { /* Code taken from gstrtph264pay.c, needs to be revised for H.265 */
const gchar *profile;
const gchar *level;
long int spsint;
guint8 sps[3];
spsint = strtol (profile_level_id, NULL, 16);
sps[0] = spsint >> 16;
sps[1] = spsint >> 8;
sps[2] = spsint;
profile = gst_codec_utils_h265_get_profile (sps, 3);
level = gst_codec_utils_h265_get_level (sps, 3);
if (profile && level) {
GST_LOG_OBJECT (payload, "In caps, have profile %s and level %s",
profile, level);
if (!strcmp (profile, "main"))
gst_structure_set (new_s, "profile", G_TYPE_STRING, profile, NULL);
else {
GValue val = { 0, };
GValue profiles = { 0, };
g_value_init (&profiles, GST_TYPE_LIST);
g_value_init (&val, G_TYPE_STRING);
g_value_set_static_string (&val, profile);
gst_value_list_append_value (&profiles, &val);
g_value_set_static_string (&val, "main");
gst_value_list_append_value (&profiles, &val);
gst_structure_take_value (new_s, "profile", &profiles);
}
if (!strcmp (level, "1"))
gst_structure_set (new_s, "level", G_TYPE_STRING, level, NULL);
else {
GValue levels = { 0, };
GValue val = { 0, };
int j;
g_value_init (&levels, GST_TYPE_LIST);
g_value_init (&val, G_TYPE_STRING);
for (j = 0; j < G_N_ELEMENTS (all_levels); j++) {
g_value_set_static_string (&val, all_levels[j]);
gst_value_list_prepend_value (&levels, &val);
if (!strcmp (level, all_levels[j]))
break;
}
gst_structure_take_value (new_s, "level", &levels);
}
} else {
/* Invalid profile-level-id means main */
gst_structure_set (new_s, "profile", G_TYPE_STRING, "main", NULL);
}
} else {
/* No profile-level-id means main or unrestricted */
gst_structure_set (new_s, "profile", G_TYPE_STRING, "main", NULL);
append_unrestricted = TRUE;
}
caps = gst_caps_merge_structure (caps, new_s);
}
static void
gimp_text_undo_pop (GimpUndo *undo,
GimpUndoMode undo_mode,
GimpUndoAccumulator *accum)
{
GimpTextUndo *text_undo = GIMP_TEXT_UNDO (undo);
GimpTextLayer *layer = GIMP_TEXT_LAYER (GIMP_ITEM_UNDO (undo)->item);
GIMP_UNDO_CLASS (parent_class)->pop (undo, undo_mode, accum);
switch (undo->undo_type)
{
case GIMP_UNDO_TEXT_LAYER:
if (text_undo->pspec)
{
GValue *value;
g_return_if_fail (layer->text != NULL);
value = g_slice_new0 (GValue);
g_value_init (value, text_undo->pspec->value_type);
g_object_get_property (G_OBJECT (layer->text),
text_undo->pspec->name, value);
g_object_set_property (G_OBJECT (layer->text),
text_undo->pspec->name, text_undo->value);
g_value_unset (text_undo->value);
g_slice_free (GValue, text_undo->value);
text_undo->value = value;
}
else
{
GimpText *text;
text = (layer->text ?
gimp_config_duplicate (GIMP_CONFIG (layer->text)) : NULL);
if (layer->text && text_undo->text)
gimp_config_sync (G_OBJECT (text_undo->text),
G_OBJECT (layer->text), 0);
else
gimp_text_layer_set_text (layer, text_undo->text);
if (text_undo->text)
g_object_unref (text_undo->text);
text_undo->text = text;
}
break;
case GIMP_UNDO_TEXT_LAYER_MODIFIED:
{
gboolean modified;
#if 0
g_print ("setting layer->modified from %s to %s\n",
layer->modified ? "TRUE" : "FALSE",
text_undo->modified ? "TRUE" : "FALSE");
#endif
modified = layer->modified;
g_object_set (layer, "modified", text_undo->modified, NULL);
text_undo->modified = modified;
gimp_viewable_invalidate_preview (GIMP_VIEWABLE (layer));
}
break;
case GIMP_UNDO_TEXT_LAYER_CONVERT:
{
const Babl *format;
format = gimp_drawable_get_format (GIMP_DRAWABLE (layer));
gimp_drawable_convert_type (GIMP_DRAWABLE (layer),
gimp_item_get_image (GIMP_ITEM (layer)),
gimp_babl_format_get_base_type (text_undo->format),
gimp_babl_format_get_precision (text_undo->format),
babl_format_has_alpha (text_undo->format),
NULL, NULL,
GEGL_DITHER_NONE, GEGL_DITHER_NONE,
FALSE, NULL);
text_undo->format = format;
}
break;
default:
gimp_assert_not_reached ();
}
}
GimpValueArray *
gimp_procedure_get_return_values (GimpProcedure *procedure,
gboolean success,
const GError *error)
{
GimpValueArray *args;
GValue value = { 0, };
gint i;
g_return_val_if_fail (success == FALSE || GIMP_IS_PROCEDURE (procedure),
NULL);
if (success)
{
args = gimp_value_array_new (procedure->num_values + 1);
g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE);
g_value_set_enum (&value, GIMP_PDB_SUCCESS);
gimp_value_array_append (args, &value);
g_value_unset (&value);
for (i = 0; i < procedure->num_values; i++)
{
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (procedure->values[i]));
gimp_value_array_append (args, &value);
g_value_unset (&value);
}
}
else
{
args = gimp_value_array_new ((error && error->message) ? 2 : 1);
g_value_init (&value, GIMP_TYPE_PDB_STATUS_TYPE);
/* errors in the GIMP_PDB_ERROR domain are calling errors */
if (error && error->domain == GIMP_PDB_ERROR)
{
switch ((GimpPdbErrorCode) error->code)
{
case GIMP_PDB_ERROR_FAILED:
case GIMP_PDB_ERROR_PROCEDURE_NOT_FOUND:
case GIMP_PDB_ERROR_INVALID_ARGUMENT:
case GIMP_PDB_ERROR_INVALID_RETURN_VALUE:
case GIMP_PDB_ERROR_INTERNAL_ERROR:
g_value_set_enum (&value, GIMP_PDB_CALLING_ERROR);
break;
case GIMP_PDB_ERROR_CANCELLED:
g_value_set_enum (&value, GIMP_PDB_CANCEL);
break;
default:
g_assert_not_reached ();
}
}
else
{
g_value_set_enum (&value, GIMP_PDB_EXECUTION_ERROR);
}
gimp_value_array_append (args, &value);
g_value_unset (&value);
if (error && error->message)
{
g_value_init (&value, G_TYPE_STRING);
g_value_set_string (&value, error->message);
gimp_value_array_append (args, &value);
g_value_unset (&value);
}
}
return args;
}
static GPtrArray *
read_ip6_addresses (GKeyFile *file,
const char *setting_name,
const char *key)
{
GPtrArray *addresses;
struct in6_addr addr, gw;
guint32 prefix;
int i = 0;
addresses = g_ptr_array_sized_new (3);
/* Look for individual addresses */
while (i++ < 1000) {
char *tmp, *key_name, *str_prefix, *str_gw;
int ret;
GValueArray *values;
GByteArray *address;
GByteArray *gateway;
GValue value = { 0 };
key_name = g_strdup_printf ("%s%d", key, i);
tmp = g_key_file_get_string (file, setting_name, key_name, NULL);
g_free (key_name);
if (!tmp)
break; /* all done */
/* convert the string array into IPv6 addresses */
values = g_value_array_new (2); /* NMIP6Address has 2 items */
/* Split the address and prefix */
str_prefix = split_prefix (tmp);
/* address */
ret = inet_pton (AF_INET6, tmp, &addr);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp);
g_value_array_free (values);
goto next;
}
address = g_byte_array_new ();
g_byte_array_append (address, (guint8 *) addr.s6_addr, 16);
g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_take_boxed (&value, address);
g_value_array_append (values, &value);
g_value_unset (&value);
/* prefix */
prefix = 0;
if (str_prefix) {
if (!get_one_int (str_prefix, 128, key_name, &prefix)) {
g_value_array_free (values);
goto next;
}
} else {
/* Missing prefix defaults to /64 */
prefix = 64;
}
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, prefix);
g_value_array_append (values, &value);
g_value_unset (&value);
/* Gateway (optional) */
str_gw = split_gw (str_prefix);
if (str_gw) {
ret = inet_pton (AF_INET6, str_gw, &gw);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv6 %s gateway '%s'", __func__, key_name, tmp);
g_value_array_free (values);
goto next;
}
if (!IN6_IS_ADDR_UNSPECIFIED (&gw)) {
gateway = g_byte_array_new ();
g_byte_array_append (gateway, (guint8 *) gw.s6_addr, 16);
g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_take_boxed (&value, gateway);
g_value_array_append (values, &value);
g_value_unset (&value);
}
}
g_ptr_array_add (addresses, values);
next:
g_free (tmp);
}
if (addresses->len < 1) {
g_ptr_array_free (addresses, TRUE);
addresses = NULL;
}
return addresses;
}
int main(int argc, char *argv[]) {
GtkWidget *main_window, *scroll;
GtkWidget *treeview;
GtkTreeViewColumn *column;
GtkCellRenderer *name_renderer, *size_renderer;
GtkTreeStore *store;
GtkTreeIter categories[14];
GValue value = { 0, };
gint offset;
uint32 res_counts[14];
uint32 res_sizes[14];
int i;
Common::File in;
uint32 index_pos;
uint32 pos, len;
gtk_init(&argc, &argv);
if (argc != 2) {
printf("Usage: %s filename\n", argv[0]);
return EXIT_FAILURE;
}
in.open(argv[1], "rb");
if (!in.isOpen()) {
printf("Couldn't open %s for reading\n", argv[1]);
return EXIT_FAILURE;
}
/* Create the main window, scrollable in both directions */
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer");
gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400);
g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Create the tree view */
for (i = 0; i < ARRAYSIZE(res_counts); i++) {
res_counts[i] = 0;
res_sizes[i] = 0;
}
store = gtk_tree_store_new(N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
G_TYPE_INT);
gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
index_pos = in.readUint32LE();
in.seek(index_pos, SEEK_SET);
for (;;) {
GtkTreeIter iter;
byte type;
gchar *utf8_name;
gchar name[34];
gchar *size;
try {
pos = in.readUint32LE();
len = in.readUint32LE();
} catch (...) {
break;
}
size = make_size(len);
index_pos = in.pos();
in.seek(pos, SEEK_SET);
type = in.readByte();
in.readByte(); /* compType */
in.readUint32LE(); /* compSize */
in.readUint32LE(); /* decompSize */
in.read_noThrow(name, sizeof(name));
/*
* We need to convert from Latin-1 to UTF-8. Otherwise the text
* "CAFÉ" won't be displayed properly.
*/
utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
if (!res_counts[type]) {
gtk_tree_store_append(store, &categories[type], NULL);
gtk_tree_store_set(store, &categories[type],
NAME_COLUMN, getType(type),
SIZE_COLUMN, "",
TYPE_COLUMN, -1,
POSITION_COLUMN, -1,
LENGTH_COLUMN, -1,
-1);
}
res_counts[type]++;
res_sizes[type] += len;
gtk_tree_store_append(store, &iter, &categories[type]);
gtk_tree_store_set(store, &iter,
NAME_COLUMN, utf8_name,
SIZE_COLUMN, size,
TYPE_COLUMN, type,
POSITION_COLUMN, pos,
LENGTH_COLUMN, len);
in.seek(index_pos, SEEK_SET);
}
in.close();
for (i = 0; i < ARRAYSIZE(res_counts); i++) {
if (res_counts[i]) {
gchar size[80];
sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]);
gtk_tree_store_set(store, &categories[i],
SIZE_COLUMN, size,
-1);
}
}
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]);
/* The view now holds a reference. We can get rid of our own. */
g_object_unref(G_OBJECT(store));
name_renderer = gtk_cell_renderer_text_new();
size_renderer = gtk_cell_renderer_text_new();
g_value_init(&value, G_TYPE_FLOAT);
g_value_set_float(&value, 1.0);
g_object_set_property(G_OBJECT(size_renderer), "xalign", &value);
gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(treeview), -1, "Name", name_renderer,
"text", NAME_COLUMN,
NULL);
offset = gtk_tree_view_insert_column_with_attributes(
GTK_TREE_VIEW(treeview), -1, "Size", size_renderer,
"text", SIZE_COLUMN,
NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1);
gtk_tree_view_column_set_alignment(column, 1.0);
gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview));
gtk_container_add(GTK_CONTAINER(main_window), scroll);
gtk_widget_show_all(GTK_WIDGET(main_window));
gtk_main();
return EXIT_SUCCESS;
}
static GPtrArray *
read_ip6_routes (GKeyFile *file,
const char *setting_name,
const char *key)
{
GPtrArray *routes;
struct in6_addr addr;
guint32 prefix, metric;
int i = 0;
routes = g_ptr_array_sized_new (3);
/* Look for individual routes */
while (i++ < 1000) {
gchar **tmp;
char *key_name, *str_prefix;
gsize length = 0;
int ret;
GValueArray *values;
GByteArray *address;
GValue value = { 0 };
key_name = g_strdup_printf ("%s%d", key, i);
tmp = g_key_file_get_string_list (file, setting_name, key_name, &length, NULL);
g_free (key_name);
if (!tmp || !length)
break; /* all done */
if (length != 3) {
g_warning ("%s: ignoring invalid IPv6 address item '%s'", __func__, key_name);
goto next;
}
/* convert the string array into IPv6 routes */
values = g_value_array_new (4); /* NMIP6Route has 4 items */
/* Split the route and prefix */
str_prefix = split_prefix (tmp[0]);
/* destination address */
ret = inet_pton (AF_INET6, tmp[0], &addr);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp[0]);
g_value_array_free (values);
goto next;
}
address = g_byte_array_new ();
g_byte_array_append (address, (guint8 *) addr.s6_addr, 16);
g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_take_boxed (&value, address);
g_value_array_append (values, &value);
g_value_unset (&value);
/* prefix */
prefix = 0;
if (str_prefix) {
if (!get_one_int (str_prefix, 128, key_name, &prefix)) {
g_value_array_free (values);
goto next;
}
} else {
/* default to 64 if unspecified */
prefix = 64;
}
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, prefix);
g_value_array_append (values, &value);
g_value_unset (&value);
/* next hop address */
ret = inet_pton (AF_INET6, tmp[1], &addr);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv6 %s element '%s'", __func__, key_name, tmp[1]);
g_value_array_free (values);
goto next;
}
address = g_byte_array_new ();
g_byte_array_append (address, (guint8 *) addr.s6_addr, 16);
g_value_init (&value, DBUS_TYPE_G_UCHAR_ARRAY);
g_value_take_boxed (&value, address);
g_value_array_append (values, &value);
g_value_unset (&value);
/* metric */
metric = 0;
if (!get_one_int (tmp[2], G_MAXUINT32, key_name, &metric)) {
g_value_array_free (values);
goto next;
}
g_value_init (&value, G_TYPE_UINT);
g_value_set_uint (&value, metric);
g_value_array_append (values, &value);
g_value_unset (&value);
g_ptr_array_add (routes, values);
next:
g_strfreev (tmp);
}
if (routes->len < 1) {
g_ptr_array_free (routes, TRUE);
routes = NULL;
}
return routes;
}
/**
* gimp_rc_query:
* @rc: a #GimpRc object.
* @key: a string used as a key for the lookup.
*
* This function looks up @key in the object properties of @rc. If
* there's a matching property, a string representation of its value
* is returned. If no property is found, the list of unknown tokens
* attached to the @rc object is searched.
*
* Return value: a newly allocated string representing the value or %NULL
* if the key couldn't be found.
**/
gchar *
gimp_rc_query (GimpRc *rc,
const gchar *key)
{
GObjectClass *klass;
GObject *rc_object;
GParamSpec **property_specs;
GParamSpec *prop_spec;
guint i, n_property_specs;
gchar *retval = NULL;
g_return_val_if_fail (GIMP_IS_RC (rc), NULL);
g_return_val_if_fail (key != NULL, NULL);
rc_object = G_OBJECT (rc);
klass = G_OBJECT_GET_CLASS (rc);
property_specs = g_object_class_list_properties (klass, &n_property_specs);
if (!property_specs)
return NULL;
for (i = 0, prop_spec = NULL; i < n_property_specs && !prop_spec; i++)
{
prop_spec = property_specs[i];
if (! (prop_spec->flags & GIMP_CONFIG_PARAM_SERIALIZE) ||
strcmp (prop_spec->name, key))
{
prop_spec = NULL;
}
}
if (prop_spec)
{
GString *str = g_string_new (NULL);
GValue value = { 0, };
g_value_init (&value, prop_spec->value_type);
g_object_get_property (rc_object, prop_spec->name, &value);
if (gimp_config_serialize_value (&value, str, FALSE))
retval = g_string_free (str, FALSE);
else
g_string_free (str, TRUE);
g_value_unset (&value);
}
else
{
retval = g_strdup (gimp_rc_lookup_unknown_token (GIMP_CONFIG (rc), key));
}
g_free (property_specs);
if (!retval)
{
const gchar * const path_tokens[] =
{
"gimp_dir",
"gimp_data_dir",
"gimp_plug_in_dir",
"gimp_plugin_dir",
"gimp_sysconf_dir"
};
for (i = 0; !retval && i < G_N_ELEMENTS (path_tokens); i++)
if (strcmp (key, path_tokens[i]) == 0)
retval = g_strdup_printf ("${%s}", path_tokens[i]);
}
if (retval)
{
gchar *tmp = gimp_config_path_expand (retval, FALSE, NULL);
if (tmp)
{
g_free (retval);
retval = tmp;
}
}
return retval;
}
static void
add_mtp_track_to_db (RBMtpSource *source,
RhythmDB *db,
LIBMTP_track_t *track)
{
RhythmDBEntry *entry = NULL;
RhythmDBEntryType entry_type;
RBMtpSourcePrivate *priv = MTP_SOURCE_GET_PRIVATE (source);
char *name = NULL;
/* ignore everything except audio (allow audio/video types too, since they're probably pretty common) */
if (!(LIBMTP_FILETYPE_IS_AUDIO (track->filetype) || LIBMTP_FILETYPE_IS_AUDIOVIDEO (track->filetype))) {
rb_debug ("ignoring non-audio item %d (filetype %s)",
track->item_id,
LIBMTP_Get_Filetype_Description (track->filetype));
return;
}
/* Set URI */
g_object_get (G_OBJECT (source), "entry-type", &entry_type, NULL);
name = g_strdup_printf ("x-rb-mtp://%i/%s", track->item_id, track->filename);
entry = rhythmdb_entry_new (RHYTHMDB (db), entry_type, name);
g_free (name);
g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, entry_type);
if (entry == NULL) {
rb_debug ("cannot create entry %i", track->item_id);
g_object_unref (G_OBJECT (db));
return;
}
/* Set track number */
if (track->tracknumber != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->tracknumber);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_TRACK_NUMBER,
&value);
g_value_unset (&value);
}
/* Set length */
if (track->duration != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->duration/1000);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_DURATION,
&value);
g_value_unset (&value);
}
/* Set file size */
if (track->filesize != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_UINT64);
g_value_set_uint64 (&value, track->filesize);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_FILE_SIZE,
&value);
g_value_unset (&value);
}
/* Set playcount */
if (track->usecount != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_ULONG);
g_value_set_ulong (&value, track->usecount);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_PLAY_COUNT,
&value);
g_value_unset (&value);
}
/* Set rating */
if (track->rating != 0) {
GValue value = {0, };
g_value_init (&value, G_TYPE_DOUBLE);
g_value_set_double (&value, track->rating/20);
rhythmdb_entry_set (RHYTHMDB (db), entry,
RHYTHMDB_PROP_RATING,
&value);
g_value_unset (&value);
}
/* Set title */
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_TITLE, track->title);
/* Set album, artist and genre from MTP */
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ARTIST, track->artist);
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_ALBUM, track->album);
entry_set_string_prop (RHYTHMDB (db), entry, RHYTHMDB_PROP_GENRE, track->genre);
g_hash_table_insert (priv->entry_map, entry, track);
rhythmdb_commit (RHYTHMDB (db));
}
/* void parentChanged (in nsIDOMElement newParent); */
NS_IMETHODIMP
xgGtkElement::ParentChanged (nsIDOMElement *newParent)
{
/* no need for this rigamarole... */
if (GTK_IS_WINDOW (mObject)) {
return NS_OK;
}
/* just as a sanity check */
nsCOMPtr<xgIGObjectHolder> wrappedParent (do_QueryInterface (newParent));
GObject *parent = NULL;
if (!wrappedParent || NS_FAILED (wrappedParent->GetGObject (&parent)) ||
!GTK_IS_CONTAINER (parent)) {
g_warning (GOM_LOC ("Could not get parent widget for node: <%s>"),
G_OBJECT_TYPE_NAME (mObject));
return NS_ERROR_FAILURE;
}
g_assert (GTK_WIDGET (parent) == gtk_widget_get_parent (GTK_WIDGET (mObject)));
nsresult rv;
nsCOMPtr<nsIDOMElement> elem;
rv = mWrapper->GetElementNode (getter_AddRefs (elem));
NS_ENSURE_SUCCESS (rv, rv);
nsCOMPtr<nsIDOMNamedNodeMap> attrs;
rv = elem->GetAttributes (getter_AddRefs (attrs));
NS_ENSURE_SUCCESS (rv, rv);
PRUint32 len;
rv = attrs->GetLength (&len);
NS_ENSURE_SUCCESS (rv, rv);
nsCOMPtr<nsIDOMNode> attr;
nsAutoString attrName;
nsAutoString attrValue;
const char *camel_prop;
GValue gval = { 0 };
for (PRUint32 i = 0; i < len; i++) {
rv = attrs->Item (i, getter_AddRefs (attr));
NS_ENSURE_SUCCESS (rv, rv);
rv = attr->GetNodeName (attrName);
NS_ENSURE_SUCCESS (rv, rv);
NS_ConvertUTF16toUTF8 attrCName (attrName);
camel_prop = gom_camel_uncase (attrCName.get ());
rv = attr->GetNodeValue (attrValue);
NS_ENSURE_SUCCESS (rv, rv);
g_value_init (&gval, G_TYPE_STRING);
g_value_set_string (&gval, NS_ConvertUTF16toUTF8 (attrValue).get ());
append_child_attrs_foreach ((gpointer)camel_prop,
(gpointer)&gval,
(gpointer)mObject);
GOM_CAMEL_FREE (camel_prop, attrCName.get ());
g_value_unset (&gval);
}
return NS_OK;
}
int moloch_http_connect(MolochConn_t *conn, char *name, int defaultport, int blocking)
{
GError *error = 0;
GSocketConnectable *connectable;
GSocketAddressEnumerator *enumerator;
GSocketAddress *sockaddr;
struct timeval startTime;
struct timeval stopTime;
gettimeofday(&startTime, NULL);
connectable = g_network_address_parse(name, defaultport, &error);
if (error) {
LOG("%p: Couldn't parse connect string of %s", (void*)conn, name);
exit(0);
}
conn->name = name;
enumerator = g_socket_connectable_enumerate (connectable);
g_object_unref(connectable);
while (!conn->conn && (sockaddr = g_socket_address_enumerator_next (enumerator, NULL, &error)))
{
conn->conn = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &error);
if (!error) {
GValue value = G_VALUE_INIT;
g_value_init (&value, G_TYPE_BOOLEAN);
g_value_set_boolean (&value, blocking);
g_object_set_property(G_OBJECT(conn->conn), "blocking", &value);
g_socket_connect(conn->conn, sockaddr, NULL, &error);
}
if (error && error->code != G_IO_ERROR_PENDING) {
g_object_unref (conn->conn);
conn->conn = NULL;
} else {
struct sockaddr_in localAddress, remoteAddress;
socklen_t addressLength = sizeof(localAddress);
getsockname(g_socket_get_fd(conn->conn), (struct sockaddr*)&localAddress, &addressLength);
g_socket_address_to_native(sockaddr, &remoteAddress, addressLength, NULL);
char sessionId[MOLOCH_SESSIONID_LEN];
moloch_session_id(sessionId, localAddress.sin_addr.s_addr, localAddress.sin_port,
remoteAddress.sin_addr.s_addr, remoteAddress.sin_port);
DEBUGCONN("AAA connected %s %p %s", conn->server->names[0], conn,
moloch_friendly_session_id(17, localAddress.sin_addr.s_addr, htons(localAddress.sin_port),
remoteAddress.sin_addr.s_addr, htons(remoteAddress.sin_port)));
HASH_ADD(h_, connections, sessionId, conn);
memcpy(&conn->sessionIda, sessionId, 8);
memcpy(&conn->sessionIdb, sessionId+8, 4);
conn->server->numConns++;
}
g_object_unref (sockaddr);
}
g_object_unref (enumerator);
if (conn->conn) {
if (error) {
g_error_free(error);
error = 0;
}
} else if (error) {
LOG("%p: Error: %s", (void*)conn, error->message);
}
if (error || !conn->conn) {
if (config.logESRequests)
LOG("Connecting %p %s %d %d FAIL", (void*)conn, name, defaultport, blocking);
conn->server->lastFailedConnect = time(0);
return 1;
}
//g_object_ref (conn->conn);
g_socket_set_keepalive(conn->conn, TRUE);
int fd = g_socket_get_fd(conn->conn);
conn->readWatch = moloch_watch_fd(fd, MOLOCH_GIO_READ_COND, moloch_http_read_cb, conn);
if (!blocking) {
conn->writeWatch = moloch_watch_fd(fd, G_IO_OUT, moloch_http_conn_cb, conn);
DEBUGCONN("AAA connwritewatch %s %p fd:%d ww:%d", conn->server->names[0], conn, fd, conn->writeWatch);
}
int sendbuff = 0;
socklen_t optlen = sizeof(sendbuff);
int res = getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, &optlen);
if(res != -1 && sendbuff < 300000) {
sendbuff = 300000;
setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendbuff, sizeof(sendbuff));
}
#ifdef TCP_KEEPIDLE
res = getsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &sendbuff, &optlen);
if(res != -1 && sendbuff > 60*8) {
sendbuff = 60*8;
setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &sendbuff, sizeof(sendbuff));
}
#endif
gettimeofday(&stopTime, NULL);
if (config.logESRequests)
LOG("Connecting %p %s %d %d %ldms", (void*)conn, name, defaultport, blocking,
(stopTime.tv_sec - startTime.tv_sec)*1000 + (stopTime.tv_usec - startTime.tv_usec)/1000);
return 0;
}
static gboolean
gst_interpolation_control_source_bind (GstControlSource * source,
GParamSpec * pspec)
{
GType type, base;
GstInterpolationControlSource *self =
GST_INTERPOLATION_CONTROL_SOURCE (source);
gboolean ret = TRUE;
/* get the fundamental base type */
self->priv->type = base = type = G_PARAM_SPEC_VALUE_TYPE (pspec);
while ((type = g_type_parent (type)))
base = type;
self->priv->base = base;
/* restore type */
type = self->priv->type;
if (!gst_interpolation_control_source_set_interpolation_mode (self,
self->priv->interpolation_mode))
return FALSE;
switch (base) {
case G_TYPE_INT:{
GParamSpecInt *tpspec = G_PARAM_SPEC_INT (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_int (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_int (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_int (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_UINT:{
GParamSpecUInt *tpspec = G_PARAM_SPEC_UINT (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_uint (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_uint (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_uint (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_LONG:{
GParamSpecLong *tpspec = G_PARAM_SPEC_LONG (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_long (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_long (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_long (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_ULONG:{
GParamSpecULong *tpspec = G_PARAM_SPEC_ULONG (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_ulong (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_ulong (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_ulong (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_INT64:{
GParamSpecInt64 *tpspec = G_PARAM_SPEC_INT64 (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_int64 (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_int64 (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_int64 (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_UINT64:{
GParamSpecUInt64 *tpspec = G_PARAM_SPEC_UINT64 (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_uint64 (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_uint64 (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_uint64 (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_FLOAT:{
GParamSpecFloat *tpspec = G_PARAM_SPEC_FLOAT (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_float (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_float (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_float (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_DOUBLE:{
GParamSpecDouble *tpspec = G_PARAM_SPEC_DOUBLE (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_double (&self->priv->default_value, tpspec->default_value);
g_value_init (&self->priv->minimum_value, type);
g_value_set_double (&self->priv->minimum_value, tpspec->minimum);
g_value_init (&self->priv->maximum_value, type);
g_value_set_double (&self->priv->maximum_value, tpspec->maximum);
break;
}
case G_TYPE_BOOLEAN:{
GParamSpecBoolean *tpspec = G_PARAM_SPEC_BOOLEAN (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_boolean (&self->priv->default_value, tpspec->default_value);
break;
}
case G_TYPE_ENUM:{
GParamSpecEnum *tpspec = G_PARAM_SPEC_ENUM (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_enum (&self->priv->default_value, tpspec->default_value);
break;
}
case G_TYPE_STRING:{
GParamSpecString *tpspec = G_PARAM_SPEC_STRING (pspec);
g_value_init (&self->priv->default_value, type);
g_value_set_string (&self->priv->default_value, tpspec->default_value);
break;
}
default:
GST_WARNING ("incomplete implementation for paramspec type '%s'",
G_PARAM_SPEC_TYPE_NAME (pspec));
ret = FALSE;
break;
}
if (ret) {
self->priv->valid_cache = FALSE;
self->priv->nvalues = 0;
} else {
gst_interpolation_control_source_reset (self);
}
return ret;
}
//Cell edit handler.
//Todo: why is this getting called on double-click when the text box hasn't
//popped up yet?
static void on_cell_edit(GtkCellRendererText *renderer, gchar *path, gchar *new_text, gpointer user_data)
{
int i, j;
GtkTreeIter iter;
GValue newval, val_addr, val_type, val_offset;
uint32 addr, type, value, offset;
uint64 value64;
float valuef;
double valued;
char formatted[18]; //for reading hex64 values
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store), &iter, path);
memset(&newval, 0, sizeof(newval));
memset(&val_addr, 0, sizeof(val_addr));
memset(&val_type, 0, sizeof(val_type));
memset(&val_offset, 0, sizeof(val_offset));
switch((long)user_data) //column number
{
case Col_Name:
g_value_init(&newval, G_TYPE_STRING);
g_value_set_string(&newval, new_text);
break;
case Col_Value:
//Get address
gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Address, &val_addr);
addr = g_value_get_int(&val_addr);
//Get type
gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Type, &val_type);
type = g_value_get_int(&val_type);
//Get offset
gtk_tree_model_get_value(GTK_TREE_MODEL(store), &iter, Col_Offset, &val_offset);
offset = g_value_get_int(&val_offset);
//If pointer, follow it.
if(type & Type_pointer)
{
type &= ~Type_pointer;
addr = read_memory_32(addr) + offset;
}
//Get new value and write.
//Todo: should not write if value is invalid, or strip any non-
//numeric characters from value, to avoid the annoying bug where
//you make a typo and it gets set to zero.
//If we just copy the current value into the variables sscanf() is
//supposed to set, it won't change them when the format string is
//invalid. Not sure what happens if it's too long.
switch(type)
{
case Type_int8:
sscanf(new_text, "%d", &value);
write_memory_8(addr, value);
break;
case Type_int16:
sscanf(new_text, "%d", &value);
write_memory_16(addr, value);
break;
case Type_int32:
sscanf(new_text, "%d", &value);
write_memory_32(addr, value);
break;
case Type_int64:
sscanf(new_text, "%" PRId64, &value64);
write_memory_64(addr, value64);
break;
case Type_uint8:
sscanf(new_text, "%u", &value);
write_memory_8(addr, value);
break;
case Type_uint16:
sscanf(new_text, "%u", &value);
write_memory_16(addr, value);
break;
case Type_uint32:
sscanf(new_text, "%u", &value);
write_memory_32(addr, value);
break;
case Type_uint64:
sscanf(new_text, "%" PRIu64, &value64);
write_memory_64(addr, value64);
break;
case Type_hex8:
sscanf(new_text, "%X", &value);
write_memory_8(addr, value);
break;
case Type_hex16:
sscanf(new_text, "%X", &value);
write_memory_16(addr, value);
break;
case Type_hex32:
sscanf(new_text, "%X", &value);
write_memory_32(addr, value);
break;
case Type_hex64:
//Copy new text without spaces so it can be parsed correctly.
j = 0;
for(i=0; new_text[i]; i++)
{
if(new_text[i] == ' ') continue;
formatted[j] = new_text[i];
j++;
}
formatted[j] = '\0';
sscanf(formatted, "%" PRIX64, &value64);
write_memory_64(addr, value64);
break;
case Type_float:
//todo: the value needs to be converted to IEEE 754 somehow.
sscanf(new_text, "%f", &valuef);
write_memory_32(addr, (int)value);
break;
case Type_double:
sscanf(new_text, "%lf", &valued);
write_memory_64(addr, (uint64)value);
break;
default:
printf("on_cell_edit(): unknown type %d in \"%s\", col %d\n", type, path, (int)(long)user_data);
return;
break;
}
break;
case Col_Address:
g_value_init(&newval, G_TYPE_INT);
sscanf(new_text, "%X", &addr);
g_value_set_int(&newval, addr);
break;
case Col_Type:
//todo - this should actually be a dropdown list, not editable,
//if I had any idea how to do that.
if(strlen(new_text) > 2) return; //so "float" doesn't get parsed as 0xF
addr = 0x7F;
g_value_init(&newval, G_TYPE_INT);
sscanf(new_text, "%X", &addr);
if((addr & 0x7F) >= Num_Types) return;
g_value_set_int(&newval, addr);
break;
case Col_Offset:
g_value_init(&newval, G_TYPE_INT);
sscanf(new_text, "%X", &addr);
g_value_set_int(&newval, addr);
break;
}
if((long)user_data != Col_Value)
gtk_tree_store_set_value(store, &iter, (int)(long)user_data, &newval);
}