| /* GStreamer IMX IPU Device |
| * Copyright (c) 2014-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 <fcntl.h> |
| #include <sys/ioctl.h> |
| #include <sys/mman.h> |
| #include <linux/ipu.h> |
| #include "imx_2d_device.h" |
| |
| #define IPU_DEVICE_NAME "/dev/mxc_ipu" |
| |
| /* |
| * IPU has limitation of overlay size which is 1024x1024, |
| * define following macro to enable overlay even size larger then 1024x1024 |
| * the overlay will be cut into several blocks, each block will no larger than |
| * 1024x1024. one block will be processed each time. |
| * if this macro isn't defined, then the overlay will be processed as normal |
| * input which means the alpha will be disable. |
| */ |
| #define IPU_OVERLAY_SIZE_LIMIT_BREAK_DOWN |
| |
| #define IPU_OVERLAY_WIDTH_MAX 1024 |
| #define IPU_OVERLAY_HEIGHT_MAX 1024 |
| #define IPU_OVERLAY_BUF_SIZE_MAX (1024*1024*4) |
| |
| GST_DEBUG_CATEGORY_EXTERN (imx2ddevice_debug); |
| #define GST_CAT_DEFAULT imx2ddevice_debug |
| |
| typedef struct _Imx2DDeviceIpu { |
| gint ipu_fd; |
| struct ipu_task task; |
| gboolean deinterlace_enable; |
| PhyMemBlock vdi; |
| gboolean new_input; |
| PhyMemBlock ov_temp; |
| PhyMemBlock ov_resize; |
| } Imx2DDeviceIpu; |
| |
| typedef struct { |
| GstVideoFormat gst_video_format; |
| guint ipu_format; |
| guint bpp; |
| } IpuFmtMap; |
| |
| static IpuFmtMap ipu_fmts_map[] = { |
| {GST_VIDEO_FORMAT_I420, IPU_PIX_FMT_YUV420P, 12}, |
| {GST_VIDEO_FORMAT_NV12, IPU_PIX_FMT_NV12, 12}, |
| {GST_VIDEO_FORMAT_YV12, IPU_PIX_FMT_YVU420P, 12}, |
| {GST_VIDEO_FORMAT_UYVY, IPU_PIX_FMT_UYVY, 16}, |
| {GST_VIDEO_FORMAT_RGB16, IPU_PIX_FMT_RGB565, 16}, |
| {GST_VIDEO_FORMAT_RGBx, IPU_PIX_FMT_RGB32, 32}, |
| {GST_VIDEO_FORMAT_Y42B, IPU_PIX_FMT_YUV422P, 16}, |
| {GST_VIDEO_FORMAT_Y444, IPU_PIX_FMT_YUV444P, 24}, |
| {GST_VIDEO_FORMAT_v308, IPU_PIX_FMT_YUV444, 24}, |
| {GST_VIDEO_FORMAT_BGR, IPU_PIX_FMT_BGR24, 24}, |
| {GST_VIDEO_FORMAT_RGB, IPU_PIX_FMT_RGB24, 24}, |
| {GST_VIDEO_FORMAT_BGRx, IPU_PIX_FMT_BGR32, 32}, |
| {GST_VIDEO_FORMAT_BGRA, IPU_PIX_FMT_BGRA32, 32}, |
| {GST_VIDEO_FORMAT_RGBA, IPU_PIX_FMT_RGBA32, 32}, |
| {GST_VIDEO_FORMAT_ABGR, IPU_PIX_FMT_ABGR32, 32}, |
| |
| /* There is no corresponding GST Video format for those IPU formats |
| {GST_VIDEO_FORMAT_, IPU_PIX_FMT_VYU444, 32}, |
| {GST_VIDEO_FORMAT_, IPU_PIX_FMT_YUYV, 32}, |
| {GST_VIDEO_FORMAT_, IPU_PIX_FMT_YUV420P2, 32}, |
| {GST_VIDEO_FORMAT_, IPU_PIX_FMT_YVU422P, 32}, |
| */ |
| |
| {GST_VIDEO_FORMAT_UNKNOWN, -1, 0} |
| }; |
| |
| static const IpuFmtMap* imx_ipu_get_format(GstVideoFormat format) |
| { |
| const IpuFmtMap *map = ipu_fmts_map; |
| while(map->gst_video_format != GST_VIDEO_FORMAT_UNKNOWN) { |
| if (map->gst_video_format == format) |
| return map; |
| map++; |
| }; |
| |
| GST_ERROR ("ipu : format (%s) is not supported.", |
| gst_video_format_to_string(format)); |
| |
| return NULL; |
| } |
| |
| static const guint imx_ipu_get_bpp(guint ipu_format) |
| { |
| const IpuFmtMap *map = ipu_fmts_map; |
| while(map->gst_video_format != GST_VIDEO_FORMAT_UNKNOWN) { |
| if (map->ipu_format == ipu_format) |
| return map->bpp; |
| map++; |
| }; |
| |
| GST_ERROR ("ipu : format (%d) is not supported.", ipu_format); |
| return 8; |
| } |
| |
| static gint imx_ipu_open(Imx2DDevice *device) |
| { |
| if (!device) |
| return -1; |
| |
| gint fd = open(IPU_DEVICE_NAME, O_RDWR, 0); |
| if (fd < 0) { |
| GST_ERROR("could not open %s: %s", IPU_DEVICE_NAME, strerror(errno)); |
| return -1; |
| } |
| |
| Imx2DDeviceIpu *ipu = g_slice_alloc(sizeof(Imx2DDeviceIpu)); |
| if (!ipu) { |
| GST_ERROR("allocate ipu structure failed\n"); |
| close(fd); |
| return -1; |
| } |
| |
| memset(ipu, 0, sizeof(Imx2DDeviceIpu)); |
| ipu->ipu_fd = fd; |
| ipu->task.priority = 0; |
| ipu->task.timeout = 1000; |
| |
| device->priv = (gpointer)ipu; |
| |
| return 0; |
| } |
| |
| static gint |
| imx_ipu_alloc_mem(Imx2DDevice *device, PhyMemBlock *memblk) |
| { |
| dma_addr_t mem; |
| |
| if (!device || !device->priv || !memblk) |
| return -1; |
| |
| memblk->size = PAGE_ALIGN(memblk->size); |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| mem = (dma_addr_t)(memblk->size); |
| if (ioctl(ipu->ipu_fd, IPU_ALLOC, &mem) < 0) { |
| GST_ERROR("IPU allocate %u bytes memory failed: %s", |
| memblk->size, strerror(errno)); |
| return -1; |
| } |
| |
| memblk->paddr = (guchar *)mem; |
| memblk->vaddr = mmap(0, memblk->size, PROT_READ|PROT_WRITE, MAP_SHARED, |
| ipu->ipu_fd, (dma_addr_t)(memblk->paddr)); |
| GST_DEBUG("IPU allocated memory (%p)", memblk->paddr); |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_free_mem(Imx2DDevice *device, PhyMemBlock *memblk) |
| { |
| dma_addr_t mem; |
| |
| if (!device || !device->priv || !memblk) |
| return -1; |
| |
| if (memblk->vaddr == NULL) |
| return 0; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| GST_DEBUG("IPU free memory (%p)", memblk->paddr); |
| mem = (dma_addr_t)(memblk->paddr); |
| munmap(memblk->vaddr, memblk->size); |
| |
| if (ioctl(ipu->ipu_fd, IPU_FREE, &mem) < 0) { |
| GST_ERROR("IPU could not free memory at 0x%x: %s", mem, strerror(errno)); |
| return -1; |
| } |
| |
| memblk->paddr = NULL; |
| memblk->vaddr = NULL; |
| memblk->size = 0; |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_close(Imx2DDevice *device) |
| { |
| if (!device) |
| return -1; |
| |
| if (device) { |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| if (ipu) { |
| imx_ipu_free_mem(device, &ipu->ov_resize); |
| imx_ipu_free_mem(device, &ipu->ov_temp); |
| imx_ipu_free_mem(device, &ipu->vdi); |
| close(ipu->ipu_fd); |
| g_slice_free1(sizeof(Imx2DDeviceIpu), ipu); |
| device->priv = NULL; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_copy_mem(Imx2DDevice* device, PhyMemBlock *dst_mem, |
| PhyMemBlock *src_mem, guint offset, guint size) |
| { |
| dma_addr_t mem; |
| |
| if (!device || !device->priv || !src_mem || !dst_mem) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| if (size > src_mem->size - offset) |
| size = src_mem->size - offset; |
| |
| dst_mem->user_data = NULL; |
| dst_mem->size = PAGE_ALIGN(size); |
| |
| mem = (dma_addr_t)(dst_mem->size); |
| if (ioctl(ipu->ipu_fd, IPU_ALLOC, &mem) < 0) { |
| GST_ERROR("IPU allocate %u bytes memory failed: %s", size, strerror(errno)); |
| return -1; |
| } |
| |
| dst_mem->paddr = (guchar *)mem; |
| dst_mem->vaddr = mmap(0, dst_mem->size, PROT_READ|PROT_WRITE, MAP_SHARED, |
| ipu->ipu_fd, (dma_addr_t)(dst_mem->paddr)); |
| memcpy(dst_mem->vaddr, src_mem->vaddr+offset, size); |
| |
| GST_DEBUG ("IPU copy from vaddr (%p), paddr (%p), size (%d) to " |
| "vaddr (%p), paddr (%p), size (%d)", |
| src_mem->vaddr, src_mem->paddr, src_mem->size, |
| dst_mem->vaddr, dst_mem->paddr, dst_mem->size); |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_frame_copy(Imx2DDevice *device, |
| PhyMemBlock *from, PhyMemBlock *to) |
| { |
| if (!device || !device->priv || !from || !to) |
| return -1; |
| |
| memcpy(to->vaddr, from->vaddr, (from->size > to->size) ? to->size:from->size); |
| GST_LOG("IPU frame memory (%p)->(%p)", from->paddr, to->paddr); |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_config_input(Imx2DDevice *device, Imx2DVideoInfo* in_info) |
| { |
| if (!device || !device->priv) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| const IpuFmtMap *from_map = imx_ipu_get_format(in_info->fmt); |
| if (!from_map) |
| return -1; |
| |
| ipu->task.input.width = in_info->w; |
| ipu->task.input.height = in_info->h; |
| ipu->task.input.format = from_map->ipu_format; |
| ipu->task.input.crop.pos.x = 0; |
| ipu->task.input.crop.pos.y = 0; |
| ipu->task.input.crop.w = in_info->w; |
| ipu->task.input.crop.h = in_info->h; |
| ipu->task.input.deinterlace.enable = ipu->deinterlace_enable; |
| ipu->new_input = TRUE; |
| |
| GST_TRACE("input format = %s", gst_video_format_to_string(in_info->fmt)); |
| return 0; |
| } |
| |
| static gint imx_ipu_config_output(Imx2DDevice *device, Imx2DVideoInfo* out_info) |
| { |
| if (!device || !device->priv) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| const IpuFmtMap *to_map = imx_ipu_get_format(out_info->fmt); |
| if (!to_map) |
| return -1; |
| |
| ipu->task.output.width = out_info->w; |
| ipu->task.output.height = out_info->h; |
| ipu->task.output.format = to_map->ipu_format; |
| ipu->task.output.crop.pos.x = 0; |
| ipu->task.output.crop.pos.y = 0; |
| ipu->task.output.crop.w = out_info->w; |
| ipu->task.output.crop.h = out_info->h; |
| GST_TRACE("output format = %s", gst_video_format_to_string(out_info->fmt)); |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_check_parameters(Imx2DDevice *device, |
| PhyMemBlock *from, PhyMemBlock *to) |
| { |
| gint cnt = 100; |
| gboolean check_end = FALSE; |
| gint ret = IPU_CHECK_ERR_INPUT_CROP; |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| while(ret != IPU_CHECK_OK && ret > IPU_CHECK_ERR_MIN) { |
| ret = ioctl((ipu->ipu_fd), IPU_CHECK_TASK, &(ipu->task)); |
| GST_TRACE ("IPU CHECK TASK ret=%d", ret); |
| |
| switch(ret) { |
| case IPU_CHECK_OK: |
| check_end = TRUE; |
| break; |
| case IPU_CHECK_ERR_SPLIT_INPUTW_OVER: |
| ipu->task.input.crop.w -= 8; |
| cnt--; |
| break; |
| case IPU_CHECK_ERR_SPLIT_INPUTH_OVER: |
| ipu->task.input.crop.h -= 8; |
| cnt--; |
| break; |
| case IPU_CHECK_ERR_SPLIT_OUTPUTW_OVER: |
| ipu->task.output.crop.w -= 8; |
| cnt--; |
| break; |
| case IPU_CHECK_ERR_SPLIT_OUTPUTH_OVER: |
| ipu->task.output.crop.h -= 8; |
| cnt--; |
| break; |
| case IPU_CHECK_ERR_SPLIT_WITH_ROT: |
| if (ipu->task.output.rotate != IPU_ROTATE_NONE) { |
| g_print("out of size range for rotation! (%d,%d):%d\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.rotate); |
| } |
| check_end = TRUE; |
| break; |
| case IPU_CHECK_ERR_PROC_NO_NEED: |
| GST_INFO ("shouldn't be here, but copy frame directly anyway"); |
| imx_ipu_frame_copy(device, from, to); |
| return 1; |
| default: |
| check_end = TRUE; |
| break; |
| } |
| |
| if (check_end || cnt <= 0) |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static gboolean is_format_has_alpha(guint ipu_format) { |
| if (ipu_format == IPU_PIX_FMT_BGRA32 |
| || ipu_format == IPU_PIX_FMT_RGBA32 |
| || ipu_format == IPU_PIX_FMT_ABGR32) |
| return TRUE; |
| return FALSE; |
| } |
| |
| static gint imx_ipu_convert(Imx2DDevice *device, |
| Imx2DFrame *dst, Imx2DFrame *src) |
| { |
| if (!device || !device->priv || !dst || !src || !dst->mem || !src->mem) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| ipu->task.overlay_en = FALSE; |
| |
| // Set input |
| ipu->task.input.paddr = (dma_addr_t)(src->mem->paddr); |
| ipu->task.input.crop.pos.x = GST_ROUND_UP_8(src->crop.x); |
| ipu->task.input.crop.pos.y = GST_ROUND_UP_8(src->crop.y); |
| ipu->task.input.crop.w = GST_ROUND_DOWN_8((MIN(src->crop.w, |
| (ipu->task.input.width - ipu->task.input.crop.pos.x)))); |
| ipu->task.input.crop.h = GST_ROUND_DOWN_8(MIN(src->crop.h, |
| (ipu->task.input.height - ipu->task.input.crop.pos.y))); |
| |
| if (ipu->deinterlace_enable) { |
| switch (src->interlace_type) { |
| case IMX_2D_INTERLACE_INTERLEAVED: |
| ipu->task.input.deinterlace.enable = TRUE; |
| break; |
| case IMX_2D_INTERLACE_FIELDS: |
| GST_FIXME("2-fields deinterlacing not supported yet"); |
| ipu->task.input.deinterlace.enable = FALSE; |
| break; |
| default: |
| ipu->task.input.deinterlace.enable = FALSE; |
| break; |
| } |
| } else { |
| ipu->task.input.deinterlace.enable = FALSE; |
| } |
| |
| GST_TRACE ("ipu input : %dx%d(%d,%d->%d,%d), format=0x%x, deinterlace=%s" |
| " deinterlace-mode=%d", ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format, |
| (ipu->task.input.deinterlace.enable ? "Yes" : "No"), |
| ipu->task.input.deinterlace.motion); |
| |
| // Set output |
| ipu->task.output.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.output.crop.pos.x = GST_ROUND_DOWN_8(dst->crop.x); |
| ipu->task.output.crop.pos.y = GST_ROUND_DOWN_8(dst->crop.y); |
| ipu->task.output.crop.w = GST_ROUND_UP_8(MIN(dst->crop.w, |
| (ipu->task.output.width - ipu->task.output.crop.pos.x))); |
| ipu->task.output.crop.h = GST_ROUND_UP_8(MIN(dst->crop.h, |
| (ipu->task.output.height - ipu->task.output.crop.pos.y))); |
| |
| GST_TRACE ("ipu output : %dx%d(%d,%d->%d,%d), format=0x%x", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| if (ipu->task.input.crop.w <= 0 || ipu->task.input.crop.h <=0 || |
| ipu->task.output.crop.w <= 0 || ipu->task.output.crop.h <= 0) { |
| GST_ERROR("crop size error"); |
| return -1; |
| } |
| |
| if (imx_ipu_check_parameters(device, src->mem, dst->mem) == 1) |
| return 0; |
| |
| if (ipu->task.input.deinterlace.enable && |
| ipu->task.input.deinterlace.motion != HIGH_MOTION && ipu->new_input) { |
| imx_ipu_free_mem(device, &ipu->vdi); |
| |
| ipu->vdi.size = ipu->task.input.width * ipu->task.input.height * |
| (imx_ipu_get_bpp(ipu->task.input.format) / 8); |
| imx_ipu_alloc_mem(device, &ipu->vdi); |
| if (!ipu->vdi.vaddr) { |
| GST_ERROR ("mmap vdibuf failed"); |
| return -1; |
| } |
| ipu->task.input.paddr_n = (dma_addr_t)ipu->vdi.paddr; |
| |
| memcpy(ipu->vdi.vaddr, src->mem->vaddr, ipu->vdi.size); |
| } |
| |
| // Final conversion |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("queuing IPU task failed: %s", strerror(errno)); |
| return -1; |
| } |
| |
| if (ipu->task.input.deinterlace.enable && |
| ipu->task.input.deinterlace.motion != HIGH_MOTION) { |
| memcpy(ipu->vdi.vaddr, src->mem->vaddr, ipu->vdi.size); |
| } |
| ipu->new_input = FALSE; |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_overlay(Imx2DDevice *device, |
| Imx2DFrame *dst, Imx2DFrame *src) |
| { |
| guint orig_dst_w; |
| guint orig_dst_h; |
| guint orig_dst_fmt; |
| guint orig_src_fmt; |
| guint dst_final_x; |
| guint dst_final_y; |
| guint dst_final_w; |
| guint dst_final_h; |
| guint src_w, src_h, src_x, src_y; |
| |
| if (!device || !device->priv || !dst || !src || !dst->mem || !src->mem) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| ipu->task.input.deinterlace.enable = FALSE; |
| |
| orig_dst_w = ipu->task.output.width; |
| orig_dst_h = ipu->task.output.height; |
| orig_dst_fmt = ipu->task.output.format; |
| orig_src_fmt = ipu->task.input.format; |
| dst_final_x = GST_ROUND_UP_8(dst->crop.x); |
| dst_final_y = GST_ROUND_UP_8(dst->crop.y); |
| dst_final_w = GST_ROUND_DOWN_8(MIN(dst->crop.w, (orig_dst_w - dst_final_x))); |
| dst_final_h = GST_ROUND_DOWN_8(MIN(dst->crop.h, (orig_dst_h - dst_final_y))); |
| src_x = GST_ROUND_UP_8(src->crop.x); |
| src_y = GST_ROUND_UP_8(src->crop.y); |
| src_w = GST_ROUND_DOWN_8((MIN(src->crop.w, (src->info.w - src_x)))); |
| src_h = GST_ROUND_DOWN_8((MIN(src->crop.h, (src->info.h - src_y)))); |
| |
| if (ipu->ov_temp.vaddr == NULL) { |
| ipu->ov_temp.size = IPU_OVERLAY_BUF_SIZE_MAX; |
| if (imx_ipu_alloc_mem(device, &ipu->ov_temp) < 0) { |
| return -1; |
| } |
| } |
| |
| if (src->crop.w > IPU_OVERLAY_WIDTH_MAX |
| || src->crop.h > IPU_OVERLAY_HEIGHT_MAX) { |
| #ifdef IPU_OVERLAY_SIZE_LIMIT_BREAK_DOWN |
| guint src_bk_x, src_bk_y, src_bk_w, src_bk_h; |
| gint remain_w, remain_h; |
| gboolean scaled = FALSE; |
| |
| if (dst_final_w != src_w || dst_final_h != src_h) { |
| //scaled, copy a non-scale temp input |
| scaled = TRUE; |
| guint BPP = 4; |
| const IpuFmtMap *fmt_map = imx_ipu_get_format(dst->info.fmt); |
| if (fmt_map) |
| BPP = fmt_map->bpp/8 + (fmt_map->bpp%8 ? 1 : 0); |
| |
| if (ipu->ov_resize.vaddr == NULL) { |
| ipu->ov_resize.size = src_w * src_h * BPP; |
| if (imx_ipu_alloc_mem(device, &ipu->ov_resize) < 0) |
| return -1; |
| } else if (ipu->ov_resize.size < (src_w * src_h * BPP)) { |
| imx_ipu_free_mem(device, &ipu->ov_resize); |
| ipu->ov_resize.size = src_w * src_h * BPP; |
| if (imx_ipu_alloc_mem(device, &ipu->ov_resize) < 0) |
| return -1; |
| } |
| |
| ipu->task.input.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.input.width = orig_dst_w; |
| ipu->task.input.height = orig_dst_h; |
| ipu->task.input.format = orig_dst_fmt; |
| ipu->task.input.crop.pos.x = dst_final_x; |
| ipu->task.input.crop.pos.y = dst_final_y; |
| ipu->task.input.crop.w = dst_final_w; |
| ipu->task.input.crop.h = dst_final_h; |
| |
| GST_TRACE ("temp input src : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| ipu->task.output.paddr = (dma_addr_t)(ipu->ov_resize.paddr); |
| ipu->task.output.width = src_w; |
| ipu->task.output.height = src_h; |
| ipu->task.output.format = orig_dst_fmt; |
| ipu->task.output.crop.pos.x = 0; |
| ipu->task.output.crop.pos.y = 0; |
| ipu->task.output.crop.w = src_w; |
| ipu->task.output.crop.h = src_h; |
| |
| GST_TRACE ("temp input dst : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| ipu->task.overlay_en = FALSE; |
| |
| if (imx_ipu_check_parameters(device, dst->mem, &ipu->ov_resize) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("copy temp input failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| } |
| |
| for (remain_h=src_h, src_bk_y=src_y; remain_h > 0; |
| remain_h-=IPU_OVERLAY_HEIGHT_MAX, src_bk_y+=IPU_OVERLAY_HEIGHT_MAX) { |
| if (remain_h > IPU_OVERLAY_HEIGHT_MAX) |
| src_bk_h = IPU_OVERLAY_HEIGHT_MAX; |
| else |
| src_bk_h = remain_h; |
| |
| for (remain_w=src_w, src_bk_x=src_x; remain_w > 0; |
| remain_w-=IPU_OVERLAY_WIDTH_MAX, src_bk_x+=IPU_OVERLAY_WIDTH_MAX) { |
| if (remain_w > IPU_OVERLAY_WIDTH_MAX) |
| src_bk_w = IPU_OVERLAY_WIDTH_MAX; |
| else |
| src_bk_w = remain_w; |
| |
| // overlay src with dst in dst crop area to temp buffer |
| // with the format of src format and size in dst crop size |
| if (scaled) { |
| ipu->task.input.paddr = (dma_addr_t)(ipu->ov_resize.paddr); |
| ipu->task.input.width = src_w; |
| ipu->task.input.height = src_h; |
| ipu->task.input.crop.pos.x = src_bk_x; |
| ipu->task.input.crop.pos.y = src_bk_y; |
| } else { |
| ipu->task.input.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.input.width = orig_dst_w; |
| ipu->task.input.height = orig_dst_h; |
| ipu->task.input.crop.pos.x = dst_final_x + src_bk_x; |
| ipu->task.input.crop.pos.y = dst_final_y + src_bk_y; |
| } |
| ipu->task.input.format = orig_dst_fmt; |
| ipu->task.input.crop.w = src_bk_w; |
| ipu->task.input.crop.h = src_bk_h; |
| |
| GST_TRACE ("ipu overlapped src : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| ipu->task.output.paddr = (dma_addr_t)(ipu->ov_temp.paddr); |
| ipu->task.output.width = src_bk_w; |
| ipu->task.output.height = src_bk_h; |
| ipu->task.output.format = orig_src_fmt; |
| ipu->task.output.crop.pos.x = 0; |
| ipu->task.output.crop.pos.y = 0; |
| ipu->task.output.crop.w = src_bk_w; |
| ipu->task.output.crop.h = src_bk_h; |
| |
| GST_TRACE ("ipu overlapped dst : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| if (src->alpha == 0xFF && is_format_has_alpha(orig_src_fmt)) |
| ipu->task.overlay.alpha.mode = IPU_ALPHA_MODE_LOCAL; |
| else |
| ipu->task.overlay.alpha.mode = IPU_ALPHA_MODE_GLOBAL; |
| ipu->task.overlay.alpha.gvalue = src->alpha; |
| ipu->task.overlay.alpha.loc_alp_paddr = (dma_addr_t)NULL; |
| ipu->task.overlay.colorkey.enable = FALSE; |
| ipu->task.overlay.width = src->info.w; |
| ipu->task.overlay.height = src->info.h; |
| ipu->task.overlay.format = orig_src_fmt; |
| ipu->task.overlay.paddr = (dma_addr_t)(src->mem->paddr); |
| ipu->task.overlay.crop.pos.x = src_bk_x; |
| ipu->task.overlay.crop.pos.y = src_bk_y; |
| ipu->task.overlay.crop.w = src_bk_w; |
| ipu->task.overlay.crop.h = src_bk_h; |
| |
| GST_TRACE ("ipu overlay: %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.overlay.width, ipu->task.overlay.height, |
| ipu->task.overlay.crop.pos.x, ipu->task.overlay.crop.pos.y, |
| ipu->task.overlay.crop.w, ipu->task.overlay.crop.h, |
| ipu->task.overlay.format); |
| |
| ipu->task.overlay_en = TRUE; |
| |
| if (imx_ipu_check_parameters(device, src->mem, &ipu->ov_temp) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("overlay src to temp buffer failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| |
| // convert the temp buffer to dst crop area with the dst format |
| ipu->task.input.paddr = (dma_addr_t)(ipu->ov_temp.paddr); |
| ipu->task.input.width = src_bk_w; |
| ipu->task.input.height = src_bk_h; |
| ipu->task.input.format = orig_src_fmt; |
| ipu->task.input.crop.pos.x = 0; |
| ipu->task.input.crop.pos.y = 0; |
| ipu->task.input.crop.w = src_bk_w; |
| ipu->task.input.crop.h = src_bk_h; |
| |
| GST_TRACE ("ipu tmp input : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| if (scaled) { |
| ipu->task.output.paddr = (dma_addr_t)(ipu->ov_resize.paddr); |
| ipu->task.output.width = src_w; |
| ipu->task.output.height = src_h; |
| ipu->task.output.crop.pos.x = src_bk_x; |
| ipu->task.output.crop.pos.y = src_bk_y; |
| } else { |
| ipu->task.output.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.output.width = orig_dst_w; |
| ipu->task.output.height = orig_dst_h; |
| ipu->task.output.crop.pos.x = dst_final_x + src_bk_x; |
| ipu->task.output.crop.pos.y = dst_final_y + src_bk_y; |
| } |
| ipu->task.output.format = orig_dst_fmt; |
| ipu->task.output.crop.w = src_bk_w; |
| ipu->task.output.crop.h = src_bk_h; |
| |
| GST_TRACE ("ipu output final: %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| ipu->task.overlay_en = FALSE; |
| |
| if (scaled) { |
| if (imx_ipu_check_parameters(device, &ipu->ov_temp, &ipu->ov_resize) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("temp buffer to dst failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| } else { |
| if (imx_ipu_check_parameters(device, &ipu->ov_temp, dst->mem) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("temp buffer to dst failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| } |
| } |
| } |
| |
| if (scaled) { |
| ipu->task.input.paddr = (dma_addr_t)(ipu->ov_resize.paddr); |
| ipu->task.input.width = src_w; |
| ipu->task.input.height = src_h; |
| ipu->task.input.format = orig_dst_fmt; |
| ipu->task.input.crop.pos.x = 0; |
| ipu->task.input.crop.pos.y = 0; |
| ipu->task.input.crop.w = src_w; |
| ipu->task.input.crop.h = src_h; |
| |
| GST_TRACE ("temp input src : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| ipu->task.output.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.output.width = orig_dst_w; |
| ipu->task.output.height = orig_dst_h; |
| ipu->task.output.format = orig_dst_fmt; |
| ipu->task.output.crop.pos.x = dst_final_x; |
| ipu->task.output.crop.pos.y = dst_final_y; |
| ipu->task.output.crop.w = dst_final_w; |
| ipu->task.output.crop.h = dst_final_h; |
| |
| GST_TRACE ("temp input dst : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| ipu->task.overlay_en = FALSE; |
| |
| if (imx_ipu_check_parameters(device, &ipu->ov_resize, dst->mem) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("copy temp input failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| } |
| |
| return 0; |
| |
| #else |
| return imx_ipu_convert(device, dst, src); |
| #endif |
| } |
| |
| // overlay src with dst in dst crop area to temp buffer |
| // with the format of src format and size in dst crop size |
| ipu->task.input.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.input.width = orig_dst_w; |
| ipu->task.input.height = orig_dst_h; |
| ipu->task.input.format = orig_dst_fmt; |
| ipu->task.input.crop.pos.x = dst_final_x; |
| ipu->task.input.crop.pos.y = dst_final_y; |
| ipu->task.input.crop.w = dst_final_w; |
| ipu->task.input.crop.h = dst_final_h; |
| |
| GST_TRACE ("ipu overlapped src : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| ipu->task.output.paddr = (dma_addr_t)(ipu->ov_temp.paddr); |
| ipu->task.output.width = src_w; |
| ipu->task.output.height = src_h; |
| ipu->task.output.format = orig_src_fmt; |
| ipu->task.output.crop.pos.x = 0; |
| ipu->task.output.crop.pos.y = 0; |
| ipu->task.output.crop.w = src_w; |
| ipu->task.output.crop.h = src_h; |
| |
| GST_TRACE ("ipu overlapped dst : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| if (src->alpha == 0xFF && is_format_has_alpha(orig_src_fmt)) |
| ipu->task.overlay.alpha.mode = IPU_ALPHA_MODE_LOCAL; |
| else |
| ipu->task.overlay.alpha.mode = IPU_ALPHA_MODE_GLOBAL; |
| ipu->task.overlay.alpha.gvalue = src->alpha; |
| ipu->task.overlay.alpha.loc_alp_paddr = (dma_addr_t)NULL; |
| ipu->task.overlay.colorkey.enable = FALSE; |
| ipu->task.overlay.width = src->info.w; |
| ipu->task.overlay.height = src->info.h; |
| ipu->task.overlay.format = orig_src_fmt; |
| ipu->task.overlay.paddr = (dma_addr_t)(src->mem->paddr); |
| ipu->task.overlay.crop.pos.x = src_x; |
| ipu->task.overlay.crop.pos.y = src_y; |
| ipu->task.overlay.crop.w = src_w; |
| ipu->task.overlay.crop.h = src_h; |
| |
| GST_TRACE ("ipu overlay: %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.overlay.width, ipu->task.overlay.height, |
| ipu->task.overlay.crop.pos.x, ipu->task.overlay.crop.pos.y, |
| ipu->task.overlay.crop.w, ipu->task.overlay.crop.h, |
| ipu->task.overlay.format); |
| |
| ipu->task.overlay_en = TRUE; |
| |
| if (imx_ipu_check_parameters(device, src->mem, &ipu->ov_temp) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("overlay src to temp buffer failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| |
| // convert the temp buffer to dst crop area with the dst format |
| ipu->task.input.paddr = (dma_addr_t)(ipu->ov_temp.paddr); |
| ipu->task.input.width = src_w; |
| ipu->task.input.height = src_h; |
| ipu->task.input.format = orig_src_fmt; |
| ipu->task.input.crop.pos.x = 0; |
| ipu->task.input.crop.pos.y = 0; |
| ipu->task.input.crop.w = src_w; |
| ipu->task.input.crop.h = src_h; |
| |
| GST_TRACE ("ipu tmp input : %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.input.width, ipu->task.input.height, |
| ipu->task.input.crop.pos.x, ipu->task.input.crop.pos.y, |
| ipu->task.input.crop.w, ipu->task.input.crop.h, |
| ipu->task.input.format); |
| |
| ipu->task.output.paddr = (dma_addr_t)(dst->mem->paddr); |
| ipu->task.output.width = orig_dst_w; |
| ipu->task.output.height = orig_dst_h; |
| ipu->task.output.format = orig_dst_fmt; |
| ipu->task.output.crop.pos.x = dst_final_x; |
| ipu->task.output.crop.pos.y = dst_final_y; |
| ipu->task.output.crop.w = dst_final_w; |
| ipu->task.output.crop.h = dst_final_h; |
| |
| GST_TRACE ("ipu output final: %dx%d(%d,%d->%d,%d), format=0x%x\n", |
| ipu->task.output.width, ipu->task.output.height, |
| ipu->task.output.crop.pos.x, ipu->task.output.crop.pos.y, |
| ipu->task.output.crop.w, ipu->task.output.crop.h, |
| ipu->task.output.format); |
| |
| ipu->task.overlay_en = FALSE; |
| |
| if (imx_ipu_check_parameters(device, &ipu->ov_temp, dst->mem) == 0) { |
| if (ioctl(ipu->ipu_fd, IPU_QUEUE_TASK, &(ipu->task)) < 0) { |
| GST_ERROR("temp buffer to dst failed: %s", strerror(errno)); |
| return -1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_blend(Imx2DDevice *device, Imx2DFrame *dst, Imx2DFrame *src) |
| { |
| if (!device || !device->priv || !dst || !src || !dst->mem || !src->mem) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| |
| if (src->alpha < 0xFF || is_format_has_alpha(ipu->task.input.format)) { |
| return imx_ipu_overlay(device, dst, src); |
| } else { |
| return imx_ipu_convert(device, dst, src); |
| } |
| } |
| |
| static gint imx_ipu_blend_finish(Imx2DDevice *device) |
| { |
| //do nothing |
| return 0; |
| } |
| |
| static gint imx_ipu_fill_color(Imx2DDevice *device, Imx2DFrame *dst, |
| guint RGBA8888) |
| { |
| //don't support color filling by hardware |
| return -1; |
| } |
| |
| static gint imx_ipu_set_rotate(Imx2DDevice *device, Imx2DRotationMode rot) |
| { |
| if (!device || !device->priv) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| gint ipu_rotate = IPU_ROTATE_NONE; |
| switch (rot) { |
| case IMX_2D_ROTATION_0: ipu_rotate = IPU_ROTATE_NONE; break; |
| case IMX_2D_ROTATION_90: ipu_rotate = IPU_ROTATE_90_RIGHT; break; |
| case IMX_2D_ROTATION_180: ipu_rotate = IPU_ROTATE_180; break; |
| case IMX_2D_ROTATION_270: ipu_rotate = IPU_ROTATE_90_LEFT; break; |
| case IMX_2D_ROTATION_HFLIP: ipu_rotate = IPU_ROTATE_HORIZ_FLIP; break; |
| case IMX_2D_ROTATION_VFLIP: ipu_rotate = IPU_ROTATE_VERT_FLIP; break; |
| default: ipu_rotate = IPU_ROTATE_NONE; break; |
| } |
| ipu->task.output.rotate = ipu_rotate; |
| |
| return 0; |
| } |
| |
| static gint imx_ipu_set_deinterlace (Imx2DDevice *device, |
| Imx2DDeinterlaceMode deint_mode) |
| { |
| if (!device || !device->priv) |
| return -1; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| switch (deint_mode) { |
| case IMX_2D_DEINTERLACE_NONE: |
| ipu->deinterlace_enable = FALSE; |
| break; |
| case IMX_2D_DEINTERLACE_LOW_MOTION: |
| ipu->deinterlace_enable = TRUE; |
| ipu->task.input.deinterlace.motion = LOW_MOTION; |
| break; |
| case IMX_2D_DEINTERLACE_MID_MOTION: |
| ipu->deinterlace_enable = TRUE; |
| ipu->task.input.deinterlace.motion = MED_MOTION; |
| break; |
| case IMX_2D_DEINTERLACE_HIGH_MOTION: |
| ipu->deinterlace_enable = TRUE; |
| ipu->task.input.deinterlace.motion = HIGH_MOTION; |
| break; |
| default: |
| ipu->deinterlace_enable = FALSE; |
| break; |
| } |
| |
| return 0; |
| } |
| |
| static Imx2DRotationMode imx_ipu_get_rotate (Imx2DDevice* device) |
| { |
| if (!device || !device->priv) |
| return 0; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| Imx2DRotationMode rot = IMX_2D_ROTATION_0; |
| switch (ipu->task.output.rotate) { |
| case IPU_ROTATE_NONE: rot = IMX_2D_ROTATION_0; break; |
| case IPU_ROTATE_90_RIGHT: rot = IMX_2D_ROTATION_90; break; |
| case IPU_ROTATE_180: rot = IMX_2D_ROTATION_180; break; |
| case IPU_ROTATE_90_LEFT: rot = IMX_2D_ROTATION_270; break; |
| case IPU_ROTATE_HORIZ_FLIP: rot = IMX_2D_ROTATION_HFLIP; break; |
| case IPU_ROTATE_VERT_FLIP: rot = IMX_2D_ROTATION_VFLIP; break; |
| default: rot = IMX_2D_ROTATION_0; break; |
| } |
| |
| return rot; |
| } |
| |
| static Imx2DDeinterlaceMode imx_ipu_get_deinterlace (Imx2DDevice* device) |
| { |
| if (!device || !device->priv) |
| return 0; |
| |
| Imx2DDeviceIpu *ipu = (Imx2DDeviceIpu *) (device->priv); |
| Imx2DDeinterlaceMode deint_mode = IMX_2D_DEINTERLACE_NONE; |
| if (ipu->deinterlace_enable) { |
| switch (ipu->task.input.deinterlace.motion) { |
| case LOW_MOTION: deint_mode = IMX_2D_DEINTERLACE_LOW_MOTION; break; |
| case MED_MOTION: deint_mode = IMX_2D_DEINTERLACE_MID_MOTION; break; |
| case HIGH_MOTION: deint_mode = IMX_2D_DEINTERLACE_HIGH_MOTION; break; |
| default: deint_mode = IMX_2D_DEINTERLACE_NONE; break; |
| } |
| } |
| |
| return deint_mode; |
| } |
| |
| static gint imx_ipu_get_capabilities(Imx2DDevice* device) |
| { |
| return IMX_2D_DEVICE_CAP_CSC | IMX_2D_DEVICE_CAP_DEINTERLACE |
| | IMX_2D_DEVICE_CAP_ROTATE | IMX_2D_DEVICE_CAP_SCALE |
| | IMX_2D_DEVICE_CAP_OVERLAY | IMX_2D_DEVICE_CAP_ALPHA; |
| } |
| |
| static GList* imx_ipu_get_supported_in_fmts(Imx2DDevice* device) |
| { |
| GList* list = NULL; |
| const IpuFmtMap *map = ipu_fmts_map; |
| while (map->gst_video_format != GST_VIDEO_FORMAT_UNKNOWN) { |
| list = g_list_append(list, (gpointer)(map->gst_video_format)); |
| map++; |
| } |
| |
| return list; |
| } |
| |
| static GList* imx_ipu_get_supported_out_fmts(Imx2DDevice* device) |
| { |
| return imx_ipu_get_supported_in_fmts(device); |
| } |
| |
| Imx2DDevice * imx_ipu_create(Imx2DDeviceType device_type) |
| { |
| Imx2DDevice * device = g_slice_alloc(sizeof(Imx2DDevice)); |
| if (!device) { |
| GST_ERROR("allocate device structure failed\n"); |
| return NULL; |
| } |
| |
| device->device_type = device_type; |
| device->priv = NULL; |
| |
| device->open = imx_ipu_open; |
| device->close = imx_ipu_close; |
| device->alloc_mem = imx_ipu_alloc_mem; |
| device->free_mem = imx_ipu_free_mem; |
| device->copy_mem = imx_ipu_copy_mem; |
| device->frame_copy = imx_ipu_frame_copy; |
| device->config_input = imx_ipu_config_input; |
| device->config_output = imx_ipu_config_output; |
| device->convert = imx_ipu_convert; |
| device->blend = imx_ipu_blend; |
| device->blend_finish = imx_ipu_blend_finish; |
| device->fill = imx_ipu_fill_color; |
| device->set_rotate = imx_ipu_set_rotate; |
| device->set_deinterlace = imx_ipu_set_deinterlace; |
| device->get_rotate = imx_ipu_get_rotate; |
| device->get_deinterlace = imx_ipu_get_deinterlace; |
| device->get_capabilities = imx_ipu_get_capabilities; |
| device->get_supported_in_fmts = imx_ipu_get_supported_in_fmts; |
| device->get_supported_out_fmts = imx_ipu_get_supported_out_fmts; |
| |
| return device; |
| } |
| |
| gint imx_ipu_destroy(Imx2DDevice *device) |
| { |
| if (!device) |
| return -1; |
| |
| g_slice_free1(sizeof(Imx2DDevice), device); |
| |
| return 0; |
| } |
| |
| gboolean imx_ipu_is_exist (void) |
| { |
| return HAS_IPU(); |
| } |
