/*

 * GStreamer

 * Copyright (C) 2015 Lubosz Sarnecki <lubosz.sarnecki@collabora.co.uk>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 */

/**

 * SECTION:gstgloverlaycompositor

 * @title: GstGLOverlayCompositor

 * @short_description: Composite multiple overlays using OpenGL

 * @see_also: #GstGLMemory, #GstGLContext

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include "gstgloverlaycompositor.h"

#include "gstglcontext.h"

#include "gstglfuncs.h"

#include "gstglmemory.h"

#include "gstglshader.h"

#include "gstglslstage.h"

GST_DEBUG_CATEGORY_STATIC (gst_gl_overlay_compositor_debug);

#define GST_CAT_DEFAULT gst_gl_overlay_compositor_debug

/*****************************************************************************

 * GstGLCompositionOverlay object is internally used by GstGLOverlayCompositor

 *****************************************************************************/

#define GST_TYPE_GL_COMPOSITION_OVERLAY (gst_gl_composition_overlay_get_type())

#define GST_GL_COMPOSITION_OVERLAY(obj) \

  (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_GL_COMPOSITION_OVERLAY,\

                              GstGLCompositionOverlay))

typedef struct _GstGLCompositionOverlay GstGLCompositionOverlay;

typedef struct _GstGLCompositionOverlayClass GstGLCompositionOverlayClass;

static GType gst_gl_composition_overlay_get_type (void);

/* *INDENT-OFF* */

const gchar *fragment_shader =

  "#ifdef GL_ES\n"

  "precision mediump float;\n"

  "#endif\n"

  "varying vec2 v_texcoord;\n"

  "uniform sampler2D tex;\n"

  "void main(void)\n"

  "{\n"

  "  vec4 t = texture2D(tex, v_texcoord);\n"

#if G_BYTE_ORDER == G_LITTLE_ENDIAN

  "  gl_FragColor = t.bgra;\n"

#else

  "  gl_FragColor = t.gbar;\n"

#endif

  "}";

/* *INDENT-ON* */

struct _GstGLCompositionOverlay

{

  GstObject parent;

  GstGLContext *context;

  GLuint vao;

  GLuint index_buffer;

  GLuint position_buffer;

  GLuint texcoord_buffer;

  GLint position_attrib;

  GLint texcoord_attrib;

  GLfloat positions[16];

  GLuint texture_id;

  GstGLMemory *gl_memory;

  GstVideoOverlayRectangle *rectangle;

};

struct _GstGLCompositionOverlayClass

{

  GstObjectClass object_class;

};

G_DEFINE_TYPE (GstGLCompositionOverlay, gst_gl_composition_overlay,

    GST_TYPE_OBJECT);

static void

gst_gl_composition_overlay_init_vertex_buffer (GstGLContext * context,

    gpointer overlay_pointer)

{

  const GstGLFuncs *gl = context->gl_vtable;

  GstGLCompositionOverlay *overlay =

      (GstGLCompositionOverlay *) overlay_pointer;

  /* *INDENT-OFF* */

  static const GLfloat texcoords[] = {

      1.0f, 0.0f,

      0.0f, 0.0f,

      0.0f, 1.0f,

      1.0f, 1.0f

  };

  static const GLushort indices[] = {

    0, 1, 2, 0, 2, 3

  };

  /* *INDENT-ON* */

  if (gl->GenVertexArrays) {

    gl->GenVertexArrays (1, &overlay->vao);

    gl->BindVertexArray (overlay->vao);

  }

  gl->GenBuffers (1, &overlay->position_buffer);

  gl->BindBuffer (GL_ARRAY_BUFFER, overlay->position_buffer);

  gl->BufferData (GL_ARRAY_BUFFER, 4 * 4 * sizeof (GLfloat), overlay->positions,

      GL_STATIC_DRAW);

  /* Load the vertex position */

  gl->VertexAttribPointer (overlay->position_attrib, 4, GL_FLOAT, GL_FALSE,

      4 * sizeof (GLfloat), NULL);

  gl->GenBuffers (1, &overlay->texcoord_buffer);

  gl->BindBuffer (GL_ARRAY_BUFFER, overlay->texcoord_buffer);

  gl->BufferData (GL_ARRAY_BUFFER, 4 * 2 * sizeof (GLfloat), texcoords,

      GL_STATIC_DRAW);

  /* Load the texture coordinate */

  gl->VertexAttribPointer (overlay->texcoord_attrib, 2, GL_FLOAT, GL_FALSE,

      2 * sizeof (GLfloat), NULL);

  gl->GenBuffers (1, &overlay->index_buffer);

  gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->index_buffer);

  gl->BufferData (GL_ELEMENT_ARRAY_BUFFER, sizeof (indices), indices,

      GL_STATIC_DRAW);

  gl->EnableVertexAttribArray (overlay->position_attrib);

  gl->EnableVertexAttribArray (overlay->texcoord_attrib);

  if (gl->GenVertexArrays) {

    gl->BindVertexArray (0);

  }

  gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, 0);

  gl->BindBuffer (GL_ARRAY_BUFFER, 0);

}

