static void
get_supported_framerates (ofGstVideoFormat &video_format, GstStructure &structure)
{
const GValue *framerates;
int i, j;
framerates = gst_structure_get_value (&structure, "framerate");
if (GST_VALUE_HOLDS_FRACTION (framerates))
{
video_format.num_framerates = 1;
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
video_format.framerates[0].numerator = gst_value_get_fraction_numerator (framerates);
video_format.framerates[0].denominator = gst_value_get_fraction_denominator (framerates);
}
else if (GST_VALUE_HOLDS_LIST (framerates))
{
video_format.num_framerates = gst_value_list_get_size (framerates);
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
for (i = 0; i < video_format.num_framerates; i++)
{
const GValue *value;
value = gst_value_list_get_value (framerates, i);
video_format.framerates[i].numerator = gst_value_get_fraction_numerator (value);
video_format.framerates[i].denominator = gst_value_get_fraction_denominator (value);
}
}
else if (GST_VALUE_HOLDS_FRACTION_RANGE (framerates))
{
int numerator_min, denominator_min, numerator_max, denominator_max;
const GValue *fraction_range_min;
const GValue *fraction_range_max;
fraction_range_min = gst_value_get_fraction_range_min (framerates);
numerator_min = gst_value_get_fraction_numerator (fraction_range_min);
denominator_min = gst_value_get_fraction_denominator (fraction_range_min);
fraction_range_max = gst_value_get_fraction_range_max (framerates);
numerator_max = gst_value_get_fraction_numerator (fraction_range_max);
denominator_max = gst_value_get_fraction_denominator (fraction_range_max);
g_print ("FractionRange: %d/%d - %d/%d\n", numerator_min, denominator_min, numerator_max, denominator_max);
video_format.num_framerates = (numerator_max - numerator_min + 1) * (denominator_max - denominator_min + 1);
video_format.framerates = new ofGstFramerate[video_format.num_framerates];
int k = 0;
for (i = numerator_min; i <= numerator_max; i++)
{
for (j = denominator_min; j <= denominator_max; j++)
{
video_format.framerates[k].numerator = i;
video_format.framerates[k].denominator = j;
k++;
}
}
}
else
{
g_critical ("GValue type %s, cannot be handled for framerates", G_VALUE_TYPE_NAME (framerates));
}
}
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_to_a(VALUE self)
{
GValue *value;
value = RVAL2GOBJ(self);
return rb_ary_new3(2,
GVAL2RVAL(gst_value_get_fraction_range_min(value)),
GVAL2RVAL(gst_value_get_fraction_range_max(value)));
}
static void
gst_value_fraction_get_extremes (const GValue * v,
gint * min_num, gint * min_denom, gint * max_num, gint * max_denom)
{
if (GST_VALUE_HOLDS_FRACTION (v)) {
*min_num = *max_num = gst_value_get_fraction_numerator (v);
*min_denom = *max_denom = gst_value_get_fraction_denominator (v);
} else if (GST_VALUE_HOLDS_FRACTION_RANGE (v)) {
const GValue *min, *max;
min = gst_value_get_fraction_range_min (v);
*min_num = gst_value_get_fraction_numerator (min);
*min_denom = gst_value_get_fraction_denominator (min);
max = gst_value_get_fraction_range_max (v);
*max_num = gst_value_get_fraction_numerator (max);
*max_denom = gst_value_get_fraction_denominator (max);
} else if (GST_VALUE_HOLDS_LIST (v)) {
gint min_n = G_MAXINT, min_d = 1, max_n = 0, max_d = 1;
int i, n;
*min_num = G_MAXINT;
*min_denom = 1;
*max_num = 0;
*max_denom = 1;
n = gst_value_list_get_size (v);
g_assert (n > 0);
for (i = 0; i < n; i++) {
const GValue *t = gst_value_list_get_value (v, i);
gst_value_fraction_get_extremes (t, &min_n, &min_d, &max_n, &max_d);
if (gst_util_fraction_compare (min_n, min_d, *min_num, *min_denom) < 0) {
*min_num = min_n;
*min_denom = min_d;
}
if (gst_util_fraction_compare (max_n, max_d, *max_num, *max_denom) > 0) {
*max_num = max_n;
*max_denom = max_d;
}
}
} else {
g_warning ("Unknown type for framerate");
*min_num = 0;
*min_denom = 1;
*max_num = G_MAXINT;
*max_denom = 1;
}
}
static VALUE
fraction_range_set_min(VALUE self, VALUE min)
{
GValue *value;
GValue min_value = {0};
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 void get_supported_framerates (ofGstVideoFormat &video_format, GstStructure &structure)
{
const GValue *framerates;
ofGstFramerate framerate;
framerates = gst_structure_get_value (&structure, "framerate");
if (GST_VALUE_HOLDS_FRACTION (framerates)){
framerate.numerator = gst_value_get_fraction_numerator (framerates);
framerate.denominator = gst_value_get_fraction_denominator (framerates);
video_format.framerates.push_back(framerate);
ofLog(OF_LOG_NOTICE,"%d/%d ", framerate.numerator,
framerate.denominator);
}else if (GST_VALUE_HOLDS_LIST (framerates)){
int num_framerates = gst_value_list_get_size (framerates);
for (int i = 0; i < num_framerates; i++){
const GValue *value = gst_value_list_get_value (framerates, i);
framerate.numerator = gst_value_get_fraction_numerator (value);
framerate.denominator = gst_value_get_fraction_denominator (value);
video_format.framerates.push_back(framerate);
ofLog(OF_LOG_NOTICE,"%d/%d ", framerate.numerator,
framerate.denominator);
}
}else if (GST_VALUE_HOLDS_FRACTION_RANGE (framerates)){
int numerator_min, denominator_min, numerator_max, denominator_max;
const GValue *fraction_range_min;
const GValue *fraction_range_max;
fraction_range_min = gst_value_get_fraction_range_min (framerates);
numerator_min = gst_value_get_fraction_numerator (fraction_range_min);
denominator_min = gst_value_get_fraction_denominator (fraction_range_min);
fraction_range_max = gst_value_get_fraction_range_max (framerates);
numerator_max = gst_value_get_fraction_numerator (fraction_range_max);
denominator_max = gst_value_get_fraction_denominator (fraction_range_max);
ofLog(OF_LOG_NOTICE,"from %d/%d to %d/%d", numerator_min,
denominator_max, numerator_max, denominator_min);
for (int i = numerator_min; i <= numerator_max; i++){
for (int j = denominator_min; j <= denominator_max; j++){
framerate.numerator = i;
framerate.denominator = j;
video_format.framerates.push_back(framerate);
}
}
}else{
ofLog (OF_LOG_WARNING,"unknown GValue type %s for framerates", G_VALUE_TYPE_NAME (framerates));
}
}
static PyObject *
gi_gst_fraction_range_from_value (const GValue * value)
{
PyObject *min, *max, *fraction_range_type, *fraction_range;
const GValue *fraction;
fraction = gst_value_get_fraction_range_min (value);
min = gi_gst_fraction_from_value (fraction);
fraction = gst_value_get_fraction_range_max (value);
max = gi_gst_fraction_from_value (fraction);
fraction_range_type = gi_gst_get_type ("FractionRange");
fraction_range = PyObject_CallFunction (fraction_range_type, "NN", min, max);
Py_DECREF (fraction_range_type);
return fraction_range;
}
static void
_get_fraction_range (GstStructure * s, const gchar * field, gint * fps_n_min,
gint * fps_d_min, gint * fps_n_max, gint * fps_d_max)
{
const GValue *value;
const GValue *min_v, *max_v;
value = gst_structure_get_value (s, field);
fail_unless (value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (value));
min_v = gst_value_get_fraction_range_min (value);
fail_unless (GST_VALUE_HOLDS_FRACTION (min_v));
*fps_n_min = gst_value_get_fraction_numerator (min_v);
*fps_d_min = gst_value_get_fraction_denominator (min_v);
max_v = gst_value_get_fraction_range_max (value);
fail_unless (GST_VALUE_HOLDS_FRACTION (max_v));
*fps_n_max = gst_value_get_fraction_numerator (max_v);
*fps_d_max = gst_value_get_fraction_denominator (max_v);
}
static VALUE
fraction_range_get_max(VALUE self)
{
return GVAL2RVAL(gst_value_get_fraction_range_max(RVAL2GOBJ(self)));
}
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;
}
void test_simplify()
{
GstStructure *s1, *s2;
gboolean did_simplify;
GstCaps *caps;
caps = gst_caps_from_string (non_simple_caps_string);
fail_unless (caps != NULL,
"gst_caps_from_string (non_simple_caps_string) failed");
did_simplify = gst_caps_do_simplify (caps);
fail_unless (did_simplify == TRUE,
"gst_caps_do_simplify() should have worked");
/* check simplified caps, should be:
*
* video/x-raw-rgb, bpp=(int)8, depth=(int)8, endianness=(int)1234,
* framerate=(fraction)[ 1/100, 100 ], width=(int)[ 16, 4096 ],
* height=(int)[ 16, 4096 ];
* video/x-raw-yuv, format=(fourcc){ YV12, YUY2, I420 },
* width=(int)[ 16, 4096 ], height=(int)[ 16, 4096 ],
* framerate=(fraction)[ 1/100, 100 ]
*/
fail_unless (gst_caps_get_size (caps) == 2);
s1 = gst_caps_get_structure (caps, 0);
s2 = gst_caps_get_structure (caps, 1);
fail_unless (s1 != NULL);
fail_unless (s2 != NULL);
if (!gst_structure_has_name (s1, "video/x-raw-rgb")) {
GstStructure *tmp;
tmp = s1;
s1 = s2;
s2 = tmp;
}
fail_unless (gst_structure_has_name (s1, "video/x-raw-rgb"));
{
const GValue *framerate_value;
const GValue *width_value;
const GValue *height_value;
const GValue *val_fps;
GValue test_fps = { 0, };
gint bpp, depth, endianness;
gint min_width, max_width;
gint min_height, max_height;
fail_unless (gst_structure_get_int (s1, "bpp", &bpp));
fail_unless (bpp == 8);
fail_unless (gst_structure_get_int (s1, "depth", &depth));
fail_unless (depth == 8);
fail_unless (gst_structure_get_int (s1, "endianness", &endianness));
fail_unless (endianness == G_LITTLE_ENDIAN);
g_value_init (&test_fps, GST_TYPE_FRACTION);
framerate_value = gst_structure_get_value (s1, "framerate");
fail_unless (framerate_value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (framerate_value));
val_fps = gst_value_get_fraction_range_min (framerate_value);
gst_value_set_fraction (&test_fps, 1, 100);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
val_fps = gst_value_get_fraction_range_max (framerate_value);
gst_value_set_fraction (&test_fps, 100, 1);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
g_value_unset (&test_fps);
width_value = gst_structure_get_value (s1, "width");
fail_unless (width_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (width_value));
min_width = gst_value_get_int_range_min (width_value);
max_width = gst_value_get_int_range_max (width_value);
fail_unless (min_width == 16 && max_width == 4096);
height_value = gst_structure_get_value (s1, "height");
fail_unless (height_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (height_value));
min_height = gst_value_get_int_range_min (height_value);
max_height = gst_value_get_int_range_max (height_value);
fail_unless (min_height == 16 && max_height == 4096);
}
fail_unless (gst_structure_has_name (s2, "video/x-raw-yuv"));
{
const GValue *framerate_value;
const GValue *format_value;
const GValue *width_value;
const GValue *height_value;
const GValue *val_fps;
GValue test_fps = { 0, };
gint min_width, max_width;
gint min_height, max_height;
format_value = gst_structure_get_value (s2, "format");
fail_unless (format_value != NULL);
fail_unless (GST_VALUE_HOLDS_LIST (format_value));
fail_unless (gst_value_list_get_size (format_value) == 3);
fail_unless (check_fourcc_list (format_value) == TRUE);
g_value_init (&test_fps, GST_TYPE_FRACTION);
framerate_value = gst_structure_get_value (s2, "framerate");
fail_unless (framerate_value != NULL);
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (framerate_value));
val_fps = gst_value_get_fraction_range_min (framerate_value);
gst_value_set_fraction (&test_fps, 1, 100);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
val_fps = gst_value_get_fraction_range_max (framerate_value);
gst_value_set_fraction (&test_fps, 100, 1);
fail_unless (gst_value_compare (&test_fps, val_fps) == GST_VALUE_EQUAL);
g_value_unset (&test_fps);
width_value = gst_structure_get_value (s2, "width");
fail_unless (width_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (width_value));
min_width = gst_value_get_int_range_min (width_value);
max_width = gst_value_get_int_range_max (width_value);
fail_unless (min_width == 16 && max_width == 4096);
height_value = gst_structure_get_value (s2, "height");
fail_unless (height_value != NULL);
fail_unless (GST_VALUE_HOLDS_INT_RANGE (height_value));
min_height = gst_value_get_int_range_min (height_value);
max_height = gst_value_get_int_range_max (height_value);
fail_unless (min_height == 16 && max_height == 4096);
}
gst_caps_unref (caps);
}
