| /* |
| * Copyright (C) 2018 Synaptics Incorporated. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 as |
| * published by the Free Software Foundation. |
| * |
| * INFORMATION CONTAINED IN THIS DOCUMENT IS PROVIDED "AS-IS," AND |
| * SYNAPTICS EXPRESSLY DISCLAIMS ALL EXPRESS AND IMPLIED WARRANTIES, |
| * INCLUDING ANY IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE, AND ANY WARRANTIES OF NON-INFRINGEMENT OF ANY |
| * INTELLECTUAL PROPERTY RIGHTS. IN NO EVENT SHALL SYNAPTICS BE LIABLE |
| * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, PUNITIVE, OR |
| * CONSEQUENTIAL DAMAGES ARISING OUT OF OR IN CONNECTION WITH THE USE |
| * OF THE INFORMATION CONTAINED IN THIS DOCUMENT, HOWEVER CAUSED AND |
| * BASED ON ANY THEORY OF LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * NEGLIGENCE OR OTHER TORTIOUS ACTION, AND EVEN IF SYNAPTICS WAS |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. IF A TRIBUNAL OF |
| * COMPETENT JURISDICTION DOES NOT PERMIT THE DISCLAIMER OF DIRECT |
| * DAMAGES OR ANY OTHER DAMAGES, SYNAPTICS' TOTAL CUMULATIVE LIABILITY |
| * TO ANY PARTY SHALL NOT EXCEED ONE HUNDRED U.S. DOLLARS. |
| */ |
| |
| #include "vpp_module.h" |
| #include "vpp_cfg.h" |
| #include "avio_memmap.h" |
| #include "api_avio_dhub.h" |
| #include "util.h" |
| #include "common.h" |
| #include "vpp_api.h" |
| #include "show_logoframe.h" |
| |
| /* Memory is available for only ONE 1080p frame*/ |
| #define MAX_FRAME_DESC 1 |
| |
| #define bTST(x, b) (((x) >> (b)) & 1) |
| |
| typedef enum { |
| FB_PATTERN_CHECKER = 0, |
| FB_PATTERN_VERT_COLORBAR, |
| FB_PATTERN_CUSTOM, |
| FB_PATTERN_CUSTOM_APM, |
| MAX_PATTERNS, |
| FB_PATTERN_HORZ_COLORBAR, |
| } FB_PATTERN_TYPE; |
| |
| static VBUF_INFO *gDescArray[MAX_FRAME_DESC]; |
| static INT32 gDescIndex; |
| |
| VOID destroy_vbuf_desc(VBUF_INFO *pVBufInfo) |
| { |
| (void)pVBufInfo; |
| } |
| |
| INT32 make_frame_data(UINT32 iVideo, UINT32 *pStartAddr, |
| UINT32 uiPicH, UINT32 uiLineV, UINT32 uiWidth, |
| UINT32 uiHeight, UINT32 uiPicA, UINT32 uiPicB) |
| { |
| UINT32 *Ptr; |
| UINT32 VLines, VRep, HS, HRep, PixVal, VBlock, HBlock, PixelPerWord; |
| HRESULT Ret = MV_VPP_OK; |
| |
| if (!pStartAddr) { |
| printf("invalid input parameters\n"); |
| Ret = -1; |
| goto make_frame_data_exit; |
| } |
| |
| /** |
| * make the whole frame data |
| */ |
| Ptr = pStartAddr; |
| |
| if (iVideo) |
| PixelPerWord = 2; |
| else |
| PixelPerWord = 1; |
| |
| VBlock = uiLineV; |
| |
| for (VLines = 0; VLines < uiHeight; VLines += VBlock) { |
| if ((uiHeight - VLines) < VBlock) |
| VBlock = uiHeight - VLines; |
| |
| for (VRep = 0; VRep < VBlock; VRep++) { |
| HBlock = uiPicH * PixelPerWord; |
| |
| for (HS = 0; HS < uiWidth; HS += HBlock) { |
| if ((VLines / uiLineV + |
| HS/(uiPicH * PixelPerWord)) |
| & 0x1) |
| PixVal = uiPicB; |
| else |
| PixVal = uiPicA; |
| |
| if ((uiWidth - HS) < HBlock) |
| HBlock = uiWidth - HS; |
| |
| for (HRep = 0; HRep < HBlock/PixelPerWord; |
| HRep++) |
| *Ptr++ = PixVal; |
| } |
| } |
| } |
| make_frame_data_exit: |
| return Ret; |
| } |
| |
| VOID build_frames(VBUF_INFO *vbufinfo, VOID *vbuf, |
| INT32 srcfmt, INT32 bit_depth, INT32 x, INT32 y, INT32 width, |
| INT32 height, INT32 progressive, INT32 pattern_type, unsigned char IsPatt) |
| { |
| UINT32 datasize; |
| |
| if(bit_depth != INPUT_BIT_DEPTH_8BIT || progressive != 1 || |
| pattern_type != FB_PATTERN_CUSTOM) |
| { |
| printf("Error: Invalid Params\n"); |
| return; |
| } |
| /* set other fields of logo frame descriptor */ |
| if (srcfmt == SRCFMT_YUV422) { |
| vbufinfo->m_bytes_per_pixel = 2; |
| vbufinfo->m_srcfmt = SRCFMT_YUV422; |
| vbufinfo->m_order = ORDER_UYVY; |
| } else { |
| vbufinfo->m_bytes_per_pixel = 4; |
| vbufinfo->m_srcfmt = SRCFMT_ARGB32; |
| vbufinfo->m_order = ORDER_RGBA; |
| } |
| datasize = width * height * vbufinfo->m_bytes_per_pixel; |
| vbufinfo->m_content_width = width; |
| vbufinfo->m_content_height = height; |
| vbufinfo->m_buf_stride = vbufinfo->m_content_width * |
| vbufinfo->m_bytes_per_pixel; |
| vbufinfo->m_buf_size = (INT32)datasize; |
| vbufinfo->m_flags = 1; |
| vbufinfo->m_disp_offset = 0; |
| vbufinfo->m_buf_stride = vbufinfo->m_content_width * |
| vbufinfo->m_bytes_per_pixel; |
| vbufinfo->m_active_width = width; |
| vbufinfo->m_active_height = height; |
| vbufinfo->m_active_left = x; |
| vbufinfo->m_active_top = y; |
| vbufinfo->m_content_offset = 0; |
| if (IsPatt) { |
| if (srcfmt == SRCFMT_YUV422) |
| make_frame_data(1, vbuf, 32, 36, width, |
| height, 0x00800080, 0x00800080); |
| else |
| make_frame_data(0, vbuf, 32, 36, width, |
| height, 0xFF000000, 0xFFFFFFFF); |
| } |
| } |
| INT32 create_new_frame(INT32 width, INT32 height, INT32 progressive, |
| INT32 src_fmt, INT32 bit_depth, INT32 pattern_type, |
| VBUF_INFO **frame) { |
| |
| VBUF_INFO *vbufinfo; |
| VOID *base = NULL; |
| void* phy_base; |
| VOID *shm_handle; |
| INT32 datasize = 0; |
| INT32 result = 0; |
| |
| vbufinfo = UtilMemAllocZ(sizeof(VBUF_INFO)); |
| if (vbufinfo == NULL) |
| return -1; |
| |
| if (SRCFMT_YUV422 == src_fmt) |
| datasize = width*height*2; |
| else |
| datasize = width*height*4; |
| |
| phy_base = base = shm_handle = UtilMemAllocZ(datasize); |
| if (base == NULL) { |
| result = MV_VPP_EBADCALL; |
| printf("share memory get vitual address failed\n"); |
| goto EXIT; |
| } |
| |
| build_frames(vbufinfo, base, src_fmt, bit_depth, |
| 0, 0, width, height, |
| progressive, pattern_type, 1); |
| vbufinfo->hShm = shm_handle; |
| vbufinfo->m_pbuf_start = phy_base; |
| vbufinfo->m_bufferID = base; |
| *frame = vbufinfo; |
| EXIT: |
| return result; |
| } |
| |
| |
| VOID *MV_VPP_GetFrame(INT32 x, |
| INT32 y, INT32 w, INT32 h, INT32 stride) |
| { |
| int Ret = 0; |
| VBUF_INFO *vbufinfo = gDescArray[gDescIndex]; |
| |
| if(vbufinfo == NULL) { |
| Ret = create_new_frame(w, h, 1, SRCFMT_YUV422, |
| INPUT_BIT_DEPTH_8BIT, FB_PATTERN_CUSTOM, |
| &(gDescArray[gDescIndex])); |
| if (Ret != 0) { |
| printf("create_global_desc_array fails\n"); |
| return NULL; |
| } |
| } |
| |
| vbufinfo = gDescArray[gDescIndex]; |
| gDescIndex++; |
| if (gDescIndex == MAX_FRAME_DESC) |
| gDescIndex = 0; |
| |
| vbufinfo->m_active_left = x; |
| vbufinfo->m_active_top = y; |
| vbufinfo->m_buf_stride = stride; |
| vbufinfo->m_active_width = w; |
| vbufinfo->m_active_height = h; |
| |
| return vbufinfo; |
| } |
| |
| INT32 create_global_desc_array(VOID) |
| { |
| UtilMemSet(gDescArray, 0, MAX_FRAME_DESC * sizeof(VBUF_INFO *)); |
| return 0; |
| } |
| |
| VOID destroy_global_desc_array(VOID) |
| { |
| UtilMemSet(gDescArray, 0, MAX_FRAME_DESC * sizeof(VBUF_INFO *)); |
| } |
| |
| VOID MV_VPP_InitMemory(VOID) |
| { |
| UtilMemReset(); |
| } |