static void

gst_gl_composition_overlay_free_vertex_buffer (GstGLContext * context,

    gpointer overlay_pointer)

{

  const GstGLFuncs *gl = context->gl_vtable;

  GstGLCompositionOverlay *overlay =

      (GstGLCompositionOverlay *) overlay_pointer;

  if (overlay->vao) {

    gl->DeleteVertexArrays (1, &overlay->vao);

    overlay->vao = 0;

  }

  if (overlay->position_buffer) {

    gl->DeleteBuffers (1, &overlay->position_buffer);

    overlay->position_buffer = 0;

  }

  if (overlay->texcoord_buffer) {

    gl->DeleteBuffers (1, &overlay->position_buffer);

    overlay->position_buffer = 0;

  }

  if (overlay->index_buffer) {

    gl->DeleteBuffers (1, &overlay->index_buffer);

    overlay->index_buffer = 0;

  }

}

static void

gst_gl_composition_overlay_bind_vertex_buffer (GstGLCompositionOverlay *

    overlay)

{

  const GstGLFuncs *gl = overlay->context->gl_vtable;

  gl->BindBuffer (GL_ARRAY_BUFFER, overlay->position_buffer);

  gl->VertexAttribPointer (overlay->position_attrib, 4, GL_FLOAT, GL_FALSE,

      4 * sizeof (GLfloat), NULL);

  gl->BindBuffer (GL_ARRAY_BUFFER, overlay->texcoord_buffer);

  gl->VertexAttribPointer (overlay->texcoord_attrib, 2, GL_FLOAT, GL_FALSE,

      2 * sizeof (GLfloat), NULL);

  gl->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, overlay->index_buffer);

  gl->EnableVertexAttribArray (overlay->position_attrib);

  gl->EnableVertexAttribArray (overlay->texcoord_attrib);

}

static void

gst_gl_composition_overlay_finalize (GObject * object)

{

  GstGLCompositionOverlay *overlay;

  overlay = GST_GL_COMPOSITION_OVERLAY (object);

  if (overlay->gl_memory)

    gst_memory_unref ((GstMemory *) overlay->gl_memory);

  if (overlay->context) {

    gst_gl_context_thread_add (overlay->context,

        gst_gl_composition_overlay_free_vertex_buffer, overlay);

    gst_object_unref (overlay->context);

  }

  G_OBJECT_CLASS (gst_gl_composition_overlay_parent_class)->finalize (object);

}

static void

gst_gl_composition_overlay_class_init (GstGLCompositionOverlayClass * klass)

{

  G_OBJECT_CLASS (klass)->finalize = gst_gl_composition_overlay_finalize;

}

static void

gst_gl_composition_overlay_init (GstGLCompositionOverlay * overlay)

{

}

static void

gst_gl_composition_overlay_add_transformation (GstGLCompositionOverlay *

    overlay, GstBuffer * video_buffer)

{

  gint comp_x, comp_y;

  guint comp_width, comp_height;

  GstVideoMeta *meta;

  guint width, height;

  float rel_x, rel_y, rel_w, rel_h;

  meta = gst_buffer_get_video_meta (video_buffer);

  gst_video_overlay_rectangle_get_render_rectangle (overlay->rectangle,

      &comp_x, &comp_y, &comp_width, &comp_height);

  width = meta->width;

  height = meta->height;

  /* calculate relative position */

  rel_x = (float) comp_x / (float) width;

  rel_y = (float) comp_y / (float) height;

  rel_w = (float) comp_width / (float) width;

  rel_h = (float) comp_height / (float) height;

  /* transform from [0,1] to [-1,1], invert y axis */

  rel_x = rel_x * 2.0 - 1.0;

  rel_y = (1.0 - rel_y) * 2.0 - 1.0;

  rel_w = rel_w * 2.0;

  rel_h = rel_h * 2.0;

  /* initialize position array */

  overlay->positions[0] = rel_x + rel_w;

  overlay->positions[1] = rel_y;

  overlay->positions[2] = 0.0;

  overlay->positions[3] = 1.0;

  overlay->positions[4] = rel_x;

  overlay->positions[5] = rel_y;

  overlay->positions[6] = 0.0;

  overlay->positions[7] = 1.0;

  overlay->positions[8] = rel_x;

  overlay->positions[9] = rel_y - rel_h;

  overlay->positions[10] = 0.0;

  overlay->positions[11] = 1.0;

  overlay->positions[12] = rel_x + rel_w;

  overlay->positions[13] = rel_y - rel_h;

  overlay->positions[14] = 0.0;

  overlay->positions[15] = 1.0;

  gst_gl_context_thread_add (overlay->context,

      gst_gl_composition_overlay_free_vertex_buffer, overlay);

  gst_gl_context_thread_add (overlay->context,

      gst_gl_composition_overlay_init_vertex_buffer, overlay);

  GST_DEBUG

      ("overlay position: (%d,%d) size: %dx%d video size: %dx%d",

      comp_x, comp_y, comp_width, comp_height, meta->width, meta->height);

}

