isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-12-25 20:32:16 +00:00
Code Issues Packages Projects Releases Wiki Activity
e50dc26324
mutter/cogl-gst/cogl-gst-video-sink.c

1663 lines
45 KiB
C
Raw Normal View History

Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
/*
* Cogl-GStreamer.
*
* GStreamer integration library for Cogl.
*
* cogl-gst-video-sink.c - Gstreamer Video Sink that renders to a
* Cogl Pipeline.
*
* Authored by Jonathan Matthew <jonathan@kaolin.wh9.net>,
* Chris Lord <chris@openedhand.com>
* Damien Lespiau <damien.lespiau@intel.com>
* Matthew Allum <mallum@openedhand.com>
* Plamena Manolova <plamena.n.manolova@intel.com>
*
* Copyright (C) 2007, 2008 OpenedHand
* Copyright (C) 2009, 2010, 2013 Intel Corporation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include "config.h"
#include <gst/gst.h>
#include <gst/gstvalue.h>
#include <gst/video/video.h>
#include <gst/riff/riff-ids.h>
#include <string.h>
Declare interface types as void and remove cast macros This declares the interface types CoglFramebuffer, CoglBuffer, CoglTexture, CoglMetaTexture and CoglPrimitiveTexture as void when including the public cogl.h header so that users don't have to use lots of C type casts between instance types and interface types. This also removes all of the COGL_XYZ() type cast macros since they do nothing more than compile time type casting but it's less readable if you haven't seen that coding pattern before. Unlike with gobject based apis that use per-type macros for casting and performing runtime type checking we instead prefer to do our runtime type checking internally within the front-end public apis when objects are passed into Cogl. This greatly reduces the verbosity for users of the api and may help reduce the chance of excessive runtime type checking that can sometimes be a problem. (cherry picked from commit 248a76f5eac7e5ae4fb45208577f9a55360812a7) Since we can't break the 1.x api this version of the patch actually defines compatible NOP macros within deprecated/cogl-type-casts.h
2013-10-09 12:31:12 +00:00
/* We just need the public Cogl api for cogl-gst but we first need to
* undef COGL_COMPILATION to avoid getting an error that normally
* checks cogl.h isn't used internally. */
#undef COGL_COMPILATION
#include <cogl/cogl.h>
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
#include "cogl-gst-video-sink.h"
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
#define COGL_GST_DEFAULT_PRIORITY G_PRIORITY_HIGH_IDLE
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
#define BASE_SINK_CAPS "{ AYUV," \
"YV12," \
"I420," \
"RGBA," \
"BGRA," \
"RGB," \
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
"BGR," \
"NV12 }"
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
#define SINK_CAPS GST_VIDEO_CAPS_MAKE (BASE_SINK_CAPS)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: Move the PARAM macros into the C file These are just internal convenience macros to define the GObject properties so they shouldn't be in the public headers. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit b7b861aa87ad05a2c253afdd87323acd82fd988f)
2013-04-25 17:38:17 +00:00
#define COGL_GST_PARAM_STATIC \
(G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB)
#define COGL_GST_PARAM_READABLE \
(G_PARAM_READABLE | COGL_GST_PARAM_STATIC)
#define COGL_GST_PARAM_WRITABLE \
(G_PARAM_WRITABLE | COGL_GST_PARAM_STATIC)
#define COGL_GST_PARAM_READWRITE \
(G_PARAM_READABLE | G_PARAM_WRITABLE | COGL_GST_PARAM_STATIC)
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
static GstStaticPadTemplate sinktemplate_all =
GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS (SINK_CAPS));
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
G_DEFINE_TYPE (CoglGstVideoSink, cogl_gst_video_sink, GST_TYPE_BASE_SINK);
enum
{
PROP_0,
PROP_UPDATE_PRIORITY
};
enum
{
PIPELINE_READY_SIGNAL,
NEW_FRAME_SIGNAL,
LAST_SIGNAL
};
static guint video_sink_signals[LAST_SIGNAL] = { 0, };
typedef enum
{
COGL_GST_NOFORMAT,
COGL_GST_RGB32,
COGL_GST_RGB24,
COGL_GST_AYUV,
COGL_GST_YV12,
COGL_GST_SURFACE,
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
COGL_GST_I420,
COGL_GST_NV12
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
} CoglGstVideoFormat;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
typedef enum
{
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
COGL_GST_RENDERER_NEEDS_GLSL = (1 << 0),
COGL_GST_RENDERER_NEEDS_TEXTURE_RG = (1 << 1)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
} CoglGstRendererFlag;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
/* We want to cache the snippets instead of recreating a new one every
* time we initialise a pipeline so that if we end up recreating the
* same pipeline again then Cogl will be able to use the pipeline
* cache to avoid linking a redundant identical shader program */
typedef struct
{
CoglSnippet *vertex_snippet;
CoglSnippet *fragment_snippet;
CoglSnippet *default_sample_snippet;
int start_position;
} SnippetCacheEntry;
typedef struct
{
GQueue entries;
} SnippetCache;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
typedef struct _CoglGstSource
{
GSource source;
CoglGstVideoSink *sink;
GMutex buffer_lock;
GstBuffer *buffer;
CoglBool has_new_caps;
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
} CoglGstSource;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
typedef void (CoglGstRendererPaint) (CoglGstVideoSink *);
typedef void (CoglGstRendererPostPaint) (CoglGstVideoSink *);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
typedef struct _CoglGstRenderer
{
const char *name;
CoglGstVideoFormat format;
int flags;
GstStaticCaps caps;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
int n_layers;
void (*setup_pipeline) (CoglGstVideoSink *sink,
CoglPipeline *pipeline);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
CoglBool (*upload) (CoglGstVideoSink *sink,
GstBuffer *buffer);
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
} CoglGstRenderer;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
struct _CoglGstVideoSinkPrivate
{
CoglContext *ctx;
CoglPipeline *pipeline;
CoglTexture *frame[3];
CoglBool frame_dirty;
CoglGstVideoFormat format;
CoglBool bgr;
CoglGstSource *source;
GSList *renderers;
GstCaps *caps;
CoglGstRenderer *renderer;
GstFlowReturn flow_return;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
int custom_start;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
int free_layer;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
CoglBool default_sample;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
GstVideoInfo info;
};
static void
cogl_gst_source_finalize (GSource *source)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstSource *gst_source = (CoglGstSource *) source;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
g_mutex_lock (&gst_source->buffer_lock);
if (gst_source->buffer)
gst_buffer_unref (gst_source->buffer);
gst_source->buffer = NULL;
g_mutex_unlock (&gst_source->buffer_lock);
g_mutex_clear (&gst_source->buffer_lock);
}
int
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
cogl_gst_video_sink_get_free_layer (CoglGstVideoSink *sink)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
return sink->priv->free_layer;
}
cogl-gst: Remove the return value from attach_frame() Previously cogl_gst_video_sink_attach_frame returned the last layer used by the sink. This can also be retrieved via cogl_gst_video_sink_get_free_layer so I don't think it's necessary to return it here and it seems kind of out of place. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 0805f3e9db715fc2c97b7e60d4f3a25e7fa598fc)
2013-04-25 18:01:37 +00:00
void
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_video_sink_attach_frame (CoglGstVideoSink *sink,
CoglPipeline *pln)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
int i;
for (i = 0; i < G_N_ELEMENTS (priv->frame); i++)
if (priv->frame[i] != NULL)
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_pipeline_set_layer_texture (pln, i + priv->custom_start,
Declare interface types as void and remove cast macros This declares the interface types CoglFramebuffer, CoglBuffer, CoglTexture, CoglMetaTexture and CoglPrimitiveTexture as void when including the public cogl.h header so that users don't have to use lots of C type casts between instance types and interface types. This also removes all of the COGL_XYZ() type cast macros since they do nothing more than compile time type casting but it's less readable if you haven't seen that coding pattern before. Unlike with gobject based apis that use per-type macros for casting and performing runtime type checking we instead prefer to do our runtime type checking internally within the front-end public apis when objects are passed into Cogl. This greatly reduces the verbosity for users of the api and may help reduce the chance of excessive runtime type checking that can sometimes be a problem. (cherry picked from commit 248a76f5eac7e5ae4fb45208577f9a55360812a7) Since we can't break the 1.x api this version of the patch actually defines compatible NOP macros within deprecated/cogl-type-casts.h
2013-10-09 12:31:12 +00:00
priv->frame[i]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static CoglBool
cogl_gst_source_prepare (GSource *source,
int *timeout)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstSource *gst_source = (CoglGstSource *) source;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
*timeout = -1;
return gst_source->buffer != NULL;
}
static CoglBool
cogl_gst_source_check (GSource *source)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstSource *gst_source = (CoglGstSource *) source;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
return gst_source->buffer != NULL;
}
static void
cogl_gst_video_sink_set_priority (CoglGstVideoSink *sink,
int priority)
{
if (sink->priv->source)
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
g_source_set_priority ((GSource *) sink->priv->source, priority);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static void
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
dirty_default_pipeline (CoglGstVideoSink *sink)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
CoglGstVideoSinkPrivate *priv = sink->priv;
if (priv->pipeline)
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
{
cogl_object_unref (priv->pipeline);
priv->pipeline = NULL;
}
}
void
cogl_gst_video_sink_set_first_layer (CoglGstVideoSink *sink,
int first_layer)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
g_return_if_fail (COGL_GST_IS_VIDEO_SINK (sink));
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
if (first_layer != sink->priv->custom_start)
{
sink->priv->custom_start = first_layer;
dirty_default_pipeline (sink);
if (sink->priv->renderer)
sink->priv->free_layer = (sink->priv->custom_start +
sink->priv->renderer->n_layers);
}
}
void
cogl_gst_video_sink_set_default_sample (CoglGstVideoSink *sink,
CoglBool default_sample)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
g_return_if_fail (COGL_GST_IS_VIDEO_SINK (sink));
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
if (default_sample != sink->priv->default_sample)
{
sink->priv->default_sample = default_sample;
dirty_default_pipeline (sink);
}
}
void
cogl_gst_video_sink_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
g_return_if_fail (COGL_GST_IS_VIDEO_SINK (sink));
if (sink->priv->renderer)
sink->priv->renderer->setup_pipeline (sink, pipeline);
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
}
static SnippetCacheEntry *
get_cache_entry (CoglGstVideoSink *sink,
SnippetCache *cache)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
GList *l;
for (l = cache->entries.head; l; l = l->next)
{
SnippetCacheEntry *entry = l->data;
if (entry->start_position == priv->custom_start)
return entry;
}
return NULL;
}
static SnippetCacheEntry *
add_cache_entry (CoglGstVideoSink *sink,
SnippetCache *cache,
const char *decl)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
SnippetCacheEntry *entry = g_slice_new (SnippetCacheEntry);
char *default_source;
entry->start_position = priv->custom_start;
entry->vertex_snippet =
cogl_snippet_new (COGL_SNIPPET_HOOK_VERTEX_GLOBALS,
decl,
NULL /* post */);
entry->fragment_snippet =
cogl_snippet_new (COGL_SNIPPET_HOOK_FRAGMENT_GLOBALS,
decl,
NULL /* post */);
default_source =
g_strdup_printf (" cogl_layer *= cogl_gst_sample_video%i "
"(cogl_tex_coord%i_in.st);\n",
priv->custom_start,
priv->custom_start);
entry->default_sample_snippet =
cogl_snippet_new (COGL_SNIPPET_HOOK_LAYER_FRAGMENT,
NULL, /* declarations */
default_source);
g_free (default_source);
g_queue_push_head (&cache->entries, entry);
return entry;
}
static void
setup_pipeline_from_cache_entry (CoglGstVideoSink *sink,
CoglPipeline *pipeline,
SnippetCacheEntry *cache_entry,
int n_layers)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
if (cache_entry)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
cogl-gst: Don't replace previous layers in default shader Previously, when CoglGST generated the default sampling snippet it would set the replace string so that Cogl wouldn't generate any redundant code for the other layers. However this also meant that it wouldn't modulate with the default colour. This patch changes it to set the combine mode on all of the layers to REPLACE(PREVIOUS) so that it just copies the previous layer without generating any texture sampling. That way the fragment snippet for the final layer can just modulate the previous value with the video sampling function. This makes it possible to set a color on the pipeline and have it modulate the video. Also if we eventually add a way to insert layers before the GST sampling layer then it can modulate with those. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f5da8d2caf4b2fbaf6941642a5d5ea7b93d0dd0f)
2013-04-10 12:45:42 +00:00
int i;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
/* The global sampling function gets added to both the fragment
* and vertex stages. The hope is that the GLSL compiler will
* easily remove the dead code if it's not actually used */
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_pipeline_add_snippet (pipeline, cache_entry->vertex_snippet);
cogl_pipeline_add_snippet (pipeline, cache_entry->fragment_snippet);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: Don't replace previous layers in default shader Previously, when CoglGST generated the default sampling snippet it would set the replace string so that Cogl wouldn't generate any redundant code for the other layers. However this also meant that it wouldn't modulate with the default colour. This patch changes it to set the combine mode on all of the layers to REPLACE(PREVIOUS) so that it just copies the previous layer without generating any texture sampling. That way the fragment snippet for the final layer can just modulate the previous value with the video sampling function. This makes it possible to set a color on the pipeline and have it modulate the video. Also if we eventually add a way to insert layers before the GST sampling layer then it can modulate with those. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f5da8d2caf4b2fbaf6941642a5d5ea7b93d0dd0f)
2013-04-10 12:45:42 +00:00
/* Set all of the layers to just directly copy from the previous
* layer so that it won't redundantly generate code to sample
* the intermediate textures */
for (i = 0; i < n_layers; i++)
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_pipeline_set_layer_combine (pipeline,
priv->custom_start + i,
cogl-gst: Don't replace previous layers in default shader Previously, when CoglGST generated the default sampling snippet it would set the replace string so that Cogl wouldn't generate any redundant code for the other layers. However this also meant that it wouldn't modulate with the default colour. This patch changes it to set the combine mode on all of the layers to REPLACE(PREVIOUS) so that it just copies the previous layer without generating any texture sampling. That way the fragment snippet for the final layer can just modulate the previous value with the video sampling function. This makes it possible to set a color on the pipeline and have it modulate the video. Also if we eventually add a way to insert layers before the GST sampling layer then it can modulate with those. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f5da8d2caf4b2fbaf6941642a5d5ea7b93d0dd0f)
2013-04-10 12:45:42 +00:00
"RGBA=REPLACE(PREVIOUS)",
NULL);
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
if (priv->default_sample)
cogl_pipeline_add_layer_snippet (pipeline,
priv->custom_start + n_layers - 1,
cache_entry->default_sample_snippet);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
priv->frame_dirty = TRUE;
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglPipeline *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_video_sink_get_pipeline (CoglGstVideoSink *vt)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
CoglGstVideoSinkPrivate *priv;
g_return_val_if_fail (COGL_GST_IS_VIDEO_SINK (vt), NULL);
priv = vt->priv;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
if (priv->pipeline == NULL)
{
priv->pipeline = cogl_pipeline_new (priv->ctx);
cogl_gst_video_sink_setup_pipeline (vt, priv->pipeline);
cogl_gst_video_sink_attach_frame (vt, priv->pipeline);
priv->frame_dirty = FALSE;
}
else if (priv->frame_dirty)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
CoglPipeline *pipeline = cogl_pipeline_copy (priv->pipeline);
cogl_object_unref (priv->pipeline);
priv->pipeline = pipeline;
cogl_gst_video_sink_attach_frame (vt, pipeline);
priv->frame_dirty = FALSE;
}
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
return priv->pipeline;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static void
clear_frame_textures (CoglGstVideoSink *sink)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
int i;
for (i = 0; i < G_N_ELEMENTS (priv->frame); i++)
{
if (priv->frame[i] == NULL)
break;
else
cogl_object_unref (priv->frame[i]);
}
memset (priv->frame, 0, sizeof (priv->frame));
priv->frame_dirty = TRUE;
}
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
static inline CoglBool
is_pot (unsigned int number)
{
/* Make sure there is only one bit set */
return (number & (number - 1)) == 0;
}
/* This first tries to upload the texture to a CoglTexture2D, but
* if that's not possible it falls back to a CoglTexture2DSliced.
*
* Auto-mipmapping of any uploaded texture is disabled
*/
static CoglTexture *
video_texture_new_from_data (CoglContext *ctx,
int width,
int height,
CoglPixelFormat format,
int rowstride,
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
const uint8_t *data)
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
{
CoglBitmap *bitmap;
CoglTexture *tex;
CoglError *internal_error = NULL;
bitmap = cogl_bitmap_new_for_data (ctx,
width, height,
format,
rowstride,
(uint8_t *) data);
if ((is_pot (cogl_bitmap_get_width (bitmap)) &&
is_pot (cogl_bitmap_get_height (bitmap))) ||
cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_NPOT_BASIC))
{
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
tex = cogl_texture_2d_new_from_bitmap (bitmap);
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
if (!tex)
{
cogl_error_free (internal_error);
internal_error = NULL;
}
}
else
tex = NULL;
if (!tex)
{
/* Otherwise create a sliced texture */
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
tex = cogl_texture_2d_sliced_new_from_bitmap (bitmap,
-1); /* no maximum waste */
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
}
cogl_object_unref (bitmap);
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
cogl_texture_set_premultiplied (tex, FALSE);
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
return tex;
}
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
static void
cogl_gst_rgb24_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
static SnippetCache snippet_cache;
SnippetCacheEntry *entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source =
g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" return texture2D (cogl_sampler%i, UV);\n"
"}\n",
priv->custom_start,
priv->custom_start);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
setup_pipeline_from_cache_entry (sink, pipeline, entry, 1);
}
static void
cogl_gst_rgb24_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
setup_pipeline_from_cache_entry (sink, pipeline, NULL, 1);
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static CoglBool
cogl_gst_rgb24_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
CoglPixelFormat format;
GstVideoFrame frame;
if (priv->bgr)
format = COGL_PIXEL_FORMAT_BGR_888;
else
format = COGL_PIXEL_FORMAT_RGB_888;
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->frame[0] = video_texture_new_from_data (priv->ctx, priv->info.width,
priv->info.height,
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->info.stride[0],
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
frame.data[0]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
static CoglGstRenderer rgb24_glsl_renderer =
{
"RGB 24",
COGL_GST_RGB24,
COGL_GST_RENDERER_NEEDS_GLSL,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGB, BGR }")),
1, /* n_layers */
cogl_gst_rgb24_glsl_setup_pipeline,
cogl_gst_rgb24_upload,
};
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static CoglGstRenderer rgb24_renderer =
{
"RGB 24",
COGL_GST_RGB24,
0,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGB, BGR }")),
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
1, /* n_layers */
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
cogl_gst_rgb24_setup_pipeline,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_rgb24_upload,
};
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
static void
cogl_gst_rgb32_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
static SnippetCache snippet_cache;
SnippetCacheEntry *entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source =
g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" vec4 color = texture2D (cogl_sampler%i, UV);\n"
/* Premultiply the color */
" color.rgb *= color.a;\n"
" return color;\n"
"}\n",
priv->custom_start,
priv->custom_start);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
setup_pipeline_from_cache_entry (sink, pipeline, entry, 1);
}
static void
cogl_gst_rgb32_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
char *layer_combine;
setup_pipeline_from_cache_entry (sink, pipeline, NULL, 1);
/* Premultiply the texture using the a special layer combine */
layer_combine = g_strdup_printf ("RGB=MODULATE(PREVIOUS, TEXTURE_%i[A])\n"
"A=REPLACE(PREVIOUS[A])",
priv->custom_start);
cogl_pipeline_set_layer_combine (pipeline,
priv->custom_start + 1,
layer_combine,
NULL);
g_free(layer_combine);
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static CoglBool
cogl_gst_rgb32_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
CoglPixelFormat format;
GstVideoFrame frame;
if (priv->bgr)
format = COGL_PIXEL_FORMAT_BGRA_8888;
else
format = COGL_PIXEL_FORMAT_RGBA_8888;
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->frame[0] = video_texture_new_from_data (priv->ctx, priv->info.width,
priv->info.height,
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->info.stride[0],
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
frame.data[0]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
static CoglGstRenderer rgb32_glsl_renderer =
{
"RGB 32",
COGL_GST_RGB32,
COGL_GST_RENDERER_NEEDS_GLSL,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBA, BGRA }")),
1, /* n_layers */
cogl_gst_rgb32_glsl_setup_pipeline,
cogl_gst_rgb32_upload,
};
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static CoglGstRenderer rgb32_renderer =
{
"RGB 32",
COGL_GST_RGB32,
0,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("{ RGBA, BGRA }")),
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
2, /* n_layers */
cogl_gst_rgb32_setup_pipeline,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_rgb32_upload,
};
static CoglBool
cogl_gst_yv12_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
CoglPixelFormat format = COGL_PIXEL_FORMAT_A_8;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
GstVideoFrame frame;
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
priv->frame[0] =
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 0),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 0),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[0], frame.data[0]);
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
priv->frame[2] =
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 1),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 1),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[1], frame.data[1]);
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
priv->frame[1] =
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 2),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 2),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[2], frame.data[2]);
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
static CoglBool
cogl_gst_i420_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
cogl-gst: Use alpha textures instead of luminance textures Luminance textures are not supported on GL3 and as the textures are accessed via a shader anyway it doesn't seem like it should make much difference which component the single-component textures are in. Cogl already has code to fake alpha textures via the texture swizzle extension on GL3. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit ca1666860a325fa4d2362cdd38297d6281e997d8)
2013-04-10 15:27:57 +00:00
CoglPixelFormat format = COGL_PIXEL_FORMAT_A_8;
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
GstVideoFrame frame;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
priv->frame[0] =
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 0),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 0),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[0], frame.data[0]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
priv->frame[1] =
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 1),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 1),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[1], frame.data[1]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
priv->frame[2] =
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 2),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 2),
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
priv->info.stride[2], frame.data[2]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
static void
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_gst_yv12_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
CoglGstVideoSinkPrivate *priv = sink->priv;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static SnippetCache snippet_cache;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
SnippetCacheEntry *entry;
entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source =
g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" float y = 1.1640625 * "
cogl-gst: video-sink: fix YV12/I420 support This fixes a mistake in commit 637728dd89d51bc28 that was meant to fix yv12/i420 support but when the patch was updated based on review to use COGL_PIXEL_FORMAT_A instead of COGL_PIXEL_FORMAT_G the corresponding glsl code wasn't also updated to sample the .a component. (cherry picked from commit a02c55105c705471866df2d306879d8616289f2a)
2014-01-01 17:35:50 +00:00
"(texture2D (cogl_sampler%i, UV).a - 0.0625);\n"
" float u = texture2D (cogl_sampler%i, UV).a - 0.5;\n"
" float v = texture2D (cogl_sampler%i, UV).a - 0.5;\n"
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
" vec4 color;\n"
" color.r = y + 1.59765625 * v;\n"
" color.g = y - 0.390625 * u - 0.8125 * v;\n"
" color.b = y + 2.015625 * u;\n"
" color.a = 1.0;\n"
" return color;\n"
"}\n",
priv->custom_start,
priv->custom_start,
priv->custom_start + 1,
priv->custom_start + 2);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
setup_pipeline_from_cache_entry (sink, pipeline, entry, 3);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static CoglGstRenderer yv12_glsl_renderer =
{
"YV12 glsl",
COGL_GST_YV12,
COGL_GST_RENDERER_NEEDS_GLSL,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("YV12")),
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
3, /* n_layers */
cogl_gst_yv12_glsl_setup_pipeline,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_yv12_upload,
};
static CoglGstRenderer i420_glsl_renderer =
{
"I420 glsl",
COGL_GST_I420,
COGL_GST_RENDERER_NEEDS_GLSL,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("I420")),
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
3, /* n_layers */
cogl_gst_yv12_glsl_setup_pipeline,
cogl-gst: video-sink: fix YV12/I420 support
2013-11-26 11:11:42 +00:00
cogl_gst_i420_upload,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
};
static void
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_gst_ayuv_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
CoglGstVideoSinkPrivate *priv = sink->priv;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static SnippetCache snippet_cache;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
SnippetCacheEntry *entry;
entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source
= g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" vec4 color = texture2D (cogl_sampler%i, UV);\n"
" float y = 1.1640625 * (color.g - 0.0625);\n"
" float u = color.b - 0.5;\n"
" float v = color.a - 0.5;\n"
" color.a = color.r;\n"
" color.r = y + 1.59765625 * v;\n"
" color.g = y - 0.390625 * u - 0.8125 * v;\n"
" color.b = y + 2.015625 * u;\n"
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
/* Premultiply the color */
" color.rgb *= color.a;\n"
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
" return color;\n"
"}\n", priv->custom_start,
priv->custom_start);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: video-sink: fix ayuv pipeline setup
2013-11-26 11:28:27 +00:00
setup_pipeline_from_cache_entry (sink, pipeline, entry, 1);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static CoglBool
cogl_gst_ayuv_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
CoglPixelFormat format = COGL_PIXEL_FORMAT_RGBA_8888;
GstVideoFrame frame;
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->frame[0] = video_texture_new_from_data (priv->ctx, priv->info.width,
priv->info.height,
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
format,
gst: don't use cogl_texture_new_with_data This updates cogl-gst to use cogl_texture_2d_new_with_data instead of cogl_texture_new_with_data in preparation for removing the automagic apis in cogl-auto-texture.c Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d3af8dc9bf6c4c1b09a4f7559b0375f848368c10) Conflicts: cogl-gst/cogl-gst-video-sink.c
2013-06-08 21:45:42 +00:00
priv->info.stride[0],
remove internal_format and redundant error arguments Texture allocation is now consistently handled lazily such that the internal format can now be controlled using cogl_texture_set_components() and cogl_texture_set_premultiplied() before allocating the texture with cogl_texture_allocate(). This means that the internal_format arguments to texture constructors are now redundant and since most of the texture constructors now can't ever fail the error arguments are also redundant. This now means we no longer use CoglPixelFormat in the public api for describing the internal format of textures which had been bad solution originally due to how specific CoglPixelFormat is which is missleading when we don't support such explicit control over the internal format. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 99a53c82e9ab0a1e5ee35941bf83dc334b1fbe87) Note: there are numerous API changes for functions currently marked as 'unstable' which we don't think are in use by anyone depending on a stable 1.x api. Compared to the original patch though this avoids changing the cogl_texture_rectangle_new_with_size() api which we know is used by Mutter.
2013-07-02 00:48:54 +00:00
frame.data[0]);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
static CoglGstRenderer ayuv_glsl_renderer =
{
"AYUV glsl",
COGL_GST_AYUV,
COGL_GST_RENDERER_NEEDS_GLSL,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE ("AYUV")),
cogl-gst: video-sink: fix ayuv pipeline setup
2013-11-26 11:28:27 +00:00
1, /* n_layers */
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
cogl_gst_ayuv_glsl_setup_pipeline,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_ayuv_upload,
};
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
static void
cogl_gst_nv12_glsl_setup_pipeline (CoglGstVideoSink *sink,
CoglPipeline *pipeline)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
static SnippetCache snippet_cache;
SnippetCacheEntry *entry;
entry = get_cache_entry (sink, &snippet_cache);
if (entry == NULL)
{
char *source;
source =
g_strdup_printf ("vec4\n"
"cogl_gst_sample_video%i (vec2 UV)\n"
"{\n"
" vec4 color;\n"
" float y = 1.1640625 *\n"
" (texture2D (cogl_sampler%i, UV).a -\n"
" 0.0625);\n"
" vec2 uv = texture2D (cogl_sampler%i, UV).rg;\n"
" uv -= 0.5;\n"
" float u = uv.x;\n"
" float v = uv.y;\n"
" color.r = y + 1.59765625 * v;\n"
" color.g = y - 0.390625 * u - 0.8125 * v;\n"
" color.b = y + 2.015625 * u;\n"
" color.a = 1.0;\n"
" return color;\n"
"}\n",
priv->custom_start,
priv->custom_start,
priv->custom_start + 1);
entry = add_cache_entry (sink, &snippet_cache, source);
g_free (source);
}
setup_pipeline_from_cache_entry (sink, pipeline, entry, 2);
}
static CoglBool
cogl_gst_nv12_upload (CoglGstVideoSink *sink,
GstBuffer *buffer)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
GstVideoFrame frame;
if (!gst_video_frame_map (&frame, &priv->info, buffer, GST_MAP_READ))
goto map_fail;
clear_frame_textures (sink);
priv->frame[0] =
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 0),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 0),
COGL_PIXEL_FORMAT_A_8,
priv->info.stride[0],
frame.data[0]);
priv->frame[1] =
video_texture_new_from_data (priv->ctx,
GST_VIDEO_INFO_COMP_WIDTH (&priv->info, 1),
GST_VIDEO_INFO_COMP_HEIGHT (&priv->info, 1),
COGL_PIXEL_FORMAT_RG_88,
priv->info.stride[1],
frame.data[1]);
gst_video_frame_unmap (&frame);
return TRUE;
map_fail:
{
GST_ERROR_OBJECT (sink, "Could not map incoming video frame");
return FALSE;
}
}
static CoglGstRenderer nv12_glsl_renderer =
{
"NV12 glsl",
COGL_GST_NV12,
COGL_GST_RENDERER_NEEDS_GLSL | COGL_GST_RENDERER_NEEDS_TEXTURE_RG,
GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE_WITH_FEATURES ("memory:SystemMemory",
"NV12")),
2, /* n_layers */
cogl_gst_nv12_glsl_setup_pipeline,
cogl_gst_nv12_upload,
};
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
static GSList*
cogl_gst_build_renderers_list (CoglContext *ctx)
{
GSList *list = NULL;
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
CoglGstRendererFlag flags = 0;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
int i;
static CoglGstRenderer *const renderers[] =
{
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
/* These are in increasing order of priority so that the
* priv->renderers will be in decreasing order. That way the GLSL
* renderers will be preferred if they are available */
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
&rgb24_renderer,
&rgb32_renderer,
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
&rgb24_glsl_renderer,
&rgb32_glsl_renderer,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
&yv12_glsl_renderer,
&i420_glsl_renderer,
&ayuv_glsl_renderer,
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
&nv12_glsl_renderer,
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
NULL
};
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
if (cogl_has_feature (ctx, COGL_FEATURE_ID_GLSL))
flags |= COGL_GST_RENDERER_NEEDS_GLSL;
if (cogl_has_feature (ctx, COGL_FEATURE_ID_TEXTURE_RG))
flags |= COGL_GST_RENDERER_NEEDS_TEXTURE_RG;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
for (i = 0; renderers[i]; i++)
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
if ((renderers[i]->flags & flags) == renderers[i]->flags)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
list = g_slist_prepend (list, renderers[i]);
return list;
}
static void
append_cap (gpointer data,
gpointer user_data)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstRenderer *renderer = (CoglGstRenderer *) data;
GstCaps *caps = (GstCaps *) user_data;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
GstCaps *writable_caps;
writable_caps =
gst_caps_make_writable (gst_static_caps_get (&renderer->caps));
gst_caps_append (caps, writable_caps);
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
static GstCaps *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_build_caps (GSList *renderers)
{
GstCaps *caps;
caps = gst_caps_new_empty ();
g_slist_foreach (renderers, append_cap, caps);
return caps;
}
void
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
cogl_gst_video_sink_set_context (CoglGstVideoSink *vt,
CoglContext *ctx)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
CoglGstVideoSinkPrivate *priv = vt->priv;
if (ctx)
ctx = cogl_object_ref (ctx);
if (priv->ctx)
{
cogl_object_unref (priv->ctx);
g_slist_free (priv->renderers);
priv->renderers = NULL;
if (priv->caps)
{
gst_caps_unref (priv->caps);
priv->caps = NULL;
}
}
if (ctx)
{
priv->ctx = ctx;
priv->renderers = cogl_gst_build_renderers_list (priv->ctx);
priv->caps = cogl_gst_build_caps (priv->renderers);
}
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
static CoglGstRenderer *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_find_renderer_by_format (CoglGstVideoSink *sink,
CoglGstVideoFormat format)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
CoglGstRenderer *renderer = NULL;
GSList *element;
cogl-gst-video-sink: Premultiply the colors coming from the video Commit 99a53c82e9ab0a1e5 removed the internal format argument when uploading a video frame to a texture so that the format will just be determined automatically from the image format. However this also leaves the premultiplied state at the default and the default is TRUE. That means that when we upload RGBA data Cogl will do a premultiplied conversion on the CPU. We probably don't want to be putting a CPU conversion in the way of video frames so this patch changes it to set the premultiplied state to FALSE on the textures and then do the premultiplied conversion in the shader. This is particularly important for AYUV which uses the alpha channel for the V component so doing a premultiplied conversion on the CPU just creates garbage and messes up the image. The RGB and RGBA renderers have each been split into two; one that uses GLSL and one that uses a regular pipeline. The RGBA pipeline without GLSL is then changed to use 2 layers so we that we can do the premultiplied conversion in the second layer with a special layer combine string. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 07a57f26596c72507035369c90ed6d62568330b5)
2014-01-22 15:11:55 +00:00
/* The renderers list is in decreasing order of priority so we'll
* pick the first one that matches */
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
for (element = priv->renderers; element; element = g_slist_next (element))
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstRenderer *candidate = (CoglGstRenderer *) element->data;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
if (candidate->format == format)
{
renderer = candidate;
break;
}
}
return renderer;
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
static GstCaps *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_video_sink_get_caps (GstBaseSink *bsink,
GstCaps *filter)
{
CoglGstVideoSink *sink;
sink = COGL_GST_VIDEO_SINK (bsink);
cogl-gst: Fix get_caps implementation when no context is set If no context is set on the CoglGstVideoSink then it would previously call gst_caps_ref with a NULL pointer. This patch makes it just return NULL instead. I think that is a valid thing to do because that is what gst_base_sink_default_get_caps does. If we don't do this then it's not possible to use CoglGstVideoSink with GstParse because that tries to link the pipeline after parsing the string. That was previously causing a critical error because the freshly parsed sink doesn't have a CoglContext. Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit cf26da2964e372c9fe5bd6da060a57006a83af38)
2014-01-21 17:33:57 +00:00
if (sink->priv->caps == NULL)
return NULL;
else
return gst_caps_ref (sink->priv->caps);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static CoglBool
cogl_gst_video_sink_parse_caps (GstCaps *caps,
CoglGstVideoSink *sink,
CoglBool save)
{
CoglGstVideoSinkPrivate *priv = sink->priv;
GstCaps *intersection;
GstVideoInfo vinfo;
CoglGstVideoFormat format;
CoglBool bgr = FALSE;
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstRenderer *renderer;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
intersection = gst_caps_intersect (priv->caps, caps);
if (gst_caps_is_empty (intersection))
goto no_intersection;
gst_caps_unref (intersection);
if (!gst_video_info_from_caps (&vinfo, caps))
goto unknown_format;
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
switch (vinfo.finfo->format)
{
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
case GST_VIDEO_FORMAT_YV12:
format = COGL_GST_YV12;
break;
case GST_VIDEO_FORMAT_I420:
format = COGL_GST_I420;
break;
case GST_VIDEO_FORMAT_AYUV:
format = COGL_GST_AYUV;
bgr = FALSE;
break;
cogl-gst: video-sink: add NV12 support This adds a cogl-gst renderer to decode NV12 data. NV12 is split into two buffers, one for the luma component and another for the two chrominance components at a quarter of the resolution. The second buffer is uploaded to a two-component RG texture. RG-component textures are only supported if COGL_FEATURE_ID_TEXTURE_RG is advertised by Cogl so the NV12 cap is also only advertised when that is available. Based on a patch by Lionel Landwerlin which was in turn based on a patch from Edward Hervey and Matthieu Bouron for Clutter-Gst: https://bugzilla.gnome.org/show_bug.cgi?id=712832 Reviewed-by: Robert Bragg <robert@linux.intel.com> Reviewed-by: Lionel Landwerlin <llandwerlin@gmail.com> (cherry picked from commit 2c619216964b46aab313be3ef1c405dfc720d258)
2014-01-21 17:33:56 +00:00
case GST_VIDEO_FORMAT_NV12:
format = COGL_GST_NV12;
break;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
case GST_VIDEO_FORMAT_RGB:
format = COGL_GST_RGB24;
bgr = FALSE;
break;
case GST_VIDEO_FORMAT_BGR:
format = COGL_GST_RGB24;
bgr = TRUE;
break;
case GST_VIDEO_FORMAT_RGBA:
format = COGL_GST_RGB32;
bgr = FALSE;
break;
case GST_VIDEO_FORMAT_BGRA:
format = COGL_GST_RGB32;
bgr = TRUE;
break;
default:
goto unhandled_format;
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
renderer = cogl_gst_find_renderer_by_format (sink, format);
if (G_UNLIKELY (renderer == NULL))
goto no_suitable_renderer;
GST_INFO_OBJECT (sink, "found the %s renderer", renderer->name);
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
if (save)
{
priv->info = vinfo;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
priv->format = format;
priv->bgr = bgr;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
priv->renderer = renderer;
}
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
return TRUE;
no_intersection:
{
GST_WARNING_OBJECT (sink,
"Incompatible caps, don't intersect with %" GST_PTR_FORMAT, priv->caps);
return FALSE;
}
unknown_format:
{
GST_WARNING_OBJECT (sink, "Could not figure format of input caps");
return FALSE;
}
unhandled_format:
{
GST_ERROR_OBJECT (sink, "Provided caps aren't supported by clutter-gst");
return FALSE;
}
no_suitable_renderer:
{
GST_ERROR_OBJECT (sink, "could not find a suitable renderer");
return FALSE;
}
}
static CoglBool
cogl_gst_video_sink_set_caps (GstBaseSink *bsink,
GstCaps *caps)
{
CoglGstVideoSink *sink;
CoglGstVideoSinkPrivate *priv;
sink = COGL_GST_VIDEO_SINK (bsink);
priv = sink->priv;
if (!cogl_gst_video_sink_parse_caps (caps, sink, FALSE))
return FALSE;
g_mutex_lock (&priv->source->buffer_lock);
priv->source->has_new_caps = TRUE;
g_mutex_unlock (&priv->source->buffer_lock);
return TRUE;
}
static CoglBool
cogl_gst_source_dispatch (GSource *source,
GSourceFunc callback,
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
void *user_data)
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
{
CoglGstSource *gst_source= (CoglGstSource*) source;
CoglGstVideoSinkPrivate *priv = gst_source->sink->priv;
GstBuffer *buffer;
cogl-gst: emit ready signal on sink only after the first frame is uploaded Developers listening to the 'ready' signal on CoglGstVideoSink might call process the current frame once the signal is triggered. We need to ensure the first frame has been uploaded before letting people know that the sink is ready. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 53882aa0728c5540d8452045006a763e29d4306d)
2013-08-09 21:44:51 +00:00
gboolean pipeline_ready = FALSE;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
g_mutex_lock (&gst_source->buffer_lock);
if (G_UNLIKELY (gst_source->has_new_caps))
{
GstCaps *caps =
gst_pad_get_current_caps (GST_BASE_SINK_PAD ((GST_BASE_SINK
(gst_source->sink))));
if (!cogl_gst_video_sink_parse_caps (caps, gst_source->sink, TRUE))
goto negotiation_fail;
gst_source->has_new_caps = FALSE;
cogl-gst: Add a functions to facilitate layering These functions are used when attaching frames at a start point other than layer 0 is required. This could potentially be used to "layer" videos and textures on top of each other in the CoglPipeline. This layering could come handy if videos are used as alpha masks or normal maps, or when arranging layers in a perticular order, so Cogl could blend them nicely without extra hassle. Reviewed-by: Neil Roberts <neil@linux.intel.com> Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit f98b437c9ea79f04ef1ebbb6ff547f58b49b0008)
2013-04-16 17:15:28 +00:00
priv->free_layer = priv->custom_start + priv->renderer->n_layers;
dirty_default_pipeline (gst_source->sink);
/* We are now in a state where we could generate the pipeline if
* the application requests it so we can emit the signal.
* However we'll actually generate the pipeline lazily only if
* the application actually asks for it. */
cogl-gst: emit ready signal on sink only after the first frame is uploaded Developers listening to the 'ready' signal on CoglGstVideoSink might call process the current frame once the signal is triggered. We need to ensure the first frame has been uploaded before letting people know that the sink is ready. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 53882aa0728c5540d8452045006a763e29d4306d)
2013-08-09 21:44:51 +00:00
pipeline_ready = TRUE;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
buffer = gst_source->buffer;
gst_source->buffer = NULL;
g_mutex_unlock (&gst_source->buffer_lock);
if (buffer)
{
if (!priv->renderer->upload (gst_source->sink, buffer))
goto fail_upload;
gst_buffer_unref (buffer);
}
else
GST_WARNING_OBJECT (gst_source->sink, "No buffers available for display");
cogl-gst: emit ready signal on sink only after the first frame is uploaded Developers listening to the 'ready' signal on CoglGstVideoSink might call process the current frame once the signal is triggered. We need to ensure the first frame has been uploaded before letting people know that the sink is ready. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 53882aa0728c5540d8452045006a763e29d4306d)
2013-08-09 21:44:51 +00:00
if (G_UNLIKELY (pipeline_ready))
g_signal_emit (gst_source->sink,
video_sink_signals[PIPELINE_READY_SIGNAL],
0 /* detail */);
g_signal_emit (gst_source->sink,
video_sink_signals[NEW_FRAME_SIGNAL], 0,
NULL);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
return TRUE;
negotiation_fail:
{
GST_WARNING_OBJECT (gst_source->sink,
"Failed to handle caps. Stopping GSource");
priv->flow_return = GST_FLOW_NOT_NEGOTIATED;
g_mutex_unlock (&gst_source->buffer_lock);
return FALSE;
}
fail_upload:
{
GST_WARNING_OBJECT (gst_source->sink, "Failed to upload buffer");
priv->flow_return = GST_FLOW_ERROR;
gst_buffer_unref (buffer);
return FALSE;
}
}
static GSourceFuncs gst_source_funcs =
{
cogl_gst_source_prepare,
cogl_gst_source_check,
cogl_gst_source_dispatch,
cogl_gst_source_finalize
};
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
static CoglGstSource *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_source_new (CoglGstVideoSink *sink)
{
GSource *source;
CoglGstSource *gst_source;
source = g_source_new (&gst_source_funcs, sizeof (CoglGstSource));
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
gst_source = (CoglGstSource *) source;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
g_source_set_can_recurse (source, TRUE);
g_source_set_priority (source, COGL_GST_DEFAULT_PRIORITY);
gst_source->sink = sink;
g_mutex_init (&gst_source->buffer_lock);
gst_source->buffer = NULL;
return gst_source;
}
static void
cogl_gst_video_sink_init (CoglGstVideoSink *sink)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstVideoSinkPrivate *priv;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
sink->priv = priv = G_TYPE_INSTANCE_GET_PRIVATE (sink,
COGL_GST_TYPE_VIDEO_SINK,
CoglGstVideoSinkPrivate);
cogl-gst: move initialization code so CoglGstVideoSink can be subclassed Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 2f6068cb6783edf6e05d6e55e9700e22f31cb233)
2013-07-09 13:08:04 +00:00
priv->custom_start = 0;
priv->default_sample = TRUE;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static GstFlowReturn
_cogl_gst_video_sink_render (GstBaseSink *bsink,
GstBuffer *buffer)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (bsink);
CoglGstVideoSinkPrivate *priv = sink->priv;
CoglGstSource *gst_source = priv->source;
g_mutex_lock (&gst_source->buffer_lock);
if (G_UNLIKELY (priv->flow_return != GST_FLOW_OK))
goto dispatch_flow_ret;
if (gst_source->buffer)
gst_buffer_unref (gst_source->buffer);
gst_source->buffer = gst_buffer_ref (buffer);
g_mutex_unlock (&gst_source->buffer_lock);
g_main_context_wakeup (NULL);
return GST_FLOW_OK;
dispatch_flow_ret:
{
g_mutex_unlock (&gst_source->buffer_lock);
return priv->flow_return;
}
}
static void
cogl_gst_video_sink_dispose (GObject *object)
{
CoglGstVideoSink *self;
CoglGstVideoSinkPrivate *priv;
self = COGL_GST_VIDEO_SINK (object);
priv = self->priv;
clear_frame_textures (self);
if (priv->pipeline)
{
cogl_object_unref (priv->pipeline);
priv->pipeline = NULL;
}
if (priv->caps)
{
gst_caps_unref (priv->caps);
priv->caps = NULL;
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
G_OBJECT_CLASS (cogl_gst_video_sink_parent_class)->dispose (object);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static void
cogl_gst_video_sink_finalize (GObject *object)
{
CoglGstVideoSink *self = COGL_GST_VIDEO_SINK (object);
cogl_gst_video_sink_set_context (self, NULL);
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
G_OBJECT_CLASS (cogl_gst_video_sink_parent_class)->finalize (object);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
}
static CoglBool
cogl_gst_video_sink_start (GstBaseSink *base_sink)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (base_sink);
CoglGstVideoSinkPrivate *priv = sink->priv;
priv->source = cogl_gst_source_new (sink);
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
g_source_attach ((GSource *) priv->source, NULL);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
priv->flow_return = GST_FLOW_OK;
return TRUE;
}
static void
cogl_gst_video_sink_set_property (GObject *object,
unsigned int prop_id,
const GValue *value,
GParamSpec *pspec)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (object);
switch (prop_id)
{
case PROP_UPDATE_PRIORITY:
cogl_gst_video_sink_set_priority (sink, g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
cogl_gst_video_sink_get_property (GObject *object,
unsigned int prop_id,
GValue *value,
GParamSpec *pspec)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (object);
CoglGstVideoSinkPrivate *priv = sink->priv;
switch (prop_id)
{
case PROP_UPDATE_PRIORITY:
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
g_value_set_int (value, g_source_get_priority ((GSource *) priv->source));
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static CoglBool
cogl_gst_video_sink_stop (GstBaseSink *base_sink)
{
CoglGstVideoSink *sink = COGL_GST_VIDEO_SINK (base_sink);
CoglGstVideoSinkPrivate *priv = sink->priv;
if (priv->source)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
GSource *source = (GSource *) priv->source;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
g_source_destroy (source);
g_source_unref (source);
priv->source = NULL;
}
return TRUE;
}
static void
cogl_gst_video_sink_class_init (CoglGstVideoSinkClass *klass)
{
GObjectClass *go_class = G_OBJECT_CLASS (klass);
GstBaseSinkClass *gb_class = GST_BASE_SINK_CLASS (klass);
GstElementClass *ge_class = GST_ELEMENT_CLASS (klass);
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
GstPadTemplate *pad_template;
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
GParamSpec *pspec;
g_type_class_add_private (klass, sizeof (CoglGstVideoSinkPrivate));
go_class->set_property = cogl_gst_video_sink_set_property;
go_class->get_property = cogl_gst_video_sink_get_property;
go_class->dispose = cogl_gst_video_sink_dispose;
go_class->finalize = cogl_gst_video_sink_finalize;
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
pad_template = gst_static_pad_template_get (&sinktemplate_all);
gst_element_class_add_pad_template (ge_class, pad_template);
gst_element_class_set_metadata (ge_class,
"Cogl video sink", "Sink/Video",
"Sends video data from GStreamer to a "
"Cogl pipeline",
"Jonathan Matthew <jonathan@kaolin.wh9.net>, "
"Matthew Allum <mallum@o-hand.com, "
"Chris Lord <chris@o-hand.com>, "
"Plamena Manolova "
"<plamena.n.manolova@intel.com>");
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
gb_class->render = _cogl_gst_video_sink_render;
gb_class->preroll = _cogl_gst_video_sink_render;
gb_class->start = cogl_gst_video_sink_start;
gb_class->stop = cogl_gst_video_sink_stop;
gb_class->set_caps = cogl_gst_video_sink_set_caps;
gb_class->get_caps = cogl_gst_video_sink_get_caps;
pspec = g_param_spec_int ("update-priority",
"Update Priority",
"Priority of video updates in the thread",
-G_MAXINT, G_MAXINT,
COGL_GST_DEFAULT_PRIORITY,
COGL_GST_PARAM_READWRITE);
g_object_class_install_property (go_class, PROP_UPDATE_PRIORITY, pspec);
video_sink_signals[PIPELINE_READY_SIGNAL] =
g_signal_new ("pipeline-ready",
COGL_GST_TYPE_VIDEO_SINK,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (CoglGstVideoSinkClass, pipeline_ready),
NULL, /* accumulator */
NULL, /* accu_data */
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0 /* n_params */);
video_sink_signals[NEW_FRAME_SIGNAL] =
g_signal_new ("new-frame",
COGL_GST_TYPE_VIDEO_SINK,
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (CoglGstVideoSinkClass, new_frame),
NULL, /* accumulator */
NULL, /* accu_data */
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0 /* n_params */);
}
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstVideoSink *
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_video_sink_new (CoglContext *ctx)
{
cogl-gst: More pedantic style fixes • Fixes some overly long lines, hugging asterisks in the pointer type declarations and indentation issues. • Tidies up the GLSL source so that it will look nicer in the debug output. • Removes the backwards ‘parent_class’ define which hacks the implementation of the G_DEFINE_TYPE macro and just uses the full type name instead. Reviewed-by: Robert Bragg <robert@linux.intel.com> (cherry picked from commit 3ffe8979da4d4dc7deb221e5653b6f24f41b412c)
2013-03-19 19:37:19 +00:00
CoglGstVideoSink *sink = g_object_new (COGL_GST_TYPE_VIDEO_SINK, NULL);
Include CoglGst CoglGst is a GStreamer integration library that facilitates video playback using the Cogl API. It works by retrieving each video frame from the GStreamer pipeline and attaching it to a Cogl pipeline in the form of a Cogl texture along with possible color model conversion shaders. The pipeline is then retrieved by the user during each draw. An example use of the CoglGst API is included in the examples directory. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit dfb94cf4b0b6b42d6465df362a0c0af780596890)
2013-02-22 14:56:05 +00:00
cogl_gst_video_sink_set_context (sink, ctx);
return sink;
}
cogl-gst: expose aspect ratio apis This adds several utility apis that aim to make it as easy as possible for an application to determine what size a video should be drawn at. The important detail here is that these apis take into account the pixel-aspect-ratio in addition to the video's own aspect ratio. This patch updates the cogl-basic-video-player example to use the cogl_gst_video_sink_fit_size() api to perform letterboxing. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d26f17c97ff6b9f6d6211e0527d5965a85305a56)
2013-04-25 23:57:06 +00:00
float
cogl_gst_video_sink_get_aspect (CoglGstVideoSink *vt)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
GstVideoInfo *info;
g_return_val_if_fail (COGL_GST_IS_VIDEO_SINK (vt), 0.);
info = &vt->priv->info;
cogl-gst: expose aspect ratio apis This adds several utility apis that aim to make it as easy as possible for an application to determine what size a video should be drawn at. The important detail here is that these apis take into account the pixel-aspect-ratio in addition to the video's own aspect ratio. This patch updates the cogl-basic-video-player example to use the cogl_gst_video_sink_fit_size() api to perform letterboxing. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d26f17c97ff6b9f6d6211e0527d5965a85305a56)
2013-04-25 23:57:06 +00:00
return ((float)info->width * (float)info->par_n) /
((float)info->height * (float)info->par_d);
}
float
cogl_gst_video_sink_get_width_for_height (CoglGstVideoSink *vt,
float height)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
float aspect;
g_return_val_if_fail (COGL_GST_IS_VIDEO_SINK (vt), 0.);
aspect = cogl_gst_video_sink_get_aspect (vt);
cogl-gst: expose aspect ratio apis This adds several utility apis that aim to make it as easy as possible for an application to determine what size a video should be drawn at. The important detail here is that these apis take into account the pixel-aspect-ratio in addition to the video's own aspect ratio. This patch updates the cogl-basic-video-player example to use the cogl_gst_video_sink_fit_size() api to perform letterboxing. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d26f17c97ff6b9f6d6211e0527d5965a85305a56)
2013-04-25 23:57:06 +00:00
return height * aspect;
}
float
cogl_gst_video_sink_get_height_for_width (CoglGstVideoSink *vt,
float width)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
float aspect;
g_return_val_if_fail (COGL_GST_IS_VIDEO_SINK (vt), 0.);
aspect = cogl_gst_video_sink_get_aspect (vt);
cogl-gst: expose aspect ratio apis This adds several utility apis that aim to make it as easy as possible for an application to determine what size a video should be drawn at. The important detail here is that these apis take into account the pixel-aspect-ratio in addition to the video's own aspect ratio. This patch updates the cogl-basic-video-player example to use the cogl_gst_video_sink_fit_size() api to perform letterboxing. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d26f17c97ff6b9f6d6211e0527d5965a85305a56)
2013-04-25 23:57:06 +00:00
return width / aspect;
}
void
cogl_gst_video_sink_fit_size (CoglGstVideoSink *vt,
const CoglGstRectangle *available,
CoglGstRectangle *output)
{
cogl-gst: protect public API using type checks (cherry picked from commit 9a8c6536088368060a85f74d082c3dd8487b877c)
2013-07-05 16:27:34 +00:00
g_return_if_fail (COGL_GST_IS_VIDEO_SINK (vt));
g_return_if_fail (available != NULL);
g_return_if_fail (output != NULL);
cogl-gst: expose aspect ratio apis This adds several utility apis that aim to make it as easy as possible for an application to determine what size a video should be drawn at. The important detail here is that these apis take into account the pixel-aspect-ratio in addition to the video's own aspect ratio. This patch updates the cogl-basic-video-player example to use the cogl_gst_video_sink_fit_size() api to perform letterboxing. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit d26f17c97ff6b9f6d6211e0527d5965a85305a56)
2013-04-25 23:57:06 +00:00
if (available->height == 0.0f)
{
output->x = available->x;
output->y = available->y;
output->width = output->height = 0;
}
else
{
float available_aspect = available->width / available->height;
float video_aspect = cogl_gst_video_sink_get_aspect (vt);
if (video_aspect > available_aspect)
{
output->width = available->width;
output->height = available->width / video_aspect;
output->x = available->x;
output->y = available->y + (available->height - output->height) / 2;
}
else
{
output->width = available->height * video_aspect;
output->height = available->height;
output->x = available->x + (available->width - output->width) / 2;
output->y = available->y;
}
}
}
cogl-gst: adds _sink_is_ready() api This adds a cogl_gst_video_sink_is_ready() for code to be able to check if it's safe to call cogl_gst_video_sink_get_pipeline() or cogl_gst_video_sink_setup_pipeline() without causing an error. Normally an application can listen for the pipeline-ready signal but sometimes a sink can be passed between components that didn't have an opportunity to connect a signal handler, so they need a way to directly check the status. Reviewed-by: Neil Roberts <neil@linux.intel.com> (cherry picked from commit 9e7db391a87beee7c448f2a67b3e7202779ce9b2)
2013-07-09 17:29:24 +00:00
CoglBool
cogl_gst_video_sink_is_ready (CoglGstVideoSink *sink)
{
return !!sink->priv->renderer;
}
Reference in New Issue Copy Permalink