static gboolean
gst_gl_overlay_filter_texture (GstGLFilter * filter, guint in_tex,
guint out_tex)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
if (overlay->pbuf_has_changed && (overlay->location != NULL)) {
if ((overlay->type_file = gst_gl_overlay_load_png (filter)) == 0)
if ((overlay->type_file = gst_gl_overlay_load_jpeg (filter)) == 0)
overlay->pixbuf = NULL;
/* if loader failed then context is turned off */
gst_gl_context_thread_add (filter->context, init_pixbuf_texture, overlay);
if (overlay->pixbuf) {
free (overlay->pixbuf);
overlay->pixbuf = NULL;
}
overlay->pbuf_has_changed = FALSE;
}
gst_gl_filter_render_to_target (filter, TRUE, in_tex, out_tex,
gst_gl_overlay_callback, overlay);
return TRUE;
}
static void
gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (stuff);
GstGLFilter *filter = GST_GL_FILTER (overlay);
const GstGLFuncs *gl = filter->context->gl_vtable;
gl->MatrixMode (GL_PROJECTION);
gl->LoadIdentity ();
gluPerspective (70.0f,
(GLfloat) overlay->width_window / (GLfloat) overlay->height_window, 1.0f,
1000.0f);
gl->Enable (GL_DEPTH_TEST);
gluLookAt (0.0, 0.0, 0.01, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
if (!overlay->video_top) {
if (overlay->pbuftexture != 0)
gst_gl_overlay_load_texture (overlay, overlay->pbuftexture, 0);
// if (overlay->stretch) {
// width = (gfloat) overlay->width;
// height = (gfloat) overlay->height;
// }
gl->LoadIdentity ();
gst_gl_overlay_load_texture (overlay, texture, 1);
} else {
gst_gl_overlay_load_texture (overlay, texture, 1);
if (overlay->pbuftexture == 0)
return;
// if (overlay->stretch) {
// width = (gfloat) overlay->width;
// height = (gfloat) overlay->height;
// }
gl->LoadIdentity ();
gst_gl_overlay_load_texture (overlay, overlay->pbuftexture, 0);
}
}
static void
init_pixbuf_texture (GstGLContext * context, gpointer data)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (data);
GstGLFilter *filter = GST_GL_FILTER (overlay);
const GstGLFuncs *gl = filter->context->gl_vtable;
if (overlay->pixbuf) {
gl->DeleteTextures (1, &overlay->pbuftexture);
gl->GenTextures (1, &overlay->pbuftexture);
if (overlay->type_file == 1) {
gl->BindTexture (GL_TEXTURE_2D, overlay->pbuftexture);
gl->TexImage2D (GL_TEXTURE_2D, 0, GL_RGBA,
(gint) overlay->width, (gint) overlay->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, overlay->pixbuf);
} else if (overlay->type_file == 2) {
gl->BindTexture (GL_TEXTURE_2D, overlay->pbuftexture);
gl->TexImage2D (GL_TEXTURE_2D, 0, overlay->internalFormat,
overlay->width, overlay->height, 0, overlay->format,
GL_UNSIGNED_BYTE, overlay->pixbuf);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl->TexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
}
}
static gboolean
gst_gl_overlay_filter (GstGLFilter * filter, GstGLBuffer * inbuf,
GstGLBuffer * outbuf)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
if (overlay->pbuf_has_changed && (overlay->location != NULL)) {
if (!gst_gl_overlay_loader (filter))
overlay->pixbuf = NULL;
/* if loader failed then display is turned off */
gst_gl_display_thread_add (filter->display, init_pixbuf_texture, overlay);
if (overlay->pixbuf) {
free (overlay->pixbuf);
overlay->pixbuf = NULL;
}
overlay->pbuf_has_changed = FALSE;
}
gst_gl_filter_render_to_target (filter, inbuf->texture, outbuf->texture,
gst_gl_overlay_callback, overlay);
return TRUE;
}
/* free resources that need a gl context */
static void
gst_gl_overlay_reset_gl_resources (GstGLFilter * filter)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
glDeleteTextures (1, &overlay->pbuftexture);
}
/* free resources that need a gl context */
static void
gst_gl_overlay_reset_gl_resources (GstGLFilter * filter)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
const GstGLFuncs *gl = filter->context->gl_vtable;
gl->DeleteTextures (1, &overlay->pbuftexture);
}
static void
gst_gl_overlay_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (object);
switch (prop_id) {
case PROP_LOCATION:
if (overlay->location != NULL)
g_free (overlay->location);
overlay->pbuf_has_changed = TRUE;
overlay->location = g_value_dup_string (value);
break;
case PROP_XPOS_PNG:
overlay->pos_x_png = g_value_get_int (value);
break;
case PROP_YPOS_PNG:
overlay->pos_y_png = g_value_get_int (value);
break;
case PROP_SIZE_PNG:
overlay->size_png = g_value_get_int (value);
break;
case PROP_XPOS_VIDEO:
overlay->pos_x_video = g_value_get_int (value);
break;
case PROP_YPOS_VIDEO:
overlay->pos_y_video = g_value_get_int (value);
break;
case PROP_SIZE_VIDEO:
overlay->size_video = g_value_get_int (value);
break;
case PROP_VIDEOTOP:
overlay->video_top = g_value_get_boolean (value);
break;
case PROP_ROTATE_PNG:
overlay->rotate_png = g_value_get_int (value);
break;
case PROP_ROTATE_VIDEO:
overlay->rotate_video = g_value_get_int (value);
break;
case PROP_ANGLE_PNG:
overlay->angle_png = g_value_get_int (value);
break;
case PROP_ANGLE_VIDEO:
overlay->angle_video = g_value_get_int (value);
break;
case PROP_RATIO_VIDEO:
overlay->ratio_video = (gfloat) g_value_get_int (value);
break;
/* case PROP_STRETCH:
overlay->stretch = g_value_get_boolean (value);
break;
*/
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_gl_overlay_callback (gint width, gint height, guint texture, gpointer stuff)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (stuff);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gst_gl_overlay_draw_texture (overlay, texture);
}
static void
gst_gl_overlay_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (object);
switch (prop_id) {
case PROP_LOCATION:
g_value_set_string (value, overlay->location);
break;
case PROP_XPOS_PNG:
g_value_set_int (value, overlay->pos_x_png);
break;
case PROP_YPOS_PNG:
g_value_set_int (value, overlay->pos_y_png);
break;
case PROP_SIZE_PNG:
g_value_set_int (value, overlay->size_png);
break;
case PROP_XPOS_VIDEO:
g_value_set_int (value, overlay->pos_x_video);
break;
case PROP_YPOS_VIDEO:
g_value_set_int (value, overlay->pos_y_video);
break;
case PROP_SIZE_VIDEO:
g_value_set_int (value, overlay->size_video);
break;
case PROP_VIDEOTOP:
g_value_set_boolean (value, overlay->video_top);
break;
case PROP_ROTATE_PNG:
g_value_set_int (value, overlay->rotate_png);
break;
case PROP_ROTATE_VIDEO:
g_value_set_int (value, overlay->rotate_video);
break;
case PROP_ANGLE_PNG:
g_value_set_int (value, overlay->angle_png);
break;
case PROP_ANGLE_VIDEO:
g_value_set_int (value, overlay->angle_video);
break;
case PROP_RATIO_VIDEO:
g_value_set_int (value, (gint) overlay->ratio_video);
break;
/* case PROP_STRETCH:
g_value_set_boolean (value, overlay->stretch);
break;
*/
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
init_pixbuf_texture (GstGLDisplay * display, gpointer data)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (data);
if (overlay->pixbuf) {
glDeleteTextures (1, &overlay->pbuftexture);
glGenTextures (1, &overlay->pbuftexture);
glBindTexture (GL_TEXTURE_RECTANGLE_ARB, overlay->pbuftexture);
glTexImage2D (GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA,
(gint) overlay->width, (gint) overlay->height, 0,
GL_RGBA, GL_UNSIGNED_BYTE, overlay->pixbuf);
} else
display->isAlive = FALSE;
}
static gboolean
gst_gl_overlay_set_caps (GstGLFilter * filter, GstCaps * incaps,
GstCaps * outcaps)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
GstStructure *s = gst_caps_get_structure (incaps, 0);
gint width = 0;
gint height = 0;
gst_structure_get_int (s, "width", &width);
gst_structure_get_int (s, "height", &height);
overlay->width_window = (gfloat) width;
overlay->height_window = (gfloat) height;
return TRUE;
}
static void
gst_gl_overlay_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (object);
switch (prop_id) {
case PROP_LOCATION:
g_value_set_string (value, overlay->location);
break;
/* case PROP_STRETCH:
g_value_set_boolean (value, overlay->stretch);
break;
*/
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gint
gst_gl_overlay_load_jpeg (GstGLFilter * filter)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
FILE *fp = NULL;
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
JSAMPROW j;
int i;
fp = fopen (overlay->location, "rb");
if (!fp) {
g_error ("error: couldn't open file!\n");
return 0;
}
jpeg_create_decompress (&cinfo);
cinfo.err = jpeg_std_error (&jerr);
jpeg_stdio_src (&cinfo, fp);
jpeg_read_header (&cinfo, TRUE);
jpeg_start_decompress (&cinfo);
overlay->width = cinfo.image_width;
overlay->height = cinfo.image_height;
overlay->internalFormat = cinfo.num_components;
if (cinfo.num_components == 1)
overlay->format = GL_LUMINANCE;
else
overlay->format = GL_RGB;
overlay->pixbuf = (GLubyte *) malloc (sizeof (GLubyte) * overlay->width
* overlay->height * overlay->internalFormat);
for (i = 0; i < overlay->height; ++i) {
j = (overlay->pixbuf +
(((int) overlay->height - (i +
1)) * (int) overlay->width * overlay->internalFormat));
jpeg_read_scanlines (&cinfo, &j, 1);
}
jpeg_finish_decompress (&cinfo);
jpeg_destroy_decompress (&cinfo);
fclose (fp);
return 2;
}
static void
gst_gl_overlay_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (object);
switch (prop_id) {
case PROP_LOCATION:
if (overlay->location != NULL)
g_free (overlay->location);
overlay->pbuf_has_changed = TRUE;
overlay->location = g_value_dup_string (value);
break;
/* case PROP_STRETCH:
overlay->stretch = g_value_get_boolean (value);
break;
*/
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gint
gst_gl_overlay_load_png (GstGLFilter * filter)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
png_structp png_ptr;
png_infop info_ptr;
png_uint_32 width = 0;
png_uint_32 height = 0;
gint bit_depth = 0;
gint color_type = 0;
gint interlace_type = 0;
png_FILE_p fp = NULL;
guint y = 0;
guchar **rows = NULL;
gint filler;
png_byte magic[8];
gint n_read;
if (!filter->context)
return 1;
if ((fp = fopen (overlay->location, "rb")) == NULL)
LOAD_ERROR ("file not found");
/* Read magic number */
n_read = fread (magic, 1, sizeof (magic), fp);
if (n_read != sizeof (magic)) {
fclose (fp);
LOAD_ERROR ("can't read PNG magic number");
}
/* Check for valid magic number */
if (png_sig_cmp (magic, 0, sizeof (magic))) {
fclose (fp);
LOAD_ERROR ("not a valid PNG image");
}
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
fclose (fp);
LOAD_ERROR ("failed to initialize the png_struct");
}
png_set_error_fn (png_ptr, NULL, NULL, user_warning_fn);
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL) {
fclose (fp);
png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
LOAD_ERROR ("failed to initialize the memory for image information");
}
png_init_io (png_ptr, fp);
png_set_sig_bytes (png_ptr, sizeof (magic));
png_read_info (png_ptr, info_ptr);
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, int_p_NULL, int_p_NULL);
if (color_type == PNG_COLOR_TYPE_RGB) {
filler = 0xff;
png_set_filler (png_ptr, filler, PNG_FILLER_AFTER);
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
}
if (color_type != PNG_COLOR_TYPE_RGB_ALPHA) {
fclose (fp);
png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
LOAD_ERROR ("color type is not rgb");
}
overlay->width = width;
overlay->height = height;
overlay->pixbuf = (guchar *) malloc (sizeof (guchar) * width * height * 4);
rows = (guchar **) malloc (sizeof (guchar *) * height);
for (y = 0; y < height; ++y)
rows[y] = (guchar *) (overlay->pixbuf + y * width * 4);
png_read_image (png_ptr, rows);
free (rows);
png_read_end (png_ptr, info_ptr);
png_destroy_read_struct (&png_ptr, &info_ptr, png_infopp_NULL);
fclose (fp);
return 1;
}
static gboolean
gst_gl_overlay_loader (GstGLFilter * filter)
{
GstGLOverlay *overlay = GST_GL_OVERLAY (filter);
png_structp png_ptr;
png_infop info_ptr;
guint sig_read = 0;
png_uint_32 width = 0;
png_uint_32 height = 0;
gint bit_depth = 0;
gint color_type = 0;
gint interlace_type = 0;
png_FILE_p fp = NULL;
guint y = 0;
guchar **rows = NULL;
if (!filter->display)
return TRUE;
if ((fp = fopen (overlay->location, "rb")) == NULL)
LOAD_ERROR ("file not found");
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (png_ptr == NULL) {
fclose (fp);
LOAD_ERROR ("failed to initialize the png_struct");
}
png_set_error_fn (png_ptr, NULL, NULL, user_warning_fn);
info_ptr = png_create_info_struct (png_ptr);
if (info_ptr == NULL) {
fclose (fp);
png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
LOAD_ERROR ("failed to initialize the memory for image information");
}
png_init_io (png_ptr, fp);
png_set_sig_bytes (png_ptr, sig_read);
png_read_info (png_ptr, info_ptr);
png_get_IHDR (png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
&interlace_type, int_p_NULL, int_p_NULL);
if (color_type != PNG_COLOR_TYPE_RGB_ALPHA) {
fclose (fp);
png_destroy_read_struct (&png_ptr, png_infopp_NULL, png_infopp_NULL);
LOAD_ERROR ("color type is not rgb");
}
overlay->width = width;
overlay->height = height;
overlay->pixbuf = (guchar *) malloc (sizeof (guchar) * width * height * 4);
rows = (guchar **) malloc (sizeof (guchar *) * height);
for (y = 0; y < height; ++y)
rows[y] = (guchar *) (overlay->pixbuf + y * width * 4);
png_read_image (png_ptr, rows);
free (rows);
png_read_end (png_ptr, info_ptr);
png_destroy_read_struct (&png_ptr, &info_ptr, png_infopp_NULL);
fclose (fp);
return TRUE;
}