/* helper object API functions */

static GstGLCompositionOverlay *

gst_gl_composition_overlay_new (GstGLContext * context,

    GstVideoOverlayRectangle * rectangle,

    GLint position_attrib, GLint texcoord_attrib)

{

  GstGLCompositionOverlay *overlay =

      g_object_new (GST_TYPE_GL_COMPOSITION_OVERLAY, NULL);

  overlay->gl_memory = NULL;

  overlay->texture_id = -1;

  overlay->rectangle = rectangle;

  overlay->context = gst_object_ref (context);

  overlay->vao = 0;

  overlay->position_attrib = position_attrib;

  overlay->texcoord_attrib = texcoord_attrib;

  GST_DEBUG_OBJECT (overlay, "Created new GstGLCompositionOverlay");

  return overlay;

}

static void

_video_frame_unmap_and_free (gpointer user_data)

{

  GstVideoFrame *frame = user_data;

  gst_video_frame_unmap (frame);

  g_slice_free (GstVideoFrame, frame);

}

static void

gst_gl_composition_overlay_upload (GstGLCompositionOverlay * overlay,

    GstBuffer * buf)

{

  GstGLMemory *comp_gl_memory = NULL;

  GstBuffer *comp_buffer = NULL;

  GstBuffer *overlay_buffer = NULL;

  GstVideoInfo vinfo;

  GstVideoMeta *vmeta;

  GstVideoFrame *comp_frame;

  GstVideoFrame gl_frame;

  comp_buffer =

      gst_video_overlay_rectangle_get_pixels_unscaled_argb (overlay->rectangle,

      GST_VIDEO_OVERLAY_FORMAT_FLAG_PREMULTIPLIED_ALPHA);

  comp_frame = g_slice_new (GstVideoFrame);

  vmeta = gst_buffer_get_video_meta (comp_buffer);

  gst_video_info_set_format (&vinfo, vmeta->format, vmeta->width,

      vmeta->height);

  vinfo.stride[0] = vmeta->stride[0];

  if (gst_video_frame_map (comp_frame, &vinfo, comp_buffer, GST_MAP_READ)) {

    GstGLVideoAllocationParams *params;

    GstGLBaseMemoryAllocator *mem_allocator;

    GstAllocator *allocator;

    allocator =

        GST_ALLOCATOR (gst_gl_memory_allocator_get_default (overlay->context));

    mem_allocator = GST_GL_BASE_MEMORY_ALLOCATOR (allocator);

    gst_gl_composition_overlay_add_transformation (overlay, buf);

    params = gst_gl_video_allocation_params_new_wrapped_data (overlay->context,

        NULL, &comp_frame->info, 0, NULL, GST_GL_TEXTURE_TARGET_2D,

        GST_GL_RGBA, comp_frame->data[0], comp_frame,

        _video_frame_unmap_and_free);

    comp_gl_memory =

        (GstGLMemory *) gst_gl_base_memory_alloc (mem_allocator,

        (GstGLAllocationParams *) params);

    gst_gl_allocation_params_free ((GstGLAllocationParams *) params);

    gst_object_unref (allocator);

    overlay_buffer = gst_buffer_new ();

    gst_buffer_append_memory (overlay_buffer, (GstMemory *) comp_gl_memory);

    if (!gst_video_frame_map (&gl_frame, &comp_frame->info, overlay_buffer,

            GST_MAP_READ | GST_MAP_GL)) {

      gst_buffer_unref (overlay_buffer);

      _video_frame_unmap_and_free (comp_frame);

      GST_WARNING_OBJECT (overlay, "Cannot upload overlay texture");

      return;

    }

    gst_memory_ref ((GstMemory *) comp_gl_memory);

    overlay->gl_memory = comp_gl_memory;

    overlay->texture_id = comp_gl_memory->tex_id;

    gst_buffer_unref (overlay_buffer);

    gst_video_frame_unmap (&gl_frame);

    GST_DEBUG ("uploaded overlay texture %d", overlay->texture_id);

  } else {

    g_slice_free (GstVideoFrame, comp_frame);

  }

}

