C++ (Cpp) gst_gl_color_convert_set_format Examples

Example #1

File: gstgldownload.c Project: Lachann/gst-plugins-bad

static gboolean
_init_download (GstGLDownload * download)
{
  GstVideoFormat v_format;
  guint out_width, out_height;
  GstVideoInfo in_info;

  v_format = GST_VIDEO_INFO_FORMAT (&download->info);
  out_width = GST_VIDEO_INFO_WIDTH (&download->info);
  out_height = GST_VIDEO_INFO_HEIGHT (&download->info);

  if (download->initted)
    return TRUE;

  GST_TRACE ("initializing texture download for format %s",
      gst_video_format_to_string (v_format));

  if (USING_GLES2 (download->context) && !USING_GLES3 (download->context)) {
    /* GL_RGBA is the only officially supported texture format in GLES2 */
    if (v_format == GST_VIDEO_FORMAT_RGB || v_format == GST_VIDEO_FORMAT_BGR) {
      gst_gl_context_set_error (download->context, "Cannot download RGB "
          "textures in GLES2");
      return FALSE;
    }
  }

  gst_video_info_set_format (&in_info, GST_VIDEO_FORMAT_RGBA, out_width,
      out_height);

  gst_gl_color_convert_set_format (download->convert, &in_info,
      &download->info);

  return TRUE;
}

Example #2

File: gstglupload.c Project: MathieuDuponchelle/gst-plugins-bad

/* Called in the gl thread */
static gboolean
_init_upload (GstGLUpload * upload)
{
    GstGLFuncs *gl;
    GstVideoFormat v_format;
    GstVideoInfo out_info;

    gl = upload->context->gl_vtable;

    v_format = GST_VIDEO_INFO_FORMAT (&upload->in_info);

    GST_INFO ("Initializing texture upload for format:%s",
              gst_video_format_to_string (v_format));

    if (!gl->CreateProgramObject && !gl->CreateProgram) {
        gst_gl_context_set_error (upload->context,
                                  "Cannot upload YUV formats without OpenGL shaders");
        goto error;
    }

    gst_video_info_set_format (&out_info, GST_VIDEO_FORMAT_RGBA,
                               GST_VIDEO_INFO_WIDTH (&upload->in_info),
                               GST_VIDEO_INFO_HEIGHT (&upload->in_info));

    gst_gl_color_convert_set_format (upload->convert, &upload->in_info,
                                     &out_info);

    upload->out_tex = gst_gl_memory_wrapped_texture (upload->context, 0,
                      GST_VIDEO_GL_TEXTURE_TYPE_RGBA, GST_VIDEO_INFO_WIDTH (&upload->in_info),
                      GST_VIDEO_INFO_HEIGHT (&upload->in_info), NULL, NULL);

    upload->initted = TRUE;

    return TRUE;

error:
    return FALSE;
}

Example #3

File: gstglcolorconvert.c Project: lovebug356/gst-plugins-bad

static void
check_conversion (TestFrame * frames, guint size)
{
  gint i, j, k, l;

  for (i = 0; i < size; i++) {
    GstBuffer *inbuf;
    GstVideoInfo in_info;
    gint in_width = frames[i].width;
    gint in_height = frames[i].height;
    GstVideoFormat in_v_format = frames[i].v_format;
    gchar *in_data[GST_VIDEO_MAX_PLANES] = { 0 };
    GstGLMemory *in_mem[GST_VIDEO_MAX_PLANES] = { 0 };
    GstVideoFrame in_frame;

    gst_video_info_set_format (&in_info, in_v_format, in_width, in_height);

    for (j = 0; j < GST_VIDEO_INFO_N_PLANES (&in_info); j++) {
      in_data[j] = frames[i].data[j];
    }

    /* create GL buffer */
    inbuf = gst_buffer_new ();
    fail_unless (gst_gl_memory_setup_wrapped (context, &in_info,
            (gpointer *) in_data, in_mem));

    for (j = 0; j < GST_VIDEO_INFO_N_PLANES (&in_info); j++) {
      gst_buffer_append_memory (inbuf, (GstMemory *) in_mem[j]);
    }

    fail_unless (gst_video_frame_map (&in_frame, &in_info, inbuf,
            GST_MAP_READ));

    /* sanity check that the correct values were wrapped */
    for (j = 0; j < GST_VIDEO_INFO_N_PLANES (&in_info); j++) {
      for (k = 0; k < _video_info_plane_size (&in_info, j); k++) {
        if (in_data[j][k] != IGNORE_MAGIC)
          fail_unless (((gchar *) in_frame.data[j])[k] == in_data[j][k]);
      }
    }

    for (j = 0; j < size; j++) {
      GstBuffer *outbuf;
      GstVideoInfo out_info;
      gint out_width = frames[j].width;
      gint out_height = frames[j].height;
      GstVideoFormat out_v_format = frames[j].v_format;
      gchar *out_data[GST_VIDEO_MAX_PLANES] = { 0 };
      GstVideoFrame out_frame;

      gst_video_info_set_format (&out_info, out_v_format, out_width,
          out_height);

      for (k = 0; k < GST_VIDEO_INFO_N_PLANES (&out_info); k++) {
        out_data[k] = frames[j].data[k];
      }

      gst_gl_color_convert_set_format (convert, &in_info, &out_info);

      /* convert the data */
      outbuf = gst_gl_color_convert_perform (convert, inbuf);
      if (outbuf == NULL) {
        const gchar *in_str = gst_video_format_to_string (in_v_format);
        const gchar *out_str = gst_video_format_to_string (out_v_format);
        GST_WARNING ("failed to convert from %s to %s", in_str, out_str);
      }

      fail_unless (gst_video_frame_map (&out_frame, &out_info, outbuf,
              GST_MAP_READ));

      /* check that the converted values are correct */
      for (k = 0; k < GST_VIDEO_INFO_N_PLANES (&out_info); k++) {
        for (l = 0; l < _video_info_plane_size (&out_info, k); l++) {
          gchar out_pixel = ((gchar *) out_frame.data[k])[l];
          if (out_data[k][l] != IGNORE_MAGIC && out_pixel != IGNORE_MAGIC)
            fail_unless (out_pixel == out_data[k][l]);
          /* FIXME: check alpha clobbering */
        }
      }

      gst_video_frame_unmap (&out_frame);
      gst_buffer_unref (outbuf);
    }

    gst_video_frame_unmap (&in_frame);
    gst_buffer_unref (inbuf);
  }
}