bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, int value)
{
if (!GST_IS_COLOR_BALANCE(m_session->cameraBin())) {
// Camerabin doesn't implement gstcolorbalance interface
return false;
}
GstColorBalance *balance = GST_COLOR_BALANCE(m_session->cameraBin());
const GList *controls = gst_color_balance_list_channels(balance);
const GList *item;
GstColorBalanceChannel *colorBalanceChannel;
for (item = controls; item; item = g_list_next (item)) {
colorBalanceChannel = (GstColorBalanceChannel *)item->data;
if (!g_ascii_strcasecmp (colorBalanceChannel->label, channel.toAscii())) {
gst_color_balance_set_value (balance, colorBalanceChannel, value);
return true;
}
}
return false;
}
/* Process a color balance command */
static void update_color_channel (const gchar *channel_name, gboolean increase, GstColorBalance *cb) {
gdouble step;
gint value;
GstColorBalanceChannel *channel = NULL;
const GList *channels, *l;
/* Retrieve the list of channels and locate the requested one */
channels = gst_color_balance_list_channels (cb);
for (l = channels; l != NULL; l = l->next) {
GstColorBalanceChannel *tmp = (GstColorBalanceChannel *)l->data;
if (g_strrstr (tmp->label, channel_name)) {
channel = tmp;
break;
}
}
if (!channel)
return;
/* Change the channel's value */
step = 0.1 * (channel->max_value - channel->min_value);
value = gst_color_balance_get_value (cb, channel);
if (increase) {
value = (gint)(value + step);
if (value > channel->max_value)
value = channel->max_value;
} else {
value = (gint)(value - step);
if (value < channel->min_value)
value = channel->min_value;
}
gst_color_balance_set_value (cb, channel, value);
}
void
empathy_video_src_set_channel (GstElement *src,
EmpathyGstVideoSrcChannel channel, guint percent)
{
GstElement *color;
GstColorBalance *balance;
const GList *channels;
GList *l;
/* Find something supporting GstColorBalance */
color = gst_bin_get_by_interface (GST_BIN (src), GST_TYPE_COLOR_BALANCE);
if (color == NULL)
return;
balance = GST_COLOR_BALANCE (color);
channels = gst_color_balance_list_channels (balance);
for (l = (GList *) channels; l != NULL; l = g_list_next (l))
{
GstColorBalanceChannel *c = GST_COLOR_BALANCE_CHANNEL (l->data);
if (g_ascii_strcasecmp (c->label, channel_names[channel]) == 0)
{
gst_color_balance_set_value (balance, c,
((c->max_value - c->min_value) * percent)/100
+ c->min_value);
break;
}
}
g_object_unref (color);
}
void CameraBinImageProcessing::updateColorBalanceValues()
{
if (!GST_IS_COLOR_BALANCE(m_session->cameraBin())) {
// Camerabin doesn't implement gstcolorbalance interface
return;
}
GstColorBalance *balance = GST_COLOR_BALANCE(m_session->cameraBin());
const GList *controls = gst_color_balance_list_channels(balance);
const GList *item;
GstColorBalanceChannel *channel;
gint cur_value;
for (item = controls; item; item = g_list_next (item)) {
channel = (GstColorBalanceChannel *)item->data;
cur_value = gst_color_balance_get_value (balance, channel);
if (!g_ascii_strcasecmp (channel->label, "brightness")) {
m_values[QCameraImageProcessingControl::Brightness] = cur_value;
} else if (!g_ascii_strcasecmp (channel->label, "contrast")) {
m_values[QCameraImageProcessingControl::Contrast] = cur_value;
} else if (!g_ascii_strcasecmp (channel->label, "saturation")) {
m_values[QCameraImageProcessingControl::Saturation] = cur_value;
}
}
}
guint
empathy_video_src_get_supported_channels (GstElement *src)
{
GstColorBalance *balance;
const GList *channels;
GList *l;
guint result = 0;
balance = dup_color_balance (src);
if (balance == NULL)
goto out;
channels = gst_color_balance_list_channels (balance);
for (l = (GList *) channels; l != NULL; l = g_list_next (l))
{
GstColorBalanceChannel *channel = GST_COLOR_BALANCE_CHANNEL (l->data);
int i;
for (i = 0; i < NR_EMPATHY_GST_VIDEO_SRC_CHANNELS; i++)
{
if (g_ascii_strcasecmp (channel->label, channel_names[i]) == 0)
{
result |= (1 << i);
break;
}
}
}
g_object_unref (balance);
out:
return result;
}
guint
empathy_video_src_get_channel (GstElement *src,
EmpathyGstVideoSrcChannel channel)
{
GstColorBalance *balance;
const GList *channels;
GList *l;
guint percent = 0;
balance = dup_color_balance (src);
if (balance == NULL)
return percent;
channels = gst_color_balance_list_channels (balance);
for (l = (GList *) channels; l != NULL; l = g_list_next (l))
{
GstColorBalanceChannel *c = GST_COLOR_BALANCE_CHANNEL (l->data);
if (g_ascii_strcasecmp (c->label, channel_names[channel]) == 0)
{
percent =
((gst_color_balance_get_value (balance, c)
- c->min_value) * 100) /
(c->max_value - c->min_value);
break;
}
}
g_object_unref (balance);
return percent;
}
void CameraBinImageProcessing::updateColorBalanceValues()
{
if (!GST_IS_COLOR_BALANCE(m_session->cameraBin())) {
// Camerabin doesn't implement gstcolorbalance interface
return;
}
GstColorBalance *balance = GST_COLOR_BALANCE(m_session->cameraBin());
const GList *controls = gst_color_balance_list_channels(balance);
const GList *item;
GstColorBalanceChannel *channel;
gint cur_value;
qreal scaledValue = 0;
for (item = controls; item; item = g_list_next (item)) {
channel = (GstColorBalanceChannel *)item->data;
cur_value = gst_color_balance_get_value (balance, channel);
//map the [min_value..max_value] range to [-1.0 .. 1.0]
if (channel->min_value != channel->max_value) {
scaledValue = qreal(cur_value - channel->min_value) /
(channel->max_value - channel->min_value) * 2 - 1;
}
if (!g_ascii_strcasecmp (channel->label, "brightness")) {
m_values[QCameraImageProcessingControl::BrightnessAdjustment] = scaledValue;
} else if (!g_ascii_strcasecmp (channel->label, "contrast")) {
m_values[QCameraImageProcessingControl::ContrastAdjustment] = scaledValue;
} else if (!g_ascii_strcasecmp (channel->label, "saturation")) {
m_values[QCameraImageProcessingControl::SaturationAdjustment] = scaledValue;
}
}
}
bool CameraBinImageProcessing::setColorBalanceValue(const QString& channel, qreal value)
{
if (!GST_IS_COLOR_BALANCE(m_session->cameraBin())) {
// Camerabin doesn't implement gstcolorbalance interface
return false;
}
GstColorBalance *balance = GST_COLOR_BALANCE(m_session->cameraBin());
const GList *controls = gst_color_balance_list_channels(balance);
const GList *item;
GstColorBalanceChannel *colorBalanceChannel;
for (item = controls; item; item = g_list_next (item)) {
colorBalanceChannel = (GstColorBalanceChannel *)item->data;
if (!g_ascii_strcasecmp (colorBalanceChannel->label, channel.toLatin1())) {
//map the [-1.0 .. 1.0] range to [min_value..max_value]
gint scaledValue = colorBalanceChannel->min_value + qRound(
(value+1.0)/2.0 * (colorBalanceChannel->max_value - colorBalanceChannel->min_value));
gst_color_balance_set_value (balance, colorBalanceChannel, scaledValue);
return true;
}
}
return false;
}
QList<ColorBalanceChannelPtr> ColorBalance::channels() const
{
QList<ColorBalanceChannelPtr> result;
const GList *list = gst_color_balance_list_channels(object<GstColorBalance>());
while(list) {
result.append(ColorBalanceChannelPtr::wrap(GST_COLOR_BALANCE_CHANNEL(list->data)));
list = list->next;
}
return result;
}
int gstreamer_prepare_color_balance() {
if (color_balance_element)
gst_object_unref(color_balance_element);
color_balance_element = find_color_balance_element();
if (color_balance_element == NULL)
return 0;
if (!GST_IS_COLOR_BALANCE(color_balance_element))
return 0;
GList *channel_list = gst_color_balance_list_channels(
GST_COLOR_BALANCE(color_balance_element));
if (channel_list == NULL)
return 0;
for (int i = 0; i < 4; i++)
color_balance_channel[i] = NULL;
channel_list = g_list_first(channel_list);
while (channel_list) {
GstColorBalanceChannel *channel = channel_list->data;
if (strcasestr(channel->label, "BRIGHTNESS") != NULL)
color_balance_channel[CHANNEL_BRIGHTNESS] = channel;
else if (strcasestr(channel->label, "CONTRAST") != NULL)
color_balance_channel[CHANNEL_CONTRAST] = channel;
else if (strcasestr(channel->label, "HUE") != NULL)
color_balance_channel[CHANNEL_HUE] = channel;
else if (strcasestr(channel->label, "SATURATION") != NULL)
color_balance_channel[CHANNEL_SATURATION] = channel;
else
printf("gstplay: Unknown color balance channel %s detected.\n",
channel->label);
channel_list = g_list_next(channel_list);
}
int r = 0;
for (int i = 0; i < 4; i++) {
if (color_balance_channel[i] != NULL) {
// printf("gstplay: Color balance channel %s found.\n",
// color_balance_channel[i]->label);
if (find_xvimagesink() &&
strncmp(color_balance_channel[i]->label, "XV_", 3) != 0) {
char *s = g_malloc(strlen(color_balance_channel[i]->label) + 4);
sprintf(s, "XV_%s", color_balance_channel[i]->label);
g_free(color_balance_channel[i]->label);
color_balance_channel[i]->label = s;
printf("gstplay: Fixing mismatched xvimagesink color balance channel name to %s.\n",
s);
}
gint v = gst_color_balance_get_value(
GST_COLOR_BALANCE(color_balance_element), color_balance_channel[i]);
r |= 1 << i;
last_value_set[i] = v;
}
}
return r;
}
/* Output the current values of all Color Balance channels */
static void print_current_values (GstElement *pipeline) {
const GList *channels, *l;
/* Output Color Balance values */
channels = gst_color_balance_list_channels (GST_COLOR_BALANCE (pipeline));
for (l = channels; l != NULL; l = l->next) {
GstColorBalanceChannel *channel = (GstColorBalanceChannel *)l->data;
gint value = gst_color_balance_get_value (GST_COLOR_BALANCE (pipeline), channel);
g_print ("%s: %3d%% ", channel->label,
100 * (value - channel->min_value) / (channel->max_value - channel->min_value));
}
g_print ("\n");
}
Balance::Balance(GstElement *pipeline, QObject *parent)
: QObject(parent), balance(GST_COLOR_BALANCE(pipeline))
{
const GList *controls = gst_color_balance_list_channels(balance);
const GList *item;
GstColorBalanceChannel *channel;
gint index;
if (controls)
{
for (item = controls, index = 0; item != nullptr; item = item->next, ++index)
{
channel = (GstColorBalanceChannel *)item->data;
channels[QString(channel->label).toLower()] = channel;
}
}
}
static const GList *
gst_gl_sink_bin_color_balance_list_channels (GstColorBalance * balance)
{
GstGLSinkBin *self = GST_GL_SINK_BIN (balance);
GstColorBalance *balance_element = NULL;
const GList *list = NULL;
balance_element =
GST_COLOR_BALANCE (gst_bin_get_by_interface (GST_BIN (self),
GST_TYPE_COLOR_BALANCE));
if (balance_element) {
list = gst_color_balance_list_channels (balance_element);
gst_object_unref (balance_element);
}
return list;
}
static void
run_options (char opt)
{
int res;
switch (opt) {
case 'f':
{
GstTuner *tuner = GST_TUNER (source);
GstTunerChannel *channel;
guint freq;
channel = gst_tuner_get_channel (tuner);
freq = gst_tuner_get_frequency (tuner, channel);
printf ("\ntype the new frequency (current = %u) (-1 to cancel): ", freq);
res = scanf ("%u", &freq);
if (res != 1 || freq != -1)
gst_tuner_set_frequency (tuner, channel, freq);
}
break;
case 'n':
{
GstTuner *tuner = GST_TUNER (source);
const GList *item, *list;
const GstTunerNorm *current_norm;
GstTunerNorm *norm = NULL;
gint index, next_norm;
list = gst_tuner_list_norms (tuner);
current_norm = gst_tuner_get_norm (tuner);
printf ("\nlist of norms:\n");
for (item = list, index = 0; item != NULL; item = item->next, ++index) {
norm = item->data;
if (current_norm == norm) {
printf (" * %u - %s\n", index, norm->label);
} else {
printf (" %u - %s\n", index, norm->label);
}
}
printf ("\ntype the number of norm you want (-1 to cancel): ");
res = scanf ("%d", &next_norm);
if (res != 1 || next_norm < 0) {
break;
}
if (index <= next_norm) {
printf ("Norm %d not available\n", next_norm);
break;
}
for (item = list, index = 0; item != NULL && index <= next_norm;
item = item->next, ++index) {
norm = item->data;
}
if (norm)
gst_tuner_set_norm (tuner, norm);
}
break;
case 'i':
{
GstTuner *tuner = GST_TUNER (source);
const GList *item, *list;
const GstTunerChannel *current_channel;
GstTunerChannel *channel = NULL;
gint index, next_channel;
list = gst_tuner_list_channels (tuner);
current_channel = gst_tuner_get_channel (tuner);
printf ("\nlist of inputs:\n");
for (item = list, index = 0; item != NULL; item = item->next, ++index) {
channel = item->data;
if (current_channel == channel) {
printf (" * %u - %s\n", index, channel->label);
} else {
printf (" %u - %s\n", index, channel->label);
}
}
printf ("\ntype the number of input you want (-1 to cancel): ");
res = scanf ("%d", &next_channel);
if (res != 1 || next_channel < 0) {
break;
}
if (index <= next_channel) {
printf ("Input %d not available\n", next_channel);
break;
}
for (item = list, index = 0; item != NULL && index <= next_channel;
item = item->next, ++index) {
channel = item->data;
}
if (channel)
gst_tuner_set_channel (tuner, channel);
}
break;
case 'e':
gst_element_set_state (pipeline, GST_STATE_NULL);
g_main_loop_quit (loop);
printf ("Bye\n");
g_thread_exit (0);
break;
case 'c':
{
GstColorBalance *balance = GST_COLOR_BALANCE (source);
const GList *controls;
GstColorBalanceChannel *channel;
const GList *item;
gint index, new_value;
controls = gst_color_balance_list_channels (balance);
printf ("\n");
if (controls == NULL) {
printf ("There is no list of colorbalance controls\n");
goto done;
}
if (controls) {
printf ("list of controls:\n");
for (item = controls, index = 0; item != NULL;
item = item->next, ++index) {
channel = item->data;
printf (" %u - %s (%d - %d) = %d\n", index, channel->label,
channel->min_value, channel->max_value,
gst_color_balance_get_value (balance, channel));
}
printf ("\ntype the number of color control you want (-1 to cancel): ");
res = scanf ("%d", &new_value);
if (res != 1 || new_value == -1)
break;
for (item = controls, index = 0; item != NULL && index <= new_value;
item = item->next, ++index) {
channel = item->data;
}
printf (" %u - %s (%d - %d) = %d, type the new value: ", index - 1,
channel->label, channel->min_value, channel->max_value,
gst_color_balance_get_value (balance, channel));
res = scanf ("%d", &new_value);
if (res != 1 || new_value == -1)
break;
gst_color_balance_set_value (balance, channel, new_value);
}
}
case 'v':
{
GstVideoOrientation *vidorient = GST_VIDEO_ORIENTATION (source);
gboolean flip = FALSE;
gint center = 0;
printf ("\n");
if (gst_video_orientation_get_hflip (vidorient, &flip)) {
gint new_value;
printf ("Horizontal flip is %s\n", flip ? "on" : "off");
printf ("\ntype 1 to toggle (-1 to cancel): ");
res = scanf ("%d", &new_value);
if (res != 1 || new_value == 1) {
flip = !flip;
if (gst_video_orientation_set_hflip (vidorient, flip)) {
gst_video_orientation_get_hflip (vidorient, &flip);
printf ("Now horizontal flip is %s\n", flip ? "on" : "off");
} else {
printf ("Error toggling horizontal flip\n");
}
} else {
}
} else {
printf ("Horizontal flip control not available\n");
}
if (gst_video_orientation_get_vflip (vidorient, &flip)) {
gint new_value;
printf ("\nVertical flip is %s\n", flip ? "on" : "off");
printf ("\ntype 1 to toggle (-1 to cancel): ");
res = scanf ("%d", &new_value);
if (res != 1 || new_value == 1) {
flip = !flip;
if (gst_video_orientation_set_vflip (vidorient, flip)) {
gst_video_orientation_get_vflip (vidorient, &flip);
printf ("Now vertical flip is %s\n", flip ? "on" : "off");
} else {
printf ("Error toggling vertical flip\n");
}
} else {
}
} else {
printf ("Vertical flip control not available\n");
}
if (gst_video_orientation_get_hcenter (vidorient, ¢er)) {
printf ("Horizontal center is %d\n", center);
printf ("\ntype the new horizontal center value (-1 to cancel): ");
res = scanf ("%d", ¢er);
if (res != 1 || center != -1) {
if (gst_video_orientation_set_hcenter (vidorient, center)) {
gst_video_orientation_get_hcenter (vidorient, ¢er);
printf ("Now horizontal center is %d\n", center);
} else {
printf ("Error setting horizontal center\n");
}
} else {
}
} else {
printf ("Horizontal center control not available\n");
}
if (gst_video_orientation_get_vcenter (vidorient, ¢er)) {
printf ("Vertical center is %d\n", center);
printf ("\ntype the new vertical center value (-1 to cancel): ");
res = scanf ("%d", ¢er);
if (res != 1 || center != -1) {
if (gst_video_orientation_set_vcenter (vidorient, center)) {
gst_video_orientation_get_vcenter (vidorient, ¢er);
printf ("Now vertical center is %d\n", center);
} else {
printf ("Error setting vertical center\n");
}
} else {
}
} else {
printf ("Vertical center control not available\n");
}
}
break;
break;
default:
if (opt != 10)
printf ("error: invalid option %c", opt);
break;
}
done:
return;
}
