static int
gi_gst_fraction_range_to_value (GValue * value, PyObject * object)
{
PyObject *min, *max;
GValue vmin = G_VALUE_INIT, vmax = G_VALUE_INIT;
min = PyObject_GetAttrString (object, "start");
if (min == NULL)
goto fail;
max = PyObject_GetAttrString (object, "stop");
if (max == NULL)
goto fail;
g_value_init (&vmin, GST_TYPE_FRACTION);
if (gi_gst_fraction_to_value (&vmin, min) < 0)
goto fail;
g_value_init (&vmax, GST_TYPE_FRACTION);
if (gi_gst_fraction_to_value (&vmax, max) < 0) {
g_value_unset (&vmin);
goto fail;
}
gst_value_set_fraction_range (value, &vmin, &vmax);
g_value_unset (&vmin);
g_value_unset (&vmax);
return 0;
fail:
PyErr_SetString (PyExc_KeyError,
"Object is not compatible with Gst.FractionRange");
return -1;
}
static void
fraction_range_rvalue2gvalue(VALUE value, GValue *result)
{
GValue *val;
val = RVAL2GOBJ(value);
gst_value_set_fraction_range(result,
gst_value_get_fraction_range_min(val),
gst_value_get_fraction_range_max(val));
}
static VALUE
fraction_range_set(VALUE self, VALUE min, VALUE max)
{
GValue min_value = {0}, max_value = {0};
rbgobj_initialize_gvalue(&min_value, min);
rbgobj_initialize_gvalue(&max_value, max);
gst_value_set_fraction_range(RVAL2GOBJ(self), &min_value, &max_value);
return Qnil;
}
static VALUE
fraction_range_initialize(VALUE self, VALUE min, VALUE max)
{
GValue min_value = G_VALUE_INIT, max_value = G_VALUE_INIT;
rbgobj_initialize_gvalue(&min_value, min);
rbgobj_initialize_gvalue(&max_value, max);
gst_value_set_fraction_range(DATA_PTR(self), &min_value, &max_value);
return Qnil;
}
static VALUE
fraction_range_set_max(VALUE self, VALUE max)
{
GValue *value;
GValue max_value = {0};
value = RVAL2GOBJ(self);
rbgobj_initialize_gvalue(&max_value, max);
gst_value_set_fraction_range(value,
gst_value_get_fraction_range_min(value),
&max_value);
return Qnil;
}
static VALUE
fraction_range_set_min(VALUE self, VALUE min)
{
GValue *value;
GValue min_value = G_VALUE_INIT;
value = RVAL2GOBJ(self);
rbgobj_initialize_gvalue(&min_value, min);
gst_value_set_fraction_range(value,
&min_value,
gst_value_get_fraction_range_max(value));
return Qnil;
}
static GstCaps *
gst_deinterlace2_getcaps (GstPad * pad)
{
GstCaps *ret;
GstDeinterlace2 *self = GST_DEINTERLACE2 (gst_pad_get_parent (pad));
GstPad *otherpad;
gint len;
const GstCaps *ourcaps;
GstCaps *peercaps;
GST_OBJECT_LOCK (self);
otherpad = (pad == self->srcpad) ? self->sinkpad : self->srcpad;
ourcaps = gst_pad_get_pad_template_caps (pad);
peercaps = gst_pad_peer_get_caps (otherpad);
if (peercaps) {
ret = gst_caps_intersect (ourcaps, peercaps);
gst_caps_unref (peercaps);
} else {
ret = gst_caps_copy (ourcaps);
}
GST_OBJECT_UNLOCK (self);
if (self->fields == GST_DEINTERLACE2_ALL) {
for (len = gst_caps_get_size (ret); len > 0; len--) {
GstStructure *s = gst_caps_get_structure (ret, len - 1);
const GValue *val;
val = gst_structure_get_value (s, "framerate");
if (!val)
continue;
if (G_VALUE_TYPE (val) == GST_TYPE_FRACTION) {
gint n, d;
n = gst_value_get_fraction_numerator (val);
d = gst_value_get_fraction_denominator (val);
if (!gst_fraction_double (&n, &d, pad != self->srcpad)) {
goto error;
}
gst_structure_set (s, "framerate", GST_TYPE_FRACTION, n, d, NULL);
} else if (G_VALUE_TYPE (val) == GST_TYPE_FRACTION_RANGE) {
const GValue *min, *max;
GValue nrange = { 0, }, nmin = {
0,}, nmax = {
0,};
gint n, d;
g_value_init (&nrange, GST_TYPE_FRACTION_RANGE);
g_value_init (&nmin, GST_TYPE_FRACTION);
g_value_init (&nmax, GST_TYPE_FRACTION);
min = gst_value_get_fraction_range_min (val);
max = gst_value_get_fraction_range_max (val);
n = gst_value_get_fraction_numerator (min);
d = gst_value_get_fraction_denominator (min);
if (!gst_fraction_double (&n, &d, pad != self->srcpad)) {
g_value_unset (&nrange);
g_value_unset (&nmax);
g_value_unset (&nmin);
goto error;
}
gst_value_set_fraction (&nmin, n, d);
n = gst_value_get_fraction_numerator (max);
d = gst_value_get_fraction_denominator (max);
if (!gst_fraction_double (&n, &d, pad != self->srcpad)) {
g_value_unset (&nrange);
g_value_unset (&nmax);
g_value_unset (&nmin);
goto error;
}
gst_value_set_fraction (&nmax, n, d);
gst_value_set_fraction_range (&nrange, &nmin, &nmax);
gst_structure_set_value (s, "framerate", &nrange);
g_value_unset (&nmin);
g_value_unset (&nmax);
g_value_unset (&nrange);
} else if (G_VALUE_TYPE (val) == GST_TYPE_LIST) {
const GValue *lval;
GValue nlist = { 0, };
GValue nval = { 0, };
gint i;
g_value_init (&nlist, GST_TYPE_LIST);
for (i = gst_value_list_get_size (val); i > 0; i--) {
gint n, d;
lval = gst_value_list_get_value (val, i);
if (G_VALUE_TYPE (lval) != GST_TYPE_FRACTION)
continue;
n = gst_value_get_fraction_numerator (lval);
d = gst_value_get_fraction_denominator (lval);
/* Double/Half the framerate but if this fails simply
* skip this value from the list */
if (!gst_fraction_double (&n, &d, pad != self->srcpad)) {
continue;
}
g_value_init (&nval, GST_TYPE_FRACTION);
gst_value_set_fraction (&nval, n, d);
gst_value_list_append_value (&nlist, &nval);
g_value_unset (&nval);
}
gst_structure_set_value (s, "framerate", &nlist);
g_value_unset (&nlist);
}
}
}
GST_DEBUG_OBJECT (pad, "Returning caps %" GST_PTR_FORMAT, ret);
return ret;
error:
GST_ERROR_OBJECT (pad, "Unable to transform peer caps");
gst_caps_unref (ret);
return NULL;
}
