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;
}