static void

gst_gl_composition_overlay_draw (GstGLCompositionOverlay * overlay,

    GstGLShader * shader)

{

  const GstGLFuncs *gl = overlay->context->gl_vtable;

  if (gl->GenVertexArrays)

    gl->BindVertexArray (overlay->vao);

  else

    gst_gl_composition_overlay_bind_vertex_buffer (overlay);

  if (overlay->texture_id != -1)

    gl->BindTexture (GL_TEXTURE_2D, overlay->texture_id);

  gl->DrawElements (GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);

}

/********************************************************************

 * GstGLOverlayCompositor object, the public helper object to render

 * GstVideoCompositionOverlayMeta

 ********************************************************************/

#define DEBUG_INIT \

  GST_DEBUG_CATEGORY_INIT (gst_gl_overlay_compositor_debug, \

      "gloverlaycompositor", 0, "overlaycompositor");

G_DEFINE_TYPE_WITH_CODE (GstGLOverlayCompositor, gst_gl_overlay_compositor,

    GST_TYPE_OBJECT, DEBUG_INIT);

static void gst_gl_overlay_compositor_finalize (GObject * object);

static gboolean _is_rectangle_in_overlays (GList * overlays,

    GstVideoOverlayRectangle * rectangle);

static gboolean _is_overlay_in_rectangles (GstVideoOverlayComposition *

    composition, GstGLCompositionOverlay * overlay);

static void

gst_gl_overlay_compositor_class_init (GstGLOverlayCompositorClass * klass)

{

  G_OBJECT_CLASS (klass)->finalize = gst_gl_overlay_compositor_finalize;

}

static void

gst_gl_overlay_compositor_init (GstGLOverlayCompositor * compositor)

{

}

static void

gst_gl_overlay_compositor_init_gl (GstGLContext * context,

    gpointer compositor_pointer)

{

  GstGLOverlayCompositor *compositor =

      (GstGLOverlayCompositor *) compositor_pointer;

  GError *error = NULL;

  if (!(compositor->shader =

          gst_gl_shader_new_link_with_stages (context, &error,

              gst_glsl_stage_new_default_vertex (context),

              gst_glsl_stage_new_with_string (context, GL_FRAGMENT_SHADER,

                  GST_GLSL_VERSION_NONE,

                  GST_GLSL_PROFILE_ES | GST_GLSL_PROFILE_COMPATIBILITY,

                  fragment_shader), NULL))) {

    GST_ERROR_OBJECT (compositor, "could not initialize shader: %s",

        error->message);

    return;

  }

  compositor->position_attrib =

      gst_gl_shader_get_attribute_location (compositor->shader, "a_position");

  compositor->texcoord_attrib =

      gst_gl_shader_get_attribute_location (compositor->shader, "a_texcoord");

}

GstGLOverlayCompositor *

gst_gl_overlay_compositor_new (GstGLContext * context)

{

  GstGLOverlayCompositor *compositor =

      g_object_new (GST_TYPE_GL_OVERLAY_COMPOSITOR, NULL);

  gst_object_ref_sink (compositor);

  compositor->context = gst_object_ref (context);

  gst_gl_context_thread_add (compositor->context,

      gst_gl_overlay_compositor_init_gl, compositor);

  GST_DEBUG_OBJECT (compositor, "Created new GstGLOverlayCompositor");

  return compositor;

}

static void

gst_gl_overlay_compositor_finalize (GObject * object)

{

  GstGLOverlayCompositor *compositor;

  compositor = GST_GL_OVERLAY_COMPOSITOR (object);

  gst_gl_overlay_compositor_free_overlays (compositor);

  if (compositor->context)

    gst_object_unref (compositor->context);

  if (compositor->shader) {

    gst_object_unref (compositor->shader);

    compositor->shader = NULL;

  }

  G_OBJECT_CLASS (gst_gl_overlay_compositor_parent_class)->finalize (object);

}

static gboolean

