GValueArray * plug_in_params_to_args (GParamSpec **pspecs, gint n_pspecs, GPParam *params, gint n_params, gboolean return_values, gboolean full_copy) { GValueArray *args; gint i; g_return_val_if_fail ((pspecs != NULL && n_pspecs > 0) || (pspecs == NULL && n_pspecs == 0), NULL); g_return_val_if_fail ((params != NULL && n_params > 0) || (params == NULL && n_params == 0), NULL); args = g_value_array_new (n_params); for (i = 0; i < n_params; i++) { GValue value = { 0, }; GType type; gint count; /* first get the fallback compat GType that matches the pdb type */ type = gimp_pdb_compat_arg_type_to_gtype (params[i].type); /* then try to try to be more specific by looking at the param * spec (return values have one additional value (the status), * skip that, it's not in the array of param specs) */ if (i > 0 || ! return_values) { gint pspec_index = i; if (return_values) pspec_index--; /* are there param specs left? */ if (pspec_index < n_pspecs) { GimpPDBArgType pspec_arg_type; pspec_arg_type = gimp_pdb_compat_arg_type_from_gtype (G_PARAM_SPEC_VALUE_TYPE (pspecs[pspec_index])); /* if the param spec's GType, mapped to a pdb type, matches * the passed pdb type, use the param spec's GType */ if (pspec_arg_type == params[i].type) { type = G_PARAM_SPEC_VALUE_TYPE (pspecs[pspec_index]); } } } g_value_init (&value, type); switch (gimp_pdb_compat_arg_type_from_gtype (type)) { case GIMP_PDB_INT32: if (G_VALUE_HOLDS_INT (&value)) g_value_set_int (&value, params[i].data.d_int32); else if (G_VALUE_HOLDS_UINT (&value)) g_value_set_uint (&value, params[i].data.d_int32); else if (G_VALUE_HOLDS_ENUM (&value)) g_value_set_enum (&value, params[i].data.d_int32); else if (G_VALUE_HOLDS_BOOLEAN (&value)) g_value_set_boolean (&value, params[i].data.d_int32 ? TRUE : FALSE); else { g_printerr ("%s: unhandled GIMP_PDB_INT32 type: %s\n", G_STRFUNC, g_type_name (G_VALUE_TYPE (&value))); g_return_val_if_reached (args); } break; case GIMP_PDB_INT16: g_value_set_int (&value, params[i].data.d_int16); break; case GIMP_PDB_INT8: g_value_set_uint (&value, params[i].data.d_int8); break; case GIMP_PDB_FLOAT: g_value_set_double (&value, params[i].data.d_float); break; case GIMP_PDB_STRING: if (full_copy) g_value_set_string (&value, params[i].data.d_string); else g_value_set_static_string (&value, params[i].data.d_string); break; case GIMP_PDB_INT32ARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_int32array (&value, params[i].data.d_int32array, count); else gimp_value_set_static_int32array (&value, params[i].data.d_int32array, count); break; case GIMP_PDB_INT16ARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_int16array (&value, params[i].data.d_int16array, count); else gimp_value_set_static_int16array (&value, params[i].data.d_int16array, count); break; case GIMP_PDB_INT8ARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_int8array (&value, params[i].data.d_int8array, count); else gimp_value_set_static_int8array (&value, params[i].data.d_int8array, count); break; case GIMP_PDB_FLOATARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_floatarray (&value, params[i].data.d_floatarray, count); else gimp_value_set_static_floatarray (&value, params[i].data.d_floatarray, count); break; case GIMP_PDB_STRINGARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_stringarray (&value, (const gchar **) params[i].data.d_stringarray, count); else gimp_value_set_static_stringarray (&value, (const gchar **) params[i].data.d_stringarray, count); break; case GIMP_PDB_COLOR: gimp_value_set_rgb (&value, ¶ms[i].data.d_color); break; case GIMP_PDB_ITEM: g_value_set_int (&value, params[i].data.d_item); break; case GIMP_PDB_DISPLAY: g_value_set_int (&value, params[i].data.d_display); break; case GIMP_PDB_IMAGE: g_value_set_int (&value, params[i].data.d_image); break; case GIMP_PDB_LAYER: g_value_set_int (&value, params[i].data.d_layer); break; case GIMP_PDB_CHANNEL: g_value_set_int (&value, params[i].data.d_channel); break; case GIMP_PDB_DRAWABLE: g_value_set_int (&value, params[i].data.d_drawable); break; case GIMP_PDB_SELECTION: g_value_set_int (&value, params[i].data.d_selection); break; case GIMP_PDB_COLORARRAY: count = g_value_get_int (&args->values[i - 1]); if (full_copy) gimp_value_set_colorarray (&value, params[i].data.d_colorarray, count); else gimp_value_set_static_colorarray (&value, params[i].data.d_colorarray, count); break; case GIMP_PDB_VECTORS: g_value_set_int (&value, params[i].data.d_vectors); break; case GIMP_PDB_PARASITE: if (full_copy) g_value_set_boxed (&value, ¶ms[i].data.d_parasite); else g_value_set_static_boxed (&value, ¶ms[i].data.d_parasite); break; case GIMP_PDB_STATUS: g_value_set_enum (&value, params[i].data.d_status); break; case GIMP_PDB_END: break; } g_value_array_append (args, &value); g_value_unset (&value); } return args; }
gboolean gvalue_util_set_value_from_string (GValue *value, const char *str) { GValue tmp_value = {0, }; int i; long l; double d; g_return_val_if_fail (str != NULL, FALSE); switch (G_VALUE_TYPE (value)) { case G_TYPE_STRING: g_value_set_string (value, str); break; case G_TYPE_CHAR: #if GLIB_CHECK_VERSION(2,32,0) g_value_set_schar (value, *str); #else g_value_set_char (value, *str); #endif break; case G_TYPE_UCHAR: g_value_set_uchar (value, *str); break; case G_TYPE_INT: i = atoi (str); g_value_set_int (value, i); break; case G_TYPE_UINT: i = atoi (str); g_value_set_uint (value, (guint) i); break; case G_TYPE_INT64: i = atoi (str); g_value_set_int64 (value, (gint64) i); break; case G_TYPE_UINT64: i = atoi (str); g_value_set_uint64 (value, (guint64) i); break; case G_TYPE_LONG: l = atol (str); g_value_set_long (value, l); break; case G_TYPE_ULONG: l = atol (str); g_value_set_ulong (value, (gulong) l); break; case G_TYPE_FLOAT: d = atof (str); g_value_set_float (value, (float) d); break; case G_TYPE_DOUBLE: d = atof (str); g_value_set_float (value, d); break; case G_TYPE_BOOLEAN: if (g_ascii_strcasecmp (str, "true") == 0 || g_ascii_strcasecmp (str, "yes") == 0) g_value_set_boolean (value, TRUE); else if (g_ascii_strcasecmp (str, "false") == 0 || g_ascii_strcasecmp (str, "no") == 0) g_value_set_boolean (value, FALSE); else { i = atoi (str); g_value_set_boolean (value, i ? TRUE : FALSE); } break; default: /* Try to convert */ if (g_value_type_transformable (G_TYPE_STRING, G_VALUE_TYPE (value))) { g_value_init (&tmp_value, G_TYPE_STRING); g_value_set_static_string (&tmp_value, str); g_value_transform (&tmp_value, value); g_value_unset (&tmp_value); } else if (g_value_type_transformable (G_TYPE_INT, G_VALUE_TYPE (value))) { i = atoi (str); g_value_init (&tmp_value, G_TYPE_INT); g_value_set_int (&tmp_value, i); g_value_transform (&tmp_value, value); g_value_unset (&tmp_value); } else { g_warning ("Failed to transform integer " "value to type %s", G_VALUE_TYPE_NAME (value)); return FALSE; } break; } return TRUE; }
END_TEST #ifndef HILDON_DISABLE_DEPRECATED /* ----- Test case for new_confirmation_with_icon_name -----*/ /** * Purpose: Check that note dialog is properly created with description regular values. * Cases considered: * - Create new confirmation note with description set to TEST_STRING and icon name "control_calibration_target". * - Create new confirmation note with description set to "" and icon name NULL. * */ START_TEST (test_new_confirmation_with_icon_name_regular) { const gchar * description = NULL; const gchar * ret_description = NULL; const gchar *icon_name = NULL; const gchar * ret_icon_name = NULL; GValue value= {0, }; GValue icon_name_value= {0, }; GValue enum_value= {0, }; HildonNoteType note_type; g_value_init (&value, G_TYPE_STRING); g_value_init (&icon_name_value, G_TYPE_STRING); g_value_init (&enum_value, G_TYPE_INT); /* Test 1: create new confirmation note with description set to TEST_STRING */ description = TEST_STRING; icon_name="control_calibration_target"; note = HILDON_NOTE(hildon_note_new_confirmation_with_icon_name(n_window,description,icon_name)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_confirmation_with_icon_name"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_CONFIRMATION, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_CONFIRMATION)",note_type); g_object_get_property(G_OBJECT (note),"icon",&icon_name_value); ret_icon_name = g_value_get_string (&icon_name_value); fail_if( strcmp (icon_name,ret_icon_name) != 0, "hildon-note: icon_name (%s) was not set properly on creation. Returned icon_name: %s", icon_name,ret_icon_name); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; /* Test 2: create new confirmation note with description set to "" and icon name set to NULL */ description = ""; icon_name=NULL; note = HILDON_NOTE(hildon_note_new_confirmation_with_icon_name(n_window,description,icon_name)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_confirmation_with_icon_name"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_CONFIRMATION, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_CONFIRMATION)",note_type); g_object_get_property(G_OBJECT (note),"icon",&icon_name_value); ret_icon_name = g_value_get_string (&icon_name_value); fail_if( ret_icon_name != NULL, "hildon-note: icon_name (%s) was not set properly on creation. Returned icon_name: %s", icon_name,ret_icon_name); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; g_value_unset(&value); g_value_unset(&icon_name_value); g_value_unset(&enum_value); }
static void g_value_type_unref(gpointer instance) { g_value_unset(instance); }
static gboolean gdk_x11_screen_get_setting (GdkScreen *screen, const gchar *name, GValue *value) { const char *xsettings_name = NULL; XSettingsResult result; XSettingsSetting *setting = NULL; GdkX11Screen *x11_screen; gboolean success = FALSE; gint i; GValue tmp_val = G_VALUE_INIT; g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE); x11_screen = GDK_X11_SCREEN (screen); for (i = 0; i < GDK_SETTINGS_N_ELEMENTS(); i++) if (strcmp (GDK_SETTINGS_GDK_NAME (i), name) == 0) { xsettings_name = GDK_SETTINGS_X_NAME (i); break; } if (!xsettings_name) goto out; result = xsettings_client_get_setting (x11_screen->xsettings_client, xsettings_name, &setting); if (result != XSETTINGS_SUCCESS) goto out; switch (setting->type) { case XSETTINGS_TYPE_INT: if (check_transform (xsettings_name, G_TYPE_INT, G_VALUE_TYPE (value))) { g_value_init (&tmp_val, G_TYPE_INT); g_value_set_int (&tmp_val, setting->data.v_int); g_value_transform (&tmp_val, value); success = TRUE; } break; case XSETTINGS_TYPE_STRING: if (check_transform (xsettings_name, G_TYPE_STRING, G_VALUE_TYPE (value))) { g_value_init (&tmp_val, G_TYPE_STRING); g_value_set_string (&tmp_val, setting->data.v_string); g_value_transform (&tmp_val, value); success = TRUE; } break; case XSETTINGS_TYPE_COLOR: if (!check_transform (xsettings_name, GDK_TYPE_RGBA, G_VALUE_TYPE (value))) { GdkRGBA rgba; g_value_init (&tmp_val, GDK_TYPE_RGBA); rgba.red = setting->data.v_color.red / 65535.0; rgba.green = setting->data.v_color.green / 65535.0; rgba.blue = setting->data.v_color.blue / 65535.0; rgba.alpha = setting->data.v_color.alpha / 65535.0; g_value_set_boxed (&tmp_val, &rgba); g_value_transform (&tmp_val, value); success = TRUE; } break; } g_value_unset (&tmp_val); out: if (setting) xsettings_setting_free (setting); if (success) return TRUE; else return _gdk_x11_get_xft_setting (screen, name, value); }
/*! * \brief CvCapture_GStreamer::open Open the given file with gstreamer * \param type CvCapture type. One of CV_CAP_GSTREAMER_* * \param filename Filename to open in case of CV_CAP_GSTREAMER_FILE * \return boolean. Specifies if opening was succesful. * * In case of CV_CAP_GSTREAMER_V4L(2), a pipelin is constructed as follows: * v4l2src ! autoconvert ! appsink * * * The 'filename' parameter is not limited to filesystem paths, and may be one of the following: * * - a normal filesystem path: * e.g. video.avi or /path/to/video.avi or C:\\video.avi * - an uri: * e.g. file:///path/to/video.avi or rtsp:///path/to/stream.asf * - a gstreamer pipeline description: * e.g. videotestsrc ! videoconvert ! appsink * the appsink name should be either 'appsink0' (the default) or 'opencvsink' * * When dealing with a file, CvCapture_GStreamer will not drop frames if the grabbing interval * larger than the framerate period. (Unlike the uri or manual pipeline description, which assume * a live source) * * The pipeline will only be started whenever the first frame is grabbed. Setting pipeline properties * is really slow if we need to restart the pipeline over and over again. * * TODO: the 'type' parameter is imo unneeded. for v4l2, filename 'v4l2:///dev/video0' can be used. * I expect this to be the same for CV_CAP_GSTREAMER_1394. Is anyone actually still using v4l (v1)? * */ bool CvCapture_GStreamer::open( int type, const char* filename ) { CV_FUNCNAME("cvCaptureFromCAM_GStreamer"); __BEGIN__; gst_initializer::init(); bool stream = false; bool manualpipeline = false; char *uri = NULL; uridecodebin = NULL; GstElementFactory * testfac; if (type == CV_CAP_GSTREAMER_V4L){ testfac = gst_element_factory_find("v4lsrc"); if (!testfac){ return false; } g_object_unref(G_OBJECT(testfac)); filename = "v4lsrc ! "COLOR_ELEM" ! appsink"; } if (type == CV_CAP_GSTREAMER_V4L2){ testfac = gst_element_factory_find("v4l2src"); if (!testfac){ return false; } g_object_unref(G_OBJECT(testfac)); filename = "v4l2src ! "COLOR_ELEM" ! appsink"; } // test if we have a valid uri. If so, open it with an uridecodebin // else, we might have a file or a manual pipeline. // if gstreamer cannot parse the manual pipeline, we assume we were given and // ordinary file path. if(!gst_uri_is_valid(filename)) { uri = realpath(filename, NULL); stream = false; if(uri) { uri = g_filename_to_uri(uri, NULL, NULL); if(!uri) { CV_WARN("GStreamer: Error opening file\n"); close(); return false; } } else { GError *err = NULL; uridecodebin = gst_parse_launch(filename, &err); if(!uridecodebin) { //fprintf(stderr, "GStreamer: Error opening bin: %s\n", err->message); //close(); return false; } stream = true; manualpipeline = true; } } else { stream = true; uri = g_strdup(filename); } bool element_from_uri = false; if(!uridecodebin) { // At this writing, the v4l2 element (and maybe others too) does not support caps renegotiation. // This means that we cannot use an uridecodebin when dealing with v4l2, since setting // capture properties will not work. // The solution (probably only until gstreamer 1.2) is to make an element from uri when dealing with v4l2. gchar * protocol = gst_uri_get_protocol(uri); if (!strcasecmp(protocol , "v4l2")) { #if GST_VERSION_MAJOR == 0 uridecodebin = gst_element_make_from_uri(GST_URI_SRC, uri, "src"); #else uridecodebin = gst_element_make_from_uri(GST_URI_SRC, uri, "src", NULL); #endif element_from_uri = true; }else{ uridecodebin = gst_element_factory_make ("uridecodebin", NULL); g_object_set(G_OBJECT(uridecodebin),"uri",uri, NULL); } g_free(protocol); if(!uridecodebin) { //fprintf(stderr, "GStreamer: Error opening bin: %s\n", err->message); close(); return false; } } if(manualpipeline) { GstIterator *it = NULL; #if GST_VERSION_MAJOR == 0 it = gst_bin_iterate_sinks(GST_BIN(uridecodebin)); if(gst_iterator_next(it, (gpointer *)&sink) != GST_ITERATOR_OK) { CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n"); return false; } #else it = gst_bin_iterate_sinks (GST_BIN(uridecodebin)); gboolean done = FALSE; GstElement *element = NULL; gchar* name = NULL; GValue value = G_VALUE_INIT; while (!done) { switch (gst_iterator_next (it, &value)) { case GST_ITERATOR_OK: element = GST_ELEMENT (g_value_get_object (&value)); name = gst_element_get_name(element); if (name){ if(strstr(name, "opencvsink") != NULL || strstr(name, "appsink") != NULL) { sink = GST_ELEMENT ( gst_object_ref (element) ); done = TRUE; } g_free(name); } g_value_unset (&value); break; case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = TRUE; break; } } gst_iterator_free (it); if (!sink){ CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n"); return false; } #endif pipeline = uridecodebin; } else { pipeline = gst_pipeline_new (NULL); // videoconvert (in 0.10: ffmpegcolorspace) automatically selects the correct colorspace // conversion based on caps. color = gst_element_factory_make(COLOR_ELEM, NULL); sink = gst_element_factory_make("appsink", NULL); gst_bin_add_many(GST_BIN(pipeline), uridecodebin, color, sink, NULL); if(element_from_uri) { if(!gst_element_link(uridecodebin, color)) { CV_ERROR(CV_StsError, "GStreamer: cannot link color -> sink\n"); gst_object_unref(pipeline); return false; } }else{ g_signal_connect(uridecodebin, "pad-added", G_CALLBACK(newPad), color); } if(!gst_element_link(color, sink)) { CV_ERROR(CV_StsError, "GStreamer: cannot link color -> sink\n"); gst_object_unref(pipeline); return false; } } //TODO: is 1 single buffer really high enough? gst_app_sink_set_max_buffers (GST_APP_SINK(sink), 1); gst_app_sink_set_drop (GST_APP_SINK(sink), stream); //do not emit signals: all calls will be synchronous and blocking gst_app_sink_set_emit_signals (GST_APP_SINK(sink), 0); #if GST_VERSION_MAJOR == 0 caps = gst_caps_new_simple("video/x-raw-rgb", "bpp", G_TYPE_INT, 24, "red_mask", G_TYPE_INT, 0x0000FF, "green_mask", G_TYPE_INT, 0x00FF00, "blue_mask", G_TYPE_INT, 0xFF0000, NULL); #else // support 1 and 3 channel 8 bit data, as well as bayer (also 1 channel, 8bit) caps = gst_caps_from_string("video/x-raw, format=(string){BGR, GRAY8}; video/x-bayer,format=(string){rggb,bggr,grbg,gbrg}"); #endif gst_app_sink_set_caps(GST_APP_SINK(sink), caps); gst_caps_unref(caps); //we do not start recording here just yet. // the user probably wants to set capture properties first, so start recording whenever the first frame is requested __END__; return true; }
/* * debug_dump_element: * @bin: the bin that should be analyzed * @out: file to write to * @indent: level of graph indentation * * Helper for gst_debug_bin_to_dot_file() to recursively dump a pipeline. */ static void debug_dump_element (GstBin * bin, GstDebugGraphDetails details, FILE * out, const gint indent) { GstIterator *element_iter, *pad_iter; gboolean elements_done, pads_done; GValue item = { 0, }; GValue item2 = { 0, }; GstElement *element; GstPad *pad = NULL; guint src_pads, sink_pads; gchar *element_name; gchar *state_name = NULL; gchar *param_name = NULL; const gchar *spc = &spaces[MAX (sizeof (spaces) - (1 + indent * 2), 0)]; element_iter = gst_bin_iterate_elements (bin); elements_done = FALSE; while (!elements_done) { switch (gst_iterator_next (element_iter, &item)) { case GST_ITERATOR_OK: element = g_value_get_object (&item); element_name = debug_dump_make_object_name (GST_OBJECT (element)); if (details & GST_DEBUG_GRAPH_SHOW_STATES) { state_name = debug_dump_get_element_state (GST_ELEMENT (element)); } if (details & GST_DEBUG_GRAPH_SHOW_NON_DEFAULT_PARAMS) { param_name = debug_dump_get_element_params (GST_ELEMENT (element)); } /* elements */ fprintf (out, "%ssubgraph cluster_%s {\n", spc, element_name); fprintf (out, "%s fontname=\"Bitstream Vera Sans\";\n", spc); fprintf (out, "%s fontsize=\"8\";\n", spc); fprintf (out, "%s style=filled;\n", spc); fprintf (out, "%s color=black;\n\n", spc); fprintf (out, "%s label=\"%s\\n%s%s%s\";\n", spc, G_OBJECT_TYPE_NAME (element), GST_OBJECT_NAME (element), (state_name ? state_name : ""), (param_name ? param_name : "") ); if (state_name) { g_free (state_name); state_name = NULL; } if (param_name) { g_free (param_name); param_name = NULL; } g_free (element_name); src_pads = sink_pads = 0; if ((pad_iter = gst_element_iterate_sink_pads (element))) { debug_dump_element_pads (pad_iter, pad, element, details, out, indent, &src_pads, &sink_pads); gst_iterator_free (pad_iter); } if ((pad_iter = gst_element_iterate_src_pads (element))) { debug_dump_element_pads (pad_iter, pad, element, details, out, indent, &src_pads, &sink_pads); gst_iterator_free (pad_iter); } if (GST_IS_BIN (element)) { fprintf (out, "%s fillcolor=\"#ffffff\";\n", spc); /* recurse */ debug_dump_element (GST_BIN (element), details, out, indent + 1); } else { if (src_pads && !sink_pads) fprintf (out, "%s fillcolor=\"#ffaaaa\";\n", spc); else if (!src_pads && sink_pads) fprintf (out, "%s fillcolor=\"#aaaaff\";\n", spc); else if (src_pads && sink_pads) fprintf (out, "%s fillcolor=\"#aaffaa\";\n", spc); else fprintf (out, "%s fillcolor=\"#ffffff\";\n", spc); } fprintf (out, "%s}\n\n", spc); if ((pad_iter = gst_element_iterate_pads (element))) { pads_done = FALSE; while (!pads_done) { switch (gst_iterator_next (pad_iter, &item2)) { case GST_ITERATOR_OK: pad = g_value_get_object (&item2); if (gst_pad_is_linked (pad)) { if (gst_pad_get_direction (pad) == GST_PAD_SRC) { debug_dump_element_pad_link (pad, element, details, out, indent); } else { GstPad *peer_pad = gst_pad_get_peer (pad); if (peer_pad) { if (!GST_IS_GHOST_PAD (peer_pad) && GST_IS_PROXY_PAD (peer_pad)) { debug_dump_element_pad_link (peer_pad, NULL, details, out, indent); } gst_object_unref (peer_pad); } } } g_value_reset (&item2); break; case GST_ITERATOR_RESYNC: gst_iterator_resync (pad_iter); break; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: pads_done = TRUE; break; } } g_value_unset (&item2); gst_iterator_free (pad_iter); } g_value_reset (&item); break; case GST_ITERATOR_RESYNC: gst_iterator_resync (element_iter); break; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: elements_done = TRUE; break; } } g_value_unset (&item); gst_iterator_free (element_iter); }
static void run_shm_transmitter_test (gint flags) { GError *error = NULL; FsTransmitter *trans; FsStreamTransmitter *st; GstBus *bus = NULL; GParameter params[1]; GList *local_cands = NULL; GstStateChangeReturn ret; FsCandidate *cand; GList *remote_cands = NULL; int param_count = 0; gint bus_source; done = FALSE; connected_count = 0; g_cond_init (&cond); g_mutex_init (&test_mutex); buffer_count[0] = 0; buffer_count[1] = 0; received_known[0] = 0; received_known[1] = 0; got_candidates[0] = FALSE; got_candidates[1] = FALSE; got_prepared[0] = FALSE; got_prepared[1] = FALSE; if (unlink ("/tmp/src1") < 0 && errno != ENOENT) fail ("Could not unlink /tmp/src1: %s", strerror (errno)); if (unlink ("/tmp/src2") < 0 && errno != ENOENT) fail ("Could not unlink /tmp/src2: %s", strerror (errno)); local_cands = g_list_append (local_cands, fs_candidate_new (NULL, 1, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, "/tmp/src1", 0)); local_cands = g_list_append (local_cands, fs_candidate_new (NULL, 2, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, "/tmp/src2", 0)); if (flags & FLAG_LOCAL_CANDIDATES) { memset (params, 0, sizeof (GParameter)); params[0].name = "preferred-local-candidates"; g_value_init (¶ms[0].value, FS_TYPE_CANDIDATE_LIST); g_value_take_boxed (¶ms[0].value, local_cands); param_count = 1; } associate_on_source = !(flags & FLAG_NO_SOURCE); if ((flags & FLAG_NOT_SENDING) && (flags & FLAG_RECVONLY_FILTER)) { buffer_count[0] = 20; received_known[0] = 20; } trans = fs_transmitter_new ("shm", 2, 0, &error); if (error) ts_fail ("Error creating transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (trans == NULL, "No transmitter create, yet error is still NULL"); g_clear_error (&error); if (flags & FLAG_RECVONLY_FILTER) ts_fail_unless (g_signal_connect (trans, "get-recvonly-filter", G_CALLBACK (get_recvonly_filter), NULL)); pipeline = setup_pipeline (trans, G_CALLBACK (_handoff_handler)); bus = gst_element_get_bus (pipeline); bus_source = gst_bus_add_watch (bus, bus_error_callback, NULL); gst_bus_enable_sync_message_emission (bus); g_signal_connect (bus, "sync-message::error", G_CALLBACK (sync_error_handler), NULL); gst_object_unref (bus); st = fs_transmitter_new_stream_transmitter (trans, NULL, param_count, params, &error); if (param_count) g_value_unset (¶ms[0].value); if (error) ts_fail ("Error creating stream transmitter: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_if (st == NULL, "No stream transmitter created, yet error is NULL"); g_clear_error (&error); g_object_set (st, "sending", !(flags & FLAG_NOT_SENDING), NULL); ts_fail_unless (g_signal_connect (st, "new-local-candidate", G_CALLBACK (_new_local_candidate), trans), "Could not connect new-local-candidate signal"); ts_fail_unless (g_signal_connect (st, "local-candidates-prepared", G_CALLBACK (_candidate_prepared), NULL), "Could not connect local-candidates-prepared signal"); ts_fail_unless (g_signal_connect (st, "error", G_CALLBACK (stream_transmitter_error), NULL), "Could not connect error signal"); ts_fail_unless (g_signal_connect (st, "known-source-packet-received", G_CALLBACK (_known_source_packet_received), NULL), "Could not connect known-source-packet-received signal"); ts_fail_unless (g_signal_connect (st, "state-changed", G_CALLBACK (_state_changed), NULL), "Could not connect state-changed signal"); if (!fs_stream_transmitter_gather_local_candidates (st, &error)) { if (error) ts_fail ("Could not start gathering local candidates (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); else ts_fail ("Could not start gathering candidates" " (without a specified error)"); } else { ts_fail_unless (error == NULL); } g_clear_error (&error); ret = gst_element_set_state (pipeline, GST_STATE_PLAYING); ts_fail_if (ret == GST_STATE_CHANGE_FAILURE, "Could not set the pipeline to playing"); if (!(flags & FLAG_LOCAL_CANDIDATES)) { ret = fs_stream_transmitter_force_remote_candidates (st, local_cands, &error); fs_candidate_list_destroy (local_cands); if (error) ts_fail ("Error while adding candidate: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate"); } else { ts_fail_unless (error == NULL); } g_clear_error (&error); cand = fs_candidate_new (NULL, 1, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, NULL, 0); cand->username = g_strdup ("/tmp/src1"); remote_cands = g_list_prepend (remote_cands, cand); cand = fs_candidate_new (NULL, 2, FS_CANDIDATE_TYPE_HOST, FS_NETWORK_PROTOCOL_UDP, NULL, 0); cand->username = g_strdup ("/tmp/src2"); remote_cands = g_list_prepend (remote_cands, cand); ret = fs_stream_transmitter_force_remote_candidates (st, remote_cands, &error); fs_candidate_list_destroy (remote_cands); if (error) ts_fail ("Error while adding candidate: (%s:%d) %s", g_quark_to_string (error->domain), error->code, error->message); ts_fail_unless (ret == TRUE, "No detailed error from add_remote_candidate"); g_clear_error (&error); g_mutex_lock (&test_mutex); while (connected_count < 2) g_cond_wait (&cond, &test_mutex); g_mutex_unlock (&test_mutex); setup_fakesrc (trans, pipeline, 1); setup_fakesrc (trans, pipeline, 2); g_mutex_lock (&test_mutex); while (!done) g_cond_wait (&cond, &test_mutex); g_mutex_unlock (&test_mutex); fail_unless (got_prepared[0] == TRUE); fail_unless (got_prepared[1] == TRUE); fail_unless (got_candidates[0] == TRUE); fail_unless (got_candidates[1] == TRUE); gst_element_set_state (pipeline, GST_STATE_NULL); if (st) { fs_stream_transmitter_stop (st); g_object_unref (st); } g_object_unref (trans); g_source_remove (bus_source); gst_object_unref (pipeline); g_cond_clear (&cond); g_mutex_clear (&test_mutex); }
static void device_changed_cb(const gchar *name, PurplePrefType type, gconstpointer value, gpointer data) { GtkSizeGroup *sg = data; GtkWidget *parent, *widget; GSList *widgets; GList *devices; GValue gvalue; gint position; gchar *label, *pref; widgets = gtk_size_group_get_widgets(GTK_SIZE_GROUP(sg)); for (; widgets; widgets = g_slist_next(widgets)) { const gchar *widget_name = gtk_widget_get_name(GTK_WIDGET(widgets->data)); if (!strcmp(widget_name, name)) { gchar *temp_str; gchar delimiters[3] = {0, 0, 0}; const gchar *text; gint keyval, pos; widget = widgets->data; /* Get label with _ from the GtkLabel */ text = gtk_label_get_text(GTK_LABEL(widget)); keyval = gtk_label_get_mnemonic_keyval(GTK_LABEL(widget)); delimiters[0] = g_ascii_tolower(keyval); delimiters[1] = g_ascii_toupper(keyval); pos = strcspn(text, delimiters); if (pos != -1) { temp_str = g_strndup(text, pos); label = g_strconcat(temp_str, "_", text + pos, NULL); g_free(temp_str); } else { label = g_strdup(text); } break; } } if (widgets == NULL) return; parent = gtk_widget_get_parent(widget); widget = parent; parent = gtk_widget_get_parent(GTK_WIDGET(widget)); gvalue.g_type = 0; g_value_init(&gvalue, G_TYPE_INT); gtk_container_child_get_property(GTK_CONTAINER(parent), GTK_WIDGET(widget), "position", &gvalue); position = g_value_get_int(&gvalue); g_value_unset(&gvalue); gtk_widget_destroy(widget); pref = g_strdup(name); strcpy(pref + strlen(pref) - strlen("plugin"), "device"); devices = get_element_devices(value); if (g_list_find_custom(devices, purple_prefs_get_string(pref), (GCompareFunc)strcmp) == NULL) purple_prefs_set_string(pref, g_list_next(devices)->data); widget = pidgin_prefs_dropdown_from_list(parent, label, PURPLE_PREF_STRING, pref, devices); g_list_free(devices); g_signal_connect_swapped(widget, "destroy", G_CALLBACK(g_free), pref); g_free(label); gtk_misc_set_alignment(GTK_MISC(widget), 0, 0.5); gtk_widget_set_name(widget, name); gtk_size_group_add_widget(sg, widget); gtk_box_reorder_child(GTK_BOX(parent), gtk_widget_get_parent(GTK_WIDGET(widget)), position); }
static gboolean get_modem_properties (DBusGConnection *connection, const char *path, char **device, char **data_device, char **driver, guint32 *type, guint32 *ip_method) { DBusGProxy *proxy; GValue value = { 0 }; GError *err = NULL; proxy = dbus_g_proxy_new_for_name (connection, MM_DBUS_SERVICE, path, "org.freedesktop.DBus.Properties"); if (dbus_g_proxy_call_with_timeout (proxy, "Get", 15000, &err, G_TYPE_STRING, MM_DBUS_INTERFACE_MODEM, G_TYPE_STRING, "Type", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { *type = g_value_get_uint (&value); g_value_unset (&value); } else { nm_log_warn (LOGD_MB, "could not get device type: %s", err->message); goto out; } if (dbus_g_proxy_call_with_timeout (proxy, "Get", 15000, &err, G_TYPE_STRING, MM_DBUS_INTERFACE_MODEM, G_TYPE_STRING, "MasterDevice", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { *device = g_value_dup_string (&value); g_value_unset (&value); } else { nm_log_warn (LOGD_MB, "could not get device: %s", err->message); goto out; } if (dbus_g_proxy_call_with_timeout (proxy, "Get", 15000, &err, G_TYPE_STRING, MM_DBUS_INTERFACE_MODEM, G_TYPE_STRING, "IpMethod", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { *ip_method = g_value_get_uint (&value); g_value_unset (&value); } else { nm_log_warn (LOGD_MB, "could not get IP method: %s", err->message); goto out; } if (dbus_g_proxy_call_with_timeout (proxy, "Get", 15000, &err, G_TYPE_STRING, MM_DBUS_INTERFACE_MODEM, G_TYPE_STRING, "Device", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { *data_device = g_value_dup_string (&value); g_value_unset (&value); } else { nm_log_warn (LOGD_MB, "could not get modem data device: %s", err->message); goto out; } if (dbus_g_proxy_call_with_timeout (proxy, "Get", 15000, &err, G_TYPE_STRING, MM_DBUS_INTERFACE_MODEM, G_TYPE_STRING, "Driver", G_TYPE_INVALID, G_TYPE_VALUE, &value, G_TYPE_INVALID)) { *driver = g_value_dup_string (&value); g_value_unset (&value); } else { nm_log_warn (LOGD_MB, "could not get modem driver: %s", err->message); goto out; } out: if (err) g_error_free (err); g_object_unref (proxy); return *data_device && *driver; }
void tp_g_value_slice_free (GValue *value) { g_value_unset (value); g_slice_free (GValue, value); }
static void gval_write(FILE *file, GValue *gval) { static gint indent = 0; gint ii; GType gtype; if (gval == NULL) return; gtype = G_VALUE_TYPE(gval); if (gtype == ghb_array_get_type()) { GValue *val; gint count; indent_fprintf(file, indent, "<array>\n"); indent++; count = ghb_array_len(gval); for (ii = 0; ii < count; ii++) { val = ghb_array_get_nth(gval, ii); gval_write(file, val); } indent--; indent_fprintf(file, indent, "</array>\n"); } else if (gtype == ghb_dict_get_type()) { GValue *val; GHashTable *dict = g_value_get_boxed(gval); GList *link, *keys; keys = g_hash_table_get_keys(dict); // Sort the dictionary. Not really necessray, but it makes // finding things easier keys = g_list_sort(keys, key_cmp); link = keys; indent_fprintf(file, indent, "<dict>\n"); indent++; while (link) { gchar *key = (gchar*)link->data; val = g_hash_table_lookup(dict, key); indent_fprintf(file, indent, "<key>%s</key>\n", key); gval_write(file, val); link = link->next; } indent--; indent_fprintf(file, indent, "</dict>\n"); g_list_free(keys); } else if (gtype == G_TYPE_BOOLEAN) { gchar *tag; if (g_value_get_boolean(gval)) { tag = "true"; } else { tag = "false"; } indent_fprintf(file, indent, "<%s />\n", tag); } else if (gtype == g_date_get_type()) { GDate *date; date = g_value_get_boxed(gval); indent_fprintf(file, indent, "<date>%d-%d-%d</date>\n", g_date_get_year(date), g_date_get_month(date), g_date_get_day(date) ); } else if (gtype == ghb_rawdata_get_type()) { ghb_rawdata_t *data; gchar *base64; data = g_value_get_boxed(gval); base64 = g_base64_encode(data->data, data->size); indent_fprintf(file, indent, "<data>\n"); indent_fprintf(file, 0, "%s\n", base64); indent_fprintf(file, indent, "</data>\n"); g_free(base64); } else if (gtype == G_TYPE_DOUBLE) { gdouble val = g_value_get_double(gval); indent_fprintf(file, indent, "<real>%.17g</real>\n", val); } else if (gtype == G_TYPE_INT64) { gint val = g_value_get_int64(gval); indent_fprintf(file, indent, "<integer>%d</integer>\n", val); } else if (gtype == G_TYPE_INT) { gint val = g_value_get_int(gval); indent_fprintf(file, indent, "<integer>%d</integer>\n", val); } else if (gtype == G_TYPE_STRING) { const gchar *str = g_value_get_string(gval); gchar *esc = g_markup_escape_text(str, -1); indent_fprintf(file, indent, "<string>%s</string>\n", esc); g_free(esc); } else { // Try to make anything thats unrecognized into a string const gchar *str; GValue val = {0,}; g_value_init(&val, G_TYPE_STRING); if (g_value_transform(gval, &val)) { str = g_value_get_string(&val); gchar *esc = g_markup_escape_text(str, -1); indent_fprintf(file, indent, "<string>%s</string>\n", esc); g_free(esc); } else { g_message("failed to transform"); } g_value_unset(&val); } }
void rb_value_free (GValue *val) { g_value_unset (val); g_slice_free (GValue, val); }
static void glade_eprop_accel_show_dialog (GladeEditorProperty *eprop) { GladeEPropAccel *eprop_accel = GLADE_EPROP_ACCEL (eprop); GtkWidget *dialog, *parent, *vbox, *sw, *tree_view; GValue value = { 0, }; GList *accelerators = NULL; gint res; parent = gtk_widget_get_toplevel (GTK_WIDGET (eprop)); dialog = gtk_dialog_new_with_buttons (_("Choose accelerator keys..."), GTK_WINDOW (parent), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLEAR, GLADE_RESPONSE_CLEAR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), vbox, TRUE, TRUE, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (sw); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request (sw, 400, 200); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); tree_view = glade_eprop_accel_view (eprop); glade_eprop_accel_populate_view (eprop, GTK_TREE_VIEW (tree_view)); gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view)); gtk_widget_show (tree_view); gtk_container_add (GTK_CONTAINER (sw), tree_view); /* Run the dialog */ res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_OK) { gtk_tree_model_foreach (gtk_tree_view_get_model (GTK_TREE_VIEW (tree_view)), (GtkTreeModelForeachFunc) glade_eprop_accel_accum_accelerators, &accelerators); g_value_init (&value, GLADE_TYPE_ACCEL_GLIST); g_value_take_boxed (&value, accelerators); glade_editor_property_commit (eprop, &value); g_value_unset (&value); } else if (res == GLADE_RESPONSE_CLEAR) { g_value_init (&value, GLADE_TYPE_ACCEL_GLIST); g_value_set_boxed (&value, NULL); glade_editor_property_commit (eprop, &value); g_value_unset (&value); } /* Clean up ... */ gtk_widget_destroy (dialog); g_object_unref (G_OBJECT (eprop_accel->model)); eprop_accel->model = NULL; if (eprop_accel->parent_iters) { g_list_foreach (eprop_accel->parent_iters, (GFunc) iter_tab_free, NULL); g_list_free (eprop_accel->parent_iters); eprop_accel->parent_iters = NULL; } }
void gegl_dot_util_add_node (GString *string, GeglNode *node) { g_string_append_printf (string, "op_%p [fontsize=\"10\" label=\"", node); /* We build the record from top to bottom */ g_string_append_printf (string, "{"); /* The first row is a list of output pads */ { GSList *pads = gegl_node_get_pads (node); GSList *entry = pads; gboolean got_output = FALSE; g_string_append_printf (string, "{"); while (entry) { GeglPad *pad = entry->data; if (gegl_pad_is_output (pad)) { if (got_output) { g_string_append (string, "|"); } got_output = TRUE; g_string_append_printf (string, "<%s>%s", gegl_pad_get_name (pad), gegl_pad_get_name (pad)); } entry = g_slist_next (entry); } g_string_append_printf (string, "}|"); } /* The second row is the operation name such as gegl:translate */ g_string_append_printf (string, "%s |", gegl_node_get_debug_name (node)); /* The next rows are property names and their values */ if (1) { guint n_properties; GParamSpec **properties = gegl_operation_list_properties (gegl_node_get_operation (node), &n_properties); guint i; for (i = 0; i < n_properties; i++) { const gchar *name = properties[i]->name; GValue tvalue = { 0, }; GValue svalue = { 0, }; if (properties[i]->value_type == GEGL_TYPE_BUFFER) continue; g_value_init (&svalue, G_TYPE_STRING); g_value_init (&tvalue, properties[i]->value_type); gegl_node_get_property (node, name, &tvalue); if (g_value_transform (&tvalue, &svalue)) { gchar *sval = g_value_dup_string (&svalue); if (sval && strlen (sval) > 30) { sval[28] = '.'; sval[29] = '.'; sval[30] = '\0'; } if (sval) { g_string_append_printf (string, "%s=%s | ", name, sval); g_free (sval); } g_value_unset (&svalue); } g_value_unset (&tvalue); } g_free (properties); } /* The last row is input pads */ { GSList *pads = gegl_node_get_pads (node); GSList *entry = pads; gboolean got_input = FALSE; g_string_append_printf (string, "{"); while (entry) { GeglPad *pad = entry->data; if (gegl_pad_is_input (pad)) { if (got_input) { g_string_append (string, "|"); } got_input = TRUE; g_string_append_printf (string, "<%s>%s", gegl_pad_get_name (pad), gegl_pad_get_name (pad)); } entry = g_slist_next (entry); } g_string_append_printf (string, "}"); } g_string_append_printf (string, "}\""); g_string_append_printf (string, "shape=\"record\"];\n"); }
static GstFlowReturn gst_slvideo_buffer_alloc (GstBaseSink * bsink, guint64 offset, guint size, GstCaps * caps, GstBuffer ** buf) { gint width, height; GstStructure *structure = NULL; GstSLVideo *slvideo; slvideo = GST_SLVIDEO(bsink); // caps == requested caps // we can ignore these and reverse-negotiate our preferred dimensions with // the peer if we like - we need to do this to obey dynamic resize requests // flowing in from the app. structure = llgst_caps_get_structure (caps, 0); if (!llgst_structure_get_int(structure, "width", &width) || !llgst_structure_get_int(structure, "height", &height)) { GST_WARNING_OBJECT (slvideo, "no width/height in caps %" GST_PTR_FORMAT, caps); return GST_FLOW_NOT_NEGOTIATED; } GstBuffer *newbuf = llgst_buffer_new(); bool made_bufferdata_ptr = false; #define MAXDEPTHHACK 4 GST_OBJECT_LOCK(slvideo); if (slvideo->resize_forced_always) // app is giving us a fixed size to work with { gint slwantwidth, slwantheight; slwantwidth = slvideo->resize_try_width; slwantheight = slvideo->resize_try_height; if (slwantwidth != width || slwantheight != height) { // don't like requested caps, we will issue our own suggestion - copy // the requested caps but substitute our own width and height and see // if our peer is happy with that. GstCaps *desired_caps; GstStructure *desired_struct; desired_caps = llgst_caps_copy (caps); desired_struct = llgst_caps_get_structure (desired_caps, 0); GValue value = {0}; g_value_init(&value, G_TYPE_INT); g_value_set_int(&value, slwantwidth); llgst_structure_set_value (desired_struct, "width", &value); g_value_unset(&value); g_value_init(&value, G_TYPE_INT); g_value_set_int(&value, slwantheight); llgst_structure_set_value (desired_struct, "height", &value); if (llgst_pad_peer_accept_caps (GST_VIDEO_SINK_PAD (slvideo), desired_caps)) { // todo: re-use buffers from a pool? // todo: set MALLOCDATA to null, set DATA to point straight to shm? // peer likes our cap suggestion DEBUGMSG("peer loves us :)"); GST_BUFFER_SIZE(newbuf) = slwantwidth * slwantheight * MAXDEPTHHACK; GST_BUFFER_MALLOCDATA(newbuf) = (guint8*)g_malloc(GST_BUFFER_SIZE(newbuf)); GST_BUFFER_DATA(newbuf) = GST_BUFFER_MALLOCDATA(newbuf); llgst_buffer_set_caps (GST_BUFFER_CAST(newbuf), desired_caps); made_bufferdata_ptr = true; } else { // peer hates our cap suggestion INFOMSG("peer hates us :("); llgst_caps_unref(desired_caps); } } } GST_OBJECT_UNLOCK(slvideo); if (!made_bufferdata_ptr) // need to fallback to malloc at original size { GST_BUFFER_SIZE(newbuf) = width * height * MAXDEPTHHACK; GST_BUFFER_MALLOCDATA(newbuf) = (guint8*)g_malloc(GST_BUFFER_SIZE(newbuf)); GST_BUFFER_DATA(newbuf) = GST_BUFFER_MALLOCDATA(newbuf); llgst_buffer_set_caps (GST_BUFFER_CAST(newbuf), caps); } *buf = GST_BUFFER_CAST(newbuf); return GST_FLOW_OK; }
/*! * \brief CvVideoWriter_GStreamer::open * \param filename filename to output to * \param fourcc desired codec fourcc * \param fps desired framerate * \param frameSize the size of the expected frames * \param is_color color or grayscale * \return success * * We support 2 modes of operation. Either the user enters a filename and a fourcc * code, or enters a manual pipeline description like in CvVideoCapture_Gstreamer. * In the latter case, we just push frames on the appsink with appropriate caps. * In the former case, we try to deduce the correct container from the filename, * and the correct encoder from the fourcc profile. * * If the file extension did was not recognize, an avi container is used * */ bool CvVideoWriter_GStreamer::open( const char * filename, int fourcc, double fps, CvSize frameSize, bool is_color ) { CV_FUNCNAME("CvVideoWriter_GStreamer::open"); // check arguments assert (filename); assert (fps > 0); assert (frameSize.width > 0 && frameSize.height > 0); // init gstreamer gst_initializer::init(); // init vars bool manualpipeline = true; int bufsize = 0; GError *err = NULL; const char* mime = NULL; GstStateChangeReturn stateret; GstCaps* caps = NULL; GstCaps* videocaps = NULL; #if FULL_GST_VERSION >= VERSION_NUM(0,10,32) GstCaps* containercaps = NULL; GstEncodingContainerProfile* containerprofile = NULL; GstEncodingVideoProfile* videoprofile = NULL; #endif GstIterator *it = NULL; // we first try to construct a pipeline from the given string. // if that fails, we assume it is an ordinary filename __BEGIN__; encodebin = gst_parse_launch(filename, &err); if(!encodebin) { manualpipeline = false; } if(manualpipeline) { #if GST_VERSION_MAJOR == 0 it = gst_bin_iterate_sources(GST_BIN(encodebin)); if(gst_iterator_next(it, (gpointer *)&source) != GST_ITERATOR_OK) { CV_ERROR(CV_StsError, "GStreamer: cannot find appsink in manual pipeline\n"); return false; } #else it = gst_bin_iterate_sources (GST_BIN(encodebin)); gboolean done = FALSE; GstElement *element = NULL; gchar* name = NULL; GValue value = G_VALUE_INIT; while (!done) { switch (gst_iterator_next (it, &value)) { case GST_ITERATOR_OK: element = GST_ELEMENT (g_value_get_object (&value)); name = gst_element_get_name(element); if (name){ if(strstr(name, "opencvsrc") != NULL || strstr(name, "appsrc") != NULL) { source = GST_ELEMENT ( gst_object_ref (element) ); done = TRUE; } g_free(name); } g_value_unset (&value); break; case GST_ITERATOR_RESYNC: gst_iterator_resync (it); break; case GST_ITERATOR_ERROR: case GST_ITERATOR_DONE: done = TRUE; break; } } gst_iterator_free (it); if (!source){ CV_ERROR(CV_StsError, "GStreamer: cannot find appsrc in manual pipeline\n"); return false; } #endif pipeline = encodebin; } else { pipeline = gst_pipeline_new (NULL); // we just got a filename and a fourcc code. // first, try to guess the container from the filename //encodebin = gst_element_factory_make("encodebin", NULL); //proxy old non existing fourcc ids. These were used in previous opencv versions, //but do not even exist in gstreamer any more if (fourcc == CV_FOURCC('M','P','1','V')) fourcc = CV_FOURCC('M', 'P', 'G' ,'1'); if (fourcc == CV_FOURCC('M','P','2','V')) fourcc = CV_FOURCC('M', 'P', 'G' ,'2'); if (fourcc == CV_FOURCC('D','R','A','C')) fourcc = CV_FOURCC('d', 'r', 'a' ,'c'); //create encoder caps from fourcc videocaps = gst_riff_create_video_caps(fourcc, NULL, NULL, NULL, NULL, NULL); if (!videocaps){ CV_ERROR( CV_StsUnsupportedFormat, "Gstreamer Opencv backend does not support this codec."); } //create container caps from file extension mime = filenameToMimetype(filename); if (!mime) { CV_ERROR( CV_StsUnsupportedFormat, "Gstreamer Opencv backend does not support this file type."); } #if FULL_GST_VERSION >= VERSION_NUM(0,10,32) containercaps = gst_caps_from_string(mime); //create encodebin profile containerprofile = gst_encoding_container_profile_new("container", "container", containercaps, NULL); videoprofile = gst_encoding_video_profile_new(videocaps, NULL, NULL, 1); gst_encoding_container_profile_add_profile(containerprofile, (GstEncodingProfile *) videoprofile); #endif //create pipeline elements encodebin = gst_element_factory_make("encodebin", NULL); #if FULL_GST_VERSION >= VERSION_NUM(0,10,32) g_object_set(G_OBJECT(encodebin), "profile", containerprofile, NULL); #endif source = gst_element_factory_make("appsrc", NULL); file = gst_element_factory_make("filesink", NULL); g_object_set(G_OBJECT(file), "location", filename, NULL); } if (is_color) { input_pix_fmt = GST_VIDEO_FORMAT_BGR; bufsize = frameSize.width * frameSize.height * 3; #if GST_VERSION_MAJOR == 0 caps = gst_video_format_new_caps(GST_VIDEO_FORMAT_BGR, frameSize.width, frameSize.height, int(fps), 1, 1, 1); #else caps = gst_caps_new_simple("video/x-raw", "format", G_TYPE_STRING, "BGR", "width", G_TYPE_INT, frameSize.width, "height", G_TYPE_INT, frameSize.height, "framerate", GST_TYPE_FRACTION, int(fps), 1, NULL); caps = gst_caps_fixate(caps); #endif } else { #if FULL_GST_VERSION >= VERSION_NUM(0,10,29) input_pix_fmt = GST_VIDEO_FORMAT_GRAY8; bufsize = frameSize.width * frameSize.height; #if GST_VERSION_MAJOR == 0 caps = gst_video_format_new_caps(GST_VIDEO_FORMAT_GRAY8, frameSize.width, frameSize.height, int(fps), 1, 1, 1); #else caps = gst_caps_new_simple("video/x-raw", "format", G_TYPE_STRING, "GRAY8", "width", G_TYPE_INT, frameSize.width, "height", G_TYPE_INT, frameSize.height, "framerate", GST_TYPE_FRACTION, int(fps), 1, NULL); caps = gst_caps_fixate(caps); #endif #else CV_Assert(!"Gstreamer 0.10.29 or newer is required for grayscale input"); #endif } gst_app_src_set_caps(GST_APP_SRC(source), caps); gst_app_src_set_stream_type(GST_APP_SRC(source), GST_APP_STREAM_TYPE_STREAM); gst_app_src_set_size (GST_APP_SRC(source), -1); g_object_set(G_OBJECT(source), "format", GST_FORMAT_TIME, NULL); g_object_set(G_OBJECT(source), "block", 1, NULL); g_object_set(G_OBJECT(source), "is-live", 0, NULL); g_object_set(G_OBJECT(source), "emit-signals", 1, NULL); if(!manualpipeline) { g_object_set(G_OBJECT(file), "buffer-size", bufsize, NULL); gst_bin_add_many(GST_BIN(pipeline), source, encodebin, file, NULL); if(!gst_element_link_many(source, encodebin, file, NULL)) { CV_ERROR(CV_StsError, "GStreamer: cannot link elements\n"); } } stateret = gst_element_set_state(GST_ELEMENT(pipeline), GST_STATE_PLAYING); if(stateret == GST_STATE_CHANGE_FAILURE) { CV_ERROR(CV_StsError, "GStreamer: cannot put pipeline to play\n"); } handleMessage(pipeline); framerate = fps; num_frames = 0; __END__; return true; }
/** * * Method GetData on /org/freedesktop/DeviceKit/Power/Wakeups * * <method name="GetData"> * <arg name="data" type="a(budss)" direction="out"/> (1) * </method> * (1): array | boolean Wheter the proceess on userspace * | uint PID * | double Wakeups value * | string command line * | string details **/ static void xfpm_info_update_wakeups (XfpmInfo *info) { GtkListStore *store; GError *error = NULL; static GType collection_type = G_TYPE_INVALID; static GType struct_type = G_TYPE_INVALID; GPtrArray *array = NULL; gboolean ret; guint i; if ( G_UNLIKELY (collection_type == G_TYPE_INVALID ) ) { struct_type = dbus_g_type_get_struct ("GValueArray", G_TYPE_BOOLEAN, G_TYPE_UINT, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID); collection_type = dbus_g_type_get_collection ("GPtrArray", struct_type); } ret = dbus_g_proxy_call (info->wakeups_proxy, "GetData", &error, G_TYPE_INVALID, collection_type, &array, NULL); if ( !ret ) { g_warning ("GetData Failed on %s : %s", UPOWER_PATH_WAKEUPS, error->message); g_error_free (error); return; } store = GTK_LIST_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (info->wakeups))); gtk_list_store_clear (GTK_LIST_STORE (store)); for ( i = 0; i < array->len; i++ ) { GValue elem = { 0 }; GtkTreeIter iter; gboolean userspace; guint pid; gdouble value; gchar *cmd; gchar *formatted_cmd; gchar *details; gchar *formatted_details; gchar *pid_str; gchar *value_str; const gchar *icon; g_value_init (&elem, struct_type); g_value_set_static_boxed (&elem, g_ptr_array_index (array, i)); dbus_g_type_struct_get (&elem, 0, &userspace, 1, &pid, 2, &value, 3, &cmd, 4, &details, G_MAXUINT); if ( userspace ) { pid_str = g_strdup_printf ("%i", pid); } else { if ( pid < 0xff0 ) { pid_str = g_strdup_printf ("IRQ%i", pid); } else { pid_str = g_strdup("IRQx"); } } value_str = g_strdup_printf ("%.1f", value); icon = userspace ? "application-x-executable" : "applications-system"; formatted_cmd = gpm_stats_format_cmdline (cmd, userspace); formatted_details = gpm_stats_format_details (details); gtk_list_store_append (store, &iter); gtk_list_store_set (store, &iter, COL_WAKEUPS_TYPE, icon, COL_WAKEUPS_PID, pid_str, COL_WAKEUPS_VALUE, value_str, COL_WAKEUPS_CMD, formatted_cmd, COL_WAKEUPS_DETAILS, formatted_details, -1); g_free (cmd); g_free (details); g_free (formatted_cmd); g_free (formatted_details); g_value_unset (&elem); } g_ptr_array_free (array, TRUE); }
PpgAnimation* g_object_animatev (gpointer object, PpgAnimationMode mode, guint duration_msec, guint frame_rate, const gchar *first_property, va_list args) { PpgAnimation *animation; GObjectClass *klass; GObjectClass *pklass; const gchar *name; GParamSpec *pspec; GtkWidget *parent; GValue value = { 0 }; gchar *error = NULL; GType type; GType ptype; g_return_val_if_fail(first_property != NULL, NULL); g_return_val_if_fail(mode < PPG_ANIMATION_LAST, NULL); name = first_property; type = G_TYPE_FROM_INSTANCE(object); klass = G_OBJECT_GET_CLASS(object); animation = g_object_new(PPG_TYPE_ANIMATION, "duration", duration_msec, "frame-rate", frame_rate ? frame_rate : 60, "mode", mode, "target", object, NULL); do { /* * First check for the property on the object. If that does not exist * then check if the object has a parent and look at its child * properties (if its a GtkWidget). */ if (!(pspec = g_object_class_find_property(klass, name))) { if (!g_type_is_a(type, GTK_TYPE_WIDGET)) { g_critical("Failed to find property %s in %s", name, g_type_name(type)); goto failure; } if (!(parent = gtk_widget_get_parent(object))) { g_critical("Failed to find property %s in %s", name, g_type_name(type)); goto failure; } pklass = G_OBJECT_GET_CLASS(parent); ptype = G_TYPE_FROM_INSTANCE(parent); if (!(pspec = gtk_container_class_find_child_property(pklass, name))) { g_critical("Failed to find property %s in %s or parent %s", name, g_type_name(type), g_type_name(ptype)); goto failure; } } g_value_init(&value, pspec->value_type); G_VALUE_COLLECT(&value, args, 0, &error); if (error != NULL) { g_critical("Failed to retrieve va_list value: %s", error); g_free(error); goto failure; } ppg_animation_add_property(animation, pspec, &value); g_value_unset(&value); } while ((name = va_arg(args, const gchar *))); ppg_animation_start(animation); return animation; failure: g_object_ref_sink(animation); g_object_unref(animation); return NULL; }
static GstStructure *gst_avdtp_sink_parse_sbc_caps( GstAvdtpSink *self, sbc_capabilities_t *sbc) { GstStructure *structure; GValue *value; GValue *list; gboolean mono, stereo; structure = gst_structure_empty_new("audio/x-sbc"); value = g_value_init(g_new0(GValue, 1), G_TYPE_STRING); /* mode */ list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) { g_value_set_static_string(value, "mono"); gst_value_list_prepend_value(list, value); } if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) { g_value_set_static_string(value, "stereo"); gst_value_list_prepend_value(list, value); } if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) { g_value_set_static_string(value, "dual"); gst_value_list_prepend_value(list, value); } if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO) { g_value_set_static_string(value, "joint"); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "mode", list); g_free(list); list = NULL; } /* subbands */ list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); value = g_value_init(value, G_TYPE_INT); if (sbc->subbands & BT_A2DP_SUBBANDS_4) { g_value_set_int(value, 4); gst_value_list_prepend_value(list, value); } if (sbc->subbands & BT_A2DP_SUBBANDS_8) { g_value_set_int(value, 8); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "subbands", list); g_free(list); list = NULL; } /* blocks */ value = g_value_init(value, G_TYPE_INT); list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_16) { g_value_set_int(value, 16); gst_value_list_prepend_value(list, value); } if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_12) { g_value_set_int(value, 12); gst_value_list_prepend_value(list, value); } if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_8) { g_value_set_int(value, 8); gst_value_list_prepend_value(list, value); } if (sbc->block_length & BT_A2DP_BLOCK_LENGTH_4) { g_value_set_int(value, 4); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "blocks", list); g_free(list); list = NULL; } /* allocation */ g_value_init(value, G_TYPE_STRING); list = g_value_init(g_new0(GValue,1), GST_TYPE_LIST); if (sbc->allocation_method & BT_A2DP_ALLOCATION_LOUDNESS) { g_value_set_static_string(value, "loudness"); gst_value_list_prepend_value(list, value); } if (sbc->allocation_method & BT_A2DP_ALLOCATION_SNR) { g_value_set_static_string(value, "snr"); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "allocation", list); g_free(list); list = NULL; } /* rate */ g_value_init(value, G_TYPE_INT); list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); if (sbc->frequency & BT_SBC_SAMPLING_FREQ_48000) { g_value_set_int(value, 48000); gst_value_list_prepend_value(list, value); } if (sbc->frequency & BT_SBC_SAMPLING_FREQ_44100) { g_value_set_int(value, 44100); gst_value_list_prepend_value(list, value); } if (sbc->frequency & BT_SBC_SAMPLING_FREQ_32000) { g_value_set_int(value, 32000); gst_value_list_prepend_value(list, value); } if (sbc->frequency & BT_SBC_SAMPLING_FREQ_16000) { g_value_set_int(value, 16000); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "rate", list); g_free(list); list = NULL; } /* bitpool */ value = g_value_init(value, GST_TYPE_INT_RANGE); gst_value_set_int_range(value, MIN(sbc->min_bitpool, TEMPLATE_MAX_BITPOOL), MIN(sbc->max_bitpool, TEMPLATE_MAX_BITPOOL)); gst_structure_set_value(structure, "bitpool", value); g_value_unset(value); /* channels */ mono = FALSE; stereo = FALSE; if (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) mono = TRUE; if ((sbc->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) || (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) || (sbc->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)) stereo = TRUE; if (mono && stereo) { g_value_init(value, GST_TYPE_INT_RANGE); gst_value_set_int_range(value, 1, 2); } else { g_value_init(value, G_TYPE_INT); if (mono) g_value_set_int(value, 1); else if (stereo) g_value_set_int(value, 2); else { GST_ERROR_OBJECT(self, "Unexpected number of channels"); g_value_set_int(value, 0); } } gst_structure_set_value(structure, "channels", value); g_free(value); return structure; }
static void rhythmdb_directory_change_cb (GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type, RhythmDB *db) { char *canon_uri; char *other_canon_uri = NULL; RhythmDBEntry *entry; canon_uri = g_file_get_uri (file); if (other_file != NULL) { other_canon_uri = g_file_get_uri (other_file); } rb_debug ("directory event %d for %s", event_type, canon_uri); switch (event_type) { case G_FILE_MONITOR_EVENT_CREATED: { gboolean in_library = FALSE; int i; if (!g_settings_get_boolean (db->priv->settings, "monitor-library")) break; if (rb_uri_is_hidden (canon_uri)) break; /* ignore new files outside of the library locations */ for (i = 0; db->priv->library_locations[i] != NULL; i++) { if (g_str_has_prefix (canon_uri, db->priv->library_locations[i])) { in_library = TRUE; break; } } if (!in_library) break; } /* process directories immediately */ if (rb_uri_is_directory (canon_uri)) { actually_add_monitor (db, file, NULL); rhythmdb_add_uri (db, canon_uri); } else { add_changed_file (db, canon_uri); } break; case G_FILE_MONITOR_EVENT_CHANGED: case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED: if (rhythmdb_entry_lookup_by_location (db, canon_uri)) { add_changed_file (db, canon_uri); } break; case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT: /* hmm.. */ break; case G_FILE_MONITOR_EVENT_DELETED: entry = rhythmdb_entry_lookup_by_location (db, canon_uri); if (entry != NULL) { g_hash_table_remove (db->priv->changed_files, entry->location); rhythmdb_entry_set_visibility (db, entry, FALSE); rhythmdb_commit (db); } break; case G_FILE_MONITOR_EVENT_MOVED: if (other_canon_uri == NULL) { break; } entry = rhythmdb_entry_lookup_by_location (db, other_canon_uri); if (entry != NULL) { rb_debug ("file move target %s already exists in database", other_canon_uri); entry = rhythmdb_entry_lookup_by_location (db, canon_uri); if (entry != NULL) { g_hash_table_remove (db->priv->changed_files, entry->location); rhythmdb_entry_set_visibility (db, entry, FALSE); rhythmdb_commit (db); } } else { entry = rhythmdb_entry_lookup_by_location (db, canon_uri); if (entry != NULL) { GValue v = {0,}; g_value_init (&v, G_TYPE_STRING); g_value_set_string (&v, other_canon_uri); rhythmdb_entry_set_internal (db, entry, TRUE, RHYTHMDB_PROP_LOCATION, &v); g_value_unset (&v); } } break; case G_FILE_MONITOR_EVENT_PRE_UNMOUNT: case G_FILE_MONITOR_EVENT_UNMOUNTED: default: break; } g_free (canon_uri); g_free (other_canon_uri); }
static GstStructure *gst_avdtp_sink_parse_mpeg_caps( GstAvdtpSink *self, mpeg_capabilities_t *mpeg) { GstStructure *structure; GValue *value; GValue *list; gboolean valid_layer = FALSE; gboolean mono, stereo; if (!mpeg) return NULL; GST_LOG_OBJECT(self, "parsing mpeg caps"); structure = gst_structure_empty_new("audio/mpeg"); value = g_new0(GValue, 1); g_value_init(value, G_TYPE_INT); list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); g_value_set_int(value, 1); gst_value_list_prepend_value(list, value); g_value_set_int(value, 2); gst_value_list_prepend_value(list, value); gst_structure_set_value(structure, "mpegversion", list); g_free(list); /* layer */ GST_LOG_OBJECT(self, "setting mpeg layer"); list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); if (mpeg->layer & BT_MPEG_LAYER_1) { g_value_set_int(value, 1); gst_value_list_prepend_value(list, value); valid_layer = TRUE; } if (mpeg->layer & BT_MPEG_LAYER_2) { g_value_set_int(value, 2); gst_value_list_prepend_value(list, value); valid_layer = TRUE; } if (mpeg->layer & BT_MPEG_LAYER_3) { g_value_set_int(value, 3); gst_value_list_prepend_value(list, value); valid_layer = TRUE; } if (list) { gst_structure_set_value(structure, "layer", list); g_free(list); list = NULL; } if (!valid_layer) { gst_structure_free(structure); g_free(value); return NULL; } /* rate */ GST_LOG_OBJECT(self, "setting mpeg rate"); list = g_value_init(g_new0(GValue, 1), GST_TYPE_LIST); if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_48000) { g_value_set_int(value, 48000); gst_value_list_prepend_value(list, value); } if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_44100) { g_value_set_int(value, 44100); gst_value_list_prepend_value(list, value); } if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_32000) { g_value_set_int(value, 32000); gst_value_list_prepend_value(list, value); } if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_24000) { g_value_set_int(value, 24000); gst_value_list_prepend_value(list, value); } if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_22050) { g_value_set_int(value, 22050); gst_value_list_prepend_value(list, value); } if (mpeg->frequency & BT_MPEG_SAMPLING_FREQ_16000) { g_value_set_int(value, 16000); gst_value_list_prepend_value(list, value); } g_value_unset(value); if (list) { gst_structure_set_value(structure, "rate", list); g_free(list); list = NULL; } /* channels */ GST_LOG_OBJECT(self, "setting mpeg channels"); mono = FALSE; stereo = FALSE; if (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_MONO) mono = TRUE; if ((mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_STEREO) || (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_DUAL_CHANNEL) || (mpeg->channel_mode & BT_A2DP_CHANNEL_MODE_JOINT_STEREO)) stereo = TRUE; if (mono && stereo) { g_value_init(value, GST_TYPE_INT_RANGE); gst_value_set_int_range(value, 1, 2); } else { g_value_init(value, G_TYPE_INT); if (mono) g_value_set_int(value, 1); else if (stereo) g_value_set_int(value, 2); else { GST_ERROR_OBJECT(self, "Unexpected number of channels"); g_value_set_int(value, 0); } } gst_structure_set_value(structure, "channels", value); g_free(value); return structure; }
static GstCaps * gst_gl_filter_fixate_caps (GstBaseTransform * bt, GstPadDirection direction, GstCaps * caps, GstCaps * othercaps) { GstStructure *ins, *outs; const GValue *from_par, *to_par; GValue fpar = { 0, }, tpar = { 0,}; othercaps = gst_caps_truncate (othercaps); othercaps = gst_caps_make_writable (othercaps); GST_DEBUG_OBJECT (bt, "trying to fixate othercaps %" GST_PTR_FORMAT " based on caps %" GST_PTR_FORMAT, othercaps, caps); ins = gst_caps_get_structure (caps, 0); outs = gst_caps_get_structure (othercaps, 0); from_par = gst_structure_get_value (ins, "pixel-aspect-ratio"); to_par = gst_structure_get_value (outs, "pixel-aspect-ratio"); /* If we're fixating from the sinkpad we always set the PAR and * assume that missing PAR on the sinkpad means 1/1 and * missing PAR on the srcpad means undefined */ if (direction == GST_PAD_SINK) { if (!from_par) { g_value_init (&fpar, GST_TYPE_FRACTION); gst_value_set_fraction (&fpar, 1, 1); from_par = &fpar; } if (!to_par) { g_value_init (&tpar, GST_TYPE_FRACTION); gst_value_set_fraction (&tpar, 1, 1); to_par = &tpar; } } else { if (!to_par) { g_value_init (&tpar, GST_TYPE_FRACTION); gst_value_set_fraction (&tpar, 1, 1); to_par = &tpar; gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, NULL); } if (!from_par) { g_value_init (&fpar, GST_TYPE_FRACTION); gst_value_set_fraction (&fpar, 1, 1); from_par = &fpar; } } /* we have both PAR but they might not be fixated */ { gint from_w, from_h, from_par_n, from_par_d, to_par_n, to_par_d; gint w = 0, h = 0; gint from_dar_n, from_dar_d; gint num, den; /* from_par should be fixed */ g_return_val_if_fail (gst_value_is_fixed (from_par), othercaps); from_par_n = gst_value_get_fraction_numerator (from_par); from_par_d = gst_value_get_fraction_denominator (from_par); gst_structure_get_int (ins, "width", &from_w); gst_structure_get_int (ins, "height", &from_h); gst_structure_get_int (outs, "width", &w); gst_structure_get_int (outs, "height", &h); /* if both width and height are already fixed, we can't do anything * about it anymore */ if (w && h) { gint n = 1, d = 1; GST_DEBUG_OBJECT (bt, "dimensions already set to %dx%d, not fixating", w, h); if (!gst_value_is_fixed (to_par)) { GST_DEBUG_OBJECT (bt, "fixating to_par to %dx%d", n, d); if (gst_structure_has_field (outs, "pixel-aspect-ratio")) gst_structure_fixate_field_nearest_fraction (outs, "pixel-aspect-ratio", 1, 1); else if (n != d) gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1, NULL); } goto done; } /* Calculate input DAR */ if (!gst_util_fraction_multiply (from_w, from_h, from_par_n, from_par_d, &from_dar_n, &from_dar_d)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } GST_DEBUG_OBJECT (bt, "Input DAR is %d/%d", from_dar_n, from_dar_d); /* If either width or height are fixed there's not much we * can do either except choosing a height or width and PAR * that matches the DAR as good as possible */ if (h) { gint num, den; GST_DEBUG_OBJECT (bt, "height is fixed (%d)", h); if (!gst_value_is_fixed (to_par)) { gst_value_set_fraction (&tpar, 1, 1); } /* PAR is fixed, choose the height that is nearest to the * height with the same DAR */ to_par_n = gst_value_get_fraction_numerator (to_par); to_par_d = gst_value_get_fraction_denominator (to_par); GST_DEBUG_OBJECT (bt, "PAR is fixed %d/%d", to_par_n, to_par_d); if (!gst_util_fraction_multiply (from_dar_n, from_dar_d, to_par_d, to_par_n, &num, &den)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } w = (guint) gst_util_uint64_scale_int (h, num, den); gst_structure_fixate_field_nearest_int (outs, "width", w); goto done; } else if (w) { gint num, den; GST_DEBUG_OBJECT (bt, "width is fixed (%d)", w); if (!gst_value_is_fixed (to_par)) { gst_value_set_fraction (&tpar, 1, 1); } /* PAR is fixed, choose the height that is nearest to the * height with the same DAR */ to_par_n = gst_value_get_fraction_numerator (to_par); to_par_d = gst_value_get_fraction_denominator (to_par); GST_DEBUG_OBJECT (bt, "PAR is fixed %d/%d", to_par_n, to_par_d); if (!gst_util_fraction_multiply (from_dar_n, from_dar_d, to_par_d, to_par_n, &num, &den)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } h = (guint) gst_util_uint64_scale_int (w, den, num); gst_structure_fixate_field_nearest_int (outs, "height", h); goto done; } else if (gst_value_is_fixed (to_par)) { GstStructure *tmp; gint set_h, set_w, f_h, f_w; to_par_n = gst_value_get_fraction_numerator (to_par); to_par_d = gst_value_get_fraction_denominator (to_par); /* Calculate scale factor for the PAR change */ if (!gst_util_fraction_multiply (from_dar_n, from_dar_d, to_par_n, to_par_d, &num, &den)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } /* Try to keep the input height */ tmp = gst_structure_copy (outs); gst_structure_fixate_field_nearest_int (tmp, "height", from_h); gst_structure_get_int (tmp, "height", &set_h); /* This might have failed but try to scale the width * to keep the DAR nonetheless */ w = (guint) gst_util_uint64_scale_int (set_h, num, den); gst_structure_fixate_field_nearest_int (tmp, "width", w); gst_structure_get_int (tmp, "width", &set_w); gst_structure_free (tmp); /* We kept the DAR and the height is nearest to the original height */ if (set_w == w) { gst_structure_set (outs, "width", G_TYPE_INT, set_w, "height", G_TYPE_INT, set_h, NULL); goto done; } f_h = set_h; f_w = set_w; /* If the former failed, try to keep the input width at least */ tmp = gst_structure_copy (outs); gst_structure_fixate_field_nearest_int (tmp, "width", from_w); gst_structure_get_int (tmp, "width", &set_w); /* This might have failed but try to scale the width * to keep the DAR nonetheless */ h = (guint) gst_util_uint64_scale_int (set_w, den, num); gst_structure_fixate_field_nearest_int (tmp, "height", h); gst_structure_get_int (tmp, "height", &set_h); gst_structure_free (tmp); /* We kept the DAR and the width is nearest to the original width */ if (set_h == h) { gst_structure_set (outs, "width", G_TYPE_INT, set_w, "height", G_TYPE_INT, set_h, NULL); goto done; } /* If all this failed, keep the height that was nearest to the orignal * height and the nearest possible width. This changes the DAR but * there's not much else to do here. */ gst_structure_set (outs, "width", G_TYPE_INT, f_w, "height", G_TYPE_INT, f_h, NULL); goto done; } else { GstStructure *tmp; gint set_h, set_w, set_par_n, set_par_d, tmp2; /* width, height and PAR are not fixed */ /* First try to keep the height and width as good as possible * and scale PAR */ tmp = gst_structure_copy (outs); gst_structure_fixate_field_nearest_int (tmp, "height", from_h); gst_structure_get_int (tmp, "height", &set_h); gst_structure_fixate_field_nearest_int (tmp, "width", from_w); gst_structure_get_int (tmp, "width", &set_w); if (!gst_util_fraction_multiply (from_dar_n, from_dar_d, set_h, set_w, &to_par_n, &to_par_d)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } if (!gst_structure_has_field (tmp, "pixel-aspect-ratio")) gst_structure_set_value (tmp, "pixel-aspect-ratio", to_par); gst_structure_fixate_field_nearest_fraction (tmp, "pixel-aspect-ratio", to_par_n, to_par_d); gst_structure_get_fraction (tmp, "pixel-aspect-ratio", &set_par_n, &set_par_d); gst_structure_free (tmp); if (set_par_n == to_par_n && set_par_d == to_par_d) { gst_structure_set (outs, "width", G_TYPE_INT, set_w, "height", G_TYPE_INT, set_h, NULL); if (gst_structure_has_field (outs, "pixel-aspect-ratio") || set_par_n != set_par_d) gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, set_par_n, set_par_d, NULL); goto done; } /* Otherwise try to scale width to keep the DAR with the set * PAR and height */ if (!gst_util_fraction_multiply (from_dar_n, from_dar_d, set_par_d, set_par_n, &num, &den)) { GST_ELEMENT_ERROR (bt, CORE, NEGOTIATION, (NULL), ("Error calculating the output scaled size - integer overflow")); goto done; } w = (guint) gst_util_uint64_scale_int (set_h, num, den); tmp = gst_structure_copy (outs); gst_structure_fixate_field_nearest_int (tmp, "width", w); gst_structure_get_int (tmp, "width", &tmp2); gst_structure_free (tmp); if (tmp2 == w) { gst_structure_set (outs, "width", G_TYPE_INT, tmp2, "height", G_TYPE_INT, set_h, NULL); if (gst_structure_has_field (outs, "pixel-aspect-ratio") || set_par_n != set_par_d) gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, set_par_n, set_par_d, NULL); goto done; } /* ... or try the same with the height */ h = (guint) gst_util_uint64_scale_int (set_w, den, num); tmp = gst_structure_copy (outs); gst_structure_fixate_field_nearest_int (tmp, "height", h); gst_structure_get_int (tmp, "height", &tmp2); gst_structure_free (tmp); if (tmp2 == h) { gst_structure_set (outs, "width", G_TYPE_INT, set_w, "height", G_TYPE_INT, tmp2, NULL); if (gst_structure_has_field (outs, "pixel-aspect-ratio") || set_par_n != set_par_d) gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, set_par_n, set_par_d, NULL); goto done; } /* If all fails we can't keep the DAR and take the nearest values * for everything from the first try */ gst_structure_set (outs, "width", G_TYPE_INT, set_w, "height", G_TYPE_INT, set_h, NULL); if (gst_structure_has_field (outs, "pixel-aspect-ratio") || set_par_n != set_par_d) gst_structure_set (outs, "pixel-aspect-ratio", GST_TYPE_FRACTION, set_par_n, set_par_d, NULL); } } done: othercaps = gst_caps_fixate (othercaps); GST_DEBUG_OBJECT (bt, "fixated othercaps to %" GST_PTR_FORMAT, othercaps); if (from_par == &fpar) g_value_unset (&fpar); if (to_par == &tpar) g_value_unset (&tpar); return othercaps; }
/** * gimp_config_deserialize_property: * @config: a #GimpConfig. * @scanner: a #GScanner. * @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; }
static void __get_view_constraints(xmlNode *node, MgdSchemaTypeAttr *type) { xmlNode *cur; for (cur = node->children; cur; cur = cur->next) { if (cur->type == XML_ELEMENT_NODE && g_str_equal(cur->name, "constraint")) { /* FIXME, add constraint to reserved words constants */ xmlChar *property = xmlGetProp(cur, (const xmlChar *)"property"); if (!property || (property && *property == '\0')) __view_error(cur, "Can not add constraint with empty property", NULL); gchar **classprop = g_strsplit((gchar *)property, ":", 2); if (!classprop || classprop[0] == NULL || classprop[1] == NULL) { __view_error(cur, "Constraint property misconfigured", NULL); return; } MidgardDBObjectClass *klass = MIDGARD_DBOBJECT_CLASS(MIDGARD_OBJECT_GET_CLASS_BY_NAME((const gchar *)classprop[0])); if (!klass) __view_error(cur, "Class %s not registered", classprop[0]); MidgardCoreQueryConstraint *constraint = midgard_core_query_constraint_new(); if (!midgard_core_query_constraint_parse_property(&constraint, klass, classprop[1])) __view_error(cur, "Can not parse %s constraint property", classprop[1]); g_strfreev(classprop); xmlFree(property); /* Add operator */ xmlChar *operator = xmlGetProp(cur, (const xmlChar *)"operator"); if (!operator || (operator && *operator == '\0')) __view_error(cur, "Can not add constraint with empty operator", NULL); if (!midgard_core_query_constraint_add_operator(constraint, (const gchar *)operator)) __view_error(cur, "Invalid operator", NULL); xmlFree(operator); /* Add value */ xmlChar *valtype = xmlGetProp(cur, (const xmlChar *)"value_type"); if (!valtype || (valtype && *valtype == '\0')) __view_error(cur, "Can not add constraint with empty value_type", NULL); GType vtype = midgard_core_schema_gtype_from_string((const gchar *)valtype); if (!vtype) __view_error(cur, "Invalid %s value_type", valtype); xmlFree(valtype); xmlChar *value = xmlGetProp(cur, (const xmlChar *)"value"); if (!value || (value && *value == '\0')) __view_error(cur, "Can not add constraint with empty value", NULL); /* Get value as string and convert to declared type */ GValue strval = {0, }; g_value_init(&strval, G_TYPE_STRING); g_value_set_string(&strval, (const gchar *)value); GValue val = {0, }; g_value_init(&val, vtype); g_value_transform((const GValue *) &strval, &val); midgard_core_query_constraint_add_value(constraint, &val); midgard_core_query_constraint_build_condition(constraint); type->constraints = g_slist_append(type->constraints, (gpointer) constraint); g_value_unset(&val); g_value_unset(&strval); xmlFree(value); } } }
static gboolean gst_video_crop_transform_dimension_value (const GValue * src_val, gint delta, GValue * dest_val, GstPadDirection direction, gboolean dynamic) { gboolean ret = TRUE; if (G_VALUE_HOLDS_INT (src_val)) { gint ival = g_value_get_int (src_val); ival = gst_video_crop_transform_dimension (ival, delta); if (dynamic) { if (direction == GST_PAD_SRC) { if (ival == G_MAXINT) { g_value_init (dest_val, G_TYPE_INT); g_value_set_int (dest_val, ival); } else { g_value_init (dest_val, GST_TYPE_INT_RANGE); gst_value_set_int_range (dest_val, ival, G_MAXINT); } } else { if (ival == 1) { g_value_init (dest_val, G_TYPE_INT); g_value_set_int (dest_val, ival); } else { g_value_init (dest_val, GST_TYPE_INT_RANGE); gst_value_set_int_range (dest_val, 1, ival); } } } else { g_value_init (dest_val, G_TYPE_INT); g_value_set_int (dest_val, ival); } } else if (GST_VALUE_HOLDS_INT_RANGE (src_val)) { gint min = gst_value_get_int_range_min (src_val); gint max = gst_value_get_int_range_max (src_val); min = gst_video_crop_transform_dimension (min, delta); max = gst_video_crop_transform_dimension (max, delta); if (dynamic) { if (direction == GST_PAD_SRC) max = G_MAXINT; else min = 1; } if (min == max) { g_value_init (dest_val, G_TYPE_INT); g_value_set_int (dest_val, min); } else { g_value_init (dest_val, GST_TYPE_INT_RANGE); gst_value_set_int_range (dest_val, min, max); } } else if (GST_VALUE_HOLDS_LIST (src_val)) { gint i; g_value_init (dest_val, GST_TYPE_LIST); for (i = 0; i < gst_value_list_get_size (src_val); ++i) { const GValue *list_val; GValue newval = { 0, }; list_val = gst_value_list_get_value (src_val, i); if (gst_video_crop_transform_dimension_value (list_val, delta, &newval, direction, dynamic)) gst_value_list_append_value (dest_val, &newval); g_value_unset (&newval); } if (gst_value_list_get_size (dest_val) == 0) { g_value_unset (dest_val); ret = FALSE; } } else { ret = FALSE; } return ret; }
END_TEST /* ----- Test case for new_information -----*/ /** * Purpose: Check that note dialog is properly created with description regular values. * Cases considered: * - Create new information note with description set to TEST_STRING. * - Create new information note with description set to "". * */ START_TEST (test_new_information_regular) { const gchar * description = NULL; const gchar * ret_description = NULL; GValue value= {0, }; GValue enum_value= {0, }; HildonNoteType note_type; g_value_init (&value, G_TYPE_STRING); g_value_init (&enum_value, G_TYPE_INT); /* Test 1: create new information note with description set to "Standard question?" */ description = TEST_STRING; note = HILDON_NOTE(hildon_note_new_information(n_window,description)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_information"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_INFORMATION_THEME, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_INFORMATION_THEME)",note_type); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; /* Test 2: create new information note with description set to "" */ description = ""; note = HILDON_NOTE(hildon_note_new_information(n_window,description)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_information"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_INFORMATION_THEME, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_INFORMATION_THEME)",note_type); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; g_value_unset(&value); g_value_unset(&enum_value); }
static GstCaps * gst_video_crop_transform_caps (GstBaseTransform * trans, GstPadDirection direction, GstCaps * caps, GstCaps * filter_caps) { GstVideoCrop *vcrop; GstCaps *other_caps; gint dy, dx, i, left, right, bottom, top; gboolean w_dynamic, h_dynamic; vcrop = GST_VIDEO_CROP (trans); GST_OBJECT_LOCK (vcrop); GST_LOG_OBJECT (vcrop, "l=%d,r=%d,b=%d,t=%d", vcrop->prop_left, vcrop->prop_right, vcrop->prop_bottom, vcrop->prop_top); w_dynamic = (vcrop->prop_left == -1 || vcrop->prop_right == -1); h_dynamic = (vcrop->prop_top == -1 || vcrop->prop_bottom == -1); left = (vcrop->prop_left == -1) ? 0 : vcrop->prop_left; right = (vcrop->prop_right == -1) ? 0 : vcrop->prop_right; bottom = (vcrop->prop_bottom == -1) ? 0 : vcrop->prop_bottom; top = (vcrop->prop_top == -1) ? 0 : vcrop->prop_top; GST_OBJECT_UNLOCK (vcrop); if (direction == GST_PAD_SRC) { dx = left + right; dy = top + bottom; } else { dx = 0 - (left + right); dy = 0 - (top + bottom); } GST_LOG_OBJECT (vcrop, "transforming caps %" GST_PTR_FORMAT, caps); other_caps = gst_caps_new_empty (); for (i = 0; i < gst_caps_get_size (caps); ++i) { const GValue *v; GstStructure *structure, *new_structure; GValue w_val = { 0, }, h_val = { 0,}; structure = gst_caps_get_structure (caps, i); v = gst_structure_get_value (structure, "width"); if (!gst_video_crop_transform_dimension_value (v, dx, &w_val, direction, w_dynamic)) { GST_WARNING_OBJECT (vcrop, "could not tranform width value with dx=%d" ", caps structure=%" GST_PTR_FORMAT, dx, structure); continue; } v = gst_structure_get_value (structure, "height"); if (!gst_video_crop_transform_dimension_value (v, dy, &h_val, direction, h_dynamic)) { g_value_unset (&w_val); GST_WARNING_OBJECT (vcrop, "could not tranform height value with dy=%d" ", caps structure=%" GST_PTR_FORMAT, dy, structure); continue; } new_structure = gst_structure_copy (structure); gst_structure_set_value (new_structure, "width", &w_val); gst_structure_set_value (new_structure, "height", &h_val); g_value_unset (&w_val); g_value_unset (&h_val); GST_LOG_OBJECT (vcrop, "transformed structure %2d: %" GST_PTR_FORMAT " => %" GST_PTR_FORMAT, i, structure, new_structure); gst_caps_append_structure (other_caps, new_structure); } if (!gst_caps_is_empty (other_caps) && filter_caps) { GstCaps *tmp = gst_caps_intersect_full (filter_caps, other_caps, GST_CAPS_INTERSECT_FIRST); gst_caps_replace (&other_caps, tmp); gst_caps_unref (tmp); } return other_caps; }
END_TEST #endif /* ----- Test case for new_cancel_with_progress_bar -----*/ /** * Purpose: Check that note dialog is properly created with description regular values. * Cases considered: * - Create new confirmation note with description set to TEST_STRING and NULL GtkProgressBar. * - Create new confirmation note with description set to "" and correct GtkProgressBar. * */ START_TEST (test_new_cancel_with_progress_bar_regular) { const gchar * description = NULL; const gchar * ret_description = NULL; GValue value= {0, }; GValue enum_value= {0, }; GtkProgressBar * progress_bar=NULL; HildonNoteType note_type; g_value_init (&value, G_TYPE_STRING); g_value_init (&enum_value, G_TYPE_INT); /* Test 1: create new confirmation note with description set to TEST_STRING and NULL GtkProgressBar */ description = TEST_STRING; note = HILDON_NOTE(hildon_note_new_cancel_with_progress_bar(n_window,description,progress_bar)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_cancel_with_progress_bar"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_PROGRESSBAR, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_PROGRESSBAR)",note_type); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; /* Test 2: create new confirmation note with description set to "" */ description = ""; progress_bar = GTK_PROGRESS_BAR(gtk_progress_bar_new()); fail_if(!GTK_IS_PROGRESS_BAR(progress_bar), "hildon-note: Progress bar creation failed in hildon_note_new_cancel_with_progress_bar"); gtk_progress_bar_set_fraction(progress_bar,0.5); note = HILDON_NOTE(hildon_note_new_cancel_with_progress_bar(n_window,description,progress_bar)); fail_if(!HILDON_IS_NOTE(note), "hildon-note: Creation failed with hildon_note_new_cancel_with_progress_bar"); g_object_get_property(G_OBJECT (note),"description",&value); ret_description = g_value_get_string (&value); fail_if( strcmp (description,ret_description) != 0, "hildon-note: Description (%s) was not set properly on creation. Returned description: %s", description,ret_description); g_object_get_property(G_OBJECT (note),"note_type",&enum_value); note_type = g_value_get_int(&enum_value); fail_if( note_type != HILDON_NOTE_TYPE_PROGRESSBAR, "hildon-note: Type was not set property on creation (HILDON_NOTE_TYPE_PROGRESSBAR)",note_type); gtk_widget_destroy (GTK_WIDGET (progress_bar)); gtk_widget_destroy (GTK_WIDGET (note)); note=NULL; g_value_unset(&value); g_value_unset(&enum_value); }
/** * pyg_value_from_pyobject: * @value: the GValue object to store the converted value in. * @obj: the Python object to convert. * * This function converts a Python object and stores the result in a * GValue. The GValue must be initialised in advance with * g_value_init(). If the Python object can't be converted to the * type of the GValue, then an error is returned. * * Returns: 0 on success, -1 on error. */ int pyg_value_from_pyobject(GValue *value, PyObject *obj) { PyObject *tmp; switch (G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value))) { case G_TYPE_INTERFACE: /* we only handle interface types that have a GObject prereq */ if (g_type_is_a(G_VALUE_TYPE(value), G_TYPE_OBJECT)) { if (obj == Py_None) g_value_set_object(value, NULL); else { if (!PyObject_TypeCheck(obj, &PyGObject_Type)) { return -1; } if (!G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj), G_VALUE_TYPE(value))) { return -1; } g_value_set_object(value, pygobject_get(obj)); } } else { return -1; } break; case G_TYPE_CHAR: #if PY_VERSION_HEX < 0x03000000 if (PyString_Check(obj)) { g_value_set_char(value, PyString_AsString(obj)[0]); } else #endif if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_char(value, PYGLIB_PyBytes_AsString(tmp)[0]); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_UCHAR: if (PYGLIB_PyLong_Check(obj)) { glong val; val = PYGLIB_PyLong_AsLong(obj); if (val >= 0 && val <= 255) g_value_set_uchar(value, (guchar)PYGLIB_PyLong_AsLong (obj)); else return -1; #if PY_VERSION_HEX < 0x03000000 } else if (PyString_Check(obj)) { g_value_set_uchar(value, PyString_AsString(obj)[0]); #endif } else if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_uchar(value, PYGLIB_PyBytes_AsString(tmp)[0]); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_BOOLEAN: g_value_set_boolean(value, PyObject_IsTrue(obj)); break; case G_TYPE_INT: g_value_set_int(value, PYGLIB_PyLong_AsLong(obj)); break; case G_TYPE_UINT: { if (PYGLIB_PyLong_Check(obj)) { glong val; val = PYGLIB_PyLong_AsLong(obj); if (val >= 0 && val <= G_MAXUINT) g_value_set_uint(value, (guint)val); else return -1; } else { g_value_set_uint(value, PyLong_AsUnsignedLong(obj)); } } break; case G_TYPE_LONG: g_value_set_long(value, PYGLIB_PyLong_AsLong(obj)); break; case G_TYPE_ULONG: #if PY_VERSION_HEX < 0x03000000 if (PyInt_Check(obj)) { long val; val = PYGLIB_PyLong_AsLong(obj); if (val < 0) { PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property"); return -1; } g_value_set_ulong(value, (gulong)val); } else #endif if (PyLong_Check(obj)) g_value_set_ulong(value, PyLong_AsUnsignedLong(obj)); else return -1; break; case G_TYPE_INT64: g_value_set_int64(value, PyLong_AsLongLong(obj)); break; case G_TYPE_UINT64: #if PY_VERSION_HEX < 0x03000000 if (PyInt_Check(obj)) { long v = PyInt_AsLong(obj); if (v < 0) { PyErr_SetString(PyExc_OverflowError, "negative value not allowed for uint64 property"); return -1; } g_value_set_uint64(value, v); } else #endif if (PyLong_Check(obj)) g_value_set_uint64(value, PyLong_AsUnsignedLongLong(obj)); else return -1; break; case G_TYPE_ENUM: { gint val = 0; if (pyg_enum_get_value(G_VALUE_TYPE(value), obj, &val) < 0) { PyErr_Clear(); return -1; } g_value_set_enum(value, val); } break; case G_TYPE_FLAGS: { gint val = 0; if (pyg_flags_get_value(G_VALUE_TYPE(value), obj, &val) < 0) { PyErr_Clear(); return -1; } g_value_set_flags(value, val); } break; case G_TYPE_FLOAT: g_value_set_float(value, PyFloat_AsDouble(obj)); break; case G_TYPE_DOUBLE: g_value_set_double(value, PyFloat_AsDouble(obj)); break; case G_TYPE_STRING: if (obj == Py_None) { g_value_set_string(value, NULL); #if PY_VERSION_HEX < 0x03000000 } else if (PyString_Check(obj)) { g_value_set_string(value, PyString_AsString(obj)); #endif } else if (PyUnicode_Check(obj)) { tmp = PyUnicode_AsUTF8String(obj); g_value_set_string(value, PYGLIB_PyBytes_AsString(tmp)); Py_DECREF(tmp); } else { PyErr_Clear(); return -1; } break; case G_TYPE_POINTER: if (obj == Py_None) g_value_set_pointer(value, NULL); else if (PyObject_TypeCheck(obj, &PyGPointer_Type) && G_VALUE_HOLDS(value, ((PyGPointer *)obj)->gtype)) g_value_set_pointer(value, pyg_pointer_get(obj, gpointer)); else if (PYGLIB_CPointer_Check(obj)) g_value_set_pointer(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; case G_TYPE_BOXED: { PyGTypeMarshal *bm; if (obj == Py_None) g_value_set_boxed(value, NULL); else if (G_VALUE_HOLDS(value, PY_TYPE_OBJECT)) g_value_set_boxed(value, obj); else if (PyObject_TypeCheck(obj, &PyGBoxed_Type) && G_VALUE_HOLDS(value, ((PyGBoxed *)obj)->gtype)) g_value_set_boxed(value, pyg_boxed_get(obj, gpointer)); else if (G_VALUE_HOLDS(value, G_TYPE_VALUE)) { GType type; GValue *n_value; type = pyg_type_from_object((PyObject*)Py_TYPE(obj)); if (G_UNLIKELY (! type)) { PyErr_Clear(); return -1; } n_value = g_new0 (GValue, 1); g_value_init (n_value, type); g_value_take_boxed (value, n_value); return pyg_value_from_pyobject (n_value, obj); } else if (PySequence_Check(obj) && G_VALUE_HOLDS(value, G_TYPE_VALUE_ARRAY)) return pyg_value_array_from_pyobject(value, obj, NULL); else if (PYGLIB_PyUnicode_Check(obj) && G_VALUE_HOLDS(value, G_TYPE_GSTRING)) { GString *string; char *buffer; Py_ssize_t len; if (PYGLIB_PyUnicode_AsStringAndSize(obj, &buffer, &len)) return -1; string = g_string_new_len(buffer, len); g_value_set_boxed(value, string); g_string_free (string, TRUE); break; } else if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL) return bm->tovalue(value, obj); else if (PYGLIB_CPointer_Check(obj)) g_value_set_boxed(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; } case G_TYPE_PARAM: if (PyGParamSpec_Check(obj)) g_value_set_param(value, PYGLIB_CPointer_GetPointer(obj, NULL)); else return -1; break; case G_TYPE_OBJECT: if (obj == Py_None) { g_value_set_object(value, NULL); } else if (PyObject_TypeCheck(obj, &PyGObject_Type) && G_TYPE_CHECK_INSTANCE_TYPE(pygobject_get(obj), G_VALUE_TYPE(value))) { g_value_set_object(value, pygobject_get(obj)); } else return -1; break; default: { PyGTypeMarshal *bm; if ((bm = pyg_type_lookup(G_VALUE_TYPE(value))) != NULL) return bm->tovalue(value, obj); break; } } if (PyErr_Occurred()) { g_value_unset(value); PyErr_Clear(); return -1; } return 0; }