static void
check_rgb_buf (const guint8 * pixels, guint32 r_mask, guint32 g_mask,
guint32 b_mask, guint32 a_mask, guint8 r_expected, guint8 g_expected,
guint8 b_expected, guint bpp, guint depth)
{
guint32 pixel, red, green, blue, alpha;
switch (bpp) {
case 32:
pixel = GST_READ_UINT32_BE (pixels);
break;
case 24:
pixel = (GST_READ_UINT8 (pixels) << 16) |
(GST_READ_UINT8 (pixels + 1) << 8) |
(GST_READ_UINT8 (pixels + 2) << 0);
break;
case 16:
if (G_BYTE_ORDER == G_LITTLE_ENDIAN)
pixel = GST_READ_UINT16_LE (pixels);
else
pixel = GST_READ_UINT16_BE (pixels);
break;
default:
g_return_if_reached ();
}
red = right_shift_colour (r_mask, pixel);
green = right_shift_colour (g_mask, pixel);
blue = right_shift_colour (b_mask, pixel);
alpha = right_shift_colour (a_mask, pixel);
/* can't enable this by default, valgrind will complain about accessing
* uninitialised memory for the depth=24,bpp=32 formats ... */
/* GST_LOG ("pixels: 0x%02x 0x%02x 0x%02x 0x%02x => pixel = 0x%08x",
pixels[0], (guint) pixels[1], pixels[2], pixels[3], pixel); */
/* fix up the mask (for rgb15/16) */
if (bpp == 16) {
r_expected = fix_expected_colour (r_mask, r_expected);
g_expected = fix_expected_colour (g_mask, g_expected);
b_expected = fix_expected_colour (b_mask, b_expected);
}
fail_unless (red == r_expected, "RED: expected 0x%02x, found 0x%02x",
r_expected, red);
fail_unless (green == g_expected, "GREEN: expected 0x%02x, found 0x%02x",
g_expected, green);
fail_unless (blue == b_expected, "BLUE: expected 0x%02x, found 0x%02x",
b_expected, blue);
fail_unless (a_mask == 0 || alpha != 0); /* better than nothing */
}
/* Note: lots of this code here is also in the videotestsrc.c unit test */
void test_rgb_to_rgb()
{
const struct
{
const gchar *pattern_name;
gint pattern_enum;
guint8 r_expected;
guint8 g_expected;
guint8 b_expected;
} test_patterns[] = {
{
"white", 3, 0xff, 0xff, 0xff}, {
"red", 4, 0xff, 0x00, 0x00}, {
"green", 5, 0x00, 0xff, 0x00}, {
"blue", 6, 0x00, 0x00, 0xff}, {
"black", 2, 0x00, 0x00, 0x00}
};
GstElement *pipeline, *src, *filter1, *csp, *filter2, *sink;
const GstCaps *template_caps;
GstBuffer *buf = NULL;
GstPad *srcpad;
GList *conversions, *l;
gint p;
/* test check function */
fail_unless (right_shift_colour (0x00ff0000, 0x11223344) == 0x22);
pipeline = gst_pipeline_new ("pipeline");
src = gst_check_setup_element ("videotestsrc");
filter1 = gst_check_setup_element ("capsfilter");
csp = gst_check_setup_element ("ffmpegcolorspace");
filter2 = gst_element_factory_make ("capsfilter", "to_filter");
sink = gst_check_setup_element ("fakesink");
gst_bin_add_many (GST_BIN (pipeline), src, filter1, csp, filter2, sink, NULL);
fail_unless (gst_element_link (src, filter1));
fail_unless (gst_element_link (filter1, csp));
fail_unless (gst_element_link (csp, filter2));
fail_unless (gst_element_link (filter2, sink));
srcpad = gst_element_get_pad (src, "src");
template_caps = gst_pad_get_pad_template_caps (srcpad);
gst_object_unref (srcpad);
g_object_set (sink, "signal-handoffs", TRUE, NULL);
g_signal_connect (sink, "preroll-handoff", G_CALLBACK (got_buf_cb), &buf);
GST_LOG ("videotestsrc src template caps: %" GST_PTR_FORMAT, template_caps);
conversions = create_rgb_conversions ();
for (l = conversions; l != NULL; l = l->next) {
RGBConversion *conv = (RGBConversion *) l->data;
/* does videotestsrc support the from_caps? */
if (!gst_caps_is_subset (conv->from_caps, template_caps)) {
GST_DEBUG ("videotestsrc doesn't support from_caps %" GST_PTR_FORMAT,
conv->from_caps);
continue;
}
/* caps are supported, let's run some tests then ... */
for (p = 0; p < G_N_ELEMENTS (test_patterns); ++p) {
GstStateChangeReturn state_ret;
RGBFormat *from = &conv->from_fmt;
RGBFormat *to = &conv->to_fmt;
/* trick compiler into thinking from is used, might throw warning
* otherwise if the debugging system is disabled */
fail_unless (from != NULL);
gst_element_set_state (pipeline, GST_STATE_NULL);
g_object_set (src, "pattern", test_patterns[p].pattern_enum, NULL);
GST_INFO ("%5s %u/%u %08x %08x %08x %08x %u => "
"%5s %u/%u %08x %08x %08x %08x %u, pattern=%s",
from->nick, from->bpp, from->depth, from->red_mask,
from->green_mask, from->blue_mask, from->alpha_mask,
from->endianness, to->nick, to->bpp, to->depth, to->red_mask,
to->green_mask, to->blue_mask, to->alpha_mask, to->endianness,
test_patterns[p].pattern_name);
/* now get videotestsrc to produce a buffer with the given caps */
g_object_set (filter1, "caps", conv->from_caps, NULL);
/* ... and force ffmpegcolorspace to convert to our target caps */
g_object_set (filter2, "caps", conv->to_caps, NULL);
state_ret = gst_element_set_state (pipeline, GST_STATE_PAUSED);
if (state_ret == GST_STATE_CHANGE_FAILURE) {
GstMessage *msg;
GError *err = NULL;
msg = gst_bus_poll (GST_ELEMENT_BUS (pipeline), GST_MESSAGE_ERROR, 0);
fail_if (msg == NULL, "expected ERROR message on the bus");
fail_unless (GST_MESSAGE_TYPE (msg) == GST_MESSAGE_ERROR);
gst_message_parse_error (msg, &err, NULL);
fail_unless (err != NULL);
if (msg->src == GST_OBJECT_CAST (src) &&
err->code == GST_STREAM_ERROR_FORMAT) {
GST_DEBUG ("ffmpegcolorspace does not support this conversion");
gst_message_unref (msg);
g_error_free (err);
continue;
}
fail_unless (state_ret != GST_STATE_CHANGE_FAILURE,
"pipeline _set_state() to PAUSED failed: %s", err->message);
}
state_ret = gst_element_get_state (pipeline, NULL, NULL, GST_CLOCK_TIME_NONE);
fail_unless (state_ret == GST_STATE_CHANGE_SUCCESS,
"pipeline failed going to PAUSED state");
state_ret = gst_element_set_state (pipeline, GST_STATE_NULL);
fail_unless (state_ret == GST_STATE_CHANGE_SUCCESS);
fail_unless (buf != NULL);
/* check buffer caps */
{
GstStructure *s;
gint v;
fail_unless (GST_BUFFER_CAPS (buf) != NULL);
s = gst_caps_get_structure (GST_BUFFER_CAPS (buf), 0);
fail_unless (gst_structure_get_int (s, "bpp", &v));
fail_unless_equals_int (v, to->bpp);
fail_unless (gst_structure_get_int (s, "depth", &v));
fail_unless_equals_int (v, to->depth);
fail_unless (gst_structure_get_int (s, "red_mask", &v));
fail_unless_equals_int (v, to->red_mask);
fail_unless (gst_structure_get_int (s, "green_mask", &v));
fail_unless_equals_int (v, to->green_mask);
fail_unless (gst_structure_get_int (s, "blue_mask", &v));
fail_unless_equals_int (v, to->blue_mask);
/* there mustn't be an alpha_mask if there's no alpha component */
if (to->depth == 32) {
fail_unless (gst_structure_get_int (s, "alpha_mask", &v));
fail_unless_equals_int (v, to->alpha_mask);
} else {
fail_unless (gst_structure_get_value (s, "alpha_mask") == NULL);
}
}
/* now check the top-left pixel */
check_rgb_buf (GST_BUFFER_DATA (buf), to->red_mask,
to->green_mask, to->blue_mask, to->alpha_mask,
test_patterns[p].r_expected, test_patterns[p].g_expected,
test_patterns[p].b_expected, to->endianness, to->bpp, to->depth);
gst_buffer_unref (buf);
buf = NULL;
}
}
g_list_foreach (conversions, (GFunc) rgb_conversion_free, NULL);
g_list_free (conversions);
gst_element_set_state (pipeline, GST_STATE_NULL);
gst_object_unref (pipeline);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}