_is_rectangle_in_overlays (GList * overlays,

    GstVideoOverlayRectangle * rectangle)

{

  GList *l;

  for (l = overlays; l != NULL; l = l->next) {

    GstGLCompositionOverlay *overlay = (GstGLCompositionOverlay *) l->data;

    if (overlay->rectangle == rectangle)

      return TRUE;

  }

  return FALSE;

}

static gboolean

_is_overlay_in_rectangles (GstVideoOverlayComposition * composition,

    GstGLCompositionOverlay * overlay)

{

  guint i;

  for (i = 0; i < gst_video_overlay_composition_n_rectangles (composition); i++) {

    GstVideoOverlayRectangle *rectangle =

        gst_video_overlay_composition_get_rectangle (composition, i);

    if (overlay->rectangle == rectangle)

      return TRUE;

  }

  return FALSE;

}

void

gst_gl_overlay_compositor_free_overlays (GstGLOverlayCompositor * compositor)

{

  GList *l = compositor->overlays;

  while (l != NULL) {

    GList *next = l->next;

    GstGLCompositionOverlay *overlay = (GstGLCompositionOverlay *) l->data;

    compositor->overlays = g_list_delete_link (compositor->overlays, l);

    gst_object_unref (overlay);

    l = next;

  }

  g_list_free (compositor->overlays);

  compositor->overlays = NULL;

}

void

gst_gl_overlay_compositor_upload_overlays (GstGLOverlayCompositor * compositor,

    GstBuffer * buf)

{

  GstVideoOverlayCompositionMeta *composition_meta;

  composition_meta = gst_buffer_get_video_overlay_composition_meta (buf);

  if (composition_meta) {

    GstVideoOverlayComposition *composition = NULL;

    guint num_overlays, i;

    GList *l = compositor->overlays;

    GST_DEBUG ("GstVideoOverlayCompositionMeta found.");

    composition = composition_meta->overlay;

    num_overlays = gst_video_overlay_composition_n_rectangles (composition);

    /* add new overlays to list */

    for (i = 0; i < num_overlays; i++) {

      GstVideoOverlayRectangle *rectangle =

          gst_video_overlay_composition_get_rectangle (composition, i);

      if (!_is_rectangle_in_overlays (compositor->overlays, rectangle)) {

        GstGLCompositionOverlay *overlay =

            gst_gl_composition_overlay_new (compositor->context, rectangle,

            compositor->position_attrib, compositor->texcoord_attrib);

        gst_object_ref_sink (overlay);

        gst_gl_composition_overlay_upload (overlay, buf);

        compositor->overlays = g_list_append (compositor->overlays, overlay);

      }

    }

    /* remove old overlays from list */

    while (l != NULL) {

      GList *next = l->next;

      GstGLCompositionOverlay *overlay = (GstGLCompositionOverlay *) l->data;

      if (!_is_overlay_in_rectangles (composition, overlay)) {

        compositor->overlays = g_list_delete_link (compositor->overlays, l);

        gst_object_unref (overlay);

      }

      l = next;

    }

  } else {

    gst_gl_overlay_compositor_free_overlays (compositor);

  }

}

void

gst_gl_overlay_compositor_draw_overlays (GstGLOverlayCompositor * compositor)

{

  const GstGLFuncs *gl = compositor->context->gl_vtable;

  if (compositor->overlays != NULL) {

    GList *l;

    gl->Enable (GL_BLEND);

    gl->BlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    gst_gl_shader_use (compositor->shader);

    gl->ActiveTexture (GL_TEXTURE0);

    gst_gl_shader_set_uniform_1i (compositor->shader, "tex", 0);

    for (l = compositor->overlays; l != NULL; l = l->next) {

      GstGLCompositionOverlay *overlay = (GstGLCompositionOverlay *) l->data;

      gst_gl_composition_overlay_draw (overlay, compositor->shader);

    }

    gl->BindTexture (GL_TEXTURE_2D, 0);

    gl->Disable (GL_BLEND);

  }

}

GstCaps *

gst_gl_overlay_compositor_add_caps (GstCaps * caps)

{

  GstCaps *composition_caps;

  int i;

  composition_caps = gst_caps_copy (caps);

  for (i = 0; i < gst_caps_get_size (composition_caps); i++) {

    GstCapsFeatures *f = gst_caps_get_features (composition_caps, i);

    gst_caps_features_add (f,

        GST_CAPS_FEATURE_META_GST_VIDEO_OVERLAY_COMPOSITION);

  }

  caps = gst_caps_merge (composition_caps, caps);

  return caps;

}