Convert Grayscale to RGB - arrays

Question

My problem is: I have a picture in my buffer buffer = (unsigned short *) malloc(imageSize*2);
This picture is 8 bit per pixel and 1 byte per pixel, so it is a Grayscale picture.
But to display it I need an RGB picture. Because only an RGB picture is supported.
So I need to change the picture from:
index | 1 | 2 |...
grayvalue | 128 | 135 |...
to
index | 1 | 2 |...
grayvalue | 128,128,128 | 135,135,135 |...
for | r,g,b |.
My idea is to make an array from the buffer array[grayvalue] = buffer[count], somehow add 2 grayvalues to the same pixel and change the array back into a buffer. But I can´t find how to get an array from a buffer and how to add the grayvalues to 1 pixel. I hope someone has an idea what I mean and can link me to information that I overlooked.
Edit:
#include <stdlib.h>
#include <gtk/gtk.h>
int main (int argc, char *argv[])
{
long int imageSize = 0;
unsigned short *buffer = NULL;
const int Width = 1936, Height = 1460;
/*code to take raw image data from camera*/
// Put raw image data from the camera in the buffer.
buffer = (unsigned short *) malloc(imageSize*2);
// GTK
GtkWidget *window;
GtkWidget* image;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data ((unsigned short *) buffer, GDK_COLORSPACE_RGB,FALSE, 8,
Width, Height, Width*1, NULL, NULL);
gtk_window_set_title (GTK_WINDOW (window), "Image Viewer");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
image = gtk_image_new_from_pixbuf (pixbuf);
gtk_container_add(GTK_CONTAINER (window), image);
gtk_widget_show_all (window);
gtk_main ();
free (buffer);
return 0;
}
This is the program I use to Display my Image. The Code that I use to take a picture with the camera can´t be shared.

Answer 1

Your code hase 1 main problem:
You create the pixbuf with wrong rowstride value. It is in bytes, not in pixels. For RGB pixels you need 3 bytes.
After this is fixed you need to convert your greyscale pixels to RGBB pixels. This is not "combining pixels" but simply repeating the same value.
This is some sample code to convert 8bit greyscale to 24bit RGB pixels:
// build:
// gcc -o test `pkg-config --cflags gtk+-3.0` test.c `pkg-config --libs gtk+-3.0`
#include <stdlib.h>
#include <stdint.h>
#include <gtk/gtk.h>
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
} rgb;
int main (int argc, char *argv[])
{
size_t Width = 1936;
size_t Height = 1280;
size_t Stride_8 = Width; // Might need rounding up
size_t Stride_rgb = Width; // Might need rounding up
//Due to lack of camera data, lets use some dummy data...
uint8_t *buffer_8 = malloc(Stride_8*Height);
for (size_t x = 0; x < Width; x++)
for (size_t y = 0; y < Height; y++)
buffer_8[Stride_8*y + x] = (x+y) & 0xFF;
/*code to take raw image data from camera*/
// Put greyscale image data from the camera into the RGB buffer.
rgb *buffer_rgb = malloc(Stride_rgb * Height * sizeof(rgb));
for (size_t x = 0; x < Width; x++)
for (size_t y = 0; y < Height; y++)
{
// Convert 1 byte greyscale in 3 byte RGB:
uint8_t grey = buffer_8[Stride_8*y + x];
buffer_rgb[Stride_rgb*y + x].r = grey;
buffer_rgb[Stride_rgb*y + x].g = grey;
buffer_rgb[Stride_rgb*y + x].b = grey;
}
// GTK
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (window), "test");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
GdkPixbuf *pixbuf_rgb = gdk_pixbuf_new_from_data((guchar*)buffer_rgb, GDK_COLORSPACE_RGB,FALSE, 8,
Width, Height, Stride_rgb*3, NULL, NULL);
GtkWidget *image = gtk_image_new_from_pixbuf(pixbuf_rgb);
gtk_container_add(GTK_CONTAINER(window), image);
gtk_widget_show_all(window);
gtk_main();
free(buffer_rgb);
free(buffer_8);
return 0;
}