From: Yuqing Zhu Date: Thu, 13 Oct 2016 01:59:51 +0000 (+0800) Subject: gstreamer1.0-plugins-bad: Accelerate gldownload with directviv API X-Git-Tag: 2.2~173 X-Git-Url: https://code.ossystems.io/gitweb?a=commitdiff_plain;h=7d3e10c59af9aef7e672b906fa29203672772c1f;p=meta-freescale.git gstreamer1.0-plugins-bad: Accelerate gldownload with directviv API 1) Propose a physical buffer pool to upstream in gldownload 2) Bind the physical buffer with texture via dirctviv 3) In gldownload, wrap the physical buffer to gstbuffer, pass to downstream plugins. Signed-off-by: Yuqing Zhu Signed-off-by: Otavio Salvador --- diff --git a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0003-MMFMWK-6930-glplugin-Accelerate-gldownload-with-dire.patch b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0003-MMFMWK-6930-glplugin-Accelerate-gldownload-with-dire.patch new file mode 100644 index 00000000..1cead36d --- /dev/null +++ b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0003-MMFMWK-6930-glplugin-Accelerate-gldownload-with-dire.patch @@ -0,0 +1,729 @@ +From 05bbd82dd527afa44d6b403b02a0dbd198c96859 Mon Sep 17 00:00:00 2001 +From: Jian Li +Date: Fri, 6 Nov 2015 15:00:19 +0800 +Subject: [PATCH 14/18] MMFMWK-6930 [glplugin] Accelerate gldownload with + directviv API +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +1) Propose a physical buffer pool to upstream in gldownload +2) Bind the physical buffer with texture via dirctviv +3) In gldownload, wrap the physical buffer to gstbuffer, pass to + downstream plugins. + +Upstream-Status: Inappropriate [i.MX specific] + +Signed-off-by: Jian Li +Signed-off-by: Lyon Wang +--- + ext/gl/gstgldownloadelement.c | 91 ++++++++++++ + gst-libs/gst/gl/Makefile.am | 4 + + gst-libs/gst/gl/gstglbufferpool.c | 12 ++ + gst-libs/gst/gl/gstglphymemory.c | 254 ++++++++++++++++++++++++++++++++ + gst-libs/gst/gl/gstglphymemory.h | 43 ++++++ + gst-libs/gst/gl/gstglvivdirecttexture.c | 147 +++++++++--------- + gst-libs/gst/gl/gstglvivdirecttexture.h | 3 + + 7 files changed, 484 insertions(+), 70 deletions(-) + create mode 100644 gst-libs/gst/gl/gstglphymemory.c + create mode 100644 gst-libs/gst/gl/gstglphymemory.h + +diff --git a/ext/gl/gstgldownloadelement.c b/ext/gl/gstgldownloadelement.c +index ff931fa..9ea0146 100644 +--- a/ext/gl/gstgldownloadelement.c ++++ b/ext/gl/gstgldownloadelement.c +@@ -23,6 +23,7 @@ + #endif + + #include ++#include + #include "gstgldownloadelement.h" + + GST_DEBUG_CATEGORY_STATIC (gst_gl_download_element_debug); +@@ -45,6 +46,8 @@ gst_gl_download_element_prepare_output_buffer (GstBaseTransform * bt, + GstBuffer * buffer, GstBuffer ** outbuf); + static GstFlowReturn gst_gl_download_element_transform (GstBaseTransform * bt, + GstBuffer * buffer, GstBuffer * outbuf); ++static gboolean gst_gl_download_element_propose_allocation (GstBaseTransform * ++ bt, GstQuery * decide_query, GstQuery * query); + + static GstStaticPadTemplate gst_gl_download_element_src_pad_template = + GST_STATIC_PAD_TEMPLATE ("src", +@@ -70,6 +73,7 @@ gst_gl_download_element_class_init (GstGLDownloadElementClass * klass) + bt_class->prepare_output_buffer = + gst_gl_download_element_prepare_output_buffer; + bt_class->transform = gst_gl_download_element_transform; ++ bt_class->propose_allocation = gst_gl_download_element_propose_allocation; + + bt_class->passthrough_on_same_caps = TRUE; + +@@ -160,9 +164,24 @@ static GstFlowReturn + gst_gl_download_element_prepare_output_buffer (GstBaseTransform * bt, + GstBuffer * inbuf, GstBuffer ** outbuf) + { ++ GstGLDownloadElement *download = GST_GL_DOWNLOAD_ELEMENT (bt); + GstCaps *src_caps = gst_pad_get_current_caps (bt->srcpad); + GstCapsFeatures *features = NULL; + gint i, n; ++ GstGLMemory *glmem; ++ ++ glmem = gst_buffer_peek_memory (inbuf, 0); ++ if (gst_is_gl_physical_memory (glmem)) { ++ GstGLContext *context = GST_GL_BASE_FILTER (bt)->context; ++ GstVideoInfo info; ++ ++ gst_video_info_from_caps (&info, src_caps); ++ *outbuf = gst_gl_phymem_buffer_to_gstbuffer (context, &info, inbuf); ++ ++ GST_DEBUG_OBJECT (download, "gl download with direct viv."); ++ ++ return GST_FLOW_OK; ++ } + + *outbuf = inbuf; + +@@ -194,3 +213,75 @@ gst_gl_download_element_transform (GstBaseTransform * bt, + { + return GST_FLOW_OK; + } ++ ++static gboolean ++gst_gl_download_element_propose_allocation (GstBaseTransform * bt, ++ GstQuery * decide_query, GstQuery * query) ++{ ++ GstGLContext *context = GST_GL_BASE_FILTER (bt)->context; ++ GstGLDownloadElement *download = GST_GL_DOWNLOAD_ELEMENT (bt); ++ GstAllocationParams params; ++ GstAllocator *allocator = NULL; ++ GstBufferPool *pool = NULL; ++ guint n_pools, i; ++ GstVideoInfo info; ++ GstCaps *caps; ++ GstStructure *config; ++ gsize size; ++ ++ gst_query_parse_allocation (query, &caps, NULL); ++ if (!gst_video_info_from_caps (&info, caps)) { ++ GST_WARNING_OBJECT (bt, "invalid caps specified"); ++ return FALSE; ++ } ++ ++ GST_DEBUG_OBJECT (bt, "video format is %s", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (&info))); ++ ++ gst_allocation_params_init (¶ms); ++ if (gst_is_gl_physical_memory_supported_fmt (&info)) { ++ allocator = gst_phy_mem_allocator_obtain (); ++ GST_DEBUG_OBJECT (bt, "obtain physical memory allocator %p.", allocator); ++ } ++ ++ if (!allocator) ++ allocator = gst_allocator_find (GST_GL_MEMORY_ALLOCATOR_NAME); ++ ++ if (!allocator) { ++ GST_ERROR_OBJECT (bt, "Can't obtain physical memory allocator."); ++ return FALSE; ++ } ++ ++ gst_query_add_allocation_param (query, allocator, ¶ms); ++ gst_object_unref (allocator); ++ ++ n_pools = gst_query_get_n_allocation_pools (query); ++ for (i = 0; i < n_pools; i++) { ++ gst_query_parse_nth_allocation_pool (query, i, &pool, NULL, NULL, NULL); ++ gst_object_unref (pool); ++ pool = NULL; ++ } ++ ++ //new buffer pool ++ pool = gst_gl_buffer_pool_new (context); ++ config = gst_buffer_pool_get_config (pool); ++ ++ /* the normal size of a frame */ ++ size = info.size; ++ gst_buffer_pool_config_set_params (config, caps, size, 0, 0); ++ gst_buffer_pool_config_add_option (config, GST_BUFFER_POOL_OPTION_GL_SYNC_META); ++ ++ if (!gst_buffer_pool_set_config (pool, config)) { ++ gst_object_unref (pool); ++ GST_WARNING_OBJECT (bt, "failed setting config"); ++ return FALSE; ++ } ++ ++ GST_DEBUG_OBJECT (download, "create pool %p", pool); ++ ++ //propose 3 buffers for better performance ++ gst_query_add_allocation_pool (query, pool, size, 3, 0); ++ ++ gst_object_unref (pool); ++ ++ return TRUE; ++} +diff --git a/gst-libs/gst/gl/Makefile.am b/gst-libs/gst/gl/Makefile.am +index c396603..5c05230 100644 +--- a/gst-libs/gst/gl/Makefile.am ++++ b/gst-libs/gst/gl/Makefile.am +@@ -34,6 +34,7 @@ libgstgl_@GST_API_VERSION@_la_SOURCES = \ + gstgloverlaycompositor.c \ + gstglquery.c \ + gstglvivdirecttexture.c \ ++ gstglphymemory.c \ + gstglcontrolbindingproxy.c + + libgstgl_@GST_API_VERSION@includedir = $(includedir)/gstreamer-@GST_API_VERSION@/gst/gl +@@ -68,6 +69,7 @@ libgstgl_@GST_API_VERSION@include_HEADERS = \ + gstgl_fwd.h \ + gstgl_enums.h \ + gstglvivdirecttexture.h \ ++ gstglphymemory.h \ + gl.h + + noinst_HEADERS = \ +@@ -84,6 +86,8 @@ libgstgl_@GST_API_VERSION@_la_LIBADD = \ + $(GST_LIBS) \ + $(GL_LIBS) + ++libgstgl_@GST_API_VERSION@_la_LIBADD += -lgstfsl-$(GST_API_VERSION) ++ + if HAVE_WINDOW_WIN32 + SUBDIRS += win32 + libgstgl_@GST_API_VERSION@_la_LIBADD += win32/libgstgl-win32.la +diff --git a/gst-libs/gst/gl/gstglbufferpool.c b/gst-libs/gst/gl/gstglbufferpool.c +index 90536b0..71c726a 100644 +--- a/gst-libs/gst/gl/gstglbufferpool.c ++++ b/gst-libs/gst/gl/gstglbufferpool.c +@@ -30,6 +30,8 @@ + #include + #endif + ++#include ++ + /** + * SECTION:gstglbufferpool + * @short_description: buffer pool for #GstGLMemory objects +@@ -290,6 +292,16 @@ gst_gl_buffer_pool_alloc (GstBufferPool * pool, GstBuffer ** buffer, + } + #endif + ++ if ((g_strcmp0 (priv->allocator->mem_type, GST_GL_PHY_MEM_ALLOCATOR) == 0)) { ++ GstAllocator* allocator = (GstAllocator*) gst_phy_mem_allocator_obtain (); ++ if (!gst_gl_physical_memory_setup_buffer (allocator, buf, priv->gl_params)) { ++ GST_ERROR_OBJECT (pool, "Can't create physcial buffer."); ++ return GST_FLOW_ERROR; ++ } ++ *buffer = buf; ++ return GST_FLOW_OK; ++ } ++ + alloc = GST_GL_MEMORY_ALLOCATOR (priv->allocator); + if (!gst_gl_memory_setup_buffer (alloc, buf, priv->gl_params)) + goto mem_create_failed; +diff --git a/gst-libs/gst/gl/gstglphymemory.c b/gst-libs/gst/gl/gstglphymemory.c +new file mode 100644 +index 0000000..52ae41f +--- /dev/null ++++ b/gst-libs/gst/gl/gstglphymemory.c +@@ -0,0 +1,254 @@ ++/* ++ * GStreamer ++ * Copyright (c) 2015, Freescale Semiconductor, Inc. ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Library General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Library General Public License for more details. ++ * ++ * You should have received a copy of the GNU Library General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, ++ * Boston, MA 02110-1301, USA. ++ */ ++ ++#ifdef HAVE_CONFIG_H ++#include "config.h" ++#endif ++ ++#include "gstglvivdirecttexture.h" ++#include "gstglphymemory.h" ++#include "g2d.h" ++ ++GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_PHY_MEMORY); ++#define GST_CAT_DEFAULT GST_CAT_GL_PHY_MEMORY ++ ++typedef struct _GstPhyMemAllocator GstPhyMemAllocator; ++typedef struct _GstPhyMemAllocatorClass GstPhyMemAllocatorClass; ++ ++struct _GstPhyMemAllocator ++{ ++ GstAllocatorPhyMem parent; ++}; ++ ++struct _GstPhyMemAllocatorClass ++{ ++ GstAllocatorPhyMemClass parent_class; ++}; ++ ++GType gst_phy_mem_allocator_get_type (void); ++G_DEFINE_TYPE (GstPhyMemAllocator, gst_phy_mem_allocator, GST_TYPE_ALLOCATOR_PHYMEM); ++ ++static int ++alloc_phymem (GstAllocatorPhyMem *allocator, PhyMemBlock *memblk) ++{ ++ struct g2d_buf *pbuf = NULL; ++ ++ memblk->size = PAGE_ALIGN(memblk->size); ++ ++ pbuf = g2d_alloc (memblk->size, 0); ++ if (!pbuf) { ++ GST_ERROR("G2D allocate %u bytes memory failed: %s", ++ memblk->size, strerror(errno)); ++ return -1; ++ } ++ ++ memblk->vaddr = (guchar*) pbuf->buf_vaddr; ++ memblk->paddr = (guchar*) pbuf->buf_paddr; ++ memblk->user_data = (gpointer) pbuf; ++ GST_DEBUG("G2D allocated memory (%p)", memblk->paddr); ++ ++ return 1; ++} ++ ++static int ++free_phymem (GstAllocatorPhyMem *allocator, PhyMemBlock *memblk) ++{ ++ GST_DEBUG("G2D free memory (%p)", memblk->paddr); ++ gint ret = g2d_free ((struct g2d_buf*)(memblk->user_data)); ++ memblk->user_data = NULL; ++ memblk->vaddr = NULL; ++ memblk->paddr = NULL; ++ memblk->size = 0; ++ ++ return ret; ++} ++ ++static void ++gst_phy_mem_allocator_class_init (GstPhyMemAllocatorClass * klass) ++{ ++ GstAllocatorPhyMemClass *phy_allocator_klass = (GstAllocatorPhyMemClass *) klass; ++ ++ phy_allocator_klass->alloc_phymem = alloc_phymem; ++ phy_allocator_klass->free_phymem = free_phymem; ++} ++ ++static void ++gst_phy_mem_allocator_init (GstPhyMemAllocator * allocator) ++{ ++ GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator); ++ ++ alloc->mem_type = GST_GL_PHY_MEM_ALLOCATOR; ++} ++ ++ ++static gpointer ++gst_phy_mem_allocator_init_instance (gpointer data) ++{ ++ GstAllocator *allocator = ++ g_object_new (gst_phy_mem_allocator_get_type (), NULL); ++ ++ GST_DEBUG_CATEGORY_INIT (GST_CAT_GL_PHY_MEMORY, "glphymemory", 0, ++ "GLPhysical Memory"); ++ ++ gst_allocator_register (GST_GL_PHY_MEM_ALLOCATOR, gst_object_ref (allocator)); ++ ++ return allocator; ++} ++ ++static void ++_finish_texture (GstGLContext * ctx, gpointer *data) ++{ ++ GstGLFuncs *gl = ctx->gl_vtable; ++ ++ gl->Finish (); ++} ++ ++static void ++gst_gl_phy_mem_destroy (GstMemory *mem) ++{ ++ gst_memory_unref (mem); ++} ++ ++ ++GstAllocator * ++gst_phy_mem_allocator_obtain (void) ++{ ++ static GOnce once = G_ONCE_INIT; ++ ++ g_once (&once, gst_phy_mem_allocator_init_instance, NULL); ++ ++ g_return_val_if_fail (once.retval != NULL, NULL); ++ ++ return (GstAllocator *) (g_object_ref (once.retval)); ++} ++ ++gboolean ++gst_is_gl_physical_memory (GstMemory * mem) ++{ ++ GstGLBaseMemory *glmem; ++ g_return_val_if_fail (gst_is_gl_memory (mem), FALSE); ++ ++ glmem = (GstGLBaseMemory*) mem; ++ ++ if (glmem->user_data ++ && GST_IS_MINI_OBJECT_TYPE(glmem->user_data, GST_TYPE_MEMORY)) ++ return gst_memory_is_type ((GstMemory*)glmem->user_data, GST_GL_PHY_MEM_ALLOCATOR); ++ else ++ return FALSE; ++} ++ ++gboolean ++gst_is_gl_physical_memory_supported_fmt (GstVideoInfo * info) ++{ ++ if (GST_VIDEO_INFO_IS_RGB(info) ++ && gst_gl_is_directviv_supported_format (GST_VIDEO_INFO_FORMAT (info))) { ++ return TRUE; ++ } ++ else ++ return FALSE; ++} ++ ++gboolean ++gst_gl_physical_memory_setup_buffer (GstAllocator * allocator, GstBuffer *buffer, ++ GstGLVideoAllocationParams * params) ++{ ++ GstGLBaseMemoryAllocator *gl_alloc; ++ GstMemory *mem = NULL; ++ PhyMemBlock *memblk = NULL; ++ GstGLMemory *glmem = NULL; ++ gsize size; ++ ++ GstVideoInfo * info = params->v_info; ++ GstVideoAlignment * valign = params->valign; ++ ++ GST_DEBUG ("glphymemory setup buffer format %s", gst_video_format_to_string (GST_VIDEO_INFO_FORMAT (info))); ++ ++ if (!gst_is_gl_physical_memory_supported_fmt (info)) { ++ GST_DEBUG ("Not support format."); ++ return FALSE; ++ } ++ ++ //allocator = (GstAllocator*) gst_phy_mem_allocator_obtain (); ++ size = gst_gl_get_plane_data_size (info, valign, 0); ++ mem = gst_allocator_alloc (allocator, size, params->parent.alloc_params); ++ if (!mem) { ++ GST_DEBUG ("Can't allocate physical memory size %d", size); ++ return FALSE; ++ } ++ ++ memblk = gst_memory_query_phymem_block (mem); ++ if (!memblk) { ++ GST_ERROR("Can't find physic memory block."); ++ return FALSE; ++ } ++ ++ gl_alloc = ++ GST_GL_BASE_MEMORY_ALLOCATOR (gst_gl_memory_allocator_get_default ++ (params->parent.context)); ++ ++ params->plane = 0; ++ params->parent.user_data = mem; ++ params->parent.notify = gst_gl_phy_mem_destroy; ++ ++ glmem = (GstGLMemory *)gst_gl_base_memory_alloc (gl_alloc, (GstGLAllocationParams *) params); ++ if (!glmem) { ++ GST_ERROR("Can't get gl memory."); ++ return FALSE; ++ } ++ ++ gst_buffer_append_memory (buffer, (GstMemory *) glmem); ++ ++ gst_buffer_add_video_meta_full (buffer, 0, ++ GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info), ++ GST_VIDEO_INFO_HEIGHT (info), 1, info->offset, info->stride); ++ ++ gst_gl_viv_direct_bind_data(params->parent.context, glmem->tex_id, ++ GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info), ++ GST_VIDEO_INFO_HEIGHT (info), memblk->vaddr, memblk->paddr); ++ ++ return TRUE; ++} ++ ++GstBuffer * ++gst_gl_phymem_buffer_to_gstbuffer (GstGLContext * ctx, ++ GstVideoInfo * info, GstBuffer *glbuf) ++{ ++ GstBuffer *buf; ++ GstGLBaseMemory *glmem; ++ ++ gst_gl_context_thread_add (ctx, (GstGLContextThreadFunc) _finish_texture, NULL); ++ ++ glmem = gst_buffer_peek_memory (glbuf, 0); ++ ++ buf = gst_buffer_new (); ++ gst_buffer_append_memory (buf, (GstMemory *) glmem->user_data); ++ gst_memory_ref ((GstMemory *)glmem->user_data); ++ ++ gst_buffer_add_video_meta_full (buf, 0, ++ GST_VIDEO_INFO_FORMAT (info), GST_VIDEO_INFO_WIDTH (info), ++ GST_VIDEO_INFO_HEIGHT (info), 1, info->offset, info->stride); ++ GST_BUFFER_FLAGS (buf) = GST_BUFFER_FLAGS (glbuf); ++ GST_BUFFER_PTS (buf) = GST_BUFFER_PTS (glbuf); ++ GST_BUFFER_DTS (buf) = GST_BUFFER_DTS (glbuf); ++ GST_BUFFER_DURATION (buf) = GST_BUFFER_DURATION (glbuf); ++ ++ return buf; ++} ++ +diff --git a/gst-libs/gst/gl/gstglphymemory.h b/gst-libs/gst/gl/gstglphymemory.h +new file mode 100644 +index 0000000..b1a69e7 +--- /dev/null ++++ b/gst-libs/gst/gl/gstglphymemory.h +@@ -0,0 +1,43 @@ ++/* ++ * GStreamer ++ * Copyright (c) 2015, Freescale Semiconductor, Inc. ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Library General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Library General Public License for more details. ++ * ++ * You should have received a copy of the GNU Library General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, ++ * Boston, MA 02110-1301, USA. ++ */ ++ ++#ifndef _GST_GL_PHY_MEMORY_H_ ++#define _GST_GL_PHY_MEMORY_H_ ++ ++#include ++#include ++#include ++#include ++ ++#include ++ ++G_BEGIN_DECLS ++ ++#define GST_GL_PHY_MEM_ALLOCATOR "GLPhyMemory" ++ ++GstAllocator *gst_phy_mem_allocator_obtain (void); ++gboolean gst_is_gl_physical_memory (GstMemory * mem); ++gboolean gst_is_gl_physical_memory_supported_fmt (GstVideoInfo * info); ++gboolean gst_gl_physical_memory_setup_buffer (GstAllocator * allocator, GstBuffer *buffer, GstGLVideoAllocationParams * params); ++GstBuffer * gst_gl_phymem_buffer_to_gstbuffer (GstGLContext * ctx, GstVideoInfo * info, GstBuffer *glbuf); ++ ++G_END_DECLS ++ ++#endif /* _GST_GL_PHY_MEMORY_H_ */ +diff --git a/gst-libs/gst/gl/gstglvivdirecttexture.c b/gst-libs/gst/gl/gstglvivdirecttexture.c +index c19b617..e8e0b82 100644 +--- a/gst-libs/gst/gl/gstglvivdirecttexture.c ++++ b/gst-libs/gst/gl/gstglvivdirecttexture.c +@@ -22,6 +22,7 @@ + #include "config.h" + #endif + ++#include + #include "gl.h" + + GST_DEBUG_CATEGORY_EXTERN (gst_gl_upload_debug); +@@ -37,17 +38,28 @@ typedef struct { + gboolean ret; + } GstVivDirectTexture; + ++typedef struct { ++ GstVideoFormat gst_fmt; ++ guint viv_fmt; ++} VIV_FMT_MAP; ++ ++static VIV_FMT_MAP viv_fmt_map_table[] = { ++ {GST_VIDEO_FORMAT_I420, GL_VIV_I420}, ++ {GST_VIDEO_FORMAT_YV12, GL_VIV_YV12}, ++ {GST_VIDEO_FORMAT_NV12, GL_VIV_NV12}, ++ {GST_VIDEO_FORMAT_NV21, GL_VIV_NV21}, ++ {GST_VIDEO_FORMAT_YUY2, GL_VIV_YUY2}, ++ {GST_VIDEO_FORMAT_UYVY, GL_VIV_UYVY}, ++ {GST_VIDEO_FORMAT_RGBA, GL_RGBA}, ++ {GST_VIDEO_FORMAT_RGBx, GL_RGBA}, ++ {GST_VIDEO_FORMAT_BGRA, GL_BGRA_EXT}, ++ {GST_VIDEO_FORMAT_RGB16, GL_RGB565_OES} ++}; ++ + gboolean + gst_is_physical_buffer (GstBuffer *buffer) + { +- +- GstMemory *mem; +- +- mem = gst_buffer_peek_memory (buffer, 0); +- if (!mem->allocator) +- return FALSE; +- +- return g_type_check_instance_is_a (mem->allocator, g_type_from_name("GstAllocatorPhyMem")); ++ return gst_buffer_is_phymem (buffer); + } + + static void +@@ -65,32 +77,64 @@ _do_viv_direct_tex_bind_mem (GstGLContext * context, GstVivDirectTexture * viv_t + } + + gboolean ++gst_gl_is_directviv_supported_format (GstVideoFormat fmt) ++{ ++ gint i; ++ gboolean ret = FALSE; ++ ++ for (i=0; iblock; +- +- GstVideoFormat fmt = GST_VIDEO_INFO_FORMAT (info); ++ PhyMemBlock *memblk; ++ GstVideoMeta *vmeta; ++ GstVideoFormat fmt; + gint width, height; +- GstVideoMeta *vmeta = gst_buffer_get_video_meta (buffer); ++ ++ memblk = gst_buffer_query_phymem_block (buffer); ++ if (!memblk) ++ return FALSE; ++ ++ width = GST_VIDEO_INFO_WIDTH (info); ++ height = GST_VIDEO_INFO_HEIGHT (info); ++ ++ vmeta = gst_buffer_get_video_meta (buffer); ++ fmt = GST_VIDEO_INFO_FORMAT (info); + if (vmeta && (fmt == GST_VIDEO_FORMAT_I420 || fmt == GST_VIDEO_FORMAT_NV12)) { + width = vmeta->stride[0]; + height = vmeta->offset[1] / width; +@@ -100,44 +144,7 @@ gst_gl_viv_direct_bind_gstbuffer (GstGLContext * context, guint tex_id, GstVideo + height = GST_VIDEO_INFO_HEIGHT (info); + } + +- guint viv_fmt; +- switch (fmt) { +- case GST_VIDEO_FORMAT_I420: +- viv_fmt = GL_VIV_I420; +- break; +- case GST_VIDEO_FORMAT_YV12: +- viv_fmt = GL_VIV_YV12; +- break; +- case GST_VIDEO_FORMAT_NV12: +- viv_fmt = GL_VIV_NV12; +- break; +- case GST_VIDEO_FORMAT_NV21: +- viv_fmt = GL_VIV_NV21; +- break; +- case GST_VIDEO_FORMAT_YUY2: +- viv_fmt = GL_VIV_YUY2; +- break; +- case GST_VIDEO_FORMAT_UYVY: +- viv_fmt = GL_VIV_UYVY; +- break; +- case GST_VIDEO_FORMAT_RGBA: +- viv_fmt = GL_RGBA; +- break; +- case GST_VIDEO_FORMAT_BGRA: +- viv_fmt = GL_BGRA_EXT; +- break; +- case GST_VIDEO_FORMAT_RGB16: +- viv_fmt = GL_RGB565_OES; +- break; +- default: +- GST_ERROR ("Not supported format %d for viv direct texture upload.", fmt); +- viv_fmt = GL_NONE; +- return FALSE; +- } +- +- GstVivDirectTexture viv_tex = {tex_id, width, height, viv_fmt, memblk->vaddr, memblk->paddr, FALSE}; +- gst_gl_context_thread_add (context, (GstGLContextThreadFunc) _do_viv_direct_tex_bind_mem, &viv_tex); +- +- return viv_tex.ret; ++ return gst_gl_viv_direct_bind_data (context, tex_id, fmt, width, height, memblk->vaddr, memblk->paddr); + } + ++ +diff --git a/gst-libs/gst/gl/gstglvivdirecttexture.h b/gst-libs/gst/gl/gstglvivdirecttexture.h +index fa88e1a..9a2d123 100644 +--- a/gst-libs/gst/gl/gstglvivdirecttexture.h ++++ b/gst-libs/gst/gl/gstglvivdirecttexture.h +@@ -28,6 +28,9 @@ + G_BEGIN_DECLS + + gboolean gst_is_physical_buffer (GstBuffer *buffer); ++gboolean gst_gl_is_directviv_supported_format (GstVideoFormat fmt); ++gboolean gst_gl_viv_direct_bind_data (GstGLContext * context, guint tex_id, GstVideoFormat fmt, gint width, gint height, ++ gpointer * vaddr, gpointer *paddr); + gboolean gst_gl_viv_direct_bind_gstbuffer (GstGLContext * context, guint tex_id, GstVideoInfo * info, GstBuffer * buffer); + + G_END_DECLS +-- +1.9.1 + diff --git a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0004-Fix-dependence-issue-between-gst-plugin-.patch b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0004-Fix-dependence-issue-between-gst-plugin-.patch new file mode 100755 index 00000000..44633cf9 --- /dev/null +++ b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad/0004-Fix-dependence-issue-between-gst-plugin-.patch @@ -0,0 +1,74 @@ +From 4f73ba8dde190b0e2d3a7a16b394762f7459ca31 Mon Sep 17 00:00:00 2001 +From: Haihua Hu +Date: Fri, 5 Aug 2016 17:04:02 +0800 +Subject: [PATCH] [MMFMWK-7259]Fix dependence issue between gst-plugin-bad and + imx-gst1.0-plugin + +Change dependence to gst-plugin-base since we have move physical memory allocator +to gst-plugin-base + +Upstream-Status: Inappropriate [i.MX specific] + +Signed-off-by: Haihua Hu +--- + gst-libs/gst/gl/Makefile.am | 2 +- + gst-libs/gst/gl/gstglphymemory.c | 2 +- + gst-libs/gst/gl/gstglphymemory.h | 2 +- + gst-libs/gst/gl/gstglvivdirecttexture.c | 2 +- + 4 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/gst-libs/gst/gl/Makefile.am b/gst-libs/gst/gl/Makefile.am +index 5c05230..55f8a20 100644 +--- a/gst-libs/gst/gl/Makefile.am ++++ b/gst-libs/gst/gl/Makefile.am +@@ -86,7 +86,7 @@ libgstgl_@GST_API_VERSION@_la_LIBADD = \ + $(GST_LIBS) \ + $(GL_LIBS) + +-libgstgl_@GST_API_VERSION@_la_LIBADD += -lgstfsl-$(GST_API_VERSION) ++libgstgl_@GST_API_VERSION@_la_LIBADD += -lg2d + + if HAVE_WINDOW_WIN32 + SUBDIRS += win32 +diff --git a/gst-libs/gst/gl/gstglphymemory.c b/gst-libs/gst/gl/gstglphymemory.c +index 52ae41f..e28546c 100644 +--- a/gst-libs/gst/gl/gstglphymemory.c ++++ b/gst-libs/gst/gl/gstglphymemory.c +@@ -24,7 +24,7 @@ + + #include "gstglvivdirecttexture.h" + #include "gstglphymemory.h" +-#include "g2d.h" ++#include + + GST_DEBUG_CATEGORY_STATIC (GST_CAT_GL_PHY_MEMORY); + #define GST_CAT_DEFAULT GST_CAT_GL_PHY_MEMORY +diff --git a/gst-libs/gst/gl/gstglphymemory.h b/gst-libs/gst/gl/gstglphymemory.h +index b1a69e7..ebb9911 100644 +--- a/gst-libs/gst/gl/gstglphymemory.h ++++ b/gst-libs/gst/gl/gstglphymemory.h +@@ -24,7 +24,7 @@ + #include + #include + #include +-#include ++#include + + #include + +diff --git a/gst-libs/gst/gl/gstglvivdirecttexture.c b/gst-libs/gst/gl/gstglvivdirecttexture.c +index e8e0b82..242b7c0 100644 +--- a/gst-libs/gst/gl/gstglvivdirecttexture.c ++++ b/gst-libs/gst/gl/gstglvivdirecttexture.c +@@ -22,7 +22,7 @@ + #include "config.h" + #endif + +-#include ++#include + #include "gl.h" + + GST_DEBUG_CATEGORY_EXTERN (gst_gl_upload_debug); +-- +1.9.1 + diff --git a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad_%.bbappend b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad_%.bbappend index 16d0ce84..be23ff77 100644 --- a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad_%.bbappend +++ b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-bad_%.bbappend @@ -12,6 +12,8 @@ PACKAGECONFIG_GL_mx6sl = "${@bb.utils.contains('DISTRO_FEATURES', 'opengl', \ SRC_URI_append = " file://0001-glplugin-Change-wayland-default-res-to-1024x768.patch \ file://0002-Add-directviv-to-glimagesink-to-improve-playback-per.patch \ + file://0003-MMFMWK-6930-glplugin-Accelerate-gldownload-with-dire.patch \ + file://0004-Fix-dependence-issue-between-gst-plugin-.patch \ " diff --git a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base/0002-Remove-dependence-on-imx-plugin-git.patch b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base/0002-Remove-dependence-on-imx-plugin-git.patch new file mode 100755 index 00000000..80009a9a --- /dev/null +++ b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base/0002-Remove-dependence-on-imx-plugin-git.patch @@ -0,0 +1,433 @@ +From 950fe3a224eb5339c946193413f9373c333ea1f0 Mon Sep 17 00:00:00 2001 +From: Haihua Hu +Date: Fri, 5 Aug 2016 17:08:40 +0800 +Subject: [PATCH] [MMFMWK-7259] Remove dependence on imx plugin git. + +Add physical memory allocator + +Upstream-Status: Inappropriate [i.MX specific] + +Signed-off-by: Haihua Hu +--- + gst-libs/gst/allocators/Makefile.am | 6 +- + gst-libs/gst/allocators/gstallocatorphymem.c | 314 +++++++++++++++++++++++++++ + gst-libs/gst/allocators/gstallocatorphymem.h | 64 ++++++ + 3 files changed, 382 insertions(+), 2 deletions(-) + create mode 100755 gst-libs/gst/allocators/gstallocatorphymem.c + create mode 100755 gst-libs/gst/allocators/gstallocatorphymem.h + +diff --git a/gst-libs/gst/allocators/Makefile.am b/gst-libs/gst/allocators/Makefile.am +index 5c11b8a..13ffd9c 100644 +--- a/gst-libs/gst/allocators/Makefile.am ++++ b/gst-libs/gst/allocators/Makefile.am +@@ -5,13 +5,15 @@ libgstallocators_@GST_API_VERSION@_includedir = $(includedir)/gstreamer-@GST_API + libgstallocators_@GST_API_VERSION@_include_HEADERS = \ + allocators.h \ + gstfdmemory.h \ +- gstdmabuf.h ++ gstdmabuf.h \ ++ gstallocatorphymem.h + + noinst_HEADERS = + + libgstallocators_@GST_API_VERSION@_la_SOURCES = \ + gstfdmemory.c \ +- gstdmabuf.c ++ gstdmabuf.c \ ++ gstallocatorphymem.c + + libgstallocators_@GST_API_VERSION@_la_LIBADD = $(GST_LIBS) $(LIBM) + libgstallocators_@GST_API_VERSION@_la_CFLAGS = $(GST_PLUGINS_BASE_CFLAGS) $(GST_CFLAGS) +diff --git a/gst-libs/gst/allocators/gstallocatorphymem.c b/gst-libs/gst/allocators/gstallocatorphymem.c +new file mode 100755 +index 0000000..cf5995e +--- /dev/null ++++ b/gst-libs/gst/allocators/gstallocatorphymem.c +@@ -0,0 +1,314 @@ ++/* ++ * Copyright (c) 2013-2015, Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Library General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Library General Public License for more details. ++ * ++ * You should have received a copy of the GNU Library General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ */ ++ ++#include ++#include ++#include "gstallocatorphymem.h" ++ ++typedef struct { ++ GstMemory mem; ++ guint8 *vaddr; ++ guint8 *paddr; ++ PhyMemBlock block; ++} GstMemoryPhy; ++ ++static int ++default_copy (GstAllocatorPhyMem *allocator, PhyMemBlock *dst_mem, ++ PhyMemBlock *src_mem, guint offset, guint size) ++{ ++ GST_WARNING ("No default copy implementation for physical memory allocator.\n"); ++ return -1; ++} ++ ++static gpointer ++gst_phymem_map (GstMemory * mem, gsize maxsize, GstMapFlags flags) ++{ ++ GstMemoryPhy *phymem = (GstMemoryPhy*) mem; ++ ++ if (GST_MEMORY_IS_READONLY(mem) && (flags & GST_MAP_WRITE)) { ++ GST_ERROR("memory is read only"); ++ return NULL; ++ } ++ ++ return phymem->vaddr; ++} ++ ++static void ++gst_phymem_unmap (GstMemory * mem) ++{ ++ return; ++} ++ ++static GstMemory * ++gst_phymem_copy (GstMemory * mem, gssize offset, gssize size) ++{ ++ GstAllocatorPhyMemClass *klass; ++ GstMemoryPhy *src_mem = (GstMemoryPhy *)mem; ++ ++ GstMemoryPhy *dst_mem = g_slice_alloc(sizeof(GstMemoryPhy)); ++ if(dst_mem == NULL) { ++ GST_ERROR("Can't allocate for GstMemoryPhy structure.\n"); ++ return NULL; ++ } ++ ++ klass = GST_ALLOCATOR_PHYMEM_CLASS(G_OBJECT_GET_CLASS(mem->allocator)); ++ if(klass == NULL) { ++ GST_ERROR("Can't get class from allocator object.\n"); ++ return NULL; ++ } ++ ++ if(klass->copy_phymem((GstAllocatorPhyMem*)mem->allocator, ++ &dst_mem->block, &src_mem->block, offset, size) < 0) { ++ GST_WARNING ("Copy phymem %d failed.\n", size); ++ return NULL; ++ } ++ ++ GST_DEBUG ("copied phymem, vaddr(%p), paddr(%p), size(%d).\n", ++ dst_mem->block.vaddr, dst_mem->block.paddr, dst_mem->block.size); ++ ++ dst_mem->vaddr = dst_mem->block.vaddr; ++ dst_mem->paddr = dst_mem->block.paddr; ++ ++ gst_memory_init (GST_MEMORY_CAST (dst_mem), ++ mem->mini_object.flags&(~GST_MEMORY_FLAG_READONLY), ++ mem->allocator, NULL, mem->maxsize, mem->align, ++ mem->offset, mem->size); ++ ++ return (GstMemory*)dst_mem; ++} ++ ++static GstMemory * ++gst_phymem_share (GstMemory * mem, gssize offset, gssize size) ++{ ++ GST_ERROR("Not implemented mem_share in gstallocatorphymem.\n"); ++ return NULL; ++} ++ ++static gboolean ++gst_phymem_is_span (GstMemory * mem1, GstMemory * mem2, gsize * offset) ++{ ++ return FALSE; ++} ++ ++static gpointer ++gst_phymem_get_phy (GstMemory * mem) ++{ ++ GstMemoryPhy *phymem = (GstMemoryPhy*) mem; ++ ++ return phymem->paddr; ++} ++ ++static GstMemory * ++base_alloc (GstAllocator * allocator, gsize size, ++ GstAllocationParams * params) ++{ ++ GstAllocatorPhyMemClass *klass; ++ GstMemoryPhy *mem; ++ gsize maxsize, aoffset, offset, align, padding; ++ guint8 *data; ++ ++ mem = g_slice_alloc(sizeof(GstMemoryPhy)); ++ if(mem == NULL) { ++ GST_ERROR("Can allocate for GstMemoryPhy structure.\n"); ++ return NULL; ++ } ++ ++ klass = GST_ALLOCATOR_PHYMEM_CLASS(G_OBJECT_GET_CLASS(allocator)); ++ if(klass == NULL) { ++ GST_ERROR("Can't get class from allocator object.\n"); ++ return NULL; ++ } ++ ++ GST_DEBUG ("allocate params, prefix (%d), padding (%d), align (%d), flags (%x).\n", ++ params->prefix, params->padding, params->align, params->flags); ++ ++ maxsize = size + params->prefix + params->padding; ++ mem->block.size = maxsize; ++ if(klass->alloc_phymem((GstAllocatorPhyMem*)allocator, &mem->block) < 0) { ++ GST_ERROR("Allocate phymem %d failed.\n", maxsize); ++ return NULL; ++ } ++ ++ GST_DEBUG ("allocated phymem, vaddr(%p), paddr(%p), size(%d).\n", ++ mem->block.vaddr, mem->block.paddr, mem->block.size); ++ ++ data = mem->block.vaddr; ++ offset = params->prefix; ++ align = params->align; ++ /* do alignment */ ++ if ((aoffset = ((guintptr)data & align))) { ++ aoffset = (align + 1) - aoffset; ++ data += aoffset; ++ maxsize -= aoffset; ++ } ++ mem->vaddr = mem->block.vaddr + aoffset; ++ mem->paddr = mem->block.paddr + aoffset; ++ ++ GST_DEBUG ("aligned vaddr(%p), paddr(%p), size(%d).\n", ++ mem->block.vaddr, mem->block.paddr, mem->block.size); ++ ++ if (offset && (params->flags & GST_MEMORY_FLAG_ZERO_PREFIXED)) ++ memset (data, 0, offset); ++ ++ padding = maxsize - (offset + size); ++ if (padding && (params->flags & GST_MEMORY_FLAG_ZERO_PADDED)) ++ memset (data + offset + size, 0, padding); ++ ++ gst_memory_init (GST_MEMORY_CAST (mem), params->flags, allocator, NULL, maxsize, align, offset, size); ++ ++ return (GstMemory*)mem; ++} ++ ++static void ++base_free (GstAllocator * allocator, GstMemory * mem) ++{ ++ GstAllocatorPhyMemClass *klass; ++ GstMemoryPhy *phymem; ++ ++ klass = GST_ALLOCATOR_PHYMEM_CLASS(G_OBJECT_GET_CLASS(allocator)); ++ if(klass == NULL) { ++ GST_ERROR("Can't get class from allocator object, can't free %p\n", mem); ++ return; ++ } ++ ++ phymem = (GstMemoryPhy*)mem; ++ ++ GST_DEBUG ("free phymem, vaddr(%p), paddr(%p), size(%d).\n", ++ phymem->block.vaddr, phymem->block.paddr, phymem->block.size); ++ ++ klass->free_phymem((GstAllocatorPhyMem*)allocator, &phymem->block); ++ g_slice_free1(sizeof(GstMemoryPhy), mem); ++ ++ return; ++} ++ ++static int ++default_alloc (GstAllocatorPhyMem *allocator, PhyMemBlock *phy_mem) ++{ ++ GST_ERROR ("No default allocating implementation for physical memory allocation.\n"); ++ return -1; ++} ++ ++static int ++default_free (GstAllocatorPhyMem *allocator, PhyMemBlock *phy_mem) ++{ ++ GST_ERROR ("No default free implementation for physical memory allocation.\n"); ++ return -1; ++} ++ ++G_DEFINE_TYPE (GstAllocatorPhyMem, gst_allocator_phymem, GST_TYPE_ALLOCATOR); ++ ++static void ++gst_allocator_phymem_class_init (GstAllocatorPhyMemClass * klass) ++{ ++ GstAllocatorClass *allocator_class; ++ ++ allocator_class = (GstAllocatorClass *) klass; ++ ++ allocator_class->alloc = base_alloc; ++ allocator_class->free = base_free; ++ klass->alloc_phymem = default_alloc; ++ klass->free_phymem = default_free; ++ klass->copy_phymem = default_copy; ++} ++ ++static void ++gst_allocator_phymem_init (GstAllocatorPhyMem * allocator) ++{ ++ GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator); ++ ++ alloc->mem_map = gst_phymem_map; ++ alloc->mem_unmap = gst_phymem_unmap; ++ alloc->mem_copy = gst_phymem_copy; ++ alloc->mem_share = gst_phymem_share; ++ alloc->mem_is_span = gst_phymem_is_span; ++} ++ ++ ++//global functions ++ ++gboolean ++gst_buffer_is_phymem (GstBuffer *buffer) ++{ ++ gboolean ret = FALSE; ++ PhyMemBlock * memblk; ++ GstMemory *mem = gst_buffer_get_memory (buffer, 0); ++ if(mem == NULL) { ++ GST_ERROR ("Not get memory from buffer.\n"); ++ return FALSE; ++ } ++ ++ if(GST_IS_ALLOCATOR_PHYMEM(mem->allocator)) { ++ if (NULL == ((GstMemoryPhy*)mem)->block.paddr) { ++ GST_WARNING("physical address in memory block is invalid"); ++ ret = FALSE; ++ } else { ++ ret = TRUE; ++ } ++ } ++ ++ gst_memory_unref (mem); ++ ++ return ret; ++} ++ ++PhyMemBlock * ++gst_buffer_query_phymem_block (GstBuffer *buffer) ++{ ++ GstMemory *mem; ++ GstMemoryPhy *memphy; ++ PhyMemBlock *memblk; ++ ++ mem = gst_buffer_get_memory (buffer, 0); ++ if(mem == NULL) { ++ GST_ERROR ("Not get memory from buffer.\n"); ++ return NULL; ++ } ++ ++ if(!GST_IS_ALLOCATOR_PHYMEM(mem->allocator)) { ++ gst_memory_unref (mem); ++ return NULL; ++ } ++ ++ memphy = (GstMemoryPhy*) mem; ++ memblk = &memphy->block; ++ ++ gst_memory_unref (mem); ++ ++ return memblk; ++} ++ ++PhyMemBlock * ++gst_memory_query_phymem_block (GstMemory *mem) ++{ ++ GstMemoryPhy *memphy; ++ PhyMemBlock *memblk; ++ ++ if (!mem) ++ return NULL; ++ ++ if (!GST_IS_ALLOCATOR_PHYMEM(mem->allocator)) ++ return NULL; ++ ++ memphy = (GstMemoryPhy*) mem; ++ memblk = &memphy->block; ++ ++ return memblk; ++} ++ +diff --git a/gst-libs/gst/allocators/gstallocatorphymem.h b/gst-libs/gst/allocators/gstallocatorphymem.h +new file mode 100755 +index 0000000..f0833ae +--- /dev/null ++++ b/gst-libs/gst/allocators/gstallocatorphymem.h +@@ -0,0 +1,64 @@ ++/* ++ * Copyright (c) 2013-2015, Freescale Semiconductor, Inc. All rights reserved. ++ * ++ * This library is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU Library General Public ++ * License as published by the Free Software Foundation; either ++ * version 2 of the License, or (at your option) any later version. ++ * ++ * This library is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ * Library General Public License for more details. ++ * ++ * You should have received a copy of the GNU Library General Public ++ * License along with this library; if not, write to the ++ * Free Software Foundation, Inc., 59 Temple Place - Suite 330, ++ * Boston, MA 02111-1307, USA. ++ */ ++ ++#ifndef __ALLOCATOR_PHYMEM_H__ ++#define __ALLOCATOR_PHYMEM_H__ ++ ++#include ++#include ++ ++#define PAGE_ALIGN(x) (((x) + 4095) & ~4095) ++ ++#define GST_TYPE_ALLOCATOR_PHYMEM (gst_allocator_phymem_get_type()) ++#define GST_ALLOCATOR_PHYMEM(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_ALLOCATOR_PHYMEM, GstAllocatorPhyMem)) ++#define GST_ALLOCATOR_PHYMEM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_ALLOCATOR_PHYMEM, GstAllocatorPhyMemClass)) ++#define GST_IS_ALLOCATOR_PHYMEM(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_ALLOCATOR_PHYMEM)) ++#define GST_IS_ALLOCATOR_PHYMEM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_ALLOCATOR_PHYMEM)) ++ ++typedef struct _GstAllocatorPhyMem GstAllocatorPhyMem; ++typedef struct _GstAllocatorPhyMemClass GstAllocatorPhyMemClass; ++ ++/* also change gst-libs/gst/gl/gstglvivdirecttexture.c in gst-plugins-bad git ++ * if changed below structure */ ++typedef struct { ++ guint8 *vaddr; ++ guint8 *paddr; ++ guint8 *caddr; ++ gsize size; ++ gpointer *user_data; ++} PhyMemBlock; ++ ++struct _GstAllocatorPhyMem { ++ GstAllocator parent; ++}; ++ ++struct _GstAllocatorPhyMemClass { ++ GstAllocatorClass parent_class; ++ int (*alloc_phymem) (GstAllocatorPhyMem *allocator, PhyMemBlock *phy_mem); ++ int (*free_phymem) (GstAllocatorPhyMem *allocator, PhyMemBlock *phy_mem); ++ int (*copy_phymem) (GstAllocatorPhyMem *allocator, PhyMemBlock *det_mem, ++ PhyMemBlock *src_mem, guint offset, guint size); ++}; ++ ++GType gst_allocator_phymem_get_type (void); ++gboolean gst_buffer_is_phymem (GstBuffer *buffer); ++PhyMemBlock *gst_buffer_query_phymem_block (GstBuffer *buffer); ++PhyMemBlock *gst_memory_query_phymem_block (GstMemory *mem); ++ ++#endif +-- +1.9.1 + diff --git a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base_%.bbappend b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base_%.bbappend index f1992c3b..279a27cc 100644 --- a/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base_%.bbappend +++ b/recipes-multimedia/gstreamer/gstreamer1.0-plugins-base_%.bbappend @@ -2,6 +2,7 @@ FILESEXTRAPATHS_prepend := "${THISDIR}/${PN}:" IMX_PATCHES = " file://gstplaybin-remove-flag-deinterlace.patch \ file://0001-MMFMWK-7030-Linux_MX6QP_ARD-IMXCameraApp-When-Enable.patch \ + file://0002-Remove-dependence-on-imx-plugin-git.patch \ " SRC_URI_append_mx6 = "${IMX_PATCHES}"