Просмотр исходного кода

Merge starlight_multimedia_JPU branch

Signed-off-by: sw.multimedia <sw.multimedia@starfivetech.com>
sw.multimedia 2 лет назад
Родитель
Сommit
3e520915e6
49 измененных файлов с 3617 добавлено и 571 удалено
  1. 41 0
      soft_3rdpart/codaj12/codaj12Driver_buildroot.mak
  2. 148 0
      soft_3rdpart/codaj12/codaj12_buildroot.mak
  3. 11 3
      soft_3rdpart/codaj12/jdi/jdi.h
  4. 74 1
      soft_3rdpart/codaj12/jpuapi/jpuapi.c
  5. 9 3
      soft_3rdpart/codaj12/jpuapi/jpuapi.h
  6. 5 1
      soft_3rdpart/codaj12/jpuapi/jpuapifunc.h
  7. 5 1
      soft_3rdpart/codaj12/jpuapi/jpuconfig.h
  8. 5 1
      soft_3rdpart/codaj12/jpuapi/regdefine.h
  9. 41 10
      soft_3rdpart/codaj12/sample/helper/bitstreamfeeder.c
  10. 121 0
      soft_3rdpart/codaj12/sample/helper/bsfeeder_buffer_impl.c
  11. 5 1
      soft_3rdpart/codaj12/sample/helper/cnm_fpga.h
  12. 7 2
      soft_3rdpart/codaj12/sample/helper/datastructure.h
  13. 119 1
      soft_3rdpart/codaj12/sample/helper/jpuhelper.c
  14. 5 1
      soft_3rdpart/codaj12/sample/helper/jpulog.h
  15. 5 1
      soft_3rdpart/codaj12/sample/helper/platform.h
  16. 8 2
      soft_3rdpart/codaj12/sample/helper/yuv_feeder.h
  17. 14 4
      soft_3rdpart/codaj12/sample/main_helper.h
  18. 30 8
      soft_3rdpart/omx-il/Makefile
  19. 443 0
      soft_3rdpart/omx-il/component/image/common/SF_OMX_mjpeg_common.c
  20. 136 0
      soft_3rdpart/omx-il/component/image/common/SF_OMX_mjpeg_common.h
  21. 1212 0
      soft_3rdpart/omx-il/component/image/dec/SF_OMX_Mjpeg_decoder.c
  22. 237 95
      soft_3rdpart/omx-il/component/video/common/SF_OMX_video_common.c
  23. 85 2
      soft_3rdpart/omx-il/component/video/common/SF_OMX_video_common.h
  24. 156 105
      soft_3rdpart/omx-il/component/video/dec/SF_OMX_Vdec_decoder.c
  25. 117 109
      soft_3rdpart/omx-il/component/video/enc/SF_OMX_Venc_encoder.c
  26. 25 95
      soft_3rdpart/omx-il/core/SF_OMX_Core.c
  27. 18 83
      soft_3rdpart/omx-il/core/SF_OMX_Core.h
  28. 3 3
      soft_3rdpart/omx-il/tests/dec_test.c
  29. 1 1
      soft_3rdpart/omx-il/tests/enc_test.c
  30. 394 0
      soft_3rdpart/omx-il/tests/mjpeg_dec_test.c
  31. 1 1
      soft_3rdpart/wave511/code/WaveDecode_buildroot.mak
  32. 7 2
      soft_3rdpart/wave511/code/sample_v2/component/cnm_app.h
  33. 5 1
      soft_3rdpart/wave511/code/sample_v2/component/cnm_app_internal.h
  34. 10 3
      soft_3rdpart/wave511/code/sample_v2/component/component.h
  35. 7 2
      soft_3rdpart/wave511/code/sample_v2/component_decoder/decoder_listener.h
  36. 7 2
      soft_3rdpart/wave511/code/sample_v2/component_encoder/encoder_listener.h
  37. 12 4
      soft_3rdpart/wave511/code/sample_v2/helper/main_helper.h
  38. 8 2
      soft_3rdpart/wave511/code/sample_v2/helper/misc/debug.h
  39. 6 1
      soft_3rdpart/wave511/code/sample_v2/helper/misc/pbu.h
  40. 5 1
      soft_3rdpart/wave511/code/vdi/mm.h
  41. 11 3
      soft_3rdpart/wave511/code/vdi/vdi.h
  42. 5 1
      soft_3rdpart/wave511/code/vdi/vdi_osal.h
  43. 8 2
      soft_3rdpart/wave511/code/vpuapi/coda9/coda9.h
  44. 7 2
      soft_3rdpart/wave511/code/vpuapi/coda9/coda9_vpuconfig.h
  45. 8 2
      soft_3rdpart/wave511/code/vpuapi/product.h
  46. 13 5
      soft_3rdpart/wave511/code/vpuapi/vpuapi.h
  47. 5 1
      soft_3rdpart/wave511/code/vpuapi/vpuapifunc.h
  48. 5 1
      soft_3rdpart/wave511/code/vpuapi/vputypes.h
  49. 7 2
      soft_3rdpart/wave511/code/vpuapi/wave/wave5.h

+ 41 - 0
soft_3rdpart/codaj12/codaj12Driver_buildroot.mak

@@ -0,0 +1,41 @@
+# Comment/uncomment the	following line to disable/enable debugging
+#DEBUG = y
+
+# Add your debugging flag (or not) to CFLAGS
+ifeq ($(DEBUG),y)
+  DEBFLAGS = -O	-g # "-O" is needed to expand inlines
+else
+  DEBFLAGS = -O2
+endif
+
+export ARCH=riscv
+export SUBARCH=riscv
+export CROSS_COMPILE=riscv64-buildroot-linux-gnu-
+
+DRV_PATH  := $(shell pwd)/jdi/linux/driver
+EXTRA_CFLAGS +=	$(DEBFLAGS) -I$(LDDINCDIR) -Wno-unused-function
+
+ifneq ($(KERNELRELEASE),)
+# call from kernel build system
+
+obj-m	:= jdec.o
+
+else
+
+default:
+	$(MAKE) -C $(KERNELDIR)	M=$(DRV_PATH) LDDINCDIR=$(DRV_PATH)/../include modules
+
+endif
+
+
+
+clean:
+	rm -rf $(DRV_PATH)/*.o $(DRV_PATH)/*~ $(DRV_PATH)/core $(DRV_PATH)/.depend $(DRV_PATH)/.*.cmd $(DRV_PATH)/*.ko $(DRV_PATH)/*.mod.c $(DRV_PATH)/modules.order $(DRV_PATH)/.tmp_versions $(DRV_PATH)/*.dwo $(DRV_PATH)/.*.dwo
+
+depend .depend dep:
+	$(CC) $(CFLAGS)	-M *.c > .depend
+
+
+ifeq (.depend,$(wildcard .depend))
+include	.depend
+endif

+ 148 - 0
soft_3rdpart/codaj12/codaj12_buildroot.mak

@@ -0,0 +1,148 @@
+# ----------------------------------------------------------------------
+#
+# codaj12
+#
+# ----------------------------------------------------------------------
+.PHONY: CREATE_DIR
+BUILD_CONFIGURATION := EmbeddedRiscvLinux
+PRODUCT := CODAJ12
+PRODUCT := CODDAJ12C
+
+USE_PTHREAD = yes
+USE_RTL_SIM = no
+LINT_HOME   = etc/lint
+
+UNAME = $(shell uname -a)
+ifneq (,$(findstring i386, $(UNAME)))
+    USE_32BIT = yes
+endif
+
+ifeq ($(RTL_SIM), 1)
+USE_RTL_SIM = yes
+endif
+
+REFC    := 0
+
+ifeq ($(USE_32BIT), yes)
+PLATFORM    = nativelinux
+else
+PLATFORM    = nativelinux_64bit
+endif
+
+CROSS_CC_PREFIX =
+JDI_C           = jdi/linux/jdi.c
+VDI_OSAL_C      =
+MM_C            =
+PLATFORM_FLAGS  =
+JDI_VPATH       = jdi/linux
+ifeq ("$(BUILD_CONFIGURATION)", "NonOS")
+    CROSS_CC_PREFIX = arm-none-eabi-
+    JDI_C           = jdi/nonos/jdi.c
+    VDI_OSAL_C      =
+    MM_C            = jdi/mm.c
+    USE_PTHREAD     = no
+    PLATFORM        = none
+    DEFINES         = -DLIB_C_STUB
+    PLATFORM_FLAGS  =
+    JDI_VPATH       = jdi/nonos
+    NONOS_RULE      = options_nonos.lnt
+endif
+ifeq ("$(BUILD_CONFIGURATION)", "EmbeddedLinux")
+    CROSS_CC_PREFIX = arm-none-linux-gnueabi-
+    PLATFORM        = armlinux
+endif
+
+ifeq ("$(BUILD_CONFIGURATION)", "EmbeddedRiscvLinux")
+    CROSS_CC_PREFIX = riscv64-buildroot-linux-gnu-
+    PLATFORM        = riscvlinux
+endif
+CC  = $(CROSS_CC_PREFIX)gcc
+CXX = $(CROSS_CC_PREFIX)g++
+LINKER=$(CC)
+AR  = $(CROSS_CC_PREFIX)ar
+
+INCLUDES = -I./jpuapi -I./ffmpeg/include -I./sample/helper -I./sample -I./jdi -I../
+ifeq ($(USE_RTL_SIM), yes)
+DEFINES += -DCNM_SIM_PLATFORM -DCNM_SIM_DPI_INTERFACE -DSUPPORT_DECODER
+DEFINES += -D$(PRODUCT) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+else
+DEFINES += -D$(PRODUCT) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE
+endif	# USE_SIM_PLATFORM
+DEFINES += -DUSE_FEEDING_METHOD_BUFFER
+
+CFLAGS  += -g -I. -Wno-implicit-function-declaration -Wno-format -Wl,--fatal-warning $(INCLUDES) $(DEFINES) $(PLATFORM_FLAGS)
+ifeq ($(USE_RTL_SIM), yes)
+ifeq ($(IUS), 1)
+CFLAGS  += -fPIC # ncverilog is 64bit version
+endif
+endif
+ARFLAGS += cru
+
+LDFLAGS  = $(PLATFORM_FLAGS)
+
+ifeq ($(USE_PTHREAD), yes)
+LDLIBS  += -lpthread
+endif
+LDLIBS  += -lm
+
+BUILDLIST=DECTEST
+MAKEFILE=codaj12_buildroot.mak
+DECTEST=libcodadec.so
+
+OBJDIR=obj
+ALLOBJS=*.o
+ALLDEPS=*.dep
+ALLLIBS=*.a
+RM=rm -f
+MKDIR=mkdir -p
+
+SOURCES_COMMON = jpuapi.c jpuapifunc.c jpuhelper.c jpulog.c cnm_fpga.c main_jpg_dec_test.c \
+                platform.c datastructure.c bitstreamfeeder.c bsfeeder_fixedsize_impl.c bsfeeder_buffer_impl.c\
+                $(JDI_C)             \
+                $(VDI_OSAL_C)        \
+                $(MM_C)
+
+VPATH = jdi:
+VPATH += sample:
+VPATH += sample/helper:
+VPATH += $(JDI_VPATH):jpuapi
+
+VPATH2=$(patsubst %,-I%,$(subst :, ,$(VPATH)))
+
+OBJECTNAMES_COMMON=$(patsubst %.c,%.o,$(patsubst %.cpp,%.o,$(SOURCES_COMMON)))
+OBJECTPATHS_COMMON=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_COMMON)))
+
+SOURCES_DECTEST = sample/main_jpg_dec_test.c
+ifeq ($(USE_RTL_SIM), yes)
+	SOURCES_DECTEST += sample/main_sim.c
+endif
+
+OBJECTNAMES_DECTEST=$(patsubst %.c,%.o,$(patsubst %.cpp,%.o,$(SOURCES_DECTEST)))
+OBJECTPATHS_DECTEST=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_DECTEST))) $(OBJECTPATHS_COMMON)
+
+all: $(BUILDLIST)
+
+ifeq ($(USE_RTL_SIM), yes)
+DECTEST: CREATE_DIR $(OBJECTPATHS_COMMON)
+else
+DECTEST: CREATE_DIR $(OBJECTPATHS_COMMON)
+	$(LINKER) -g -fPIC -shared -o $(DECTEST) $(LDFLAGS) -Wl,-gc-section -Wl,--start-group $(OBJECTPATHS_COMMON) $(LDLIBS) -Wl,--end-group
+endif
+
+
+-include $(OBJECTPATHS:.o=.dep)
+
+clean:
+	$(RM) $(DECTEST)
+	$(RM) $(OBJDIR)/$(ALLOBJS)
+	$(RM) $(OBJDIR)/$(ALLDEPS)
+
+CREATE_DIR:
+	-mkdir -p $(OBJDIR)
+
+obj/%.o: %.c $(MAKEFILE)
+	$(CC) -g -fPIC -shared $(CFLAGS) -Wall -Werror -c $< -o $@ -MD -MF $(@:.o=.dep)
+
+lint:
+	"$(LINT_HOME)/flint" -i"$(LINT_HOME)" $(DEFINES) $(INCLUDES) $(VPATH2) linux_std.lnt $(HAPS_RULE) $(NONOS_RULE)  $(SOURCES_COMMON)
+

+ 11 - 3
soft_3rdpart/codaj12/jdi/jdi.h

@@ -28,9 +28,17 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdarg.h>
-#include "../jpuapi/jpuconfig.h"
-#include "mm.h"
-#include "jputypes.h"
+
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jpuconfig.h"
+    #include "codaj12/jdi/mm.h"
+    #include "codaj12/jpuapi/jputypes.h"
+#else
+    #include "../jpuapi/jpuconfig.h"
+    #include "mm.h"
+    #include "jputypes.h"
+#endif
+
 
 #define MAX_JPU_BUFFER_POOL 32
 #define JpuWriteInstReg( INST_IDX, ADDR, DATA )		jdi_write_register( ((unsigned long)INST_IDX*NPT_REG_SIZE)+ADDR, DATA ) // system register write 	with instance index

+ 74 - 1
soft_3rdpart/codaj12/jpuapi/jpuapi.c

@@ -230,7 +230,7 @@ JpgRet JPU_DecOpen(JpgDecHandle * pHandle, JpgDecOpenParam * pop)
 
     pDecInfo->streamWrPtr = pop->bitstreamBuffer;
     pDecInfo->streamRdPtr = pop->bitstreamBuffer;
-
+    JLOG(INFO, "streamWrPtr = %x\r\n", pop->bitstreamBuffer);
     pDecInfo->streamBufStartAddr = pop->bitstreamBuffer;
     pDecInfo->streamBufSize     = pop->bitstreamBufferSize;
     pDecInfo->streamBufEndAddr  = pop->bitstreamBuffer + pop->bitstreamBufferSize;
@@ -374,6 +374,21 @@ JpgRet JPU_DecGetInitialInfo(JpgDecHandle handle, JpgDecInitialInfo * info)
     return JPG_RET_SUCCESS;
 }
 
+FrameBuffer *JPU_GetFrameBufPool(JpgDecHandle handle)
+{
+    JpgInst * pJpgInst;
+    JpgDecInfo * pDecInfo;
+    JpgRet ret;
+
+
+    ret = CheckJpgInstValidity(handle);
+    if (ret != JPG_RET_SUCCESS)
+        return NULL;
+
+    pJpgInst = handle;
+    pDecInfo = &pJpgInst->JpgInfo->decInfo;
+    return pDecInfo->frameBufPool;
+}
 
 JpgRet JPU_DecRegisterFrameBuffer(JpgDecHandle handle, FrameBuffer * bufArray, int num, int stride)
 {
@@ -414,6 +429,61 @@ JpgRet JPU_DecRegisterFrameBuffer(JpgDecHandle handle, FrameBuffer * bufArray, i
     return JPG_RET_SUCCESS;
 }
 
+JpgRet JPU_DecRegisterFrameBuffer2(JpgDecHandle handle, FrameBuffer * bufArray, int stride)
+{
+    JpgInst * pJpgInst;
+    JpgDecInfo * pDecInfo;
+    JpgRet ret;
+    int number;
+
+    ret = CheckJpgInstValidity(handle);
+    if (ret != JPG_RET_SUCCESS)
+        return ret;
+
+    pJpgInst = handle;
+    pDecInfo = &pJpgInst->JpgInfo->decInfo;
+    number = pDecInfo->numFrameBuffers;
+
+    if (!pDecInfo->initialInfoObtained) {
+        return JPG_RET_WRONG_CALL_SEQUENCE;
+    }
+
+    if (bufArray == 0) {
+        return JPG_RET_INVALID_FRAME_BUFFER;
+    }
+
+    if ((stride % 8) != 0) {
+        return JPG_RET_INVALID_STRIDE;
+    }
+
+    
+    if (pDecInfo->frameBufPool == NULL)
+    {
+        //First register
+        JLOG(INFO, "%s First register frame buffer\r\n", __FUNCTION__);
+        pDecInfo->frameBufPool = bufArray;
+        pDecInfo->stride          = stride;
+        pDecInfo->stride_c        = bufArray->strideC;
+    }
+    
+    //check wether frameBufPool and bufArray match
+    if (pDecInfo->frameBufPool[number].bufY != bufArray->bufY)
+    {
+        JLOG(ERR, "Does not support discontinuous array!\n");
+        return JPG_RET_FAILURE;
+    }
+    number ++;
+
+    if (number >= MAX_FRAME)
+    {
+        JLOG(ERR, "Too lot of frame buffer! %d/%d\n", number, MAX_FRAME);
+        return JPG_RET_FAILURE;
+    }
+    pDecInfo->numFrameBuffers = number;
+    JLOG(INFO, "%s numFrameBuffers = %d\r\n", __FUNCTION__, pDecInfo->numFrameBuffers);
+    return JPG_RET_SUCCESS;
+}
+
 JpgRet JPU_DecGetBitstreamBuffer(JpgDecHandle handle,
     PhysicalAddress * prdPtr,
     PhysicalAddress * pwrPtr,
@@ -883,6 +953,9 @@ JpgRet JPU_DecStartOneFrame(JpgDecHandle handle, JpgDecParam *param)
     JpuWriteInstReg(instRegIndex, MJPEG_ROT_INFO_REG, (ppuEnable<<4) | (pDecInfo->mirrorIndex<<2) | pDecInfo->rotationIndex);
 
     val = (pDecInfo->frameIdx % pDecInfo->numFrameBuffers);
+    JLOG(INFO, "%s: bufY = %lx bufCb = %lx bufCr = %lx stride = %d stride_c = %d\r\n", __FUNCTION__,
+        pDecInfo->frameBufPool[val].bufY, pDecInfo->frameBufPool[val].bufCb, pDecInfo->frameBufPool[val].bufCr, 
+        pDecInfo->stride, pDecInfo->stride_c);
     JpuWriteInstReg(instRegIndex, MJPEG_DPB_BASE00_REG, pDecInfo->frameBufPool[val].bufY);
     JpuWriteInstReg(instRegIndex, MJPEG_DPB_BASE01_REG, pDecInfo->frameBufPool[val].bufCb);
     JpuWriteInstReg(instRegIndex, MJPEG_DPB_BASE02_REG, pDecInfo->frameBufPool[val].bufCr);

+ 9 - 3
soft_3rdpart/codaj12/jpuapi/jpuapi.h

@@ -26,9 +26,15 @@
 #ifndef JPUAPI_H_INCLUDED
 #define JPUAPI_H_INCLUDED
 
-#include "jpuconfig.h"
-#include "../jdi/jdi.h"
-#include "jputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jpuconfig.h"
+    #include "codaj12/jdi/jdi.h"
+    #include "codaj12/jpuapi/jputypes.h"
+#else
+    #include "jpuconfig.h"
+    #include "../jdi/jdi.h"
+    #include "jputypes.h"
+#endif
 
 /* _n: number, _s: significance */
 #define JPU_CEIL(_s, _n)        (((_n)+(_s-1))&~(_s-1))

+ 5 - 1
soft_3rdpart/codaj12/jpuapi/jpuapifunc.h

@@ -26,7 +26,11 @@
 #ifndef JPUAPI_UTIL_H_INCLUDED
 #define JPUAPI_UTIL_H_INCLUDED
 
-#include "jpuapi.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jpuapi.h"
+#else
+    #include "jpuapi.h"
+#endif
 
 #define DC_TABLE_INDEX0				0
 #define AC_TABLE_INDEX0				1

+ 5 - 1
soft_3rdpart/codaj12/jpuapi/jpuconfig.h

@@ -25,7 +25,11 @@
 #ifndef _JPU_CONFIG_H_
 #define _JPU_CONFIG_H_
 
-#include "../config.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/config.h"
+#else
+    #include "../config.h"
+#endif
 
 #define MAX_NUM_JPU_CORE                1
 #define MAX_NUM_INSTANCE                4

+ 5 - 1
soft_3rdpart/codaj12/jpuapi/regdefine.h

@@ -22,8 +22,12 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-#include "../config.h"
 
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/config.h"
+#else
+    #include "../config.h"
+#endif
 
 #ifndef NPT_REGDEFINE_H_INCLUDED
 #define NPT_REGDEFINE_H_INCLUDED

+ 41 - 10
soft_3rdpart/codaj12/sample/helper/bitstreamfeeder.c

@@ -45,6 +45,11 @@ extern void* BSFeederFrameSize_Create(const char* path);
 extern BOOL BSFeederFrameSize_Destroy(void* feeder);
 extern Int32 BSFeederFrameSize_Act(void* feeder, BSChunk* packet);
 
+extern void* BSFeederBuffer_Create(const char* path);
+extern BOOL BSFeederBuffer_Destroy(void* feeder);
+extern Int32 BSFeederBuffer_Act(void* feeder,BSChunk* chunk);
+extern BOOL BSFeederBuffer_Rewind(void* feeder);
+extern void BSFeederBuffer_SetFeedingSize(void* feeder,Uint32 feedingSize);
 /**
 * Abstract Bitstream Feeader Functions 
 */
@@ -61,6 +66,11 @@ BSFeeder BitstreamFeeder_Create(const char* path, FeedingMethod method, EndianMo
     case FEEDING_METHOD_FRAME_SIZE:
         feeder = BSFeederFrameSize_Create(path);
         break;
+#endif
+#ifdef USE_FEEDING_METHOD_BUFFER
+    case FEEDING_METHOD_BUFFER:
+        feeder = BSFeederBuffer_Create(path);
+        break;
 #endif
     default:
         feeder = NULL;
@@ -83,6 +93,15 @@ BSFeeder BitstreamFeeder_Create(const char* path, FeedingMethod method, EndianMo
     return (BSFeeder)handle;
 }
 
+Uint32 BitstreamFeeder_SetData(BSFeeder feeder, void *data, Uint32 size)
+{
+    BitstreamFeeder* bsf = (BitstreamFeeder*)feeder;
+    bsf->remainData = data;
+    bsf->remainDataSize = size;
+
+    return 0;
+}
+
 Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* bsBuffer)
 {
     BitstreamFeeder* bsf = (BitstreamFeeder*)feeder;
@@ -98,9 +117,9 @@ Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* b
     }
 
     JPU_DecGetBitstreamBuffer(handle, NULL/* rdPtr */, &wrPtr, &room);
-
+    JLOG(INFO, "wrptr address = %x\r\n", wrPtr);
     endian = bsf->endian;
-
+    JLOG(INFO, "endian = %d\r\n", endian);
     if (bsf->remainData == NULL) {
         chunk.size = bsBuffer->size; 
         chunk.data = malloc(chunk.size);
@@ -117,6 +136,11 @@ Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* b
         case FEEDING_METHOD_FRAME_SIZE:
             feedingSize = BSFeederFrameSize_Act(bsf->actualFeeder, &chunk);
             break;
+#endif
+#ifdef USE_FEEDING_METHOD_BUFFER
+        case FEEDING_METHOD_BUFFER:
+            feedingSize = BSFeederBuffer_Act(bsf->actualFeeder, &chunk);
+            break;
 #endif
         default:
             JLOG(ERR, "%s:%d Invalid method(%d)\n", __FUNCTION__, __LINE__, bsf->method);
@@ -125,6 +149,7 @@ Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* b
         }
     }
     else {
+        JLOG(INFO, "Get data from remain\r\n");
         chunk.data  = bsf->remainData;
         feedingSize = bsf->remainDataSize;
     }
@@ -161,11 +186,12 @@ Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* b
             rightSize = endAddr-wrPtr;
             leftSize  = (wrPtr+wSize) - endAddr;
             if (rightSize > 0) {
+                JLOG(INFO, "1 wrptr address = %x, addr = %p, size = %x\r\n", wrPtr, ptr, rightSize);
                 JpuWriteMem(wrPtr, ptr, rightSize, (int)endian);
             }
             wrPtr = base;
         }
-
+        JLOG(INFO, "2 wrptr address = %x, ptr = %p, rightsize = %x, size = %x\r\n", wrPtr, ptr, rightSize, leftSize);
         JpuWriteMem(wrPtr, ptr+rightSize, leftSize, (int)endian);
 
         JPU_DecUpdateBitstreamBuffer(handle, wSize);
@@ -174,11 +200,11 @@ Uint32 BitstreamFeeder_Act(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t* b
     if (TRUE == chunk.eos) {
         JPU_DecUpdateBitstreamBuffer(handle, 0);
     }
-
+    JLOG(INFO, "bsf->remainData = %p, chunk.data = %p\r\n", bsf->remainData, chunk.data);
     bsf->eos = chunk.eos;
-    if (NULL == bsf->remainData) 
-        free(chunk.data);
-
+    // if (NULL == bsf->remainData) 
+    //     free(chunk.data);
+    JLOG(INFO, "%s out\r\n", __FUNCTION__);
     return feedingSize;
 }
 
@@ -210,15 +236,20 @@ BOOL BitstreamFeeder_Destroy(BSFeeder feeder)
     case FEEDING_METHOD_FRAME_SIZE:
         BSFeederFrameSize_Destroy(bsf->actualFeeder);
         break;
+#endif
+#ifdef USE_FEEDING_METHOD_BUFFER
+    case FEEDING_METHOD_BUFFER:
+        BSFeederBuffer_Destroy(bsf->actualFeeder);
+        break;
 #endif
     default:
         JLOG(ERR, "%s:%d Invalid method(%d)\n", __FUNCTION__, __LINE__, bsf->method);
         break;
     }
 
-    if (bsf->remainData) {
-        free(bsf->remainData);
-    }
+    // if (bsf->remainData) {
+    //     free(bsf->remainData);
+    // }
 
     free(bsf);
 

+ 121 - 0
soft_3rdpart/codaj12/sample/helper/bsfeeder_buffer_impl.c

@@ -0,0 +1,121 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <errno.h>
+
+#include "jpuapifunc.h"
+#include "main_helper.h"
+
+#define MAX_FEEDING_SIZE 0x400000    /* 4MBytes */
+#define DEFAULT_FEEDING_SIZE 0x20000 /* 128KBytes */
+
+typedef struct FeederFixedContext
+{
+    void *address;
+    Uint32 size;
+    Uint32 offset;
+    Uint32 feedingSize;
+    BOOL eos;
+} FeederFixedContext;
+
+void *BSFeederBuffer_Create(const char *path)
+{
+    FeederFixedContext *context = NULL;
+
+    context = (FeederFixedContext *)malloc(sizeof(FeederFixedContext));
+    if (context == NULL)
+    {
+        JLOG(ERR, "%s:%d failed to allocate memory\n", __FUNCTION__, __LINE__);
+        return NULL;
+    }
+
+    context->feedingSize = DEFAULT_FEEDING_SIZE;
+    context->eos = FALSE;
+    context->offset = 0;
+    return (void *)context;
+}
+
+BOOL BSFeederBuffer_Destroy(void *feeder)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+
+    if (context == NULL)
+    {
+        JLOG(ERR, "%s:%d Null handle\n", __FUNCTION__, __LINE__);
+        return FALSE;
+    }
+
+    free(context);
+
+    return TRUE;
+}
+
+void BSFeederBuffer_SetData(
+    void *feeder,
+    char *address,
+    Uint32 size)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+    context->address = address;
+    context->size = size;
+}
+
+void BSFeederBuffer_SetEos(void *feeder)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+    context->eos = TRUE;
+}
+
+BOOL BSFeederBuffer_GetEos(void *feeder)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+    return context->eos;
+}
+
+Int32 BSFeederBuffer_Act(
+    void *feeder,
+    BSChunk *chunk)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+
+    if (context == NULL)
+    {
+        JLOG(ERR, "%s:%d Null handle\n", __FUNCTION__, __LINE__);
+        return 0;
+    }
+    // Due to memory performance, memset is temporarily commented
+    // memset(chunk->data, 0x00, chunk->size);
+    if (context->size == 0)
+    {
+        chunk->eos = TRUE;
+        return 0;
+    }
+
+    do
+    {
+        memcpy(chunk->data, context->address, context->size);
+    } while (FALSE);
+
+    return context->size;
+}
+
+BOOL BSFeederBuffer_Rewind(
+    void *feeder)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+
+    context->eos = FALSE;
+
+    return TRUE;
+}
+
+void BSFeederBuffer_SetFeedingSize(
+    void *feeder,
+    Uint32 feedingSize)
+{
+    FeederFixedContext *context = (FeederFixedContext *)feeder;
+    if (feedingSize > 0)
+    {
+        context->feedingSize = feedingSize;
+    }
+}

+ 5 - 1
soft_3rdpart/codaj12/sample/helper/cnm_fpga.h

@@ -26,7 +26,11 @@
 #ifndef CNM_FPGA_H_INCLUDED
 #define CNM_FPGA_H_INCLUDED
 
-#include "jputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jputypes.h"
+#else
+    #include "jputypes.h"
+#endif
 
 #ifdef __cplusplus
 extern "C" {

+ 7 - 2
soft_3rdpart/codaj12/sample/helper/datastructure.h

@@ -25,8 +25,13 @@
 #ifndef __DATA_STRUCTURE_H__
 #define __DATA_STRUCTURE_H__
 
-#include "jputypes.h"
-#include "platform.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jputypes.h"
+    #include "codaj12/sample/helper/platform.h"
+#else
+    #include "jputypes.h"
+    #include "platform.h"
+#endif
 
 #ifdef __cplusplus
 extern "C" {

+ 119 - 1
soft_3rdpart/codaj12/sample/helper/jpuhelper.c

@@ -33,7 +33,7 @@
 #include "jpulog.h"
 #include "main_helper.h"
 
-static fb_context s_fb[MAX_NUM_INSTANCE];
+fb_context s_fb[MAX_NUM_INSTANCE];
 
 static int StoreYuvImageBurstFormat_V20(int chromaStride, Uint8 * dst, int picWidth, int picHeight, Uint32 bitDepth,Uint64 addrY, Uint64 addrCb, Uint64 addrCr, Uint32 stride, FrameFormat format, int endian, CbCrInterLeave interLeave, PackedFormat packed);
 // Figure A.6 - Zig-zag sequence of quantized DCT coefficients
@@ -1119,6 +1119,117 @@ BOOL AllocateFrameBuffer(Uint32 instIdx, FrameFormat subsample, CbCrInterLeave c
     return TRUE;
 }
 
+BOOL UpdateFrameBuffers(Uint32 instIdx, Uint32 num, FRAME_BUF *frameBuf)
+{
+    fb_context *fb = &s_fb[instIdx];
+    Uint32 index = num - 1;
+    fb->last_num = num;
+    fb->last_addr = frameBuf[index].vbY.phys_addr;
+    fb->last_addr += fb->frameBuf[index].vbCb.size;
+    fb->last_addr = JPU_CEIL(8, fb->last_addr);
+    fb->last_addr += fb->frameBuf[index].vbCr.size;
+    fb->last_addr = JPU_CEIL(8, fb->last_addr);
+    JLOG(INFO, "%s: Update %d buffers\r\n",__FUNCTION__, num);
+    memcpy(fb->frameBuf, frameBuf, sizeof(FRAME_BUF) * num);
+    return TRUE;
+}
+
+void *AllocateOneFrameBuffer(Uint32 instIdx, FrameFormat subsample, CbCrInterLeave cbcrIntlv, PackedFormat packed,
+                         Uint32 rotation, BOOL scalerOn, Uint32 width, Uint32 height, Uint32 bitDepth, Uint32 *bufferIndex)
+{
+    fb_context *fb;
+    Uint32  fbLumaStride, fbLumaHeight, fbChromaStride, fbChromaHeight;
+    Uint32  fbLumaSize, fbChromaSize, fbSize;
+    Uint32  i;
+    Uint32  bytePerPixel = (bitDepth + 7)/8;
+    void * virt_addr = NULL;
+
+    JLOG(INFO, "%s function in width, height = [%d, %d]\r\n", __FUNCTION__, width, height);
+    if (rotation == 90 || rotation == 270) {
+        if (subsample == FORMAT_422) subsample = FORMAT_440;
+        else if (subsample == FORMAT_440) subsample = FORMAT_422;
+    }
+
+    GetFrameBufStride(subsample, cbcrIntlv, packed, scalerOn, width, height, bytePerPixel, &fbLumaStride, &fbLumaHeight, &fbChromaStride, &fbChromaHeight);
+    fbLumaSize   = fbLumaStride * fbLumaHeight;
+    fbChromaSize = fbChromaStride * fbChromaHeight;
+
+    if (cbcrIntlv == CBCR_SEPARATED) {
+        /* fbChromaSize MUST be zero when format is packed mode */
+        fbSize = fbLumaSize + 2*fbChromaSize;
+
+    }
+    else {
+        /* Semi-planar */
+        fbSize = fbLumaSize + fbChromaSize;
+    }
+
+    if (fbSize == 0)
+    {
+        switch (subsample)
+        {
+        case FORMAT_420:
+            fbSize = width * height * 3 / 2;
+            break;
+        case FORMAT_422:
+        case FORMAT_440:
+            fbSize = width * height * 2;
+        case FORMAT_444:
+            fbSize = width * height * 3;
+            /* code */
+            break;
+        default:
+            break;
+        }
+        JLOG(WARN, "%s: fbSize == 0! Use defalut size %d\r\n", __FUNCTION__, fbSize);
+    }
+
+    fb = &s_fb[instIdx];
+    fb->vb_base.size = fbSize;
+    if (jdi_allocate_dma_memory(&fb->vb_base) < 0) {
+        JLOG(ERR, "Fail to allocate frame buffer size=%d\n", fb->vb_base.size);
+        return NULL;
+    }
+    fb->last_addr = fb->vb_base.phys_addr;
+
+    i = fb->last_num;
+    JLOG(INFO, "%s: store on index %d\r\n", __FUNCTION__, i);
+    fb->frameBuf[i].Format = subsample;
+    fb->frameBuf[i].Index  = i;
+    fb->frameBuf[i].vbY.phys_addr = fb->vb_base.phys_addr;
+    fb->frameBuf[i].vbY.size = fbLumaSize;
+    // Store virt addr
+    fb->frameBuf[i].vbY.virt_addr = fb->vb_base.virt_addr;
+    
+    fb->last_addr += fb->frameBuf[i].vbY.size;
+    fb->last_addr = JPU_CEIL(8, fb->last_addr);
+    JLOG(INFO, "%s: fbChromaSize = %d, fbLumaSize = %d\r\n", __FUNCTION__, fbChromaSize, fbLumaSize);
+    if (fbChromaSize) {
+        fb->frameBuf[i].vbCb.phys_addr = fb->last_addr;
+        fb->frameBuf[i].vbCb.size = fbChromaSize;
+
+        fb->last_addr += fb->frameBuf[i].vbCb.size;
+        fb->last_addr = JPU_CEIL(8, fb->last_addr);
+
+        fb->frameBuf[i].vbCr.phys_addr = (cbcrIntlv == CBCR_SEPARATED) ? fb->last_addr : 0;
+        fb->frameBuf[i].vbCr.size      = (cbcrIntlv == CBCR_SEPARATED) ? fbChromaSize  : 0;
+
+        fb->last_addr += fb->frameBuf[i].vbCr.size;
+        fb->last_addr = JPU_CEIL(8, fb->last_addr);
+    }
+
+    fb->frameBuf[i].strideY = fbLumaStride;
+    fb->frameBuf[i].strideC = fbChromaStride;
+
+    *bufferIndex = fb->last_num;
+    fb->last_num += 1;
+
+    virt_addr = (void *)fb->vb_base.virt_addr;
+
+    JLOG(INFO, "%s function OUT, number = %d, return = %p\r\n", __FUNCTION__, fb->last_num, virt_addr);
+    return virt_addr;
+}
+
 int GetDPBBufSize(int framebufFormat, int picWidth, int picHeight, int picWidth_C, int interleave)
 {
     int framebufSize = 0;
@@ -1517,6 +1628,13 @@ FRAME_BUF *GetFrameBuffer(int instIdx, int idx)
     return &fb->frameBuf[idx];
 }
 
+Uint32 GetFrameBufferCount(int instIdx)
+{
+    fb_context *fb;
+    fb = &s_fb[instIdx];
+    return fb->last_num;
+}
+
 FRAME_BUF* FindFrameBuffer(int instIdx, PhysicalAddress addrY)
 {
     int i;

+ 5 - 1
soft_3rdpart/codaj12/sample/helper/jpulog.h

@@ -25,7 +25,11 @@
 #ifndef _LOG_H_
 #define _LOG_H_
 
-#include "jputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jputypes.h"
+#else
+    #include "jputypes.h"
+#endif
 
 
 

+ 5 - 1
soft_3rdpart/codaj12/sample/helper/platform.h

@@ -25,7 +25,11 @@
 #ifndef __JPU_PLATFORM_H__
 #define __JPU_PLATFORM_H__
 
-#include "jputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jputypes.h"
+#else
+    #include "jputypes.h"
+#endif
 /************************************************************************/
 /* JpuMutex                                                                */
 /************************************************************************/

+ 8 - 2
soft_3rdpart/codaj12/sample/helper/yuv_feeder.h

@@ -25,8 +25,14 @@
 #ifndef __JPU_YUV_FEEDER_H__
 #define __JPU_YUV_FEEDER_H__
 
-#include "jpuapi.h"
-#include "datastructure.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jpuapi.h"
+    #include "codaj12/sample/helper/datastructure.h"
+#else
+    #include "jpuapi.h"
+    #include "datastructure.h"
+#endif
+
 
 #define SOURCE_YUV                  0
 

+ 14 - 4
soft_3rdpart/codaj12/sample/main_helper.h

@@ -26,10 +26,17 @@
 #ifndef JPUHELPER_H_INCLUDED
 #define JPUHELPER_H_INCLUDED
 
-#include "jpulog.h"
-#include "jpuapi.h"
-#include "cnm_fpga.h"
-#include "yuv_feeder.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "codaj12/jpuapi/jpuapi.h"
+    #include "codaj12/sample/helper/jpulog.h"
+    #include "codaj12/sample/helper/cnm_fpga.h"
+    #include "codaj12/sample/helper/yuv_feeder.h"
+#else
+    #include "jpulog.h"
+    #include "jpuapi.h"
+    #include "cnm_fpga.h"
+    #include "yuv_feeder.h"
+#endif
 
 #define MAX_FILE_PATH    256
 
@@ -54,6 +61,9 @@ typedef struct {
 typedef enum {
     FEEDING_METHOD_FIXED_SIZE,
     FEEDING_METHOD_FRAME_SIZE,      /*!<< use FFMPEG demuxer */
+#ifdef USE_FEEDING_METHOD_BUFFER
+    FEEDING_METHOD_BUFFER,
+#endif
     FEEDING_METHOD_MAX
 } FeedingMethod;
 

+ 30 - 8
soft_3rdpart/omx-il/Makefile

@@ -21,13 +21,22 @@ AR  = $(CROSS_CC_PREFIX)ar
 DEFINES = -DUSE_FEEDING_METHOD_BUFFER
 INCLUDES = -I./include/khronos -I./core -I./component/video/common
 $(warning "the value of LOCAL_PATH is$(STAGING_DIR)")
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component/
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component_encoder/
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component_decoder/
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/vpuapi/
-INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/helper/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component_encoder/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/component_decoder/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/vpuapi/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/wave511/sample_v2/helper/
 INCLUDES += -I$(STAGING_DIR)/usr/include/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/codaj12/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/codaj12/jpuapi/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/codaj12/linux/driver/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/codaj12/sample/
+# INCLUDES += -I$(STAGING_DIR)/usr/include/codaj12/sample/helper/
+
+
+#mjpeg
+INCLUDES += -I./component/image/common
 
 CFLAGS  += -g -I. -Wno-implicit-function-declaration -Wno-format -Wl,--fatal-warning $(INCLUDES) $(DEFINES) $(PLATFORM_FLAGS)
 CFLAGS  += -fpic
@@ -43,9 +52,12 @@ RM=rm -f
 MKDIR=mkdir -p
 SOURCES_COMMON = SF_OMX_Core.c SF_OMX_video_common.c 
 SOURCES_COMMON += SF_OMX_Vdec_decoder.c SF_OMX_Venc_encoder.c
+#mjpeg
+SOURCES_COMMON += SF_OMX_mjpeg_common.c SF_OMX_Mjpeg_decoder.c
 #test
 SOURCES_DEC_TEST = dec_test.c
 SOURCES_ENC_TEST = enc_test.c
+MJPET_SOURCES_DEC_TEST = mjpeg_dec_test.c
 
 VPATH  = component/video/common:
 VPATH += component/video/enc:
@@ -53,6 +65,10 @@ VPATH += component/video/dec:
 VPATH += core:
 VPATH += tests:
 
+#mjpeg
+VPATH += component/image/common:
+VPATH += component/image/dec:
+
 OBJECTNAMES_COMMON=$(patsubst %.c,%.o,$(SOURCES_COMMON))
 OBJECTPATHS_COMMON=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_COMMON)))
 OBJECTNAMES_DEC_TEST=$(patsubst %.c,%.o,$(SOURCES_DEC_TEST))
@@ -60,12 +76,15 @@ OBJECTPATHS_DEC_TEST=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_DEC_TEST)))
 OBJECTNAMES_ENC_TEST=$(patsubst %.c,%.o,$(SOURCES_ENC_TEST))
 OBJECTPATHS_ENC_TEST=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_ENC_TEST)))
 
+OBJECTNAMES_MJPEG_DEC_TEST=$(patsubst %.c,%.o,$(MJPET_SOURCES_DEC_TEST))
+OBJECTPATHS_MJPEG_DEC_TEST=$(addprefix $(OBJDIR)/,$(notdir $(OBJECTNAMES_MJPEG_DEC_TEST)))
+
 all: omx-il
 
 omx-il: CREATE_DIR $(OBJECTPATHS_COMMON)
-	$(CC) -fPIC -shared -o libsf-omx-il.so $(LDFLAGS) $(OBJECTPATHS_COMMON)
+	$(CC) -g -fPIC -shared -o libsf-omx-il.so $(LDFLAGS) $(OBJECTPATHS_COMMON)
 
-test: video-dec-test video-enc-test
+test: video-dec-test video-enc-test mjpeg-dec-test
 
 video-dec-test: CREATE_DIR $(OBJECTPATHS_DEC_TEST)
 	$(CC) -o video_dec_test $(LDFLAGS) $(LDFLAGS_FFMPEG) -lsf-omx-il $(OBJECTPATHS_DEC_TEST) -L./
@@ -73,6 +92,9 @@ video-dec-test: CREATE_DIR $(OBJECTPATHS_DEC_TEST)
 video-enc-test: CREATE_DIR $(OBJECTPATHS_ENC_TEST)
 	$(CC) -o video_enc_test $(LDFLAGS) $(LDFLAGS_FFMPEG) -lsf-omx-il $(OBJECTPATHS_ENC_TEST) -L./
 
+mjpeg-dec-test: CREATE_DIR $(OBJECTPATHS_MJPEG_DEC_TEST)
+	$(CC) -g -o mjpeg_dec_test $(LDFLAGS) $(LDFLAGS_FFMPEG) -lsf-omx-il $(OBJECTPATHS_MJPEG_DEC_TEST) -L./
+
 clean:
 
 CREATE_DIR:

+ 443 - 0
soft_3rdpart/omx-il/component/image/common/SF_OMX_mjpeg_common.c

@@ -0,0 +1,443 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 StarFive Technology Co., Ltd.
+ */
+#include "SF_OMX_mjpeg_common.h"
+
+static void sf_get_component_functions(SF_CODAJ12_FUNCTIONS *funcs, OMX_PTR *sohandle);
+
+OMX_ERRORTYPE GetStateMjpegCommon(OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATETYPE *pState)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = NULL;
+    SF_OMX_COMPONENT *pSfOMXComponent = NULL;
+    OMX_STATETYPE nextState;
+
+    FunctionIn();
+
+EXIT:
+    FunctionOut();
+    return ret;
+}
+
+OMX_ERRORTYPE InitMjpegStructorCommon(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    char *strDebugLevel = NULL;
+    int debugLevel = 0;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = NULL;
+
+    FunctionIn();
+    if (pSfOMXComponent == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    pSfOMXComponent->pOMXComponent = malloc(sizeof(OMX_COMPONENTTYPE));
+    if (pSfOMXComponent->pOMXComponent == NULL)
+    {
+        ret = OMX_ErrorInsufficientResources;
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
+        goto ERROR;
+    }
+    memset(pSfOMXComponent->pOMXComponent, 0, sizeof(OMX_COMPONENTTYPE));
+
+    pSfOMXComponent->soHandle = dlopen(pSfOMXComponent->libName, RTLD_NOW);
+    if (pSfOMXComponent->soHandle == NULL)
+    {
+        ret = OMX_ErrorInsufficientResources;
+        LOG(SF_LOG_ERR, "could not open %s, error: %s\r\n", pSfOMXComponent->libName, dlerror());
+        goto ERROR;
+    }
+
+    pSfOMXComponent->componentImpl = malloc(sizeof(SF_CODAJ12_IMPLEMEMT));
+    if (pSfOMXComponent->componentImpl == NULL)
+    {
+        ret = OMX_ErrorInsufficientResources;
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
+        goto ERROR;
+    }
+    memset(pSfOMXComponent->componentImpl, 0, sizeof(SF_CODAJ12_IMPLEMEMT));
+
+    pSfCodaj12Implement = (SF_CODAJ12_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    pSfCodaj12Implement->functions = malloc(sizeof(SF_CODAJ12_FUNCTIONS));
+    pSfCodaj12Implement->currentState = OMX_StateLoaded;
+    pSfCodaj12Implement->frameFormat = DEFAULT_FRAME_FORMAT;
+    if (pSfCodaj12Implement->functions == NULL)
+    {
+        ret = OMX_ErrorInsufficientResources;
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
+        goto ERROR;
+    }
+    memset(pSfCodaj12Implement->functions, 0, sizeof(SF_CODAJ12_FUNCTIONS));
+    sf_get_component_functions(pSfCodaj12Implement->functions, pSfOMXComponent->soHandle);
+
+    if (strstr(pSfOMXComponent->componentName, "sf.dec") != NULL)
+    {
+        pSfCodaj12Implement->config = malloc(sizeof(DecConfigParam));
+        if (pSfCodaj12Implement->config == NULL)
+        {
+            ret = OMX_ErrorInsufficientResources;
+            LOG(SF_LOG_ERR, "malloc fail\r\n");
+            goto ERROR;
+        }
+        memset(pSfCodaj12Implement->config, 0, sizeof(DecConfigParam));
+    }
+    else
+    {
+        ret = OMX_ErrorBadParameter;
+        LOG(SF_LOG_ERR, "unknown component!\r\n");
+        goto ERROR;
+    }
+
+    pSfOMXComponent->pOMXComponent->pComponentPrivate = pSfOMXComponent;
+
+    pSfCodaj12Implement->sInputMessageQueue = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+    if (pSfCodaj12Implement->sInputMessageQueue < 0)
+    {
+        LOG(SF_LOG_ERR, "get ipc_id error");
+        return;
+    }
+    pSfCodaj12Implement->sOutputMessageQueue = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+    if (pSfCodaj12Implement->sOutputMessageQueue < 0)
+    {
+        LOG(SF_LOG_ERR, "get ipc_id error");
+        return;
+    }
+
+    for (int i = 0; i < 2; i++)
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &pSfOMXComponent->portDefinition[i];
+
+        // OMX_IMAGE_PARAM_PORTFORMATTYPE * imagePortFormat = &pSfOMXComponent->MJPEGComponent[i];
+        // memset(&imagePortFormat, 0, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
+        // INIT_SET_SIZE_VERSION(imagePortFormat, OMX_PARAM_PORTDEFINITIONTYPE);
+        // imagePortFormat->nPortIndex = i;
+        // imagePortFormat->nIndex = 0; //TODO
+        // imagePortFormat->eCompressionFormat = OMX_IMAGE_CodingJPEG;
+        // imagePortFormat->eColorFormat = OMX_COLOR_FormatUnused;  //TODO
+
+        INIT_SET_SIZE_VERSION(pPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
+        // INIT_SET_SIZE_VERSION(pAVCComponent, OMX_VIDEO_PARAM_AVCTYPE);
+        // OMX_VIDEO_PARAM_AVCTYPE *pAVCComponent = &pSfOMXComponent->AVCComponent[i];
+        pPortDefinition->nPortIndex = i;
+        // pPortDefinition->nBufferCountActual = VPU_OUTPUT_BUF_NUMBER;
+        pPortDefinition->nBufferCountActual = (i == 0 ? CODAJ12_INPUT_BUF_NUMBER : CODAJ12_OUTPUT_BUF_NUMBER);
+        pPortDefinition->nBufferCountMin = (i == 0 ? CODAJ12_INPUT_BUF_NUMBER : CODAJ12_OUTPUT_BUF_NUMBER);
+        pPortDefinition->nBufferSize = (i == 0 ? DEFAULT_MJPEG_INPUT_BUFFER_SIZE : DEFAULT_MJPEG_OUTPUT_BUFFER_SIZE);
+        pPortDefinition->eDomain = OMX_PortDomainVideo;
+        // TODO happer
+        // pPortDefinition->format.image.pNativeWindow = 0x0;
+        pPortDefinition->format.image.nFrameWidth = DEFAULT_FRAME_WIDTH;
+        pPortDefinition->format.image.nFrameHeight = DEFAULT_FRAME_HEIGHT;
+        pPortDefinition->format.image.nStride = DEFAULT_FRAME_WIDTH;
+        pPortDefinition->format.image.nSliceHeight = DEFAULT_FRAME_HEIGHT;
+        pPortDefinition->format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
+        pPortDefinition->format.image.cMIMEType = malloc(OMX_MAX_STRINGNAME_SIZE);
+
+        if (pPortDefinition->format.image.cMIMEType == NULL)
+        {
+            ret = OMX_ErrorInsufficientResources;
+            free(pPortDefinition->format.image.cMIMEType);
+            pPortDefinition->format.image.cMIMEType = NULL;
+            LOG(SF_LOG_ERR, "malloc fail\r\n");
+            goto ERROR;
+        }
+        memset(pPortDefinition->format.image.cMIMEType, 0, OMX_MAX_STRINGNAME_SIZE);
+        pPortDefinition->format.image.pNativeRender = 0;
+        pPortDefinition->format.image.bFlagErrorConcealment = OMX_FALSE;
+        pPortDefinition->format.image.eColorFormat = OMX_COLOR_FormatUnused;
+        pPortDefinition->bEnabled = OMX_TRUE;
+
+        pPortDefinition->eDir = (i == 0 ? OMX_DirInput : OMX_DirOutput);
+    }
+
+    strcpy(pSfOMXComponent->portDefinition[1].format.image.cMIMEType, "JPEG");
+    pSfOMXComponent->portDefinition[1].format.image.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+
+    memset(pSfOMXComponent->pBufferArray, 0, sizeof(pSfOMXComponent->pBufferArray));
+    pSfOMXComponent->memory_optimization = OMX_TRUE;
+
+    FunctionOut();
+EXIT:
+    return ret;
+ERROR:
+    if (pSfOMXComponent->pOMXComponent)
+    {
+        free(pSfOMXComponent->pOMXComponent);
+        pSfOMXComponent->pOMXComponent = NULL;
+    }
+
+    return ret;
+}
+
+static void sf_get_component_functions(SF_CODAJ12_FUNCTIONS *funcs, OMX_PTR *sohandle)
+{
+    FunctionIn();
+    funcs->JPU_Init = dlsym(sohandle, "JPU_Init");
+    funcs->JPU_DecOpen = dlsym(sohandle, "JPU_DecOpen");
+    funcs->JPU_DecGetInitialInfo = dlsym(sohandle, "JPU_DecGetInitialInfo");
+    funcs->JPU_DecRegisterFrameBuffer2 = dlsym(sohandle, "JPU_DecRegisterFrameBuffer2");
+    funcs->JPU_DecRegisterFrameBuffer = dlsym(sohandle, "JPU_DecRegisterFrameBuffer");
+    funcs->JPU_DecGiveCommand = dlsym(sohandle, "JPU_DecGiveCommand");
+    funcs->JPU_DecStartOneFrame = dlsym(sohandle, "JPU_DecStartOneFrame");
+    funcs->JPU_DecGetOutputInfo = dlsym(sohandle, "JPU_DecGetOutputInfo");
+    funcs->JPU_SWReset = dlsym(sohandle, "JPU_SWReset");
+    funcs->JPU_DecSetRdPtrEx = dlsym(sohandle, "JPU_DecSetRdPtrEx");
+    funcs->JPU_DecClose = dlsym(sohandle, "JPU_DecClose");
+    funcs->JPU_WaitInterrupt = dlsym(sohandle, "JPU_WaitInterrupt");
+    funcs->JPU_GetFrameBufPool = dlsym(sohandle, "JPU_GetFrameBufPool");
+    funcs->JPU_ClrStatus = dlsym(sohandle, "JPU_ClrStatus");
+    funcs->JPU_DeInit = dlsym(sohandle, "JPU_DeInit");
+    funcs->BSFeederBuffer_SetData = dlsym(sohandle, "BSFeederBuffer_SetData");
+    funcs->BitstreamFeeder_SetData = dlsym(sohandle, "BitstreamFeeder_SetData");
+    funcs->BitstreamFeeder_Create = dlsym(sohandle, "BitstreamFeeder_Create");
+    funcs->BitstreamFeeder_Act = dlsym(sohandle, "BitstreamFeeder_Act");
+    funcs->BitstreamFeeder_Destroy = dlsym(sohandle, "BitstreamFeeder_Destroy");
+    funcs->jdi_allocate_dma_memory = dlsym(sohandle, "jdi_allocate_dma_memory");
+    funcs->jdi_free_dma_memory = dlsym(sohandle, "jdi_free_dma_memory");
+    funcs->AllocateOneFrameBuffer = dlsym(sohandle, "AllocateOneFrameBuffer");
+    funcs->FreeFrameBuffer = dlsym(sohandle, "FreeFrameBuffer");
+    funcs->GetFrameBuffer = dlsym(sohandle, "GetFrameBuffer");
+    funcs->GetFrameBufferCount = dlsym(sohandle, "GetFrameBufferCount");
+    funcs->UpdateFrameBuffers = dlsym(sohandle, "UpdateFrameBuffers");
+    FunctionOut();
+}
+
+OMX_U8 *AllocateOutputBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_U32 nSizeBytes)
+{
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    Int32 instIdx = pSfCodaj12Implement->instIdx;
+    JpgDecOpenParam *decOP = &pSfCodaj12Implement->decOP;
+    DecConfigParam *decConfig = pSfCodaj12Implement->config;
+    JpgDecInitialInfo *initialInfo = &pSfCodaj12Implement->initialInfo;
+    FrameBuffer *pFrameBuf = &pSfCodaj12Implement->frameBuf;
+    JpgDecHandle handle = pSfCodaj12Implement->handle;
+
+    Uint32 framebufWidth = 0, framebufHeight = 0, framebufStride = 0;
+    Uint32 decodingWidth, decodingHeight;
+    BOOL scalerOn = FALSE;
+    Uint32 bitDepth = 0;
+    FrameFormat subsample;
+    Uint32 temp;
+    OMX_U8 *virtAddr;
+    Uint32 bufferIndex;
+    JpgRet jpgret;
+
+    FunctionIn();
+    if (initialInfo->sourceFormat == FORMAT_420 || initialInfo->sourceFormat == FORMAT_422)
+        framebufWidth = JPU_CEIL(16, initialInfo->picWidth);
+    else
+        framebufWidth = JPU_CEIL(8, initialInfo->picWidth);
+
+    if (initialInfo->sourceFormat == FORMAT_420 || initialInfo->sourceFormat == FORMAT_440)
+        framebufHeight = JPU_CEIL(16, initialInfo->picHeight);
+    else
+        framebufHeight = JPU_CEIL(8, initialInfo->picHeight);
+
+    if (framebufWidth == 0 || framebufHeight == 0)
+    {
+        LOG(SF_LOG_WARN, "width or height == 0, use port parameters\r\n");
+        for (int i = 0; i < OMX_PORT_MAX; i ++)
+        {
+            OMX_PARAM_PORTDEFINITIONTYPE *pPort = &pSfOMXComponent->portDefinition[i];
+            framebufWidth = pPort->format.video.nFrameWidth;
+            framebufHeight = pPort->format.video.nFrameHeight;
+            if (framebufWidth > 0 && framebufHeight > 0)
+            {
+                LOG(SF_LOG_INFO, "Use port: %d\r\n", i);
+                break;
+            }
+        }
+        if (framebufWidth == 0 || framebufHeight == 0)
+        {
+            LOG(SF_LOG_ERR, "Can not get frame size\r\n");
+            return NULL;
+        }
+    }
+    LOG(SF_LOG_DEBUG, "framebufWidth: %d, framebufHeight: %d\r\n", framebufWidth, framebufHeight);
+
+    decodingWidth = framebufWidth >> decConfig->iHorScaleMode;
+    decodingHeight = framebufHeight >> decConfig->iVerScaleMode;
+    if (decOP->packedFormat != PACKED_FORMAT_NONE && decOP->packedFormat != PACKED_FORMAT_444)
+    {
+        // When packed format, scale-down resolution should be multiple of 2.
+        decodingWidth = JPU_CEIL(2, decodingWidth);
+    }
+
+    subsample = pSfCodaj12Implement->frameFormat;
+    temp = decodingWidth;
+    decodingWidth = (decConfig->rotation == 90 || decConfig->rotation == 270) ? decodingHeight : decodingWidth;
+    decodingHeight = (decConfig->rotation == 90 || decConfig->rotation == 270) ? temp : decodingHeight;
+    if (decConfig->roiEnable == TRUE)
+    {
+        decodingWidth = framebufWidth = initialInfo->roiFrameWidth;
+        decodingHeight = framebufHeight = initialInfo->roiFrameHeight;
+    }
+
+    LOG(SF_LOG_DEBUG, "decodingWidth: %d, decodingHeight: %d\n", decodingWidth, decodingHeight);
+
+    if (decOP->rotation != 0 || decOP->mirror != MIRDIR_NONE)
+    {
+        if (decOP->outputFormat != FORMAT_MAX && decOP->outputFormat != initialInfo->sourceFormat)
+        {
+            LOG(SF_LOG_ERR, "The rotator cannot work with the format converter together.\n");
+            return NULL;
+        }
+    }
+
+    LOG(SF_LOG_INFO, "<INSTANCE %d>\n", instIdx);
+    LOG(SF_LOG_INFO, "SOURCE PICTURE SIZE : W(%d) H(%d)\n", initialInfo->picWidth, initialInfo->picHeight);
+    LOG(SF_LOG_INFO, "SUBSAMPLE           : %d\n", subsample);
+
+    bitDepth = initialInfo->bitDepth;
+    scalerOn = (BOOL)(decConfig->iHorScaleMode || decConfig->iVerScaleMode);
+    // may be handle == NULL on ffmpeg case
+    if (bitDepth == 0)
+    {
+        bitDepth = 8;
+    }
+    LOG(SF_LOG_DEBUG, "AllocateOneFrameBuffer\r\n");
+    LOG_APPEND(SF_LOG_DEBUG, "instIdx = %d subsample = %d chromaInterleave = %d packedFormat = %d rotation = %d\r\n",
+                instIdx, subsample, decOP->chromaInterleave, decOP->packedFormat, decConfig->rotation);
+    LOG_APPEND(SF_LOG_DEBUG, "scalerOn = %d decodingWidth = %d decodingHeight = %d bitDepth = %d\r\n",
+                scalerOn, decodingWidth, decodingHeight, bitDepth);
+    virtAddr = (OMX_U8 *)pSfCodaj12Implement->functions->AllocateOneFrameBuffer
+        (instIdx, subsample, decOP->chromaInterleave, decOP->packedFormat, decConfig->rotation,
+        scalerOn, decodingWidth, decodingHeight, bitDepth, &bufferIndex);
+    if (virtAddr == NULL)
+    {
+        LOG(SF_LOG_ERR, "Failed to AllocateOneFrameBuffer()\n");
+        return NULL;
+    }
+    LOG(SF_LOG_INFO, "Allocate frame buffer %p, index = %d\r\n", virtAddr, bufferIndex);
+
+    //Register frame buffer
+    FRAME_BUF *pFrame = pSfCodaj12Implement->functions->GetFrameBuffer(instIdx, bufferIndex);
+    memcpy(&pSfCodaj12Implement->frame[bufferIndex], pFrame, sizeof(FRAME_BUF));
+    pFrameBuf[bufferIndex].bufY = pFrame->vbY.phys_addr;
+    pFrameBuf[bufferIndex].bufCb = pFrame->vbCb.phys_addr;
+    if (decOP->chromaInterleave == CBCR_SEPARATED)
+        pFrameBuf[bufferIndex].bufCr = pFrame->vbCr.phys_addr;
+    pFrameBuf[bufferIndex].stride = pFrame->strideY;
+    pFrameBuf[bufferIndex].strideC = pFrame->strideC;
+    pFrameBuf[bufferIndex].endian = decOP->frameEndian;
+    pFrameBuf[bufferIndex].format = (FrameFormat)pFrame->Format;
+    framebufStride = pFrameBuf[bufferIndex].stride;
+
+    // may be handle == NULL on ffmpeg case
+    jpgret = pSfCodaj12Implement->functions->JPU_DecRegisterFrameBuffer2(handle, &pFrameBuf[bufferIndex], framebufStride);
+    LOG(SF_LOG_DEBUG, "JPU_DecRegisterFrameBuffer2 ret = %d\r\n", jpgret);
+    FunctionOut();
+    return virtAddr;
+}
+
+OMX_ERRORTYPE CreateThread(OMX_HANDLETYPE *threadHandle, OMX_PTR function_name, OMX_PTR argument)
+{
+    FunctionIn();
+
+    int result = 0;
+    int detach_ret = 0;
+    THREAD_HANDLE_TYPE *thread;
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    thread = malloc(sizeof(THREAD_HANDLE_TYPE));
+    memset(thread, 0, sizeof(THREAD_HANDLE_TYPE));
+
+    pthread_attr_init(&thread->attr);
+    if (thread->stack_size != 0)
+        pthread_attr_setstacksize(&thread->attr, thread->stack_size);
+
+    /* set priority */
+    if (thread->schedparam.sched_priority != 0)
+        pthread_attr_setschedparam(&thread->attr, &thread->schedparam);
+
+    detach_ret = pthread_attr_setdetachstate(&thread->attr, PTHREAD_CREATE_JOINABLE);
+    if (detach_ret != 0)
+    {
+        free(thread);
+        *threadHandle = NULL;
+        ret = OMX_ErrorUndefined;
+        goto EXIT;
+    }
+
+    result = pthread_create(&thread->pthread, &thread->attr, function_name, (void *)argument);
+    /* pthread_setschedparam(thread->pthread, SCHED_RR, &thread->schedparam); */
+
+    switch (result)
+    {
+    case 0:
+        *threadHandle = (OMX_HANDLETYPE)thread;
+        ret = OMX_ErrorNone;
+        break;
+    case EAGAIN:
+        free(thread);
+        *threadHandle = NULL;
+        ret = OMX_ErrorInsufficientResources;
+        break;
+    default:
+        free(thread);
+        *threadHandle = NULL;
+        ret = OMX_ErrorUndefined;
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+void ThreadExit(void *value_ptr)
+{
+    pthread_exit(value_ptr);
+    return;
+}
+
+void CodaJ12FlushBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_U32 nPortNumber)
+{
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    Message data;
+    OMX_BUFFERHEADERTYPE *pOMXBuffer = NULL;
+
+    FunctionIn();
+    switch (nPortNumber)
+    {    
+    case OMX_INPUT_PORT_INDEX:
+        while (OMX_TRUE)
+        {
+            if (msgrcv(pSfCodaj12Implement->sInputMessageQueue, (void *)&data, BUFSIZ, 0, IPC_NOWAIT) == -1)
+            {
+                break;
+            }
+            else
+            {
+                pOMXBuffer = data.pBuffer;
+                pOMXBuffer->nFilledLen = 0;
+                pOMXBuffer->nFlags = OMX_BUFFERFLAG_EOS;
+                pSfOMXComponent->callbacks->EmptyBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pOMXBuffer);
+            }
+        }
+        break;
+    case OMX_OUTPUT_PORT_INDEX:
+        while (OMX_TRUE)
+        {
+            if (msgrcv(pSfCodaj12Implement->sOutputMessageQueue, (void *)&data, BUFSIZ, 0, IPC_NOWAIT) == -1)
+            {
+                break;
+            }
+            else
+            {
+                pOMXBuffer = data.pBuffer;
+                pOMXBuffer->nFilledLen = 0;
+                pOMXBuffer->nFlags = OMX_BUFFERFLAG_EOS;
+                pSfOMXComponent->callbacks->FillBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pOMXBuffer);
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    FunctionOut();
+}

+ 136 - 0
soft_3rdpart/omx-il/component/image/common/SF_OMX_mjpeg_common.h

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 StarFive Technology Co., Ltd.
+ */
+#ifndef SF_OMX_MJPEG_COMMON
+#define SF_OMX_MJPEG_COMMON
+
+#include "OMX_Component.h"
+#include "OMX_Image.h"
+#include "OMX_Index.h"
+#include "OMX_IndexExt.h"
+#include "SF_OMX_Core.h"
+#include "codaj12/jpuapi/jpuapi.h"
+#include "codaj12/jpuapi/jpuapifunc.h"
+#include "codaj12/sample/main_helper.h"
+#include <sys/queue.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <pthread.h>
+#include <errno.h>
+
+#define INIT_SET_SIZE_VERSION(_struct_, _structType_) \
+    do                                                \
+    {                                                 \
+        memset((_struct_), 0, sizeof(_structType_));  \
+        (_struct_)->nSize = sizeof(_structType_);     \
+        (_struct_)->nVersion.s.nVersionMajor = 1;     \
+        (_struct_)->nVersion.s.nVersionMinor = 18;    \
+        (_struct_)->nVersion.s.nRevision = 1;         \
+        (_struct_)->nVersion.s.nStep = 0;             \
+    } while (0)
+
+#define DEFAULT_FRAME_WIDTH 1920
+#define DEFAULT_FRAME_HEIGHT 1080
+#define DEFAULT_MJPEG_INPUT_BUFFER_SIZE (DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3) 
+#define DEFAULT_MJPEG_OUTPUT_BUFFER_SIZE (DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3)
+#define NUM_FRAME_BUF MAX_FRAME
+#define DEFAULT_FRAME_FORMAT FORMAT_420
+
+#define CODAJ12_OUTPUT_BUF_NUMBER 4
+#define CODAJ12_INPUT_BUF_NUMBER 1
+
+typedef struct _SF_CODAJ12_FUNCTIONS
+{
+    JpgRet (*JPU_Init)(void);
+    JpgRet (*JPU_DecOpen)(JpgDecHandle *pHandle, JpgDecOpenParam *pop);
+    JpgRet (*JPU_DecGetInitialInfo)(JpgDecHandle handle, JpgDecInitialInfo *info);
+    JpgRet (*JPU_DecRegisterFrameBuffer2)(JpgDecHandle handle, FrameBuffer *bufArray, int stride);
+    JpgRet (*JPU_DecRegisterFrameBuffer)(JpgDecHandle handle, FrameBuffer * bufArray, int num, int stride);
+    JpgRet (*JPU_DecGiveCommand)(JpgDecHandle handle, JpgCommand cmd, void *param);
+    JpgRet (*JPU_DecStartOneFrame)(JpgDecHandle handle, JpgDecParam *param);
+    JpgRet (*JPU_DecGetOutputInfo)(JpgDecHandle handle, JpgDecOutputInfo *info);
+    JpgRet (*JPU_SWReset)(JpgHandle handle);
+    JpgRet (*JPU_DecSetRdPtrEx)(JpgDecHandle handle, PhysicalAddress addr, BOOL updateWrPtr);
+    JpgRet (*JPU_DecClose)(JpgDecHandle handle);
+    Int32 (*JPU_WaitInterrupt)(JpgHandle handle, int timeout);
+    FrameBuffer *(*JPU_GetFrameBufPool)(JpgDecHandle handle);
+    void (*JPU_ClrStatus)(JpgHandle handle, Uint32 val);
+    void (*JPU_DeInit)(void);
+
+    void (*BSFeederBuffer_SetData)(void *feeder, char *address, Uint32 size);
+    Uint32 (*BitstreamFeeder_SetData)(BSFeeder feeder, void *data, Uint32 size);
+    BSFeeder (*BitstreamFeeder_Create)(const char *path, FeedingMethod method, EndianMode endian);
+    Uint32 (*BitstreamFeeder_Act)(BSFeeder feeder, JpgDecHandle handle, jpu_buffer_t *bsBuffer);
+    BOOL(*BitstreamFeeder_Destroy)
+    (BSFeeder feeder);
+
+    int (*jdi_allocate_dma_memory)(jpu_buffer_t *vb);
+    void (*jdi_free_dma_memory)(jpu_buffer_t *vb);
+
+    void *(*AllocateOneFrameBuffer)
+    // (Uint32 instIdx, Uint32 size, Uint32 *bufferIndex);
+    (Uint32 instIdx, FrameFormat subsample, CbCrInterLeave cbcrIntlv,
+     PackedFormat packed, Uint32 rotation, BOOL scalerOn, Uint32 width, Uint32 height, Uint32 bitDepth, Uint32 *bufferIndex);
+    void (*FreeFrameBuffer)(int instIdx);
+    FRAME_BUF *(*GetFrameBuffer)(int instIdx, int idx);
+    Uint32 (*GetFrameBufferCount)(int instIdx);
+
+    BOOL (*UpdateFrameBuffers)(Uint32 instIdx, Uint32 num, FRAME_BUF *frameBuf);
+} SF_CODAJ12_FUNCTIONS;
+
+typedef struct _THREAD_HANDLE_TYPE {
+    pthread_t          pthread;
+    pthread_attr_t     attr;
+    struct sched_param schedparam;
+    int                stack_size;
+} THREAD_HANDLE_TYPE;
+
+typedef struct _SF_CODAJ12_IMPLEMEMT
+{
+    DecConfigParam *config;
+    SF_CODAJ12_FUNCTIONS *functions;
+    BSFeeder feeder;
+    jpu_buffer_t vbStream;
+    JpgDecOpenParam decOP;
+    JpgDecHandle handle;
+    JpgDecInitialInfo initialInfo;
+    Int32 instIdx;
+    FrameBuffer frameBuf[NUM_FRAME_BUF];
+    FRAME_BUF frame[NUM_FRAME_BUF];
+    OMX_S32 sInputMessageQueue;
+    OMX_S32 sOutputMessageQueue;
+    OMX_HANDLETYPE pProcessThread;
+    OMX_BOOL bThreadRunning;
+    OMX_STATETYPE currentState;
+    FrameFormat frameFormat;
+} SF_CODAJ12_IMPLEMEMT;
+
+typedef struct Message
+{
+    long msg_type;
+    OMX_U32 msg_flag;
+    OMX_BUFFERHEADERTYPE *pBuffer;
+} Message;
+
+enum port_index
+{
+    OMX_INPUT_PORT_INDEX = 0,
+    OMX_OUTPUT_PORT_INDEX = 1,
+    OMX_PORT_MAX = 2,
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    OMX_ERRORTYPE GetStateMjpegCommon(OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATETYPE *pState);
+    OMX_ERRORTYPE InitMjpegStructorCommon(SF_OMX_COMPONENT *hComponent);
+    void GetMpegfunctions(SF_CODAJ12_FUNCTIONS *funcs, OMX_PTR *sohandle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

+ 1212 - 0
soft_3rdpart/omx-il/component/image/dec/SF_OMX_Mjpeg_decoder.c

@@ -0,0 +1,1212 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 StarFive Technology Co., Ltd.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "SF_OMX_mjpeg_common.h"
+#include "SF_OMX_Core.h"
+
+extern OMX_TICKS gInitTimeStamp;
+#define TEMP_DEBUG 1
+#define NUM_OF_PORTS 2
+
+static char *Event2Str(unsigned long event)
+{
+    char *event_str = NULL;
+    return event_str;
+}
+
+static OMX_ERRORTYPE SF_OMX_EmptyThisBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_BOOL bSendNULL = OMX_FALSE;
+    OMX_BOOL bSendMessage = OMX_TRUE;
+    FunctionIn();
+
+    if (hComponent == NULL || pBuffer == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = (SF_OMX_COMPONENT *)pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = (SF_CODAJ12_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+
+    LOG(SF_LOG_DEBUG, "nFilledLen = %d, nFlags = %d, pBuffer = %p\r\n", pBuffer->nFilledLen, pBuffer->nFlags, pBuffer->pBuffer);
+
+    if (pBuffer->nFilledLen == 0)
+    {
+        bSendNULL = OMX_TRUE;
+    }
+    else if (pBuffer->nFlags & 0x1 == 0x1)
+    {
+        bSendMessage = OMX_TRUE;
+        bSendNULL = OMX_TRUE;
+    }
+    else
+    {
+        bSendNULL = OMX_FALSE;
+        bSendMessage = OMX_TRUE;
+    }
+    Message data;
+    data.msg_type = 1;
+    data.msg_flag = 0;
+    if (bSendMessage)
+    {
+        data.pBuffer = pBuffer;
+        if (msgsnd(pSfCodaj12Implement->sInputMessageQueue, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+        {
+            LOG(SF_LOG_ERR, "msgsnd failed\n");
+        }
+    }
+    if (bSendNULL)
+    {
+        data.pBuffer = NULL;
+        if (msgsnd(pSfCodaj12Implement->sInputMessageQueue, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+        {
+            LOG(SF_LOG_ERR, "msgsnd failed\n");
+        }
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+#define MAX_INDEX 1
+static int frame_array[MAX_INDEX] = {-1};
+static int frame_array_index = 0;
+
+static OMX_ERRORTYPE SF_OMX_FillThisBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    FunctionIn();
+
+    if (hComponent == NULL || pBuffer == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = (SF_OMX_COMPONENT *)pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = (SF_CODAJ12_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    LOG(SF_LOG_DEBUG, "nFilledLen = %d, nFlags = %d, pBuffer = %p\r\n", pBuffer->nFilledLen, pBuffer->nFlags, pBuffer->pBuffer);
+    // if (pSfCodaj12Implement->functions->Queue_Enqueue(&pSfCodaj12Implement->decodeBufferQueue, (void *)pBuffer->pBuffer) == FALSE)
+    // {
+    //     return OMX_ErrorInsufficientResources;
+    // }
+    StoreOMXBuffer(pSfOMXComponent, pBuffer);
+    Message data;
+    data.msg_type = 1;
+    data.msg_flag = 0;
+    data.pBuffer = pBuffer;
+    LOG(SF_LOG_DEBUG, "Send to message queue\r\n");
+    if (msgsnd(pSfCodaj12Implement->sOutputMessageQueue, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+    {
+        LOG(SF_LOG_ERR, "msgsnd failed\n");
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static int nOutBufIndex = 0;
+
+static OMX_ERRORTYPE SF_OMX_UseBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32 nPortIndex,
+    OMX_IN OMX_PTR pAppPrivate,
+    OMX_IN OMX_U32 nSizeBytes,
+    OMX_IN OMX_U8 *pBuffer)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_AllocateBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBuffer,
+    OMX_IN OMX_U32 nPortIndex,
+    OMX_IN OMX_PTR pAppPrivate,
+    OMX_IN OMX_U32 nSizeBytes)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+
+    FunctionIn();
+    if (nSizeBytes == 0)
+    {
+        LOG(SF_LOG_ERR, "nSizeBytes = %d\r\n", nSizeBytes);
+        return OMX_ErrorBadParameter;
+    }
+    OMX_BUFFERHEADERTYPE *temp_bufferHeader = (OMX_BUFFERHEADERTYPE *)malloc(sizeof(OMX_BUFFERHEADERTYPE));
+    if (temp_bufferHeader == NULL)
+    {
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
+        return OMX_ErrorInsufficientResources;
+    }
+    memset(temp_bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE));
+    
+
+    temp_bufferHeader->nAllocLen = nSizeBytes;
+    temp_bufferHeader->pAppPrivate = pAppPrivate;
+    if (nPortIndex == 1)
+    {
+        temp_bufferHeader->pBuffer = AllocateOutputBuffer(pSfOMXComponent, nSizeBytes);
+        // temp_bufferHeader->nFilledLen = nSizeBytes;
+    }
+    else if (nPortIndex == 0)
+    {
+        jpu_buffer_t *vbStream = &pSfCodaj12Implement->vbStream;
+        vbStream->size = (nSizeBytes == 0) ? STREAM_BUF_SIZE : nSizeBytes;
+        vbStream->size = (vbStream->size + 1023) & ~1023; // ceil128(size)
+        if (pSfCodaj12Implement->functions->jdi_allocate_dma_memory(vbStream) < 0)
+        {
+            LOG(SF_LOG_ERR, "fail to allocate bitstream buffer\r\n");
+            return OMX_ErrorInsufficientResources;
+        }
+        temp_bufferHeader->pBuffer = vbStream->virt_addr;
+        temp_bufferHeader->pInputPortPrivate = (void *)vbStream->phys_addr;
+    }
+
+    if (temp_bufferHeader->pBuffer == NULL)
+    {
+        free(temp_bufferHeader);
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
+        return OMX_ErrorInsufficientResources;
+    }
+    *ppBuffer = temp_bufferHeader;
+    LOG(SF_LOG_INFO, "nPortIndex = %d, pBuffer address = %p, nFilledLen = %d, nSizeBytes = %d\r\n",
+            nPortIndex, temp_bufferHeader->pBuffer, temp_bufferHeader->nFilledLen, nSizeBytes);
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_GetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nParamIndex,
+    OMX_INOUT OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfMjpegImplement = (SF_CODAJ12_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+
+    FunctionIn();
+    if (hComponent == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    LOG(SF_LOG_INFO, "Get parameter on index %X\r\n", nParamIndex);
+    switch ((OMX_U32)nParamIndex)
+    {
+    case OMX_IndexParamImageInit:
+    case OMX_IndexParamVideoInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        portParam->nPorts = NUM_OF_PORTS;
+        portParam->nStartPortNumber = OMX_INPUT_PORT_INDEX;
+        break;
+    }
+
+    case OMX_IndexParamImagePortFormat:
+    {
+        OMX_IMAGE_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32 index = portFormat->nIndex;
+        switch (index)
+        {
+        case OMX_INPUT_PORT_INDEX:
+            portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+        default:
+            if (index > 0)
+            {
+                ret = OMX_ErrorNoMore;
+            }
+        }
+        break;
+    }
+
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
+        OMX_U32 portIndex = pPortDefinition->nPortIndex;
+        OMX_PARAM_PORTDEFINITIONTYPE *pSrcDefinition = &pSfOMXComponent->portDefinition[portIndex];
+        
+        LOG(SF_LOG_DEBUG, "Get parameter port %X\r\n",portIndex);
+        LOG_APPEND(SF_LOG_DEBUG, "width = %d, height = %d\r\n", pSrcDefinition->format.video.nFrameWidth, pSrcDefinition->format.video.nFrameHeight);
+        LOG_APPEND(SF_LOG_DEBUG, "eColorFormat = %d\r\n", pSrcDefinition->format.video.eColorFormat);
+        LOG_APPEND(SF_LOG_DEBUG, "bufferSize = %d\r\n",pSrcDefinition->nBufferSize);
+        LOG_APPEND(SF_LOG_DEBUG, "Buffer count = %d\r\n", pSrcDefinition->nBufferCountActual);
+                         
+        memcpy(pPortDefinition, pSrcDefinition, pPortDefinition->nSize);
+        break;
+    }
+
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32 index = portFormat->nIndex;
+        portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+        portFormat->xFramerate = 30;
+        LOG(SF_LOG_DEBUG, "Get video format at port %d index %d\r\n",portFormat->nPortIndex, index);
+        switch (index)
+        {
+        case 0:
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
+            break;
+        case 1:
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV422Planar;
+            break;
+        case 2:
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV444Interleaved;
+            break;
+        default:
+            if (index > 0)
+            {
+                ret = OMX_ErrorNoMore;
+            }
+        }
+        break;
+    }
+    default:
+    {
+        ret = OMX_ErrorNotImplemented;
+        break;
+    }
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+static OMX_ERRORTYPE SF_OMX_SetParameter(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_INDEXTYPE nIndex,
+    OMX_IN OMX_PTR ComponentParameterStructure)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+    if (hComponent == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    if (ComponentParameterStructure == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+    LOG(SF_LOG_INFO, "Set parameter on index %X\r\n", nIndex);
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfMjpegImplement = (SF_CODAJ12_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+
+    if (pSfOMXComponent == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    switch ((OMX_U32)nIndex)
+    {
+    case OMX_IndexParamPortDefinition:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition =
+            (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
+        OMX_PARAM_PORTDEFINITIONTYPE *pInputPort = &pSfOMXComponent->portDefinition[0];
+        OMX_PARAM_PORTDEFINITIONTYPE *pOutputPort = &pSfOMXComponent->portDefinition[1];
+
+        OMX_U32 portIndex = pPortDefinition->nPortIndex;
+        OMX_U32 width = pPortDefinition->format.image.nFrameWidth;
+        OMX_U32 height = pPortDefinition->format.image.nFrameHeight;
+        LOG(SF_LOG_INFO, "Set parameter on port %d\r\n", pPortDefinition->nPortIndex);
+        LOG_APPEND(SF_LOG_DEBUG, "width = %d, height = %d\r\n",width, height);
+        LOG_APPEND(SF_LOG_DEBUG, "eColorFormat = %d\r\n", pPortDefinition->format.video.eColorFormat);
+        LOG_APPEND(SF_LOG_DEBUG, "bufferSize = %d\r\n",pPortDefinition->nBufferSize);
+        LOG_APPEND(SF_LOG_DEBUG, "Buffer count = %d\r\n", pPortDefinition->nBufferCountActual);
+        if (portIndex == (OMX_U32)OMX_INPUT_PORT_INDEX)
+        {
+            memcpy(&pSfOMXComponent->portDefinition[portIndex], pPortDefinition, pPortDefinition->nSize);
+            pInputPort->format.image.nStride = width;
+            pInputPort->format.image.nSliceHeight = height;
+            pInputPort->nBufferSize = width * height * 2;
+        }
+        else if (portIndex == (OMX_U32)(OMX_OUTPUT_PORT_INDEX))
+        {
+            memcpy(&pSfOMXComponent->portDefinition[portIndex], pPortDefinition, pPortDefinition->nSize);
+
+            /*
+              Some client may set '0' or '1' to output port, in this case use input port parameters
+            */
+            if (width <= 1)
+            {
+                width = pInputPort->format.image.nFrameWidth;
+            }
+            if (height <= 1)
+            {
+                height = pInputPort->format.image.nFrameHeight;
+            }
+            if (width > 0 && height > 0)
+            {
+                int scalew = pInputPort->format.image.nFrameWidth / width;
+                int scaleh = pInputPort->format.image.nFrameHeight / height;
+                if (scalew > 8 || scaleh > 8 || scalew < 1 || scaleh < 1)
+                {
+                    int nInputWidth = pInputPort->format.image.nFrameWidth;
+                    int nInputHeight = pInputPort->format.image.nFrameHeight;
+                    LOG(SF_LOG_WARN, "Scaling should be 1 to 1/8 (down-scaling only)! Use input parameter. "
+                                     "OutPut[%d, %d]. Input[%d, %d]\r\n",
+                        width, height, nInputWidth, nInputHeight);
+                    width = nInputWidth;
+                    height = nInputHeight;
+                }
+
+                pOutputPort->format.image.nFrameWidth = width;
+                pOutputPort->format.image.nFrameHeight = height;
+                pOutputPort->format.image.nStride = width;
+                pOutputPort->format.image.nSliceHeight = height;
+                switch (pOutputPort->format.image.eColorFormat)
+                {
+                    case OMX_COLOR_FormatYUV420Planar:
+                        pOutputPort->nBufferSize = (width * height * 3) / 2;
+                        break;
+                    case OMX_COLOR_FormatYUV422Planar:
+                        pOutputPort->nBufferSize = width * height * 2;
+                        break;
+                    case OMX_COLOR_FormatYUV444Interleaved:
+                        pOutputPort->nBufferSize = width * height * 3;
+                        break;
+                    default:
+                        pOutputPort->nBufferSize = width * height * 4;
+                        break;
+                }
+            }      
+        }
+        else
+        {
+            ret = OMX_ErrorNoMore;
+        }
+        break;
+    }
+    case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32 nPortIndex = portFormat->nPortIndex;
+        OMX_PARAM_PORTDEFINITIONTYPE *pPort = &pSfOMXComponent->portDefinition[nPortIndex];
+        LOG(SF_LOG_DEBUG, "Set video format to port %d color %d\r\n", portFormat->nPortIndex, portFormat->eColorFormat);
+        switch (portFormat->eColorFormat)
+        {
+        case OMX_COLOR_FormatYUV420Planar:
+            pSfMjpegImplement->frameFormat = FORMAT_420;
+            pPort->format.video.eColorFormat = portFormat->eColorFormat;
+            break;
+        case OMX_COLOR_FormatYUV422Planar:
+            pSfMjpegImplement->frameFormat = FORMAT_422;
+            pPort->format.video.eColorFormat = portFormat->eColorFormat;
+            break;
+        case OMX_COLOR_FormatYUV444Interleaved:
+            pSfMjpegImplement->frameFormat = FORMAT_444;
+            pPort->format.video.eColorFormat = portFormat->eColorFormat;
+            break;
+        default:
+            ret = OMX_ErrorNotImplemented;
+            break;
+        }
+    }
+    case OMX_IndexParamVideoInit:
+    {
+        OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
+        portParam->nPorts           = 2;
+        portParam->nStartPortNumber = 0;
+        break;
+    }
+
+    case OMX_IndexParamImagePortFormat:
+        break;
+
+    default:
+        break;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_GetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+    if (hComponent == NULL)
+    {
+        return OMX_ErrorBadParameter;
+    }
+
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_SetConfig(
+    OMX_HANDLETYPE hComponent,
+    OMX_INDEXTYPE nIndex,
+    OMX_PTR pComponentConfigStructure)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+    if (hComponent == NULL)
+    {
+        return OMX_ErrorBadParameter;
+    }
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_GetExtensionIndex(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_STRING cParameterName,
+    OMX_OUT OMX_INDEXTYPE *pIndexType)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+    //TODO
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_GetComponentVersion(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_STRING pComponentName,
+    OMX_OUT OMX_VERSIONTYPE *pComponentVersion,
+    OMX_OUT OMX_VERSIONTYPE *pSpecVersion,
+    OMX_OUT OMX_UUIDTYPE *pComponentUUID)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
+    FunctionIn();
+    //TODO
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE InitDecoder(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    FunctionIn();
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    JpgRet ret = JPG_RET_SUCCESS;
+    DecConfigParam *decConfig = pSfCodaj12Implement->config;
+    jpu_buffer_t *vbStream = &pSfCodaj12Implement->vbStream;
+    JpgDecOpenParam *decOP = &pSfCodaj12Implement->decOP;
+    JpgDecHandle handle = pSfCodaj12Implement->handle;
+
+    // pSfCodaj12Implement->sInputMessageQueue = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+    // if (pSfCodaj12Implement->sInputMessageQueue < 0)
+    // {
+    //     LOG(SF_LOG_ERR, "get ipc_id error");
+    //     return;
+    // }
+    // pSfCodaj12Implement->sOutputMessageQueue = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+    // if (pSfCodaj12Implement->sOutputMessageQueue < 0)
+    // {
+    //     LOG(SF_LOG_ERR, "get ipc_id error");
+    //     return;
+    // }
+
+    ret = pSfCodaj12Implement->functions->JPU_Init();
+    if (ret != JPG_RET_SUCCESS && ret != JPG_RET_CALLED_BEFORE)
+    {
+        LOG(SF_LOG_ERR, "JPU_Init failed Error code is 0x%x \r\n", ret);
+        return;
+    }
+
+    decConfig->feedingMode = FEEDING_METHOD_BUFFER;
+    LOG(SF_LOG_DEBUG, "feedingMode = %d, StreamEndian = %d\r\n", decConfig->feedingMode, decConfig->StreamEndian);
+    if ((pSfCodaj12Implement->feeder = pSfCodaj12Implement->functions->BitstreamFeeder_Create(decConfig->bitstreamFileName, decConfig->feedingMode, (EndianMode)decConfig->StreamEndian)) == NULL)
+    {
+        return;
+    }
+
+    FunctionOut();
+    return OMX_ErrorNone;
+
+ERR_DEC_INIT:
+    pSfCodaj12Implement->functions->FreeFrameBuffer(pSfCodaj12Implement->instIdx);
+
+    pSfCodaj12Implement->functions->jdi_free_dma_memory(vbStream);
+
+    pSfCodaj12Implement->functions->JPU_DeInit();
+    FunctionOut();
+    return OMX_ErrorHardware;
+}
+
+static OMX_U32 FeedData(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    FunctionIn();
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    BSFeeder feeder = pSfCodaj12Implement->feeder;
+    JpgDecHandle handle = pSfCodaj12Implement->handle;
+    jpu_buffer_t *vbStream = &pSfCodaj12Implement->vbStream;
+    OMX_U32 nFilledLen;
+
+    OMX_BUFFERHEADERTYPE *pOMXBuffer = NULL;
+    Message data;
+    LOG(SF_LOG_INFO, "Wait for input buffer\r\n");
+    if (msgrcv(pSfCodaj12Implement->sInputMessageQueue, (void *)&data, BUFSIZ, 0, 0) == -1)
+    {
+        LOG(SF_LOG_ERR, "msgrcv failed\n");
+        return 0;
+    }
+    pOMXBuffer = data.pBuffer;
+    if (pOMXBuffer == NULL || data.msg_flag == OMX_BUFFERFLAG_EOS)
+    {
+        return 0;
+    }
+
+    nFilledLen = pOMXBuffer->nFilledLen;
+    LOG(SF_LOG_INFO, "Address = %p, size = %d\r\n", pOMXBuffer->pBuffer, nFilledLen);
+    pSfCodaj12Implement->functions->BitstreamFeeder_SetData(feeder, pOMXBuffer->pBuffer, nFilledLen);
+    pSfCodaj12Implement->functions->BitstreamFeeder_Act(feeder, handle, vbStream);
+    LOG(SF_LOG_DEBUG, "EmptyBufferDone IN\r\n");
+    pSfOMXComponent->callbacks->EmptyBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pOMXBuffer);
+    LOG(SF_LOG_DEBUG, "EmptyBufferDone OUT\r\n");
+
+    // if (pOMXBuffer->nFlags & 0x1 == 0x1)
+    // {
+    //     pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+    // }
+    FunctionOut();
+    return nFilledLen;
+}
+
+static OMX_ERRORTYPE WaitForOutputBufferReady(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    FunctionIn();
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    OMX_BUFFERHEADERTYPE *pOMXBuffer = NULL;
+    Message data;
+    LOG(SF_LOG_INFO, "Wait for output buffer\r\n");
+    if (msgrcv(pSfCodaj12Implement->sOutputMessageQueue, (void *)&data, BUFSIZ, 0, 0) == -1)
+    {
+        LOG(SF_LOG_ERR, "msgrcv failed\n");
+        return OMX_ErrorInsufficientResources;
+    }
+    pOMXBuffer = data.pBuffer;
+    if (pOMXBuffer == NULL || data.msg_flag == OMX_BUFFERFLAG_EOS)
+    {
+        LOG(SF_LOG_INFO, "Buffer end flag detected! \r\n");
+        pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+        ret = OMX_ErrorNoMore;
+    }
+    FunctionOut();
+    return ret;
+}
+
+static void ProcessThread(void *args)
+{
+    SF_OMX_COMPONENT *pSfOMXComponent = (SF_OMX_COMPONENT *)args;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    BSFeeder feeder = pSfCodaj12Implement->feeder;
+    jpu_buffer_t *vbStream = &pSfCodaj12Implement->vbStream;
+    JpgDecInitialInfo *initialInfo = &pSfCodaj12Implement->initialInfo;
+
+    JpgDecOpenParam *decOP = &pSfCodaj12Implement->decOP;
+    DecConfigParam *decConfig = pSfCodaj12Implement->config;
+
+    JpgDecHandle handle;
+    Int32 frameIdx = 0;
+    JpgDecParam decParam = {0};
+    JpgDecOutputInfo outputInfo = {0};
+    Int32 int_reason = 0;
+    Int32 instIdx;
+    FrameFormat subsample;
+    JpgRet ret = JPG_RET_SUCCESS;
+
+    FunctionIn();
+    LOG(SF_LOG_INFO, "vbStream phys_addr = %x, size = %d, virt_addr = %x\r\n", vbStream->phys_addr, vbStream->size, vbStream->virt_addr);
+    decOP->streamEndian = decConfig->StreamEndian;
+    decOP->frameEndian = decConfig->FrameEndian;
+    decOP->bitstreamBuffer = vbStream->phys_addr;
+    decOP->bitstreamBufferSize = vbStream->size;
+    //set virtual address mapped of physical address
+    decOP->pBitStream = (BYTE *)vbStream->virt_addr; //lint !e511
+    decOP->chromaInterleave = decConfig->cbcrInterleave;
+    decOP->packedFormat = decConfig->packedFormat;
+    decOP->roiEnable = decConfig->roiEnable;
+    decOP->roiOffsetX = decConfig->roiOffsetX;
+    decOP->roiOffsetY = decConfig->roiOffsetY;
+    decOP->roiWidth = decConfig->roiWidth;
+    decOP->roiHeight = decConfig->roiHeight;
+    decOP->rotation = decConfig->rotation;
+    decOP->mirror = decConfig->mirror;
+    decOP->pixelJustification = decConfig->pixelJustification;
+    decOP->outputFormat = pSfCodaj12Implement->frameFormat; //decConfig->subsample;
+    decOP->intrEnableBit = ((1 << INT_JPU_DONE) | (1 << INT_JPU_ERROR) | (1 << INT_JPU_BIT_BUF_EMPTY));
+
+    printf("streamEndian = %x  \n"
+           "frameEndian = %x   \n       "
+           "bitstreamBuffer = %x   \n   "
+           "bitstreamBufferSize = %x  \n"
+           "pBitStream = %x  \n         "
+           "chromaInterleave = %x  \n   "
+           "packedFormat = %x  \n       "
+           "roiEnable = %x   \n         "
+           "roiOffsetX = %x   \n        "
+           "roiOffsetY = %x  \n         "
+           "roiWidth = %x  \n           "
+           "roiHeight = %x   \n         "
+           "rotation = %x   \n          "
+           "mirror  = %x   \n           "
+           "pixelJustification = %x  \n "
+           "outputFormat = %x   \n "
+           "intrEnableBit = %x   \n ",
+           decOP->streamEndian,
+           decOP->frameEndian,
+           decOP->bitstreamBuffer,
+           decOP->bitstreamBufferSize,
+           //set virtual address map
+           decOP->pBitStream,
+           decOP->chromaInterleave,
+           decOP->packedFormat,
+           decOP->roiEnable,
+           decOP->roiOffsetX,
+           decOP->roiOffsetY,
+           decOP->roiWidth,
+           decOP->roiHeight,
+           decOP->rotation,
+           decOP->mirror,
+           decOP->pixelJustification,
+           decOP->outputFormat,
+           decOP->intrEnableBit);
+
+    ret = pSfCodaj12Implement->functions->JPU_DecOpen(&handle, decOP);
+    if (ret != JPG_RET_SUCCESS)
+    {
+        LOG(SF_LOG_ERR, "JPU_DecOpen failed Error code is 0x%x \r\n", ret);
+        return;
+    }
+    pSfCodaj12Implement->handle = handle;
+    instIdx = pSfCodaj12Implement->instIdx = pSfCodaj12Implement->handle->instIndex;
+
+    do
+    {
+        OMX_U32 size = FeedData(pSfOMXComponent);
+        if (size <= 0)
+        {
+            LOG(SF_LOG_INFO, "FeedData = %d, end thread\r\n", size);
+            pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+        }
+
+        if ((ret = pSfCodaj12Implement->functions->JPU_DecGetInitialInfo(handle, initialInfo)) != JPG_RET_SUCCESS)
+        {
+            if (JPG_RET_BIT_EMPTY == ret)
+            {
+                LOG(SF_LOG_INFO, "<%s:%d> BITSTREAM EMPTY\n", __FUNCTION__, __LINE__);
+                continue;
+            }
+            else
+            {
+                LOG(SF_LOG_ERR, "JPU_DecGetInitialInfo failed Error code is 0x%x, inst=%d \n", ret, instIdx);
+                return;
+            }
+        }
+    } while (JPG_RET_SUCCESS != ret);
+    //TODO:Set output info
+    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &pSfOMXComponent->portDefinition[OMX_OUTPUT_PORT_INDEX];
+    pPortDefinition->format.image.nFrameWidth = initialInfo->picWidth;
+    pPortDefinition->format.image.nFrameHeight = initialInfo->picHeight;
+    pPortDefinition->format.image.nStride = initialInfo->picWidth;
+    pPortDefinition->format.image.nSliceHeight = initialInfo->picHeight;
+    pPortDefinition->format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
+    switch (pSfCodaj12Implement->frameFormat)
+    {
+    case FORMAT_400:
+    case FORMAT_420:
+        pPortDefinition->nBufferSize = initialInfo->picWidth * initialInfo->picHeight * 3 / 2;
+        break;
+    case FORMAT_422:
+    case FORMAT_440:
+        pPortDefinition->nBufferSize = initialInfo->picWidth * initialInfo->picHeight * 2;
+        break;
+    case FORMAT_444:
+    case FORMAT_MAX:
+        pPortDefinition->nBufferSize = initialInfo->picWidth * initialInfo->picHeight * 3;
+        break;
+    default:
+        pPortDefinition->nBufferSize = initialInfo->picWidth * initialInfo->picHeight * 4;
+        break;
+    }
+    LOG(SF_LOG_DEBUG, "Output buffer size = %d\r\n", pPortDefinition->nBufferSize);
+    if (pPortDefinition->nBufferCountActual < initialInfo->minFrameBufferCount)
+    {
+        pPortDefinition->nBufferCountActual = initialInfo->minFrameBufferCount;
+    }
+    if (pPortDefinition->nBufferCountMin < initialInfo->minFrameBufferCount)
+    {
+        pPortDefinition->nBufferCountMin = initialInfo->minFrameBufferCount;
+    }
+
+    LOG(SF_LOG_DEBUG, "OMX_EventPortSettingsChanged IN\r\n");
+    pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, OMX_EventPortSettingsChanged,
+                                             1, OMX_IndexParamPortDefinition, NULL);
+    LOG(SF_LOG_DEBUG, "OMX_EventPortSettingsChanged OUT\r\n");
+    LOG(SF_LOG_INFO, "Wait for out buffers ready\r\n");
+    OMX_U32 nTimeout = 100;
+    OMX_U32 nBufferNumber = pSfOMXComponent->portDefinition[OMX_OUTPUT_PORT_INDEX].nBufferCountActual;
+    while (OMX_TRUE)
+    {
+        // LOG(SF_LOG_INFO, "GetFrameBufferCount addr = %p\r\n", pSfCodaj12Implement->functions->GetFrameBufferCount);
+        OMX_U32 number = pSfCodaj12Implement->functions->GetFrameBufferCount(instIdx);
+        OMX_S32 oldNumber = -1;
+        if (number < nBufferNumber)
+        {
+            if (oldNumber < number)
+            {
+                LOG(SF_LOG_INFO, "Wait for output buffer %d/%d\r\n", number, initialInfo->minFrameBufferCount);
+                oldNumber = number;
+            }
+            usleep(50 * 1000);
+            nTimeout --;
+            if (nTimeout < 0)
+            {
+                LOG(SF_LOG_ERR, "No buffers found on output port\r\n");
+                LOG(SF_LOG_DEBUG, "OMX_EventBufferFlag IN\r\n");
+                pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, OMX_EventBufferFlag,
+                                             1, 1, NULL);
+                LOG(SF_LOG_DEBUG, "OMX_EventBufferFlag OUT\r\n");
+                return;
+            }
+        }
+        else
+        {
+            break;
+        }
+    }
+
+    FRAME_BUF *pFrame = pSfCodaj12Implement->frame;
+    LOG(SF_LOG_INFO, "Update and regist %d FrameBuffers\r\n", nBufferNumber);
+    LOG(SF_LOG_DEBUG, "%20s%20s%20s\r\n", "virtAddr", "phyAddr", "size");
+    for (int i = 0; i < nBufferNumber; i ++)
+    {
+        LOG_APPEND(SF_LOG_DEBUG, "%20X%20X%20X\r\n", pFrame[i].vbY.virt_addr, pFrame[i].vbY.phys_addr, pFrame[i].vbY.size);
+    }
+
+    // ffmpeg: may register frame buffer append
+    if (pSfCodaj12Implement->functions->JPU_GetFrameBufPool(pSfCodaj12Implement->handle) == NULL)
+    {
+        JpgRet ret = JPG_RET_SUCCESS;
+        pSfCodaj12Implement->functions->UpdateFrameBuffers(instIdx, nBufferNumber, pFrame);
+        ret = pSfCodaj12Implement->functions->JPU_DecRegisterFrameBuffer(pSfCodaj12Implement->handle, pSfCodaj12Implement->frameBuf,
+                                        nBufferNumber, pSfCodaj12Implement->frameBuf[0].stride);
+        if (ret != JPG_RET_SUCCESS)
+        {
+            LOG(SF_LOG_ERR, "JPU_DecRegisterFrameBuffer fail ret = %d\r\n", ret);
+            pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+        }
+    }
+
+    pSfCodaj12Implement->functions->JPU_DecGiveCommand(handle, SET_JPG_SCALE_HOR, &(decConfig->iHorScaleMode));
+    pSfCodaj12Implement->functions->JPU_DecGiveCommand(handle, SET_JPG_SCALE_VER, &(decConfig->iVerScaleMode));
+
+    /* LOG HEADER */
+    LOG(SF_LOG_INFO, "I   F    FB_INDEX  FRAME_START  ECS_START  CONSUME   RD_PTR   WR_PTR      CYCLE\n");
+    LOG(SF_LOG_INFO, "-------------------------------------------------------------------------------\n");
+
+    while (pSfCodaj12Implement->bThreadRunning)
+    {
+        if (WaitForOutputBufferReady(pSfOMXComponent) != OMX_ErrorNone)
+        {
+            continue;
+        }
+
+        ret = pSfCodaj12Implement->functions->JPU_DecStartOneFrame(handle, &decParam);
+        if (ret != JPG_RET_SUCCESS && ret != JPG_RET_EOS)
+        {
+            if (ret == JPG_RET_BIT_EMPTY)
+            {
+                LOG(SF_LOG_INFO, "BITSTREAM NOT ENOUGH.............\n");
+                OMX_U32 size = FeedData(pSfOMXComponent);
+                if (size <= 0)
+                {
+                    LOG(SF_LOG_INFO, "FeedData = %d, end thread\r\n", size);
+                    pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+                }
+                continue;
+            }
+
+            LOG(SF_LOG_ERR, "JPU_DecStartOneFrame failed Error code is 0x%x \n", ret);
+            return;
+        }
+        if (ret == JPG_RET_EOS)
+        {
+            pSfCodaj12Implement->functions->JPU_DecGetOutputInfo(handle, &outputInfo);
+            break;
+        }
+
+        while (1)
+        {
+            if ((int_reason = pSfCodaj12Implement->functions->JPU_WaitInterrupt(handle, JPU_INTERRUPT_TIMEOUT_MS)) == -1)
+            {
+                LOG(SF_LOG_ERR, "Error : timeout happened\n");
+                pSfCodaj12Implement->functions->JPU_SWReset(handle);
+                break;
+            }
+
+            if (int_reason & ((1 << INT_JPU_DONE) | (1 << INT_JPU_ERROR) | (1 << INT_JPU_SLICE_DONE)))
+            {
+                // Do no clear INT_JPU_DONE and INT_JPU_ERROR interrupt. these will be cleared in JPU_DecGetOutputInfo.
+                LOG(SF_LOG_INFO, "\tINSTANCE #%d int_reason: %08x\n", handle->instIndex, int_reason);
+                break;
+            }
+
+            // if (int_reason & (1 << INT_JPU_BIT_BUF_EMPTY))
+            // {
+            //     if (decConfig->feedingMode != FEEDING_METHOD_FRAME_SIZE)
+            //     {
+            //         pSfCodaj12Implement->functions->BitstreamFeeder_Act(feeder, handle, &vbStream);
+            //     }
+            //     pSfCodaj12Implement->functions->JPU_ClrStatus(handle, (1 << INT_JPU_BIT_BUF_EMPTY));
+            // }
+        }
+        //LOG(SF_LOG_INFO, "\t<->INSTANCE #%d JPU_WaitInterrupt\n", handle->instIndex);
+
+        if ((ret = pSfCodaj12Implement->functions->JPU_DecGetOutputInfo(handle, &outputInfo)) != JPG_RET_SUCCESS)
+        {
+            LOG(SF_LOG_ERR, "JPU_DecGetOutputInfo failed Error code is 0x%x \n", ret);
+            return;
+        }
+
+        if (outputInfo.decodingSuccess == 0)
+            LOG(SF_LOG_ERR, "JPU_DecGetOutputInfo decode fail framdIdx %d \n", frameIdx);
+
+        LOG(SF_LOG_INFO, "%02d %04d  %8d     %8x %8x %10d  %8x  %8x %10d\n",
+            instIdx, frameIdx, outputInfo.indexFrameDisplay, outputInfo.bytePosFrameStart, outputInfo.ecsPtr, outputInfo.consumedByte,
+            outputInfo.rdPtr, outputInfo.wrPtr, outputInfo.frameCycle);
+
+        if (outputInfo.indexFrameDisplay == -1)
+            break;
+
+        FRAME_BUF *pFrame = pSfCodaj12Implement->functions->GetFrameBuffer(instIdx, outputInfo.indexFrameDisplay);
+        OMX_U8 *virtAddr = (OMX_U8 *)pFrame->vbY.virt_addr;
+        //TODO: Get OMX buffer by virt addr
+        OMX_BUFFERHEADERTYPE *pBuffer = GetOMXBufferByAddr(pSfOMXComponent, virtAddr);
+        ClearOMXBuffer(pSfOMXComponent, pBuffer);
+        switch (pSfCodaj12Implement->frameFormat)
+        {
+        case FORMAT_420:
+            pBuffer->nFilledLen = outputInfo.decPicWidth * outputInfo.decPicHeight * 3 / 2;
+            break;
+        case FORMAT_422:
+            pBuffer->nFilledLen = outputInfo.decPicWidth * outputInfo.decPicHeight * 2;
+            break;
+        case FORMAT_444:
+            pBuffer->nFilledLen = outputInfo.decPicWidth * outputInfo.decPicHeight * 3;
+            break;
+        default:
+            LOG(SF_LOG_ERR, "Unsupported format: %d\r\n", pSfCodaj12Implement->frameFormat);
+            break;
+        }
+        
+        LOG(SF_LOG_DEBUG, "decPicSize = [%d %d], pBuffer = %p, nFilledLen = %d\r\n",
+            outputInfo.decPicWidth, outputInfo.decPicHeight, pBuffer->pBuffer, pBuffer->nFilledLen);
+        LOG(SF_LOG_DEBUG, "FillBufferDone IN\r\n");
+        // Following comment store data loal
+        // {
+        //     FILE *fb = fopen("./out.bcp", "ab+");
+        //     LOG(SF_LOG_INFO, "%p %d\r\n", pBuffer->pBuffer, pBuffer->nFilledLen);
+        //     fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, fb);
+        //     fclose(fb);
+        // }
+        pSfOMXComponent->callbacks->FillBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pBuffer);
+        LOG(SF_LOG_DEBUG, "FillBufferDone OUT\r\n");
+        if (outputInfo.numOfErrMBs)
+        {
+            Int32 errRstIdx, errPosX, errPosY;
+            errRstIdx = (outputInfo.numOfErrMBs & 0x0F000000) >> 24;
+            errPosX = (outputInfo.numOfErrMBs & 0x00FFF000) >> 12;
+            errPosY = (outputInfo.numOfErrMBs & 0x00000FFF);
+            LOG(SF_LOG_ERR, "Error restart Idx : %d, MCU x:%d, y:%d, in Frame : %d \n", errRstIdx, errPosX, errPosY, frameIdx);
+        }
+
+        // if (pSfCodaj12Implement->bThreadRunning == OMX_FALSE)
+        // {
+        //     break;
+        // }
+        pSfCodaj12Implement->functions->JPU_DecSetRdPtrEx(handle, vbStream->phys_addr, TRUE);
+        OMX_U32 size = FeedData(pSfOMXComponent);
+        if (size <= 0)
+        {
+            LOG(SF_LOG_INFO, "FeedData = %d, end thread\r\n", size);
+            pSfCodaj12Implement->bThreadRunning = OMX_FALSE;
+        }
+    }
+    LOG(SF_LOG_DEBUG, "OMX_EventBufferFlag IN\r\n");
+    pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, OMX_EventBufferFlag,
+                                    1, 1, NULL);
+    LOG(SF_LOG_DEBUG, "OMX_EventBufferFlag OUT\r\n");
+    CodaJ12FlushBuffer(pSfOMXComponent, OMX_INPUT_PORT_INDEX);
+    CodaJ12FlushBuffer(pSfOMXComponent, OMX_OUTPUT_PORT_INDEX);
+    pSfCodaj12Implement->currentState = OMX_StateIdle;
+    FunctionOut();
+    ThreadExit(NULL);
+}
+
+static OMX_ERRORTYPE SF_OMX_SendCommand(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_COMMANDTYPE Cmd,
+    OMX_IN OMX_U32 nParam,
+    OMX_IN OMX_PTR pCmdData)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+
+    FunctionIn();
+    if (hComponent == NULL || pSfOMXComponent == NULL)
+    {
+        ret = OMX_ErrorBadParameter;
+        goto EXIT;
+    }
+
+    LOG(SF_LOG_INFO, "cmd = %X, nParam = %X\r\n", Cmd, nParam);
+    switch (Cmd)
+    {
+    case OMX_CommandStateSet:
+        pSfOMXComponent->nextState = nParam;
+        LOG(SF_LOG_INFO, "OMX dest state = %X, current state = %X\r\n", nParam, pSfCodaj12Implement->currentState);
+        switch (nParam)
+        {
+        case OMX_StateLoaded:
+            break;
+        case OMX_StateIdle:
+            switch (pSfCodaj12Implement->currentState)
+            {
+                case OMX_StateExecuting:
+                {
+                    Message data;
+                    data.msg_type = 1;
+                    data.msg_flag = OMX_BUFFERFLAG_EOS;
+                    data.pBuffer = NULL;
+                    LOG(SF_LOG_DEBUG, "Send to message queue\r\n");
+                    if (msgsnd(pSfCodaj12Implement->sOutputMessageQueue, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+                    {
+                        LOG(SF_LOG_ERR, "msgsnd failed\n");
+                    }
+                    if (msgsnd(pSfCodaj12Implement->sInputMessageQueue, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+                    {
+                        LOG(SF_LOG_ERR, "msgsnd failed\n");
+                    }
+                    pSfCodaj12Implement->currentState = OMX_StateIdle;
+                    break;
+                }
+                case OMX_StateIdle:
+                    break;
+                case OMX_StateLoaded:
+                    // InitDecoder(pSfOMXComponent);
+                    pSfCodaj12Implement->currentState = OMX_StateIdle;
+                    break;
+                default:
+                    LOG(SF_LOG_ERR, "Can't go to state %d from %d\r\n",pSfCodaj12Implement->currentState, nParam);
+                    return OMX_ErrorBadParameter;
+                    break;
+            }
+            break;
+        case OMX_StateExecuting:
+            switch (pSfCodaj12Implement->currentState)
+            {
+            case OMX_StateIdle:
+                pSfCodaj12Implement->bThreadRunning = OMX_TRUE;
+                CreateThread(&pSfCodaj12Implement->pProcessThread, ProcessThread, (void *)pSfOMXComponent);
+                pSfCodaj12Implement->currentState = OMX_StateExecuting;
+                break;
+            case OMX_StateExecuting:
+                break;
+            case OMX_StateLoaded:
+            default:
+                LOG(SF_LOG_ERR, "Can't go to state %d from %d\r\n",pSfCodaj12Implement->currentState, nParam);
+                return OMX_ErrorBadParameter;
+                break;
+            }
+            break;
+        default:
+            ret = OMX_ErrorIncorrectStateTransition;
+            break;
+        }
+        pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData,
+                                                 OMX_EventCmdComplete, OMX_CommandStateSet, nParam, NULL);
+
+        break;
+    case OMX_CommandFlush:
+    {
+        OMX_U32 nPort = nParam;
+        CodaJ12FlushBuffer(pSfOMXComponent, nPort);
+        pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData,
+                                                 OMX_EventCmdComplete, OMX_CommandFlush, nParam, NULL);
+    }
+    case OMX_CommandPortDisable:
+        pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData,
+                                                 OMX_EventCmdComplete, OMX_CommandPortDisable, nParam, NULL);
+        break;
+    case OMX_CommandPortEnable:
+        pSfOMXComponent->callbacks->EventHandler(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData,
+                                                 OMX_EventCmdComplete, OMX_CommandPortEnable, nParam, NULL);
+    default:
+        break;
+    }
+    //TODO
+EXIT:
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_GetState(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_OUT OMX_STATETYPE *pState)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
+    SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    FunctionIn();
+    *pState = pSfCodaj12Implement->currentState;
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_FreeBuffer(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_IN OMX_U32 nPortIndex,
+    OMX_IN OMX_BUFFERHEADERTYPE *pBufferHdr)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    FunctionIn();
+    //TODO
+    FunctionOut();
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_UseEGLImage(
+    OMX_IN OMX_HANDLETYPE hComponent,
+    OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
+    OMX_IN OMX_U32 nPortIndex,
+    OMX_IN OMX_PTR pAppPrivate,
+    OMX_IN void *eglImage)
+{
+    (void)hComponent;
+    (void)ppBufferHdr;
+    (void)nPortIndex;
+    (void)pAppPrivate;
+    (void)eglImage;
+    return OMX_ErrorNotImplemented;
+}
+
+static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement;
+    FunctionIn();
+
+    ret = InitMjpegStructorCommon(pSfOMXComponent);
+    if (ret != OMX_ErrorNone)
+    {
+        goto EXIT;
+    }
+
+    pSfOMXComponent->pOMXComponent->UseBuffer = &SF_OMX_UseBuffer;
+    pSfOMXComponent->pOMXComponent->AllocateBuffer = &SF_OMX_AllocateBuffer;
+    pSfOMXComponent->pOMXComponent->EmptyThisBuffer = &SF_OMX_EmptyThisBuffer;
+    pSfOMXComponent->pOMXComponent->FillThisBuffer = &SF_OMX_FillThisBuffer;
+    pSfOMXComponent->pOMXComponent->FreeBuffer = &SF_OMX_FreeBuffer;
+    // pSfOMXComponent->pOMXComponent->ComponentTunnelRequest = &SF_OMX_ComponentTunnelRequest;
+    pSfOMXComponent->pOMXComponent->GetParameter = &SF_OMX_GetParameter;
+    pSfOMXComponent->pOMXComponent->SetParameter = &SF_OMX_SetParameter;
+    pSfOMXComponent->pOMXComponent->GetConfig = &SF_OMX_GetConfig;
+    pSfOMXComponent->pOMXComponent->SetConfig = &SF_OMX_SetConfig;
+    pSfOMXComponent->pOMXComponent->SendCommand = &SF_OMX_SendCommand;
+    pSfOMXComponent->pOMXComponent->GetState = &SF_OMX_GetState;
+    // pSfOMXComponent->pOMXComponent->GetExtensionIndex = &SF_OMX_GetExtensionIndex;
+    // pSfOMXComponent->pOMXComponent->ComponentRoleEnum = &SF_OMX_ComponentRoleEnum;
+    // pSfOMXComponent->pOMXComponent->ComponentDeInit = &SF_OMX_ComponentDeInit;
+    pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    pSfCodaj12Implement->currentState = OMX_StateLoaded;
+    InitDecoder(pSfOMXComponent);
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *pSfOMXComponent)
+{
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+    SF_CODAJ12_IMPLEMEMT *pSfCodaj12Implement = pSfOMXComponent->componentImpl;
+    jpu_buffer_t *vbStream = &pSfCodaj12Implement->vbStream;
+    JpgDecHandle handle = &pSfCodaj12Implement->handle;
+    FunctionIn();
+ERR_DEC_OPEN:
+    ret = pSfCodaj12Implement->functions->JPU_DecClose(handle);
+    if (ret != JPG_RET_SUCCESS)
+        LOG(SF_LOG_ERR, "\nDec End\r\n");
+    pSfCodaj12Implement->functions->BitstreamFeeder_Destroy(pSfCodaj12Implement->feeder);
+ERR_DEC_INIT:
+    pSfCodaj12Implement->functions->FreeFrameBuffer(pSfCodaj12Implement->instIdx);
+    pSfCodaj12Implement->functions->jdi_free_dma_memory(vbStream);
+    pSfCodaj12Implement->functions->JPU_DeInit();
+    // TODO
+    // MjpegClearCommon(hComponent);
+EXIT:
+    FunctionOut();
+
+    return ret;
+}
+
+//TODO happer
+SF_OMX_COMPONENT sf_dec_decoder_mjpeg = {
+    .componentName = "sf.dec.decoder.mjpeg",
+    .libName = "libcodadec.so",
+    .pOMXComponent = NULL,
+    .SF_OMX_ComponentConstructor = SF_OMX_ComponentConstructor,
+    .SF_OMX_ComponentClear = SF_OMX_ComponentClear,
+    // .functions = NULL,
+    // .bitFormat = STD_HEVC,
+    .componentImpl = NULL,
+    .fwPath = "/lib/firmware/chagall.bin",
+    .componentRule = "video_decoder.mjpeg"};

+ 237 - 95
soft_3rdpart/omx-il/component/video/common/SF_OMX_video_common.c

@@ -4,6 +4,9 @@
  */
 #include "SF_OMX_video_common.h"
 
+extern SF_OMX_COMPONENT *sf_omx_component_list[];
+static void sf_get_component_functions(SF_COMPONENT_FUNCTIONS *funcs, OMX_PTR *sohandle);
+
 OMX_ERRORTYPE GetStateCommon(OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATETYPE *pState)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
@@ -11,7 +14,7 @@ OMX_ERRORTYPE GetStateCommon(OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATE
     SF_OMX_COMPONENT *pSfOMXComponent = NULL;
     ComponentState state;
     OMX_STATETYPE nextState;
-
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = NULL;
     FunctionIn();
     if (hComponent == NULL)
     {
@@ -20,8 +23,9 @@ OMX_ERRORTYPE GetStateCommon(OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATE
     }
     pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     nextState = pSfOMXComponent->nextState;
-    state = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+    state = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
     LOG(SF_LOG_INFO, "state = %d\r\n", state);
 
     switch (state)
@@ -50,20 +54,22 @@ EXIT:
     return ret;
 }
 
-OMX_ERRORTYPE ComponentClearCommon(SF_OMX_COMPONENT *hComponent)
+OMX_ERRORTYPE ComponentClearCommon(SF_OMX_COMPONENT *pSfOMXComponent)
 {
-    hComponent->functions->ComponentRelease(hComponent->hSFComponentExecoder);
-    hComponent->functions->ComponentDestroy(hComponent->hSFComponentExecoder, NULL);
-    hComponent->functions->DeInitLog();
-    dlclose(hComponent->soHandle);
-    free(hComponent->functions);
-    free(hComponent->testConfig);
-    free(hComponent->config);
-    free(hComponent->lsnCtx);
-    free(hComponent->pOMXComponent);
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+
+    pSfVideoImplement->functions->ComponentRelease(pSfVideoImplement->hSFComponentExecoder);
+    pSfVideoImplement->functions->ComponentDestroy(pSfVideoImplement->hSFComponentExecoder, NULL);
+    pSfVideoImplement->functions->DeInitLog();
+    dlclose(pSfOMXComponent->soHandle);
+    free(pSfVideoImplement->functions);
+    free(pSfVideoImplement->testConfig);
+    free(pSfVideoImplement->config);
+    free(pSfVideoImplement->lsnCtx);
+    free(pSfOMXComponent->pOMXComponent);
     for (int i = 0; i < 2; i++)
     {
-        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &hComponent->portDefinition[i];
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &pSfOMXComponent->portDefinition[i];
         free(pPortDefinition->format.video.cMIMEType);
     }
     return OMX_ErrorNone;
@@ -123,99 +129,110 @@ BOOL CheckDecTestConfig(TestDecConfig *testConfig)
     return isValidParameters;
 }
 
-OMX_ERRORTYPE InitComponentStructorCommon(SF_OMX_COMPONENT *hComponent)
+OMX_ERRORTYPE InitComponentStructorCommon(SF_OMX_COMPONENT *pSfOMXComponent)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     char *strDebugLevel = NULL;
     int debugLevel = 0;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = NULL;
 
     FunctionIn();
-    if (hComponent == NULL)
+    if (pSfOMXComponent == NULL)
     {
         ret = OMX_ErrorBadParameter;
         goto EXIT;
     }
 
-    hComponent->pOMXComponent = malloc(sizeof(OMX_COMPONENTTYPE));
-    if (hComponent->pOMXComponent == NULL)
+    pSfOMXComponent->pOMXComponent = malloc(sizeof(OMX_COMPONENTTYPE));
+    if (pSfOMXComponent->pOMXComponent == NULL)
     {
         ret = OMX_ErrorInsufficientResources;
         LOG(SF_LOG_ERR, "malloc fail\r\n");
         goto ERROR;
     }
-    memset(hComponent->pOMXComponent, 0, sizeof(OMX_COMPONENTTYPE));
-    hComponent->soHandle = dlopen(hComponent->libName, RTLD_NOW);
-    if (hComponent->soHandle == NULL)
+    memset(pSfOMXComponent->pOMXComponent, 0, sizeof(OMX_COMPONENTTYPE));
+    pSfOMXComponent->soHandle = dlopen(pSfOMXComponent->libName, RTLD_NOW);
+    if (pSfOMXComponent->soHandle == NULL)
+    {
+        ret = OMX_ErrorInsufficientResources;
+        LOG(SF_LOG_ERR, "could not open %s\r\n", pSfOMXComponent->libName);
+        goto ERROR;
+    }
+
+    pSfOMXComponent->componentImpl = malloc(sizeof(SF_WAVE5_IMPLEMEMT));
+    if (pSfOMXComponent->componentImpl == NULL)
     {
         ret = OMX_ErrorInsufficientResources;
-        LOG(SF_LOG_ERR, "could not open %s\r\n", hComponent->libName);
+        LOG(SF_LOG_ERR, "malloc fail\r\n");
         goto ERROR;
     }
+    pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    memset(pSfVideoImplement, 0, sizeof(SF_WAVE5_IMPLEMEMT));
 
-    hComponent->functions = malloc(sizeof(SF_COMPONENT_FUNCTIONS));
-    if (hComponent->functions == NULL)
+    pSfVideoImplement->functions = malloc(sizeof(SF_COMPONENT_FUNCTIONS));
+    if (pSfVideoImplement->functions == NULL)
     {
         ret = OMX_ErrorInsufficientResources;
         LOG(SF_LOG_ERR, "malloc fail\r\n");
         goto ERROR;
     }
-    memset(hComponent->functions, 0, sizeof(SF_COMPONENT_FUNCTIONS));
-    sf_get_component_functions(hComponent->functions, hComponent->soHandle);
+    memset(pSfVideoImplement->functions, 0, sizeof(SF_COMPONENT_FUNCTIONS));
+    sf_get_component_functions(pSfVideoImplement->functions, pSfOMXComponent->soHandle);
 
     // Init VPU log
-    if (hComponent->functions->InitLog && hComponent->functions->SetMaxLogLevel)
+    if (pSfVideoImplement->functions->InitLog && pSfVideoImplement->functions->SetMaxLogLevel)
     {
-        hComponent->functions->InitLog();
+        pSfVideoImplement->functions->InitLog();
         strDebugLevel = getenv("VPU_DEBUG");
         if (strDebugLevel)
         {
             debugLevel = atoi(strDebugLevel);
             if (debugLevel >=0)
             {
-                hComponent->functions->SetMaxLogLevel(debugLevel);
+                pSfVideoImplement->functions->SetMaxLogLevel(debugLevel);
             }
         }
     }
 
-    if (strstr(hComponent->componentName, "sf.enc") != NULL)
+    if (strstr(pSfOMXComponent->componentName, "sf.enc") != NULL)
     {
-        hComponent->testConfig = malloc(sizeof(TestEncConfig));
-        if (hComponent->testConfig == NULL)
+        pSfVideoImplement->testConfig = malloc(sizeof(TestEncConfig));
+        if (pSfVideoImplement->testConfig == NULL)
         {
             ret = OMX_ErrorInsufficientResources;
             LOG(SF_LOG_ERR, "malloc fail\r\n");
             goto ERROR;
         }
-        hComponent->lsnCtx = malloc(sizeof(EncListenerContext));
-        if (hComponent->lsnCtx == NULL)
+        pSfVideoImplement->lsnCtx = malloc(sizeof(EncListenerContext));
+        if (pSfVideoImplement->lsnCtx == NULL)
         {
             ret = OMX_ErrorInsufficientResources;
             LOG(SF_LOG_ERR, "malloc fail\r\n");
             goto ERROR;
         }
-        memset(hComponent->testConfig, 0, sizeof(TestEncConfig));
-        memset(hComponent->lsnCtx, 0, sizeof(EncListenerContext));
-        hComponent->functions->SetDefaultEncTestConfig(hComponent->testConfig);
+        memset(pSfVideoImplement->testConfig, 0, sizeof(TestEncConfig));
+        memset(pSfVideoImplement->lsnCtx, 0, sizeof(EncListenerContext));
+        pSfVideoImplement->functions->SetDefaultEncTestConfig(pSfVideoImplement->testConfig);
     }
-    else if (strstr(hComponent->componentName, "sf.dec") != NULL)
+    else if (strstr(pSfOMXComponent->componentName, "sf.dec") != NULL)
     {
-        hComponent->testConfig = malloc(sizeof(TestDecConfig));
-        if (hComponent->testConfig == NULL)
+        pSfVideoImplement->testConfig = malloc(sizeof(TestDecConfig));
+        if (pSfVideoImplement->testConfig == NULL)
         {
             ret = OMX_ErrorInsufficientResources;
             LOG(SF_LOG_ERR, "malloc fail\r\n");
             goto ERROR;
         }
-        hComponent->lsnCtx = malloc(sizeof(DecListenerContext));
-        if (hComponent->lsnCtx == NULL)
+        pSfVideoImplement->lsnCtx = malloc(sizeof(DecListenerContext));
+        if (pSfVideoImplement->lsnCtx == NULL)
         {
             ret = OMX_ErrorInsufficientResources;
             LOG(SF_LOG_ERR, "malloc fail\r\n");
             goto ERROR;
         }
-        memset(hComponent->testConfig, 0, sizeof(TestDecConfig));
-        memset(hComponent->lsnCtx, 0, sizeof(DecListenerContext));
-        hComponent->functions->SetDefaultDecTestConfig(hComponent->testConfig);
+        memset(pSfVideoImplement->testConfig, 0, sizeof(TestDecConfig));
+        memset(pSfVideoImplement->lsnCtx, 0, sizeof(DecListenerContext));
+        pSfVideoImplement->functions->SetDefaultDecTestConfig(pSfVideoImplement->testConfig);
     }
     else
     {
@@ -224,21 +241,36 @@ OMX_ERRORTYPE InitComponentStructorCommon(SF_OMX_COMPONENT *hComponent)
         goto ERROR;
     }
 
-    hComponent->config = malloc(sizeof(CNMComponentConfig));
-    if (hComponent->config == NULL)
+    if (strstr(pSfOMXComponent->componentName, "264") != NULL)
+    {
+        pSfVideoImplement->bitFormat = STD_AVC;
+    }
+    else if (strstr(pSfOMXComponent->componentName, "265") != NULL)
+    {
+        pSfVideoImplement->bitFormat = STD_HEVC;
+    }
+    else
+    {
+        ret = OMX_ErrorBadParameter;
+        LOG(SF_LOG_ERR, "unknown format!\r\n");
+        goto ERROR;
+    }
+
+    pSfVideoImplement->config = malloc(sizeof(CNMComponentConfig));
+    if (pSfVideoImplement->config == NULL)
     {
         ret = OMX_ErrorInsufficientResources;
         LOG(SF_LOG_ERR, "malloc fail\r\n");
         goto ERROR;
     }
-    memset(hComponent->config, 0, sizeof(CNMComponentConfig));
+    memset(pSfVideoImplement->config, 0, sizeof(CNMComponentConfig));
 
-    hComponent->pOMXComponent->pComponentPrivate = hComponent;
+    pSfOMXComponent->pOMXComponent->pComponentPrivate = pSfOMXComponent;
     for (int i = 0; i < 2; i++)
     {
-        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &hComponent->portDefinition[i];
-        OMX_VIDEO_PARAM_AVCTYPE *pAVCComponent = &hComponent->AVCComponent[i];
-        OMX_VIDEO_PARAM_HEVCTYPE *pHEVCComponent = &hComponent->HEVCComponent[i];
+        OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = &pSfOMXComponent->portDefinition[i];
+        OMX_VIDEO_PARAM_AVCTYPE *pAVCComponent = &pSfVideoImplement->AVCComponent[i];
+        OMX_VIDEO_PARAM_HEVCTYPE *pHEVCComponent = &pSfVideoImplement->HEVCComponent[i];
         INIT_SET_SIZE_VERSION(pPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE);
         INIT_SET_SIZE_VERSION(pAVCComponent, OMX_VIDEO_PARAM_AVCTYPE);
         INIT_SET_SIZE_VERSION(pHEVCComponent, OMX_VIDEO_PARAM_HEVCTYPE);
@@ -276,99 +308,209 @@ OMX_ERRORTYPE InitComponentStructorCommon(SF_OMX_COMPONENT *hComponent)
         pHEVCComponent->eProfile = OMX_VIDEO_HEVCProfileMain;
     }
 
-    hComponent->portDefinition[0].eDir = OMX_DirInput;
-    hComponent->portDefinition[0].nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
-    hComponent->portDefinition[0].nBufferCountActual = VPU_INPUT_BUF_NUMBER;
-    hComponent->portDefinition[0].nBufferCountMin = VPU_INPUT_BUF_NUMBER;
+    pSfOMXComponent->portDefinition[0].eDir = OMX_DirInput;
+    pSfOMXComponent->portDefinition[0].nBufferSize = DEFAULT_VIDEO_INPUT_BUFFER_SIZE;
+    pSfOMXComponent->portDefinition[0].nBufferCountActual = VPU_INPUT_BUF_NUMBER;
+    pSfOMXComponent->portDefinition[0].nBufferCountMin = VPU_INPUT_BUF_NUMBER;
 
-    strcpy(hComponent->portDefinition[1].format.video.cMIMEType, "raw/video");
-    hComponent->portDefinition[1].format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
-    hComponent->portDefinition[1].eDir = OMX_DirOutput;
-    hComponent->portDefinition[1].nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
-    hComponent->portDefinition[1].nBufferCountActual = VPU_OUTPUT_BUF_NUMBER;
-    hComponent->portDefinition[1].nBufferCountMin = VPU_OUTPUT_BUF_NUMBER;
+    strcpy(pSfOMXComponent->portDefinition[1].format.video.cMIMEType, "raw/video");
+    pSfOMXComponent->portDefinition[1].format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
+    pSfOMXComponent->portDefinition[1].eDir = OMX_DirOutput;
+    pSfOMXComponent->portDefinition[1].nBufferSize = DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE;
+    pSfOMXComponent->portDefinition[1].nBufferCountActual = VPU_OUTPUT_BUF_NUMBER;
+    pSfOMXComponent->portDefinition[1].nBufferCountMin = VPU_OUTPUT_BUF_NUMBER;
 
-    memset(hComponent->pBufferArray, 0, sizeof(hComponent->pBufferArray));
-    hComponent->memory_optimization = OMX_TRUE;
+    memset(pSfOMXComponent->pBufferArray, 0, sizeof(pSfOMXComponent->pBufferArray));
+    pSfOMXComponent->memory_optimization = OMX_TRUE;
 
     FunctionOut();
 EXIT:
     return ret;
 ERROR:
-    if (hComponent->pOMXComponent)
-    {
-        free(hComponent->pOMXComponent);
-        hComponent->pOMXComponent = NULL;
-    }
-    if (hComponent->functions)
-    {
-        free(hComponent->functions);
-        hComponent->functions = NULL;
-    }
-    if (hComponent->testConfig)
+    if (pSfOMXComponent->pOMXComponent)
     {
-        free(hComponent->testConfig);
-        hComponent->testConfig = NULL;
+        free(pSfOMXComponent->pOMXComponent);
+        pSfOMXComponent->pOMXComponent = NULL;
     }
-    if (hComponent->lsnCtx)
-    {
-        free(hComponent->lsnCtx);
-        hComponent->lsnCtx = NULL;
-    }
-    if (hComponent->config)
-    {
-        free(hComponent->config);
-        hComponent->config = NULL;
+    if (pSfVideoImplement)
+    {   
+        if (pSfVideoImplement->functions)
+        {
+            free(pSfVideoImplement->functions);
+            pSfVideoImplement->functions = NULL;
+        }
+        if (pSfVideoImplement->testConfig)
+        {
+            free(pSfVideoImplement->testConfig);
+            pSfVideoImplement->testConfig = NULL;
+        }
+        if (pSfVideoImplement->lsnCtx)
+        {
+            free(pSfVideoImplement->lsnCtx);
+            pSfVideoImplement->lsnCtx = NULL;
+        }
+        if (pSfVideoImplement->config)
+        {
+            free(pSfVideoImplement->config);
+            pSfVideoImplement->config = NULL;
+        }
+        free(pSfVideoImplement);
+        pSfVideoImplement = NULL;
     }
     return ret;
 }
 
 OMX_ERRORTYPE FlushBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_U32 nPort)
 {
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+
     FunctionIn();
     if (nPort == 0)
     {
-        ComponentImpl *pFeederComponent = pSfOMXComponent->hSFComponentFeeder;
-        OMX_U32 inputQueueCount = pSfOMXComponent->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ);
+        ComponentImpl *pFeederComponent = pSfVideoImplement->hSFComponentFeeder;
+        OMX_U32 inputQueueCount = pSfVideoImplement->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ);
         LOG(SF_LOG_PERF, "Flush %d buffers on inputPort\r\n", inputQueueCount);
         if (inputQueueCount > 0)
         {
             PortContainerExternal *input = NULL;
-            while ((input = (PortContainerExternal*)pSfOMXComponent->functions->ComponentPortGetData(&pFeederComponent->srcPort)) != NULL)
+            while ((input = (PortContainerExternal*)pSfVideoImplement->functions->ComponentPortGetData(&pFeederComponent->srcPort)) != NULL)
             {
                 if (strstr(pSfOMXComponent->componentName, "sf.dec") != NULL)
                 {
-                    pSfOMXComponent->functions->ComponentNotifyListeners(pFeederComponent, COMPONENT_EVENT_DEC_EMPTY_BUFFER_DONE, (void *)input);
+                    pSfVideoImplement->functions->ComponentNotifyListeners(pFeederComponent, COMPONENT_EVENT_DEC_EMPTY_BUFFER_DONE, (void *)input);
                 }
                 else if (strstr(pSfOMXComponent->componentName, "sf.enc") != NULL)
                 {
-                    pSfOMXComponent->functions->ComponentNotifyListeners(pFeederComponent, COMPONENT_EVENT_ENC_EMPTY_BUFFER_DONE, (void *)input);
+                    pSfVideoImplement->functions->ComponentNotifyListeners(pFeederComponent, COMPONENT_EVENT_ENC_EMPTY_BUFFER_DONE, (void *)input);
                 }
             }
         }
     }
     else if (nPort == 1)
     {
-        ComponentImpl *pRendererComponent = pSfOMXComponent->hSFComponentRender;
-        OMX_U32 OutputQueueCount = pSfOMXComponent->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ);
+        ComponentImpl *pRendererComponent = pSfVideoImplement->hSFComponentRender;
+        OMX_U32 OutputQueueCount = pSfVideoImplement->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ);
         LOG(SF_LOG_PERF, "Flush %d buffers on outputPort\r\n", OutputQueueCount);
         if (OutputQueueCount > 0)
         {
             PortContainerExternal *output = NULL;
-            while ((output = (PortContainerExternal*)pSfOMXComponent->functions->ComponentPortGetData(&pRendererComponent->sinkPort)) != NULL)
+            while ((output = (PortContainerExternal*)pSfVideoImplement->functions->ComponentPortGetData(&pRendererComponent->sinkPort)) != NULL)
             {
                 output->nFlags = 0x1;
                 output->nFilledLen = 0;
                 if (strstr(pSfOMXComponent->componentName, "sf.dec") != NULL)
                 {
-                    pSfOMXComponent->functions->ComponentNotifyListeners(pRendererComponent, COMPONENT_EVENT_DEC_FILL_BUFFER_DONE, (void *)output);
+                    pSfVideoImplement->functions->ComponentNotifyListeners(pRendererComponent, COMPONENT_EVENT_DEC_FILL_BUFFER_DONE, (void *)output);
                 }
                 else if (strstr(pSfOMXComponent->componentName, "sf.enc") != NULL)
                 {
-                    pSfOMXComponent->functions->ComponentNotifyListeners(pRendererComponent, COMPONENT_EVENT_ENC_FILL_BUFFER_DONE, (void *)output);
+                    pSfVideoImplement->functions->ComponentNotifyListeners(pRendererComponent, COMPONENT_EVENT_ENC_FILL_BUFFER_DONE, (void *)output);
                 }
             }
         }
     }
     FunctionOut();
+}
+
+static void sf_get_component_functions(SF_COMPONENT_FUNCTIONS *funcs, OMX_PTR *sohandle)
+{
+    FunctionIn();
+    funcs->ComponentCreate = dlsym(sohandle, "ComponentCreate");
+    funcs->ComponentExecute = dlsym(sohandle, "ComponentExecute");
+    funcs->ComponentGetParameter = dlsym(sohandle, "ComponentGetParameter");
+    funcs->ComponentGetState = dlsym(sohandle, "ComponentGetState");
+    funcs->ComponentNotifyListeners = dlsym(sohandle, "ComponentNotifyListeners");
+    funcs->ComponentPortCreate = dlsym(sohandle, "ComponentPortCreate");
+    funcs->ComponentPortDestroy = dlsym(sohandle, "ComponentPortDestroy");
+    funcs->ComponentPortFlush = dlsym(sohandle, "ComponentPortFlush");
+    funcs->ComponentPortGetData = dlsym(sohandle, "ComponentPortGetData");
+    funcs->ComponentPortPeekData = dlsym(sohandle, "ComponentPortPeekData");
+    funcs->ComponentPortSetData = dlsym(sohandle, "ComponentPortSetData");
+    funcs->ComponentPortWaitReadyStatus = dlsym(sohandle, "ComponentPortWaitReadyStatus");
+    funcs->ComponentRelease = dlsym(sohandle, "ComponentRelease");
+    funcs->ComponentSetParameter = dlsym(sohandle, "ComponentSetParameter");
+    funcs->ComponentStop = dlsym(sohandle, "ComponentStop");
+    funcs->ComponentSetupTunnel = dlsym(sohandle, "ComponentSetupTunnel");
+    funcs->ComponentWait = dlsym(sohandle, "ComponentWait");
+    funcs->WaitBeforeComponentPortGetData = dlsym(sohandle, "WaitBeforeComponentPortGetData");
+    funcs->ComponentChangeState = dlsym(sohandle, "ComponentChangeState");
+    funcs->ComponentDestroy = dlsym(sohandle, "ComponentDestroy");
+    funcs->ComponentRegisterListener = dlsym(sohandle, "ComponentRegisterListener");
+    funcs->ComponentPortHasInputData = dlsym(sohandle, "ComponentPortHasInputData");
+    funcs->ComponentPortGetSize = dlsym(sohandle, "ComponentPortGetSize");
+    funcs->ComponentParamReturnTest = dlsym(sohandle, "ComponentParamReturnTest");
+    //Listener
+    funcs->SetupDecListenerContext = dlsym(sohandle, "SetupDecListenerContext");
+    funcs->SetupEncListenerContext = dlsym(sohandle, "SetupEncListenerContext");
+    funcs->ClearDecListenerContext = dlsym(sohandle, "ClearDecListenerContext");
+    funcs->HandleDecCompleteSeqEvent = dlsym(sohandle, "HandleDecCompleteSeqEvent");
+    funcs->HandleDecRegisterFbEvent = dlsym(sohandle, "HandleDecRegisterFbEvent");
+    funcs->HandleDecGetOutputEvent = dlsym(sohandle, "HandleDecGetOutputEvent");
+    funcs->HandleDecCloseEvent = dlsym(sohandle, "HandleDecCloseEvent");
+    funcs->ClearEncListenerContext = dlsym(sohandle, "ClearEncListenerContext");
+    funcs->HandleEncFullEvent = dlsym(sohandle, "HandleEncFullEvent");
+    funcs->HandleEncGetOutputEvent = dlsym(sohandle, "HandleEncGetOutputEvent");
+    funcs->HandleEncCompleteSeqEvent = dlsym(sohandle, "HandleEncCompleteSeqEvent");
+    funcs->HandleEncGetEncCloseEvent = dlsym(sohandle, "HandleEncGetEncCloseEvent");
+    funcs->EncoderListener = dlsym(sohandle, "EncoderListener");
+    funcs->DecoderListener = dlsym(sohandle, "DecoderListener");
+    // Helper
+    funcs->SetDefaultEncTestConfig = dlsym(sohandle, "SetDefaultEncTestConfig");
+    funcs->SetDefaultDecTestConfig = dlsym(sohandle, "SetDefaultDecTestConfig");
+    funcs->LoadFirmware = dlsym(sohandle, "LoadFirmware");
+    funcs->SetupEncoderOpenParam = dlsym(sohandle, "SetupEncoderOpenParam");
+    funcs->SetUpDecoderOpenParam = dlsym(sohandle, "SetUpDecoderOpenParam");
+    // VPU
+    funcs->VPU_GetProductId = dlsym(sohandle, "VPU_GetProductId");
+    funcs->Queue_Enqueue = dlsym(sohandle, "Queue_Enqueue");
+    funcs->Queue_Get_Cnt = dlsym(sohandle, "Queue_Get_Cnt");
+    funcs->VPU_DecClrDispFlag = dlsym(sohandle, "VPU_DecClrDispFlag");
+    funcs->VPU_DecGetFrameBuffer = dlsym(sohandle, "VPU_DecGetFrameBuffer");
+    funcs->Render_DecClrDispFlag = dlsym(sohandle, "Render_DecClrDispFlag");
+    // VPU Log
+    funcs->InitLog = dlsym(sohandle, "InitLog");
+    funcs->DeInitLog = dlsym(sohandle, "DeInitLog");
+    funcs->SetMaxLogLevel = dlsym(sohandle, "SetMaxLogLevel");
+    funcs->GetMaxLogLevel = dlsym(sohandle, "GetMaxLogLevel");
+
+    //Renderer
+    funcs->AllocateFrameBuffer2 = dlsym(sohandle, "AllocateFrameBuffer2");
+    funcs->AttachDMABuffer = dlsym(sohandle, "AttachDMABuffer");
+    funcs->SetRenderTotalBufferNumber = dlsym(sohandle, "SetRenderTotalBufferNumber");
+    funcs->WaitForExecoderReady = dlsym(sohandle, "WaitForExecoderReady");
+    FunctionOut();
+}
+
+SF_OMX_COMPONENT *GetSFOMXComponrntByComponent(Component *pComponent)
+{
+    SF_OMX_COMPONENT *pSfOMXComponent = NULL;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = NULL;
+    int size = GetNumberOfComponent();
+
+    FunctionIn();
+    for (int i = 0; i < size; i++)
+    {
+        pSfOMXComponent = sf_omx_component_list[i];
+        if (pSfOMXComponent == NULL)
+        {
+            continue;
+        }
+        pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+        if (pSfVideoImplement == NULL)
+        {
+            continue;
+        }
+        if (pSfVideoImplement->hSFComponentExecoder == pComponent || pSfVideoImplement->hSFComponentFeeder == pComponent || pSfVideoImplement->hSFComponentRender == pComponent)
+        {
+            break;
+        }
+    }
+EXIT:
+    if (pSfOMXComponent == NULL)
+    {
+        LOG(SF_LOG_ERR, "Could not get SfOMXComponent buy %p\r\n", pComponent);
+    }
+    FunctionOut();
+
+    return pSfOMXComponent;
 }

+ 85 - 2
soft_3rdpart/omx-il/component/video/common/SF_OMX_video_common.h

@@ -11,7 +11,9 @@
 #include "OMX_Index.h"
 #include "OMX_IndexExt.h"
 #include "SF_OMX_Core.h"
-#include "component.h"
+#include "wave511/sample_v2/component/component.h"
+#include "wave511/sample_v2/component_encoder/encoder_listener.h"
+#include "wave511/sample_v2/component_decoder/decoder_listener.h"
 
 #define INIT_SET_SIZE_VERSION(_struct_, _structType_) \
     do                                                \
@@ -29,6 +31,87 @@
 #define DEFAULT_VIDEO_INPUT_BUFFER_SIZE (DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT) / 2
 #define DEFAULT_VIDEO_OUTPUT_BUFFER_SIZE (DEFAULT_FRAME_WIDTH * DEFAULT_FRAME_HEIGHT * 3) / 2
 
+typedef struct _SF_COMPONENT_FUNCTIONS
+{
+    Component (*ComponentCreate)(const char *componentName, CNMComponentConfig *componentParam);
+    BOOL(*ComponentSetupTunnel)(Component fromComponent, Component toComponent);
+    ComponentState (*ComponentExecute)(Component component);
+    Int32 (*ComponentWait)(Component component);
+    void (*ComponentStop)(Component component);
+    void (*ComponentRelease)(Component component);
+    BOOL(*ComponentChangeState)(Component component, Uint32 state);
+    BOOL(*ComponentDestroy)(Component component, BOOL *ret);
+    CNMComponentParamRet (*ComponentGetParameter)(Component from, Component to, GetParameterCMD commandType, void *data);
+    CNMComponentParamRet (*ComponentSetParameter)(Component from, Component to, SetParameterCMD commandType, void *data);
+    void (*ComponentNotifyListeners)(Component component, Uint64 event, void *data);
+    BOOL(*ComponentRegisterListener)(Component component, Uint64 events, ComponentListenerFunc func, void *context);
+    void (*ComponentPortCreate)(Port *port, Component owner, Uint32 depth, Uint32 size);
+    void (*ComponentPortSetData)(Port *port, PortContainer *portData);
+    PortContainer *(*ComponentPortPeekData)(Port *port);
+    PortContainer *(*ComponentPortGetData)(Port *port);
+    void *(*WaitBeforeComponentPortGetData)(Port *port);
+    void (*ComponentPortWaitReadyStatus)(Port *port);
+    void (*ComponentPortDestroy)(Port *port);
+    BOOL(*ComponentPortHasInputData)(Port *port);
+    Uint32 (*ComponentPortGetSize)(Port *port);
+    void (*ComponentPortFlush)(Component component);
+    ComponentState (*ComponentGetState)(Component component);
+    BOOL(*ComponentParamReturnTest)(CNMComponentParamRet ret, BOOL *retry);
+    // Listener
+    BOOL(*SetupDecListenerContext)(DecListenerContext *ctx, CNMComponentConfig *config, Component renderer);
+    BOOL(*SetupEncListenerContext)(EncListenerContext *ctx, CNMComponentConfig *config);
+    void (*ClearDecListenerContext)(DecListenerContext *ctx);
+    void (*HandleDecCompleteSeqEvent)(Component com, CNMComListenerDecCompleteSeq *param, DecListenerContext *ctx);
+    void (*HandleDecRegisterFbEvent)(Component com, CNMComListenerDecRegisterFb *param, DecListenerContext *ctx);
+    void (*HandleDecGetOutputEvent)(Component com, CNMComListenerDecDone *param, DecListenerContext *ctx);
+    void (*HandleDecCloseEvent)(Component com, CNMComListenerDecClose *param, DecListenerContext *ctx);
+    void (*ClearEncListenerContext)(EncListenerContext *ctx);
+    void (*HandleEncFullEvent)(Component com, CNMComListenerEncFull *param, EncListenerContext *ctx);
+    void (*HandleEncGetOutputEvent)(Component com, CNMComListenerEncDone *param, EncListenerContext *ctx);
+    void (*HandleEncCompleteSeqEvent)(Component com, CNMComListenerEncCompleteSeq *param, EncListenerContext *ctx);
+    void (*HandleEncGetEncCloseEvent)(Component com, CNMComListenerEncClose *param, EncListenerContext *ctx);
+    void (*EncoderListener)(Component com, Uint64 event, void *data, void *context);
+    void (*DecoderListener)(Component com, Uint64 event, void *data, void *context);
+    // Helper
+    void (*SetDefaultEncTestConfig)(TestEncConfig *testConfig);
+    void (*SetDefaultDecTestConfig)(TestDecConfig *testConfig);
+    Int32 (*LoadFirmware)(Int32 productId, Uint8 **retFirmware, Uint32 *retSizeInWord, const char *path);
+    BOOL(*SetupEncoderOpenParam)(EncOpenParam *param, TestEncConfig *config, ENC_CFG *encCfg);
+    RetCode (*SetUpDecoderOpenParam)(DecOpenParam *param, TestDecConfig *config);
+    // VPU
+    int (*VPU_GetProductId)(int coreIdx);
+    BOOL(*Queue_Enqueue)(Queue *queue, void *data);
+    Uint32 (*Queue_Get_Cnt)(Queue *queue);
+    RetCode (*VPU_DecClrDispFlag)(DecHandle handle, int index);
+    RetCode (*VPU_DecGetFrameBuffer)(DecHandle handle, int frameIdx, FrameBuffer* frameBuf);
+    void (*Render_DecClrDispFlag)(void *context, int index);
+    // VPU Log
+    int (*InitLog)(void);
+    void (*DeInitLog)(void);
+    void (*SetMaxLogLevel)(int level);
+    int (*GetMaxLogLevel)(void);
+    // FrameBuffer
+    void* (*AllocateFrameBuffer2)(ComponentImpl* com, Uint32 size);
+    BOOL (*AttachDMABuffer)(ComponentImpl* com, Uint64 virtAddress, Uint32 size);
+    void (*SetRenderTotalBufferNumber)(ComponentImpl* com, Uint32 number);
+    void (*WaitForExecoderReady)(ComponentImpl *com)
+} SF_COMPONENT_FUNCTIONS;
+
+typedef struct _SF_WAVE5_IMPLEMEMT
+{
+    SF_COMPONENT_FUNCTIONS *functions;
+    Component *hSFComponentExecoder;
+    Component *hSFComponentFeeder;
+    Component *hSFComponentRender;
+    void *testConfig;
+    CNMComponentConfig *config;
+    void *lsnCtx;
+    Uint16 *pusBitCode;
+    CodStd bitFormat;
+    OMX_VIDEO_PARAM_AVCTYPE AVCComponent[2];
+    OMX_VIDEO_PARAM_HEVCTYPE HEVCComponent[2];
+} SF_WAVE5_IMPLEMEMT;
+
 #ifdef __cplusplus
 extern "C"
 {
@@ -40,7 +123,7 @@ extern "C"
     OMX_ERRORTYPE InitComponentStructorCommon(SF_OMX_COMPONENT *hComponent);
     OMX_ERRORTYPE ComponentClearCommon(SF_OMX_COMPONENT *hComponent);
     OMX_ERRORTYPE FlushBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_U32 nPort);
-
+    SF_OMX_COMPONENT *GetSFOMXComponrntByComponent(Component *pComponent);
 #ifdef __cplusplus
 }
 #endif

+ 156 - 105
soft_3rdpart/omx-il/component/video/dec/SF_OMX_Vdec_decoder.c

@@ -71,6 +71,7 @@ static void OnEventArrived(Component com, unsigned long event, void *data, void
     OMX_U64 diff_time = 0; // ms
     FunctionIn();
     SF_OMX_COMPONENT *pSfOMXComponent = GetSFOMXComponrntByComponent(com);
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     char *event_str = Event2Str(event);
 
     LOG(SF_LOG_INFO, "event=%lX %s\r\n", event, event_str);
@@ -120,8 +121,8 @@ static void OnEventArrived(Component com, unsigned long event, void *data, void
             pOMXBuffer->pBuffer, pOMXBuffer->nFilledLen, pOMXBuffer->nTimeStamp, pOMXBuffer->nFlags);
         LOG(SF_LOG_INFO, "indexFrameDisplay = %d, OMXBuferFlag = %d, OMXBufferAddr = %p\r\n",
                         pPortContainerExternal->nFlags, (OMX_U32)pOMXBuffer->pOutputPortPrivate, pOMXBuffer->pBuffer);
-        ComponentImpl *pRendererComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-        LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
+        ComponentImpl *pRendererComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+        LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
                                                     pSfOMXComponent->portDefinition[1].nBufferCountActual);
 
         pSfOMXComponent->callbacks->FillBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pOMXBuffer);
@@ -130,7 +131,7 @@ static void OnEventArrived(Component com, unsigned long event, void *data, void
     case COMPONENT_EVENT_DEC_REGISTER_FB:
     {
         /*The width and height vpu return will align to 16, eg: 1080 will be 1088. so check scale value at first.*/
-        TestDecConfig *testConfig = (TestDecConfig *)pSfOMXComponent->testConfig;
+        TestDecConfig *testConfig = (TestDecConfig *)pSfVideoImplement->testConfig;
         OMX_U32 nWidth = testConfig->scaleDownWidth;
         OMX_U32 nHeight = testConfig->scaleDownHeight;
         if (nWidth <= 0 || nHeight <= 0)
@@ -191,8 +192,9 @@ static OMX_ERRORTYPE SF_OMX_EmptyThisBuffer(
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
 
-    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
+    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
 
     PortContainerExternal *pPortContainerExternal = malloc(sizeof(PortContainerExternal));
     if (pPortContainerExternal == NULL)
@@ -205,13 +207,13 @@ static OMX_ERRORTYPE SF_OMX_EmptyThisBuffer(
     pPortContainerExternal->nFilledLen = pBuffer->nFilledLen;
     pPortContainerExternal->nFlags = pBuffer->nFlags;
 
-    if (pSfOMXComponent->functions->Queue_Enqueue(pFeederComponent->srcPort.inputQ, (void *)pPortContainerExternal) != OMX_TRUE)
+    if (pSfVideoImplement->functions->Queue_Enqueue(pFeederComponent->srcPort.inputQ, (void *)pPortContainerExternal) != OMX_TRUE)
     {
         LOG(SF_LOG_ERR, "%p:%p FAIL\r\n", pFeederComponent->srcPort.inputQ, pPortContainerExternal);
         free(pPortContainerExternal);
         return OMX_ErrorInsufficientResources;
     }
-    LOG(SF_LOG_PERF, "input queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ),
+    LOG(SF_LOG_PERF, "input queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ),
                                                     pSfOMXComponent->portDefinition[0].nBufferCountActual);
     LOG(SF_LOG_INFO, "input buffer address = %p, size = %d, flag = %x\r\n", pBuffer->pBuffer, pBuffer->nFilledLen, pBuffer->nFlags);
     free(pPortContainerExternal);
@@ -242,7 +244,8 @@ static OMX_ERRORTYPE SF_OMX_FillThisBuffer(
 
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = (SF_OMX_COMPONENT *)pOMXComponent->pComponentPrivate;
-    ComponentImpl *pRendererComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pRendererComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
     PortContainerExternal *pPortContainerExternal = malloc(sizeof(PortContainerExternal));
     if (pPortContainerExternal == NULL)
     {
@@ -256,20 +259,20 @@ static OMX_ERRORTYPE SF_OMX_FillThisBuffer(
     if (gInitTimeStamp != 0)
     {
         int clear = frame_array[frame_array_index];
-        pSfOMXComponent->functions->Render_DecClrDispFlag(pRendererComponent->context, clear);
+        pSfVideoImplement->functions->Render_DecClrDispFlag(pRendererComponent->context, clear);
         frame_array[frame_array_index] = (int)pBuffer->pOutputPortPrivate;
         LOG(SF_LOG_INFO, "store display flag: %d, clear display flag: %d\r\n", frame_array[frame_array_index], clear);
         frame_array_index ++;
     }
 
     if (frame_array_index == MAX_INDEX) frame_array_index = 0;
-    if (pSfOMXComponent->functions->Queue_Enqueue(pRendererComponent->sinkPort.inputQ, (void *)pPortContainerExternal) == FALSE)
+    if (pSfVideoImplement->functions->Queue_Enqueue(pRendererComponent->sinkPort.inputQ, (void *)pPortContainerExternal) == FALSE)
     {
         LOG(SF_LOG_ERR, "%p:%p FAIL\r\n", pRendererComponent->sinkPort.inputQ, pPortContainerExternal);
         free(pPortContainerExternal);
         return OMX_ErrorInsufficientResources;
     }
-    LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
+    LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
                                                     pSfOMXComponent->portDefinition[1].nBufferCountActual);
     free(pPortContainerExternal);
     pRendererComponent->pause = OMX_FALSE;
@@ -292,7 +295,8 @@ static OMX_ERRORTYPE SF_OMX_UseBuffer(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
-    ComponentImpl *pComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
     FunctionIn();
 
     if (hComponent == NULL)
@@ -300,7 +304,7 @@ static OMX_ERRORTYPE SF_OMX_UseBuffer(
         ret = OMX_ErrorBadParameter;
         goto EXIT;
     }
-    if (pSfOMXComponent->functions->AttachDMABuffer(pComponentRender, (Uint64)pBuffer, nSizeBytes) == FALSE)
+    if (pSfVideoImplement->functions->AttachDMABuffer(pComponentRender, (Uint64)pBuffer, nSizeBytes) == FALSE)
     {
         LOG(SF_LOG_ERR, "Failed to attach dma buffer\r\n");
         return OMX_ErrorInsufficientResources;
@@ -340,7 +344,8 @@ static OMX_ERRORTYPE SF_OMX_AllocateBuffer(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
-    ComponentImpl *pComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
 
     FunctionIn();
     if (nSizeBytes == 0)
@@ -363,7 +368,7 @@ static OMX_ERRORTYPE SF_OMX_AllocateBuffer(
         // Alloc DMA memory first
         if (pSfOMXComponent->memory_optimization)
         {
-            temp_bufferHeader->pBuffer = pSfOMXComponent->functions->AllocateFrameBuffer2(pComponentRender, nSizeBytes);
+            temp_bufferHeader->pBuffer = pSfVideoImplement->functions->AllocateFrameBuffer2(pComponentRender, nSizeBytes);
         }
         // DMA Memory alloc fail, goto normal alloc
         if (temp_bufferHeader->pBuffer == NULL)
@@ -410,7 +415,6 @@ static OMX_ERRORTYPE SF_OMX_GetParameter(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
-
     FunctionIn();
     LOG(SF_LOG_INFO, "Get parameter on index %X\r\n", nParamIndex);
     if (hComponent == NULL)
@@ -434,14 +438,26 @@ static OMX_ERRORTYPE SF_OMX_GetParameter(
         switch (index)
         {
         case 0:
+            portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
+            portFormat->xFramerate = 30;
+            break;
+        case 1:
             portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
             portFormat->eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
             portFormat->xFramerate = 30;
+            break;
+        case 2:
+            portFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
+            portFormat->eColorFormat = OMX_COLOR_FormatYUV420PackedSemiPlanar;
+            portFormat->xFramerate = 30;
+            break;
         default:
             if (index > 0)
             {
                 ret = OMX_ErrorNoMore;
             }
+            break;
         }
     }
 
@@ -503,18 +519,48 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
 
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
 
     if (pSfOMXComponent == NULL)
     {
         ret = OMX_ErrorBadParameter;
         goto EXIT;
     }
-    TestDecConfig *testConfig = pSfOMXComponent->testConfig;
+    TestDecConfig *testConfig = pSfVideoImplement->testConfig;
     LOG(SF_LOG_INFO, "Set parameter on index %X\r\n", nIndex);
     switch ((OMX_U32)nIndex)
     {
     case OMX_IndexParamVideoPortFormat:
+    {
+        OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
+        OMX_U32 nPortIndex = portFormat->nPortIndex;
+        TestDecConfig *pTestDecConfig = (TestDecConfig *)pSfVideoImplement->testConfig;
+        OMX_PARAM_PORTDEFINITIONTYPE *pPort = &pSfOMXComponent->portDefinition[nPortIndex];
+        LOG(SF_LOG_DEBUG, "Set video format to port %d color %d\r\n", portFormat->nPortIndex, portFormat->eColorFormat);
+        switch (portFormat->eColorFormat)
+        {
+             case OMX_COLOR_FormatYUV420Planar: //I420
+                pTestDecConfig->cbcrInterleave = FALSE;
+                pTestDecConfig->nv21 = FALSE;
+                pPort->format.video.eColorFormat = portFormat->eColorFormat;
+                break;
+            case OMX_COLOR_FormatYUV420SemiPlanar: //NV12
+                pTestDecConfig->cbcrInterleave = TRUE;
+                pTestDecConfig->nv21 = FALSE;
+                pPort->format.video.eColorFormat = portFormat->eColorFormat;
+                break;
+            case OMX_COLOR_FormatYUV420PackedSemiPlanar: //NV21
+                pTestDecConfig->cbcrInterleave = TRUE;
+                pTestDecConfig->nv21 = TRUE;
+                pPort->format.video.eColorFormat = portFormat->eColorFormat;
+                break;
+            default:
+                LOG(SF_LOG_ERR, "Error to set parameter: %d, only nv12 nv21 i420 supported\r\n", portFormat->eColorFormat);
+                return OMX_ErrorBadParameter;
+                break;
+        }
         break;
+    }
     case OMX_IndexParamVideoBitrate:
         break;
     case OMX_IndexParamVideoQuantization:
@@ -526,7 +572,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
         OMX_PARAM_PORTDEFINITIONTYPE *pPortDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
         OMX_PARAM_PORTDEFINITIONTYPE *pInputPort = &pSfOMXComponent->portDefinition[0];
         OMX_PARAM_PORTDEFINITIONTYPE *pOutputPort = &pSfOMXComponent->portDefinition[1];
-        TestDecConfig *pTestDecConfig = (TestDecConfig *)pSfOMXComponent->testConfig;
+        TestDecConfig *pTestDecConfig = (TestDecConfig *)pSfVideoImplement->testConfig;
         OMX_U32 portIndex = pPortDefinition->nPortIndex;
         OMX_U32 width = pPortDefinition->format.video.nFrameWidth;
         OMX_U32 height = pPortDefinition->format.video.nFrameHeight;
@@ -539,9 +585,9 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
             if (pPortDefinition->nBufferCountActual != pInputPort->nBufferCountActual)
             {
                 LOG(SF_LOG_INFO, "Set input buffer count = %d\r\n", pPortDefinition->nBufferCountActual);
-                ComponentImpl *pFeederComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-                pSfOMXComponent->functions->ComponentPortDestroy(&pFeederComponent->srcPort);
-                pSfOMXComponent->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfOMXComponent->hSFComponentFeeder,
+                ComponentImpl *pFeederComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+                pSfVideoImplement->functions->ComponentPortDestroy(&pFeederComponent->srcPort);
+                pSfVideoImplement->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfVideoImplement->hSFComponentFeeder,
                                                                 pPortDefinition->nBufferCountActual, sizeof(PortContainerExternal));
             }
 
@@ -555,11 +601,11 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
         {
             if (pPortDefinition->nBufferCountActual != pOutputPort->nBufferCountActual)
             {
-                ComponentImpl *pRenderComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-                pSfOMXComponent->functions->SetRenderTotalBufferNumber(pRenderComponent, pPortDefinition->nBufferCountActual);
+                ComponentImpl *pRenderComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+                pSfVideoImplement->functions->SetRenderTotalBufferNumber(pRenderComponent, pPortDefinition->nBufferCountActual);
                 LOG(SF_LOG_INFO, "Set output buffer count = %d\r\n", pPortDefinition->nBufferCountActual);
-                pSfOMXComponent->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
-                pSfOMXComponent->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfOMXComponent->hSFComponentRender,
+                pSfVideoImplement->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
+                pSfVideoImplement->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfVideoImplement->hSFComponentRender,
                                                                 pPortDefinition->nBufferCountActual, sizeof(PortContainerExternal));
             }
 
@@ -597,7 +643,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
             pTestDecConfig->scaleDownWidth = VPU_CEIL(width, 2);
             pTestDecConfig->scaleDownHeight = VPU_CEIL(height, 2);
             LOG(SF_LOG_INFO, "Set scale = %d, %d\r\n", pTestDecConfig->scaleDownWidth , pTestDecConfig->scaleDownHeight);
-            /*
+             /*
                 if cbcrInterleave is FALSE and nv21 is FALSE, the default dec format is I420
                 if cbcrInterleave is TRUE and nv21 is FALSE, then the dec format is NV12
                 if cbcrInterleave is TRUE and nv21 is TRUE, then the dec format is NV21
@@ -629,7 +675,6 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
                 return OMX_ErrorBadParameter;
                 break;
             }
-
         }
     }
     break;
@@ -764,17 +809,18 @@ static OMX_ERRORTYPE InitDecoder(SF_OMX_COMPONENT *pSfOMXComponent)
     CNMComponentConfig *config = NULL;
     Uint32 sizeInWord;
     char *fwPath = NULL;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
 
-    if (pSfOMXComponent->hSFComponentExecoder != NULL)
+    if (pSfVideoImplement->hSFComponentExecoder != NULL)
     {
         return OMX_ErrorNone;
     }
 
     FunctionIn();
 
-    testConfig = (TestDecConfig *)pSfOMXComponent->testConfig;
+    testConfig = (TestDecConfig *)pSfVideoImplement->testConfig;
 
-    testConfig->productId = (ProductId)pSfOMXComponent->functions->VPU_GetProductId(testConfig->coreIdx);
+    testConfig->productId = (ProductId)pSfVideoImplement->functions->VPU_GetProductId(testConfig->coreIdx);
     if (CheckDecTestConfig(testConfig) == FALSE)
     {
         LOG(SF_LOG_ERR, "fail to CheckTestConfig()\n");
@@ -797,44 +843,44 @@ static OMX_ERRORTYPE InitDecoder(SF_OMX_COMPONENT *pSfOMXComponent)
         return OMX_ErrorBadParameter;
     }
     LOG(SF_LOG_INFO, "FW PATH = %s\n", fwPath);
-    if (pSfOMXComponent->functions->LoadFirmware(testConfig->productId, (Uint8 **)&(pSfOMXComponent->pusBitCode), &sizeInWord, fwPath) < 0)
+    if (pSfVideoImplement->functions->LoadFirmware(testConfig->productId, (Uint8 **)&(pSfVideoImplement->pusBitCode), &sizeInWord, fwPath) < 0)
     {
         LOG(SF_LOG_ERR, "Failed to load firmware: %s\n", fwPath);
         return OMX_ErrorInsufficientResources;
     }
 
-    config = pSfOMXComponent->config;
+    config = pSfVideoImplement->config;
     memcpy(&(config->testDecConfig), testConfig, sizeof(TestDecConfig));
-    config->bitcode = (Uint8 *)pSfOMXComponent->pusBitCode;
+    config->bitcode = (Uint8 *)pSfVideoImplement->pusBitCode;
     config->sizeOfBitcode = sizeInWord;
 
-    if (pSfOMXComponent->functions->SetUpDecoderOpenParam(&config->decOpenParam, &config->testDecConfig) != RETCODE_SUCCESS)
+    if (pSfVideoImplement->functions->SetUpDecoderOpenParam(&config->decOpenParam, &config->testDecConfig) != RETCODE_SUCCESS)
     {
         LOG(SF_LOG_ERR, "SetupDecoderOpenParam error\n");
         return OMX_ErrorBadParameter;
     }
-    LOG(SF_LOG_INFO, "cbcrInterleave = %d, nv21 = %d\r\n", testConfig->cbcrInterleave, testConfig->nv21);
-    pSfOMXComponent->hSFComponentExecoder = pSfOMXComponent->functions->ComponentCreate("wave_decoder", config);
-    pSfOMXComponent->hSFComponentFeeder = pSfOMXComponent->functions->ComponentCreate("feeder", config);
-    pSfOMXComponent->hSFComponentRender = pSfOMXComponent->functions->ComponentCreate("renderer", config);
+    LOG(SF_LOG_DEBUG, "cbcrInterleave = %d, nv21 = %d\r\n", testConfig->cbcrInterleave, testConfig->nv21);
+    pSfVideoImplement->hSFComponentExecoder = pSfVideoImplement->functions->ComponentCreate("wave_decoder", config);
+    pSfVideoImplement->hSFComponentFeeder = pSfVideoImplement->functions->ComponentCreate("feeder", config);
+    pSfVideoImplement->hSFComponentRender = pSfVideoImplement->functions->ComponentCreate("renderer", config);
 
-    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-    pSfOMXComponent->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfOMXComponent->hSFComponentFeeder, VPU_INPUT_BUF_NUMBER, sizeof(PortContainerExternal));
+    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+    pSfVideoImplement->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfVideoImplement->hSFComponentFeeder, VPU_INPUT_BUF_NUMBER, sizeof(PortContainerExternal));
 
-    ComponentImpl *pRenderComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-    pSfOMXComponent->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
-    pSfOMXComponent->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfOMXComponent->hSFComponentRender, VPU_OUTPUT_BUF_NUMBER, sizeof(PortContainerExternal));
+    ComponentImpl *pRenderComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+    pSfVideoImplement->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
+    pSfVideoImplement->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfVideoImplement->hSFComponentRender, VPU_OUTPUT_BUF_NUMBER, sizeof(PortContainerExternal));
 
-    if (pSfOMXComponent->functions->SetupDecListenerContext(pSfOMXComponent->lsnCtx, config, NULL) == TRUE)
+    if (pSfVideoImplement->functions->SetupDecListenerContext(pSfVideoImplement->lsnCtx, config, NULL) == TRUE)
     {
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentExecoder,
-                                                              COMPONENT_EVENT_DEC_ALL, pSfOMXComponent->functions->DecoderListener, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentRender,
-                                                              COMPONENT_EVENT_DEC_DECODED_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentFeeder,
-                                                              COMPONENT_EVENT_DEC_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentRender,
-                                                              COMPONENT_EVENT_DEC_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentExecoder,
+                                                              COMPONENT_EVENT_DEC_ALL, pSfVideoImplement->functions->DecoderListener, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentRender,
+                                                              COMPONENT_EVENT_DEC_DECODED_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentFeeder,
+                                                              COMPONENT_EVENT_DEC_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentRender,
+                                                              COMPONENT_EVENT_DEC_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
     }
     else
     {
@@ -842,8 +888,8 @@ static OMX_ERRORTYPE InitDecoder(SF_OMX_COMPONENT *pSfOMXComponent)
         return OMX_ErrorBadParameter;
     }
 
-    pSfOMXComponent->functions->ComponentSetupTunnel(pSfOMXComponent->hSFComponentFeeder, pSfOMXComponent->hSFComponentExecoder);
-    pSfOMXComponent->functions->ComponentSetupTunnel(pSfOMXComponent->hSFComponentExecoder, pSfOMXComponent->hSFComponentRender);
+    pSfVideoImplement->functions->ComponentSetupTunnel(pSfVideoImplement->hSFComponentFeeder, pSfVideoImplement->hSFComponentExecoder);
+    pSfVideoImplement->functions->ComponentSetupTunnel(pSfVideoImplement->hSFComponentExecoder, pSfVideoImplement->hSFComponentRender);
     FunctionOut();
     return OMX_ErrorNone;
 }
@@ -857,6 +903,7 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     ComponentImpl *pSFComponentDecoder = NULL;
     ComponentImpl *pSFComponentFeeder = NULL;
     ComponentImpl *pSFComponentRender = NULL;
@@ -879,14 +926,14 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
         switch (nParam)
         {
         case OMX_StateLoaded:
-            if (pSfOMXComponent->hSFComponentExecoder == NULL)
+            if (pSfVideoImplement->hSFComponentExecoder == NULL)
             {
                 break;
             }
-            pSFComponentDecoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-            componentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            pSFComponentDecoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+            componentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", componentState);
             switch(componentState)
             {
@@ -894,8 +941,8 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                 case COMPONENT_STATE_PREPARED:
                 case COMPONENT_STATE_EXECUTED:
                 case COMPONENT_STATE_TERMINATED:
-                    if (pSfOMXComponent->functions->Queue_Get_Cnt(pSFComponentRender->sinkPort.inputQ) > 0 ||
-                        pSfOMXComponent->functions->Queue_Get_Cnt(pSFComponentFeeder->srcPort.inputQ) > 0)
+                    if (pSfVideoImplement->functions->Queue_Get_Cnt(pSFComponentRender->sinkPort.inputQ) > 0 ||
+                        pSfVideoImplement->functions->Queue_Get_Cnt(pSFComponentFeeder->srcPort.inputQ) > 0)
                     {
                         LOG(SF_LOG_ERR, "Buffer not flush!\r\n")
                         // ret = OMX_ErrorIncorrectStateTransition;
@@ -912,7 +959,7 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
             }
             break;
         case OMX_StateIdle:
-            if (pSfOMXComponent->hSFComponentExecoder == NULL)
+            if (pSfVideoImplement->hSFComponentExecoder == NULL)
             {
                 ret = InitDecoder(pSfOMXComponent);
                 if (ret != OMX_ErrorNone)
@@ -920,10 +967,10 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                     goto EXIT;
                 }
             }
-            pSFComponentDecoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-            componentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            pSFComponentDecoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+            componentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", componentState);
             switch(componentState)
             {
@@ -956,11 +1003,11 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
             {
                 goto EXIT;
             }
-            pSFComponentDecoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+            pSFComponentDecoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
 
-            componentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            componentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", componentState);
             switch(componentState)
             {
@@ -972,19 +1019,19 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                 if (pSFComponentDecoder->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentDecoder->name);
-                    componentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentDecoder);
+                    componentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentDecoder);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", componentState);
                 }
                 if (pSFComponentFeeder->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentFeeder->name);
-                    componentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentFeeder);
+                    componentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentFeeder);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", componentState);
                 }
                 if (pSFComponentRender->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentRender->name);
-                    componentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentRender);
+                    componentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentRender);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", componentState);
                 }
                 break;
@@ -1089,20 +1136,21 @@ static OMX_ERRORTYPE SF_OMX_UseEGLImage(
     return OMX_ErrorNotImplemented;
 }
 
-static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *hComponent)
+static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *pSfOMXComponent)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     FunctionIn();
 
-    ret = InitComponentStructorCommon(hComponent);
+    ret = InitComponentStructorCommon(pSfOMXComponent);
     if (ret != OMX_ErrorNone)
     {
         goto EXIT;
     }
-    TestDecConfig *pTestDecConfig = (TestDecConfig *)hComponent->testConfig;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    TestDecConfig *pTestDecConfig = (TestDecConfig *)pSfVideoImplement->testConfig;
     pTestDecConfig->feedingMode = FEEDING_METHOD_BUFFER;
     pTestDecConfig->bitstreamMode = BS_MODE_PIC_END;
-    pTestDecConfig->bitFormat = hComponent->bitFormat;
+    pTestDecConfig->bitFormat = pSfVideoImplement->bitFormat;
     /* 
      if cbcrInterleave is FALSE and nv21 is FALSE, the default dec format is I420
      if cbcrInterleave is TRUE and nv21 is FALSE, then the dec format is NV12
@@ -1111,21 +1159,21 @@ static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *hComponent)
     pTestDecConfig->cbcrInterleave = TRUE;
     pTestDecConfig->nv21 = FALSE;
 
-    hComponent->pOMXComponent->UseBuffer = &SF_OMX_UseBuffer;
-    hComponent->pOMXComponent->AllocateBuffer = &SF_OMX_AllocateBuffer;
-    hComponent->pOMXComponent->EmptyThisBuffer = &SF_OMX_EmptyThisBuffer;
-    hComponent->pOMXComponent->FillThisBuffer = &SF_OMX_FillThisBuffer;
-    hComponent->pOMXComponent->FreeBuffer = &SF_OMX_FreeBuffer;
-    // hComponent->pOMXComponent->ComponentTunnelRequest = &SF_OMX_ComponentTunnelRequest;
-    hComponent->pOMXComponent->GetParameter = &SF_OMX_GetParameter;
-    hComponent->pOMXComponent->SetParameter = &SF_OMX_SetParameter;
-    hComponent->pOMXComponent->GetConfig = &SF_OMX_GetConfig;
-    hComponent->pOMXComponent->SetConfig = &SF_OMX_SetConfig;
-    hComponent->pOMXComponent->SendCommand = &SF_OMX_SendCommand;
-    hComponent->pOMXComponent->GetState = &SF_OMX_GetState;
-    // hComponent->pOMXComponent->GetExtensionIndex = &SF_OMX_GetExtensionIndex;
-    // hComponent->pOMXComponent->ComponentRoleEnum = &SF_OMX_ComponentRoleEnum;
-    // hComponent->pOMXComponent->ComponentDeInit = &SF_OMX_ComponentDeInit;
+    pSfOMXComponent->pOMXComponent->UseBuffer = &SF_OMX_UseBuffer;
+    pSfOMXComponent->pOMXComponent->AllocateBuffer = &SF_OMX_AllocateBuffer;
+    pSfOMXComponent->pOMXComponent->EmptyThisBuffer = &SF_OMX_EmptyThisBuffer;
+    pSfOMXComponent->pOMXComponent->FillThisBuffer = &SF_OMX_FillThisBuffer;
+    pSfOMXComponent->pOMXComponent->FreeBuffer = &SF_OMX_FreeBuffer;
+    // pSfOMXComponent->pOMXComponent->ComponentTunnelRequest = &SF_OMX_ComponentTunnelRequest;
+    pSfOMXComponent->pOMXComponent->GetParameter = &SF_OMX_GetParameter;
+    pSfOMXComponent->pOMXComponent->SetParameter = &SF_OMX_SetParameter;
+    pSfOMXComponent->pOMXComponent->GetConfig = &SF_OMX_GetConfig;
+    pSfOMXComponent->pOMXComponent->SetConfig = &SF_OMX_SetConfig;
+    pSfOMXComponent->pOMXComponent->SendCommand = &SF_OMX_SendCommand;
+    pSfOMXComponent->pOMXComponent->GetState = &SF_OMX_GetState;
+    // pSfOMXComponent->pOMXComponent->GetExtensionIndex = &SF_OMX_GetExtensionIndex;
+    // pSfOMXComponent->pOMXComponent->ComponentRoleEnum = &SF_OMX_ComponentRoleEnum;
+    // pSfOMXComponent->pOMXComponent->ComponentDeInit = &SF_OMX_ComponentDeInit;
 
 EXIT:
     FunctionOut();
@@ -1133,12 +1181,13 @@ EXIT:
     return ret;
 }
 
-static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *hComponent)
+static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *pSfOMXComponent)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
-    ComponentImpl *pSFComponentDecoder = (ComponentImpl *)hComponent->hSFComponentExecoder;
-    ComponentImpl *pSFComponentFeeder = (ComponentImpl *)hComponent->hSFComponentFeeder;
-    ComponentImpl *pSFComponentRender = (ComponentImpl *)hComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pSFComponentDecoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+    ComponentImpl *pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+    ComponentImpl *pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
 
     FunctionIn();
     if (pSFComponentDecoder == NULL || pSFComponentFeeder == NULL || pSFComponentRender == NULL)
@@ -1148,13 +1197,13 @@ static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *hComponent)
     pSFComponentDecoder->terminate = OMX_TRUE;
     pSFComponentFeeder->terminate = OMX_TRUE;
     pSFComponentRender->terminate = OMX_TRUE;
-    hComponent->functions->ComponentWait(hComponent->hSFComponentFeeder);
-    hComponent->functions->ComponentWait(hComponent->hSFComponentExecoder);
-    hComponent->functions->ComponentWait(hComponent->hSFComponentRender);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentFeeder);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentExecoder);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentRender);
 
-    free(hComponent->pusBitCode);
-    hComponent->functions->ClearDecListenerContext(hComponent->lsnCtx);
-    ComponentClearCommon(hComponent);
+    free(pSfVideoImplement->pusBitCode);
+    pSfVideoImplement->functions->ClearDecListenerContext(pSfVideoImplement->lsnCtx);
+    ComponentClearCommon(pSfOMXComponent);
 EXIT:
     FunctionOut();
 
@@ -1167,8 +1216,9 @@ SF_OMX_COMPONENT sf_dec_decoder_h265 = {
     .pOMXComponent = NULL,
     .SF_OMX_ComponentConstructor = SF_OMX_ComponentConstructor,
     .SF_OMX_ComponentClear = SF_OMX_ComponentClear,
-    .functions = NULL,
-    .bitFormat = STD_HEVC,
+    // .functions = NULL,
+    // .bitFormat = STD_HEVC,
+    .componentImpl = NULL,
     .fwPath = "/lib/firmware/chagall.bin",
     .componentRule = "video_decoder.hevc"};
 
@@ -1178,7 +1228,8 @@ SF_OMX_COMPONENT sf_dec_decoder_h264 = {
     .pOMXComponent = NULL,
     .SF_OMX_ComponentConstructor = SF_OMX_ComponentConstructor,
     .SF_OMX_ComponentClear = SF_OMX_ComponentClear,
-    .functions = NULL,
-    .bitFormat = STD_AVC,
+    // .functions = NULL,
+    // .bitFormat = STD_AVC,
+    .componentImpl = NULL,
     .fwPath = "/lib/firmware/chagall.bin",
     .componentRule = "video_decoder.avc"};

+ 117 - 109
soft_3rdpart/omx-il/component/video/enc/SF_OMX_Venc_encoder.c

@@ -60,6 +60,7 @@ static void OnEventArrived(Component com, unsigned long event, void *data, void
 {
     FunctionIn();
     SF_OMX_COMPONENT *pSfOMXComponent = GetSFOMXComponrntByComponent(com);
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     ComponentImpl *pSFComponent = (ComponentImpl *)com;
     static OMX_U32 enc_cnt = 0;
     static struct timeval tv_old = {0};
@@ -110,8 +111,8 @@ static void OnEventArrived(Component com, unsigned long event, void *data, void
         }
         LOG(SF_LOG_PERF, "OMX finish one buffer, address = %p, size = %d, nTimeStamp = %d, nFlags = %X\r\n", pOMXBuffer->pBuffer, pOMXBuffer->nFilledLen, pOMXBuffer->nTimeStamp, pOMXBuffer->nFlags);
         pSfOMXComponent->callbacks->FillBufferDone(pSfOMXComponent->pOMXComponent, pSfOMXComponent->pAppData, pOMXBuffer);
-        ComponentImpl *pRendererComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-        LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
+        ComponentImpl *pRendererComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+        LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
                                                     pSfOMXComponent->portDefinition[1].nBufferCountActual);
     }
     break;
@@ -147,8 +148,8 @@ static OMX_ERRORTYPE SF_OMX_EmptyThisBuffer(
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
 
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
-
-    ComponentImpl *pFeederComponent = pSfOMXComponent->hSFComponentFeeder;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pFeederComponent = pSfVideoImplement->hSFComponentFeeder;
 
     PortContainerExternal *pPortContainerExternal = malloc(sizeof(PortContainerExternal));
     if (pPortContainerExternal == NULL)
@@ -162,13 +163,13 @@ static OMX_ERRORTYPE SF_OMX_EmptyThisBuffer(
     pPortContainerExternal->nFlags = pBuffer->nFlags;
     pPortContainerExternal->nBufferIndex = (OMX_U32)pBuffer->pInputPortPrivate;
     LOG(SF_LOG_INFO, "Index = %d, Address = %p, Flag = %X\r\n",(int)pBuffer->pInputPortPrivate, pBuffer->pBuffer, pBuffer->nFlags);
-    if (pSfOMXComponent->functions->Queue_Enqueue(pFeederComponent->srcPort.inputQ, (void *)pPortContainerExternal) != OMX_TRUE)
+    if (pSfVideoImplement->functions->Queue_Enqueue(pFeederComponent->srcPort.inputQ, (void *)pPortContainerExternal) != OMX_TRUE)
     {
         LOG(SF_LOG_ERR, "%p:%p FAIL\r\n", pFeederComponent->srcPort.inputQ, pPortContainerExternal);
         free(pPortContainerExternal);
         return OMX_ErrorInsufficientResources;
     }
-    LOG(SF_LOG_PERF, "input queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ), 
+    LOG(SF_LOG_PERF, "input queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pFeederComponent->srcPort.inputQ), 
                                                     pSfOMXComponent->portDefinition[0].nBufferCountActual);
     free(pPortContainerExternal);
     pFeederComponent->pause = OMX_FALSE;
@@ -193,7 +194,8 @@ static OMX_ERRORTYPE SF_OMX_FillThisBuffer(
 
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = (SF_OMX_COMPONENT *)pOMXComponent->pComponentPrivate;
-    ComponentImpl *pRendererComponent = pSfOMXComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pRendererComponent = pSfVideoImplement->hSFComponentRender;
     PortContainerExternal *pPortContainerExternal = malloc(sizeof(PortContainerExternal));
     if (pPortContainerExternal == NULL)
     {
@@ -203,13 +205,13 @@ static OMX_ERRORTYPE SF_OMX_FillThisBuffer(
     memset(pPortContainerExternal, 0, sizeof(PortContainerExternal));
     pPortContainerExternal->pBuffer = pBuffer->pBuffer;
     pPortContainerExternal->nFilledLen = pBuffer->nAllocLen;
-    if (pSfOMXComponent->functions->Queue_Enqueue(pRendererComponent->sinkPort.inputQ, (void *)pPortContainerExternal) == -1)
+    if (pSfVideoImplement->functions->Queue_Enqueue(pRendererComponent->sinkPort.inputQ, (void *)pPortContainerExternal) == -1)
     {
         LOG(SF_LOG_ERR, "%p:%p FAIL\r\n", pRendererComponent->sinkPort.inputQ, pPortContainerExternal);
         free(pPortContainerExternal);
         return OMX_ErrorInsufficientResources;
     }
-    LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfOMXComponent->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
+    LOG(SF_LOG_PERF, "output queue count=%d/%d\r\n", pSfVideoImplement->functions->Queue_Get_Cnt(pRendererComponent->sinkPort.inputQ),
                                                         pSfOMXComponent->portDefinition[1].nBufferCountActual);
     free(pPortContainerExternal);
     pRendererComponent->pause = OMX_FALSE;
@@ -270,7 +272,8 @@ static OMX_ERRORTYPE SF_OMX_AllocateBuffer(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
-    ComponentImpl *pComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
     OMX_U32 i = 0;
 
     FunctionIn();
@@ -295,7 +298,7 @@ static OMX_ERRORTYPE SF_OMX_AllocateBuffer(
         // Alloc DMA memory first
         if (pSfOMXComponent->memory_optimization)
         {
-            temp_bufferHeader->pBuffer = pSfOMXComponent->functions->AllocateFrameBuffer2(pComponentFeeder, nSizeBytes);
+            temp_bufferHeader->pBuffer = pSfVideoImplement->functions->AllocateFrameBuffer2(pComponentFeeder, nSizeBytes);
         }
         // DMA Memory alloc fail, goto normal alloc
         if (temp_bufferHeader->pBuffer == NULL)
@@ -343,6 +346,7 @@ static OMX_ERRORTYPE SF_OMX_GetParameter(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     OMX_PARAM_PORTDEFINITIONTYPE *pInputPort = &pSfOMXComponent->portDefinition[0];
     OMX_PARAM_PORTDEFINITIONTYPE *pOutputPort = &pSfOMXComponent->portDefinition[1];
 
@@ -429,7 +433,7 @@ static OMX_ERRORTYPE SF_OMX_GetParameter(
     {
         OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
         OMX_U32 nPortIndex = pDstAVCComponent->nPortIndex;
-        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = &pSfOMXComponent->AVCComponent[nPortIndex];
+        OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent = &pSfVideoImplement->AVCComponent[nPortIndex];
 
         LOG(SF_LOG_INFO, "Get nPFrames = %d on port %d\r\n", pSrcAVCComponent->nPFrames, nPortIndex);
         memcpy(pDstAVCComponent, pSrcAVCComponent, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
@@ -439,7 +443,7 @@ static OMX_ERRORTYPE SF_OMX_GetParameter(
     {
         OMX_VIDEO_PARAM_HEVCTYPE *pDstHEVCComponent = (OMX_VIDEO_PARAM_HEVCTYPE *)ComponentParameterStructure;
         OMX_U32 nPortIndex = pDstHEVCComponent->nPortIndex;
-        OMX_VIDEO_PARAM_HEVCTYPE *pSrcHEVCComponent = &pSfOMXComponent->HEVCComponent[nPortIndex];
+        OMX_VIDEO_PARAM_HEVCTYPE *pSrcHEVCComponent = &pSfVideoImplement->HEVCComponent[nPortIndex];
 
         LOG(SF_LOG_INFO, "Get nKeyFrameInterval = %d on port %d\r\n", pSrcHEVCComponent->nKeyFrameInterval, nPortIndex);
         memcpy(pDstHEVCComponent, pSrcHEVCComponent, sizeof(OMX_VIDEO_PARAM_HEVCTYPE));
@@ -489,6 +493,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
 
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     OMX_PARAM_PORTDEFINITIONTYPE *pInputPort = &pSfOMXComponent->portDefinition[0];
     OMX_PARAM_PORTDEFINITIONTYPE *pOutputPort = &pSfOMXComponent->portDefinition[1];
 
@@ -512,8 +517,8 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
         LOG(SF_LOG_INFO, "Set width = %d, height = %d, xFramerate = %d, nBitrate = %d, nBufferCountActual = %d on port %d\r\n",
             width, height, xFramerate, nBitrate, nBufferCountActual, portIndex);
         OMX_COLOR_FORMATTYPE eColorFormat = pPortDefinition->format.video.eColorFormat;
-        TestEncConfig *pTestEncConfig = (TestEncConfig *)pSfOMXComponent->testConfig;
-        CNMComponentConfig *config = pSfOMXComponent->config;
+        TestEncConfig *pTestEncConfig = (TestEncConfig *)pSfVideoImplement->testConfig;
+        CNMComponentConfig *config = pSfVideoImplement->config;
         EncOpenParam *encOpenParam = &config->encOpenParam;
 
         if (xFramerate == 0)
@@ -526,9 +531,9 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
             if (nBufferCountActual != pInputPort->nBufferCountActual)
             {
                 LOG(SF_LOG_INFO, "Set input buffer count = %d\r\n", nBufferCountActual);
-                ComponentImpl *pFeederComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-                pSfOMXComponent->functions->ComponentPortDestroy(&pFeederComponent->srcPort);
-                pSfOMXComponent->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfOMXComponent->hSFComponentFeeder,
+                ComponentImpl *pFeederComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+                pSfVideoImplement->functions->ComponentPortDestroy(&pFeederComponent->srcPort);
+                pSfVideoImplement->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfVideoImplement->hSFComponentFeeder,
                                                                 nBufferCountActual, sizeof(PortContainerExternal));
             }
 
@@ -560,10 +565,10 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
             LOG(SF_LOG_INFO, "Current output buffer count = %d\r\n", pOutputPort->nBufferCountActual);
             if (nBufferCountActual != pOutputPort->nBufferCountActual)
             {
-                ComponentImpl *pRenderComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+                ComponentImpl *pRenderComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
                 LOG(SF_LOG_INFO, "Set output buffer count = %d\r\n", nBufferCountActual);
-                pSfOMXComponent->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
-                pSfOMXComponent->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfOMXComponent->hSFComponentRender,
+                pSfVideoImplement->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
+                pSfVideoImplement->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfVideoImplement->hSFComponentRender,
                                                                 nBufferCountActual, sizeof(PortContainerExternal));
             }
 
@@ -592,7 +597,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
     case OMX_IndexParamVideoPortFormat:
         {
             OMX_VIDEO_PARAM_PORTFORMATTYPE *portFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE *)ComponentParameterStructure;
-            TestEncConfig *pTestEncConfig = (TestEncConfig *)pSfOMXComponent->testConfig;
+            TestEncConfig *pTestEncConfig = (TestEncConfig *)pSfVideoImplement->testConfig;
             OMX_COLOR_FORMATTYPE eColorFormat = portFormat->eColorFormat;
             LOG(SF_LOG_INFO, "Set eColorFormat to %d\r\n", eColorFormat);
             switch (eColorFormat)
@@ -641,7 +646,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
         }
         else
         {
-            pSfOMXComponent->AVCComponent[1].nPFrames = pAVCIntraPeriod->nPFrames;
+            pSfVideoImplement->AVCComponent[1].nPFrames = pAVCIntraPeriod->nPFrames;
         }
     }
     break;
@@ -649,7 +654,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
     {
         OMX_VIDEO_PARAM_AVCTYPE *pSrcAVCComponent= (OMX_VIDEO_PARAM_AVCTYPE *)ComponentParameterStructure;
         OMX_U32 nPortIndex = pSrcAVCComponent->nPortIndex;
-        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = &pSfOMXComponent->AVCComponent[nPortIndex];
+        OMX_VIDEO_PARAM_AVCTYPE *pDstAVCComponent = &pSfVideoImplement->AVCComponent[nPortIndex];
         OMX_U32 nPFrames = pSrcAVCComponent->nPFrames;
 
         LOG(SF_LOG_INFO, "Set nPFrames = %d on port %d\r\n", nPFrames, nPortIndex);
@@ -666,7 +671,7 @@ static OMX_ERRORTYPE SF_OMX_SetParameter(
     {
         OMX_VIDEO_PARAM_HEVCTYPE *pSrcHEVCComponent= (OMX_VIDEO_PARAM_HEVCTYPE *)ComponentParameterStructure;
         OMX_U32 nPortIndex = pSrcHEVCComponent->nPortIndex;
-        OMX_VIDEO_PARAM_HEVCTYPE *pDstHEVCComponent = &pSfOMXComponent->HEVCComponent[nPortIndex];
+        OMX_VIDEO_PARAM_HEVCTYPE *pDstHEVCComponent = &pSfVideoImplement->HEVCComponent[nPortIndex];
         OMX_U32 nKeyFrameInterval = pSrcHEVCComponent->nKeyFrameInterval;
 
         LOG(SF_LOG_INFO, "Set nKeyFrameInterval = %d on port %d\r\n", nKeyFrameInterval, nPortIndex);
@@ -800,17 +805,18 @@ static OMX_ERRORTYPE InitEncoder(SF_OMX_COMPONENT *pSfOMXComponent)
     CNMComponentConfig *config = NULL;
     Uint32 sizeInWord;
     char *fwPath = NULL;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
 
-    if (pSfOMXComponent->hSFComponentExecoder != NULL)
+    if (pSfVideoImplement->hSFComponentExecoder != NULL)
     {
         return OMX_ErrorNone;
     }
 
     FunctionIn();
 
-    testConfig = (TestEncConfig *)pSfOMXComponent->testConfig;
+    testConfig = (TestEncConfig *)pSfVideoImplement->testConfig;
 
-    testConfig->productId = (ProductId)pSfOMXComponent->functions->VPU_GetProductId(testConfig->coreIdx);
+    testConfig->productId = (ProductId)pSfVideoImplement->functions->VPU_GetProductId(testConfig->coreIdx);
     if (CheckEncTestConfig(testConfig) == FALSE)
     {
         LOG(SF_LOG_ERR, "fail to CheckTestConfig()\n");
@@ -833,25 +839,25 @@ static OMX_ERRORTYPE InitEncoder(SF_OMX_COMPONENT *pSfOMXComponent)
         return OMX_ErrorBadParameter;
     }
     LOG(SF_LOG_INFO, "FW PATH = %s\n", fwPath);
-    if (pSfOMXComponent->functions->LoadFirmware(testConfig->productId, (Uint8 **)&(pSfOMXComponent->pusBitCode), &sizeInWord, fwPath) < 0)
+    if (pSfVideoImplement->functions->LoadFirmware(testConfig->productId, (Uint8 **)&(pSfVideoImplement->pusBitCode), &sizeInWord, fwPath) < 0)
     {
         LOG(SF_LOG_ERR, "Failed to load firmware: %s\n", fwPath);
         return OMX_ErrorInsufficientResources;
     }
 
-    config = pSfOMXComponent->config;
+    config = pSfVideoImplement->config;
     memcpy(&(config->testEncConfig), testConfig, sizeof(TestEncConfig));
-    config->bitcode = (Uint8 *)pSfOMXComponent->pusBitCode;
+    config->bitcode = (Uint8 *)pSfVideoImplement->pusBitCode;
     config->sizeOfBitcode = sizeInWord;
     LOG(SF_LOG_INFO, "cbcrInterleave= %d, nv21 = %d\r\n", config->testEncConfig.cbcrInterleave, config->testEncConfig.nv21);
     memcpy(config->testEncConfig.cfgFileName, WAVE521_CONFIG_FILE, sizeof(WAVE521_CONFIG_FILE));
     LOG(SF_LOG_INFO, "Get width = %d, height = %d \r\n", config->encOpenParam.picWidth, config->encOpenParam.picHeight);
-    if (pSfOMXComponent->functions->SetupEncoderOpenParam(&config->encOpenParam, &config->testEncConfig, NULL) == OMX_FALSE)
+    if (pSfVideoImplement->functions->SetupEncoderOpenParam(&config->encOpenParam, &config->testEncConfig, NULL) == OMX_FALSE)
     {
         LOG(SF_LOG_ERR, "SetupEncoderOpenParam error\n");
         return OMX_ErrorBadParameter;
     }
-    CNMComponentConfig *pCNMComponentConfig = (CNMComponentConfig*)pSfOMXComponent->config;
+    CNMComponentConfig *pCNMComponentConfig = (CNMComponentConfig*)pSfVideoImplement->config;
     config->encOpenParam.picWidth = pSfOMXComponent->portDefinition[0].format.video.nFrameWidth;
     config->encOpenParam.picHeight = pSfOMXComponent->portDefinition[0].format.video.nFrameHeight;
 
@@ -875,51 +881,51 @@ static OMX_ERRORTYPE InitEncoder(SF_OMX_COMPONENT *pSfOMXComponent)
         pSfOMXComponent->portDefinition[1].format.video.nBitrate = config->encOpenParam.bitRate;
     }
 
-    if (pSfOMXComponent->bitFormat == STD_AVC)
+    if (pSfVideoImplement->bitFormat == STD_AVC)
     {
-        config->encOpenParam.EncStdParam.waveParam.intraPeriod = pSfOMXComponent->AVCComponent[1].nPFrames;
+        config->encOpenParam.EncStdParam.waveParam.intraPeriod = pSfVideoImplement->AVCComponent[1].nPFrames;
     }
-    else if (pSfOMXComponent->bitFormat == STD_HEVC)
+    else if (pSfVideoImplement->bitFormat == STD_HEVC)
     {
-        config->encOpenParam.EncStdParam.waveParam.intraPeriod = pSfOMXComponent->HEVCComponent[1].nKeyFrameInterval;
+        config->encOpenParam.EncStdParam.waveParam.intraPeriod = pSfVideoImplement->HEVCComponent[1].nKeyFrameInterval;
     }
     LOG(SF_LOG_INFO, "Get width = %d, height = %d frameRateInfo = %d intraPeriod = %d bitrate = %d\r\n",
         config->encOpenParam.picWidth, config->encOpenParam.picHeight, config->encOpenParam.frameRateInfo,
         config->encOpenParam.EncStdParam.waveParam.intraPeriod, config->encOpenParam.bitRate);
 
-    pSfOMXComponent->hSFComponentExecoder = pSfOMXComponent->functions->ComponentCreate("wave_encoder", config);
-    pSfOMXComponent->hSFComponentFeeder = pSfOMXComponent->functions->ComponentCreate("yuvfeeder", config);
-    pSfOMXComponent->hSFComponentRender = pSfOMXComponent->functions->ComponentCreate("reader", config);
+    pSfVideoImplement->hSFComponentExecoder = pSfVideoImplement->functions->ComponentCreate("wave_encoder", config);
+    pSfVideoImplement->hSFComponentFeeder = pSfVideoImplement->functions->ComponentCreate("yuvfeeder", config);
+    pSfVideoImplement->hSFComponentRender = pSfVideoImplement->functions->ComponentCreate("reader", config);
 
-    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-    pSfOMXComponent->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfOMXComponent->hSFComponentFeeder,
+    ComponentImpl *pFeederComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+    pSfVideoImplement->functions->ComponentPortCreate(&pFeederComponent->srcPort, pSfVideoImplement->hSFComponentFeeder,
                     pSfOMXComponent->portDefinition[0].nBufferCountActual, sizeof(PortContainerExternal));
 
-    ComponentImpl *pRenderComponent = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-    pSfOMXComponent->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
-    pSfOMXComponent->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfOMXComponent->hSFComponentRender,
+    ComponentImpl *pRenderComponent = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+    pSfVideoImplement->functions->ComponentPortDestroy(&pRenderComponent->sinkPort);
+    pSfVideoImplement->functions->ComponentPortCreate(&pRenderComponent->sinkPort, pSfVideoImplement->hSFComponentRender,
                     pSfOMXComponent->portDefinition[1].nBufferCountActual, sizeof(PortContainerExternal));
 
-    if (pSfOMXComponent->functions->SetupEncListenerContext(pSfOMXComponent->lsnCtx, config) == TRUE)
+    if (pSfVideoImplement->functions->SetupEncListenerContext(pSfVideoImplement->lsnCtx, config) == TRUE)
     {
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentExecoder,
-                                                              COMPONENT_EVENT_ENC_ALL, pSfOMXComponent->functions->EncoderListener, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentExecoder,
-                                                              COMPONENT_EVENT_ENC_REGISTER_FB, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentExecoder,
-                                                              COMPONENT_EVENT_ENC_ENCODED_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentFeeder,
-                                                              COMPONENT_EVENT_ENC_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
-        pSfOMXComponent->functions->ComponentRegisterListener(pSfOMXComponent->hSFComponentRender,
-                                                              COMPONENT_EVENT_ENC_ALL, OnEventArrived, (void *)pSfOMXComponent->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentExecoder,
+                                                              COMPONENT_EVENT_ENC_ALL, pSfVideoImplement->functions->EncoderListener, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentExecoder,
+                                                              COMPONENT_EVENT_ENC_REGISTER_FB, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentExecoder,
+                                                              COMPONENT_EVENT_ENC_ENCODED_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentFeeder,
+                                                              COMPONENT_EVENT_ENC_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
+        pSfVideoImplement->functions->ComponentRegisterListener(pSfVideoImplement->hSFComponentRender,
+                                                              COMPONENT_EVENT_ENC_ALL, OnEventArrived, (void *)pSfVideoImplement->lsnCtx);
     }
     else
     {
         LOG(SF_LOG_ERR, "ComponentRegisterListener fail\r\n");
         return OMX_ErrorBadParameter;
     }
-    pSfOMXComponent->functions->ComponentSetupTunnel(pSfOMXComponent->hSFComponentFeeder, pSfOMXComponent->hSFComponentExecoder);
-    pSfOMXComponent->functions->ComponentSetupTunnel(pSfOMXComponent->hSFComponentExecoder, pSfOMXComponent->hSFComponentRender);
+    pSfVideoImplement->functions->ComponentSetupTunnel(pSfVideoImplement->hSFComponentFeeder, pSfVideoImplement->hSFComponentExecoder);
+    pSfVideoImplement->functions->ComponentSetupTunnel(pSfVideoImplement->hSFComponentExecoder, pSfVideoImplement->hSFComponentRender);
     FunctionOut();
     return OMX_ErrorNone;
 }
@@ -933,6 +939,7 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     OMX_COMPONENTTYPE *pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
     SF_OMX_COMPONENT *pSfOMXComponent = pOMXComponent->pComponentPrivate;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
     ComponentImpl *pSFComponentEncoder = NULL;
     ComponentImpl *pSFComponentFeeder = NULL;
     ComponentImpl *pSFComponentRender = NULL;
@@ -955,14 +962,14 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
         switch (nParam)
         {
         case OMX_StateLoaded:
-            if (pSfOMXComponent->hSFComponentExecoder == NULL)
+            if (pSfVideoImplement->hSFComponentExecoder == NULL)
             {
                 break;
             }
-            pSFComponentEncoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-            currentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            pSFComponentEncoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+            currentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", currentState);
             switch(currentState)
             {
@@ -970,8 +977,8 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                 case COMPONENT_STATE_PREPARED:
                 case COMPONENT_STATE_EXECUTED:
                 case COMPONENT_STATE_TERMINATED:
-                if (pSfOMXComponent->functions->Queue_Get_Cnt(pSFComponentRender->sinkPort.inputQ) > 0 ||
-                    pSfOMXComponent->functions->Queue_Get_Cnt(pSFComponentFeeder->srcPort.inputQ) > 0)
+                if (pSfVideoImplement->functions->Queue_Get_Cnt(pSFComponentRender->sinkPort.inputQ) > 0 ||
+                    pSfVideoImplement->functions->Queue_Get_Cnt(pSFComponentFeeder->srcPort.inputQ) > 0)
                 {
                     LOG(SF_LOG_ERR, "Buffer not flush!\r\n")
                     // ret = OMX_ErrorIncorrectStateTransition;
@@ -987,7 +994,7 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
             }
             break;
         case OMX_StateIdle:
-            if (pSfOMXComponent->hSFComponentExecoder == NULL)
+            if (pSfVideoImplement->hSFComponentExecoder == NULL)
             {
                 ret = InitEncoder(pSfOMXComponent);
                 if (ret != OMX_ErrorNone)
@@ -996,10 +1003,10 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                 }
             }
 
-            pSFComponentEncoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
-            currentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            pSFComponentEncoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
+            currentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", currentState);
             switch(currentState)
             {
@@ -1010,22 +1017,22 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
                 if (pSFComponentEncoder->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentEncoder->name);
-                    currentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentEncoder);
+                    currentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentEncoder);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", currentState);
                 }
                 if (pSFComponentFeeder->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentFeeder->name);
-                    currentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentFeeder);
+                    currentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentFeeder);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", currentState);
                 }
                 if (pSFComponentRender->thread == NULL)
                 {
                     LOG(SF_LOG_INFO, "execute component %s\r\n", pSFComponentRender->name);
-                    currentState = pSfOMXComponent->functions->ComponentExecute(pSFComponentRender);
+                    currentState = pSfVideoImplement->functions->ComponentExecute(pSFComponentRender);
                     LOG(SF_LOG_INFO, "ret = %d\r\n", currentState);
                 }
-                pSfOMXComponent->functions->WaitForExecoderReady(pSFComponentEncoder);
+                pSfVideoImplement->functions->WaitForExecoderReady(pSFComponentEncoder);
                 break;
             case COMPONENT_STATE_PREPARED:
             case COMPONENT_STATE_EXECUTED:
@@ -1044,12 +1051,12 @@ static OMX_ERRORTYPE SF_OMX_SendCommand(
             break;
 
         case OMX_StateExecuting:
-            pSFComponentEncoder = (ComponentImpl *)pSfOMXComponent->hSFComponentExecoder;
-            pSFComponentFeeder = (ComponentImpl *)pSfOMXComponent->hSFComponentFeeder;
-            pSFComponentRender = (ComponentImpl *)pSfOMXComponent->hSFComponentRender;
+            pSFComponentEncoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+            pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+            pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
 
 
-            currentState = pSfOMXComponent->functions->ComponentGetState(pSfOMXComponent->hSFComponentExecoder);
+            currentState = pSfVideoImplement->functions->ComponentGetState(pSfVideoImplement->hSFComponentExecoder);
             LOG(SF_LOG_INFO, "VPU Current state = %X\r\n", currentState);
             switch(currentState)
             {
@@ -1149,18 +1156,18 @@ static OMX_ERRORTYPE SF_OMX_UseEGLImage(
     return OMX_ErrorNotImplemented;
 }
 
-static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *hComponent)
+static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *pSfOMXComponent)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
     FunctionIn();
-
-    ret = InitComponentStructorCommon(hComponent);
+    ret = InitComponentStructorCommon(pSfOMXComponent);
     if (ret != OMX_ErrorNone)
     {
         goto EXIT;
     }
-    TestEncConfig *pTestEncConfig = (TestEncConfig *)hComponent->testConfig;
-    pTestEncConfig->stdMode = hComponent->bitFormat;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    TestEncConfig *pTestEncConfig = (TestEncConfig *)pSfVideoImplement->testConfig;
+    pTestEncConfig->stdMode = pSfVideoImplement->bitFormat;
     pTestEncConfig->frame_endian = VPU_FRAME_ENDIAN;
     pTestEncConfig->stream_endian = VPU_STREAM_ENDIAN;
     pTestEncConfig->source_endian = VPU_SOURCE_ENDIAN;
@@ -1177,18 +1184,18 @@ static OMX_ERRORTYPE SF_OMX_ComponentConstructor(SF_OMX_COMPONENT *hComponent)
     pTestEncConfig->cbcrInterleave = TRUE;
     pTestEncConfig->nv21 = FALSE;
 
-    hComponent->pOMXComponent->UseBuffer = &SF_OMX_UseBuffer;
-    hComponent->pOMXComponent->AllocateBuffer = &SF_OMX_AllocateBuffer;
-    hComponent->pOMXComponent->EmptyThisBuffer = &SF_OMX_EmptyThisBuffer;
-    hComponent->pOMXComponent->FillThisBuffer = &SF_OMX_FillThisBuffer;
-    hComponent->pOMXComponent->FreeBuffer = &SF_OMX_FreeBuffer;
-    // hComponent->pOMXComponent->ComponentTunnelRequest = &SF_OMX_ComponentTunnelRequest;
-    hComponent->pOMXComponent->GetParameter = &SF_OMX_GetParameter;
-    hComponent->pOMXComponent->SetParameter = &SF_OMX_SetParameter;
-    hComponent->pOMXComponent->GetConfig = &SF_OMX_GetConfig;
-    hComponent->pOMXComponent->SetConfig = &SF_OMX_SetConfig;
-    hComponent->pOMXComponent->SendCommand = &SF_OMX_SendCommand;
-    hComponent->pOMXComponent->GetState = &SF_OMX_GetState;
+    pSfOMXComponent->pOMXComponent->UseBuffer = &SF_OMX_UseBuffer;
+    pSfOMXComponent->pOMXComponent->AllocateBuffer = &SF_OMX_AllocateBuffer;
+    pSfOMXComponent->pOMXComponent->EmptyThisBuffer = &SF_OMX_EmptyThisBuffer;
+    pSfOMXComponent->pOMXComponent->FillThisBuffer = &SF_OMX_FillThisBuffer;
+    pSfOMXComponent->pOMXComponent->FreeBuffer = &SF_OMX_FreeBuffer;
+    // pSfOMXComponent->pOMXComponent->ComponentTunnelRequest = &SF_OMX_ComponentTunnelRequest;
+    pSfOMXComponent->pOMXComponent->GetParameter = &SF_OMX_GetParameter;
+    pSfOMXComponent->pOMXComponent->SetParameter = &SF_OMX_SetParameter;
+    pSfOMXComponent->pOMXComponent->GetConfig = &SF_OMX_GetConfig;
+    pSfOMXComponent->pOMXComponent->SetConfig = &SF_OMX_SetConfig;
+    pSfOMXComponent->pOMXComponent->SendCommand = &SF_OMX_SendCommand;
+    pSfOMXComponent->pOMXComponent->GetState = &SF_OMX_GetState;
 
 EXIT:
     FunctionOut();
@@ -1196,12 +1203,13 @@ EXIT:
     return ret;
 }
 
-static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *hComponent)
+static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *pSfOMXComponent)
 {
     OMX_ERRORTYPE ret = OMX_ErrorNone;
-    ComponentImpl *pSFComponentEncoder = (ComponentImpl *)hComponent->hSFComponentExecoder;
-    ComponentImpl *pSFComponentFeeder = (ComponentImpl *)hComponent->hSFComponentFeeder;
-    ComponentImpl *pSFComponentRender = (ComponentImpl *)hComponent->hSFComponentRender;
+    SF_WAVE5_IMPLEMEMT *pSfVideoImplement = (SF_WAVE5_IMPLEMEMT *)pSfOMXComponent->componentImpl;
+    ComponentImpl *pSFComponentEncoder = (ComponentImpl *)pSfVideoImplement->hSFComponentExecoder;
+    ComponentImpl *pSFComponentFeeder = (ComponentImpl *)pSfVideoImplement->hSFComponentFeeder;
+    ComponentImpl *pSFComponentRender = (ComponentImpl *)pSfVideoImplement->hSFComponentRender;
 
     FunctionIn();
     if (pSFComponentEncoder == NULL || pSFComponentFeeder == NULL || pSFComponentRender == NULL)
@@ -1211,13 +1219,13 @@ static OMX_ERRORTYPE SF_OMX_ComponentClear(SF_OMX_COMPONENT *hComponent)
     pSFComponentEncoder->terminate = OMX_TRUE;
     pSFComponentFeeder->terminate = OMX_TRUE;
     pSFComponentRender->terminate = OMX_TRUE;
-    hComponent->functions->ComponentWait(hComponent->hSFComponentFeeder);
-    hComponent->functions->ComponentWait(hComponent->hSFComponentExecoder);
-    hComponent->functions->ComponentWait(hComponent->hSFComponentRender);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentFeeder);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentExecoder);
+    pSfVideoImplement->functions->ComponentWait(pSfVideoImplement->hSFComponentRender);
 
-    free(hComponent->pusBitCode);
-    hComponent->functions->ClearEncListenerContext(hComponent->lsnCtx);
-    ComponentClearCommon(hComponent);
+    free(pSfVideoImplement->pusBitCode);
+    pSfVideoImplement->functions->ClearEncListenerContext(pSfVideoImplement->lsnCtx);
+    ComponentClearCommon(pSfOMXComponent);
 EXIT:
     FunctionOut();
 
@@ -1230,8 +1238,8 @@ SF_OMX_COMPONENT sf_enc_encoder_h265 = {
     .pOMXComponent = NULL,
     .SF_OMX_ComponentConstructor = SF_OMX_ComponentConstructor,
     .SF_OMX_ComponentClear = SF_OMX_ComponentClear,
-    .functions = NULL,
-    .bitFormat = STD_HEVC,
+    // .bitFormat = STD_HEVC,
+    .componentImpl = NULL,
     .fwPath = "/lib/firmware/chagall.bin",
     .componentRule = "video_encoder.hevc"};
 
@@ -1241,7 +1249,7 @@ SF_OMX_COMPONENT sf_enc_encoder_h264 = {
     .pOMXComponent = NULL,
     .SF_OMX_ComponentConstructor = SF_OMX_ComponentConstructor,
     .SF_OMX_ComponentClear = SF_OMX_ComponentClear,
-    .functions = NULL,
-    .bitFormat = STD_AVC,
+    // .bitFormat = STD_AVC,
+    .componentImpl = NULL,
     .fwPath = "/lib/firmware/chagall.bin",
     .componentRule = "video_encoder.avc"};

+ 25 - 95
soft_3rdpart/omx-il/core/SF_OMX_Core.c

@@ -15,12 +15,14 @@ extern SF_OMX_COMPONENT sf_dec_decoder_h265;
 extern SF_OMX_COMPONENT sf_dec_decoder_h264;
 extern SF_OMX_COMPONENT sf_enc_encoder_h265;
 extern SF_OMX_COMPONENT sf_enc_encoder_h264;
+extern SF_OMX_COMPONENT sf_dec_decoder_mjpeg;
 
-static SF_OMX_COMPONENT *sf_omx_component_list[] = {
+SF_OMX_COMPONENT *sf_omx_component_list[] = {
     &sf_dec_decoder_h265,
     &sf_dec_decoder_h264,
     &sf_enc_encoder_h265,
     &sf_enc_encoder_h264,
+    &sf_dec_decoder_mjpeg,
     NULL,
 };
 
@@ -225,99 +227,6 @@ OMX_API OMX_ERRORTYPE OMX_GetRolesOfComponent(
     return ret;
 }
 
-void sf_get_component_functions(SF_COMPONENT_FUNCTIONS *funcs, OMX_PTR *sohandle)
-{
-    FunctionIn();
-    funcs->ComponentCreate = dlsym(sohandle, "ComponentCreate");
-    funcs->ComponentExecute = dlsym(sohandle, "ComponentExecute");
-    funcs->ComponentGetParameter = dlsym(sohandle, "ComponentGetParameter");
-    funcs->ComponentGetState = dlsym(sohandle, "ComponentGetState");
-    funcs->ComponentNotifyListeners = dlsym(sohandle, "ComponentNotifyListeners");
-    funcs->ComponentPortCreate = dlsym(sohandle, "ComponentPortCreate");
-    funcs->ComponentPortDestroy = dlsym(sohandle, "ComponentPortDestroy");
-    funcs->ComponentPortFlush = dlsym(sohandle, "ComponentPortFlush");
-    funcs->ComponentPortGetData = dlsym(sohandle, "ComponentPortGetData");
-    funcs->ComponentPortPeekData = dlsym(sohandle, "ComponentPortPeekData");
-    funcs->ComponentPortSetData = dlsym(sohandle, "ComponentPortSetData");
-    funcs->ComponentPortWaitReadyStatus = dlsym(sohandle, "ComponentPortWaitReadyStatus");
-    funcs->ComponentRelease = dlsym(sohandle, "ComponentRelease");
-    funcs->ComponentSetParameter = dlsym(sohandle, "ComponentSetParameter");
-    funcs->ComponentStop = dlsym(sohandle, "ComponentStop");
-    funcs->ComponentSetupTunnel = dlsym(sohandle, "ComponentSetupTunnel");
-    funcs->ComponentWait = dlsym(sohandle, "ComponentWait");
-    funcs->WaitBeforeComponentPortGetData = dlsym(sohandle, "WaitBeforeComponentPortGetData");
-    funcs->ComponentChangeState = dlsym(sohandle, "ComponentChangeState");
-    funcs->ComponentDestroy = dlsym(sohandle, "ComponentDestroy");
-    funcs->ComponentRegisterListener = dlsym(sohandle, "ComponentRegisterListener");
-    funcs->ComponentPortHasInputData = dlsym(sohandle, "ComponentPortHasInputData");
-    funcs->ComponentPortGetSize = dlsym(sohandle, "ComponentPortGetSize");
-    funcs->ComponentParamReturnTest = dlsym(sohandle, "ComponentParamReturnTest");
-    //Listener
-    funcs->SetupDecListenerContext = dlsym(sohandle, "SetupDecListenerContext");
-    funcs->SetupEncListenerContext = dlsym(sohandle, "SetupEncListenerContext");
-    funcs->ClearDecListenerContext = dlsym(sohandle, "ClearDecListenerContext");
-    funcs->HandleDecCompleteSeqEvent = dlsym(sohandle, "HandleDecCompleteSeqEvent");
-    funcs->HandleDecRegisterFbEvent = dlsym(sohandle, "HandleDecRegisterFbEvent");
-    funcs->HandleDecGetOutputEvent = dlsym(sohandle, "HandleDecGetOutputEvent");
-    funcs->HandleDecCloseEvent = dlsym(sohandle, "HandleDecCloseEvent");
-    funcs->ClearEncListenerContext = dlsym(sohandle, "ClearEncListenerContext");
-    funcs->HandleEncFullEvent = dlsym(sohandle, "HandleEncFullEvent");
-    funcs->HandleEncGetOutputEvent = dlsym(sohandle, "HandleEncGetOutputEvent");
-    funcs->HandleEncCompleteSeqEvent = dlsym(sohandle, "HandleEncCompleteSeqEvent");
-    funcs->HandleEncGetEncCloseEvent = dlsym(sohandle, "HandleEncGetEncCloseEvent");
-    funcs->EncoderListener = dlsym(sohandle, "EncoderListener");
-    funcs->DecoderListener = dlsym(sohandle, "DecoderListener");
-    // Helper
-    funcs->SetDefaultEncTestConfig = dlsym(sohandle, "SetDefaultEncTestConfig");
-    funcs->SetDefaultDecTestConfig = dlsym(sohandle, "SetDefaultDecTestConfig");
-    funcs->LoadFirmware = dlsym(sohandle, "LoadFirmware");
-    funcs->SetupEncoderOpenParam = dlsym(sohandle, "SetupEncoderOpenParam");
-    funcs->SetUpDecoderOpenParam = dlsym(sohandle, "SetUpDecoderOpenParam");
-    // VPU
-    funcs->VPU_GetProductId = dlsym(sohandle, "VPU_GetProductId");
-    funcs->Queue_Enqueue = dlsym(sohandle, "Queue_Enqueue");
-    funcs->Queue_Get_Cnt = dlsym(sohandle, "Queue_Get_Cnt");
-    funcs->VPU_DecClrDispFlag = dlsym(sohandle, "VPU_DecClrDispFlag");
-    funcs->VPU_DecGetFrameBuffer = dlsym(sohandle, "VPU_DecGetFrameBuffer");
-    funcs->Render_DecClrDispFlag = dlsym(sohandle, "Render_DecClrDispFlag");
-    // VPU Log
-    funcs->InitLog = dlsym(sohandle, "InitLog");
-    funcs->DeInitLog = dlsym(sohandle, "DeInitLog");
-    funcs->SetMaxLogLevel = dlsym(sohandle, "SetMaxLogLevel");
-    funcs->GetMaxLogLevel = dlsym(sohandle, "GetMaxLogLevel");
-
-    //Renderer
-    funcs->AllocateFrameBuffer2 = dlsym(sohandle, "AllocateFrameBuffer2");
-    funcs->AttachDMABuffer = dlsym(sohandle, "AttachDMABuffer");
-    funcs->SetRenderTotalBufferNumber = dlsym(sohandle, "SetRenderTotalBufferNumber");
-    funcs->WaitForExecoderReady = dlsym(sohandle, "WaitForExecoderReady");
-    FunctionOut();
-}
-
-SF_OMX_COMPONENT *GetSFOMXComponrntByComponent(Component *pComponent)
-{
-    SF_OMX_COMPONENT *pSFOMXComponent = NULL;
-    int size = GetNumberOfComponent();
-
-    FunctionIn();
-    for (int i = 0; i < size; i++)
-    {
-        pSFOMXComponent = sf_omx_component_list[i];
-        if (pSFOMXComponent == NULL)
-        {
-            goto EXIT;
-        }
-        if (pSFOMXComponent->hSFComponentExecoder == pComponent || pSFOMXComponent->hSFComponentFeeder == pComponent || pSFOMXComponent->hSFComponentRender == pComponent)
-        {
-            break;
-        }
-    }
-EXIT:
-    FunctionOut();
-
-    return pSFOMXComponent;
-}
-
 OMX_ERRORTYPE ClearOMXBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_BUFFERHEADERTYPE *pBuffer)
 {
     OMX_U32 i = 0;
@@ -326,6 +235,7 @@ OMX_ERRORTYPE ClearOMXBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_BUFFERHEADER
         if (pSfOMXComponent->pBufferArray[i] == pBuffer)
         {
             pSfOMXComponent->pBufferArray[i] = NULL;
+            LOG(SF_LOG_DEBUG, "Clear OMX buffer %p at index %d\r\n", pBuffer, i);
             return OMX_ErrorNone;
         }
     }
@@ -344,6 +254,7 @@ OMX_U32 GetOMXBufferCount(SF_OMX_COMPONENT *pSfOMXComponent)
     {
         if (pSfOMXComponent->pBufferArray[i] != NULL)
         {
+            LOG(SF_LOG_DEBUG, "find OMX buffer %p at index %d\r\n", pSfOMXComponent->pBufferArray[i], i);
             count++;
         }
     }
@@ -359,6 +270,7 @@ OMX_ERRORTYPE StoreOMXBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_BUFFERHEADER
         if (pSfOMXComponent->pBufferArray[i] == NULL)
         {
             pSfOMXComponent->pBufferArray[i] = pBuffer;
+            LOG(SF_LOG_DEBUG, "Store OMX buffer %p at index %d\r\n", pBuffer, i);
             return OMX_ErrorNone;
         }
     }
@@ -378,6 +290,11 @@ OMX_BUFFERHEADERTYPE *GetOMXBufferByAddr(SF_OMX_COMPONENT *pSfOMXComponent, OMX_
     for (i = 0; i < sizeof(pSfOMXComponent->pBufferArray) / sizeof(pSfOMXComponent->pBufferArray[0]); i++)
     {
         pOMXBuffer = pSfOMXComponent->pBufferArray[i];
+        LOG(SF_LOG_DEBUG, "Compare OMX buffer %p at index %d with addr %p\r\n", pOMXBuffer, i, pAddr);
+        if (pOMXBuffer == NULL)
+        {
+            continue;
+        }
         if (pOMXBuffer->pBuffer == pAddr)
         {
             return pOMXBuffer;
@@ -388,7 +305,20 @@ OMX_BUFFERHEADERTYPE *GetOMXBufferByAddr(SF_OMX_COMPONENT *pSfOMXComponent, OMX_
     FunctionOut();
     return NULL;
 }
+void SF_LogMsgAppend(int level, const char *format, ...)
+{
+    va_list ptr;
 
+    if (level > gDebugLevel)
+    {
+        return;
+    }
+    
+    printf("%66s\t", " ");
+    va_start(ptr, format);
+    vprintf(format, ptr);
+    va_end(ptr);
+}
 void SF_LogMsg(int level, const char *function, int line, const char *format, ...)
 {
     char *prefix = "";
@@ -425,4 +355,4 @@ void SF_LogMsg(int level, const char *function, int line, const char *format, ..
     va_start(ptr, format);
     vprintf(format, ptr);
     va_end(ptr);
-}
+}

+ 18 - 83
soft_3rdpart/omx-il/core/SF_OMX_Core.h

@@ -9,9 +9,7 @@
 #include "OMX_Core.h"
 #include "OMX_Component.h"
 #include "OMX_VideoExt.h"
-#include "component.h"
-#include "encoder_listener.h"
-#include "decoder_listener.h"
+
 #include <sys/time.h>
 #include <stdarg.h>
 #include <dlfcn.h>
@@ -30,6 +28,7 @@ enum
 };
 void SF_LogMsg(int level, const char *function, int line, const char *format, ...);
 #define LOG(level, ...) SF_LogMsg(level, __FUNCTION__, __LINE__, __VA_ARGS__);
+#define LOG_APPEND(level, ...) SF_LogMsgAppend(level, __VA_ARGS__);
 #define FunctionIn() SF_LogMsg(SF_LOG_DEBUG, __FUNCTION__, __LINE__, "FUN IN\r\n");
 #define FunctionOut() SF_LogMsg(SF_LOG_DEBUG, __FUNCTION__, __LINE__, "FUN OUT\r\n");
 #else
@@ -39,72 +38,6 @@ void SF_LogMsg(int level, const char *function, int line, const char *format, ..
 #define VPU_OUTPUT_BUF_NUMBER 10
 #define VPU_INPUT_BUF_NUMBER 5
 
-typedef struct _SF_COMPONENT_FUNCTIONS
-{
-    Component (*ComponentCreate)(const char *componentName, CNMComponentConfig *componentParam);
-    BOOL(*ComponentSetupTunnel)(Component fromComponent, Component toComponent);
-    ComponentState (*ComponentExecute)(Component component);
-    Int32 (*ComponentWait)(Component component);
-    void (*ComponentStop)(Component component);
-    void (*ComponentRelease)(Component component);
-    BOOL(*ComponentChangeState)(Component component, Uint32 state);
-    BOOL(*ComponentDestroy)(Component component, BOOL *ret);
-    CNMComponentParamRet (*ComponentGetParameter)(Component from, Component to, GetParameterCMD commandType, void *data);
-    CNMComponentParamRet (*ComponentSetParameter)(Component from, Component to, SetParameterCMD commandType, void *data);
-    void (*ComponentNotifyListeners)(Component component, Uint64 event, void *data);
-    BOOL(*ComponentRegisterListener)(Component component, Uint64 events, ComponentListenerFunc func, void *context);
-    void (*ComponentPortCreate)(Port *port, Component owner, Uint32 depth, Uint32 size);
-    void (*ComponentPortSetData)(Port *port, PortContainer *portData);
-    PortContainer *(*ComponentPortPeekData)(Port *port);
-    PortContainer *(*ComponentPortGetData)(Port *port);
-    void *(*WaitBeforeComponentPortGetData)(Port *port);
-    void (*ComponentPortWaitReadyStatus)(Port *port);
-    void (*ComponentPortDestroy)(Port *port);
-    BOOL(*ComponentPortHasInputData)(Port *port);
-    Uint32 (*ComponentPortGetSize)(Port *port);
-    void (*ComponentPortFlush)(Component component);
-    ComponentState (*ComponentGetState)(Component component);
-    BOOL(*ComponentParamReturnTest)(CNMComponentParamRet ret, BOOL *retry);
-    // Listener
-    BOOL(*SetupDecListenerContext)(DecListenerContext *ctx, CNMComponentConfig *config, Component renderer);
-    BOOL(*SetupEncListenerContext)(EncListenerContext *ctx, CNMComponentConfig *config);
-    void (*ClearDecListenerContext)(DecListenerContext *ctx);
-    void (*HandleDecCompleteSeqEvent)(Component com, CNMComListenerDecCompleteSeq *param, DecListenerContext *ctx);
-    void (*HandleDecRegisterFbEvent)(Component com, CNMComListenerDecRegisterFb *param, DecListenerContext *ctx);
-    void (*HandleDecGetOutputEvent)(Component com, CNMComListenerDecDone *param, DecListenerContext *ctx);
-    void (*HandleDecCloseEvent)(Component com, CNMComListenerDecClose *param, DecListenerContext *ctx);
-    void (*ClearEncListenerContext)(EncListenerContext *ctx);
-    void (*HandleEncFullEvent)(Component com, CNMComListenerEncFull *param, EncListenerContext *ctx);
-    void (*HandleEncGetOutputEvent)(Component com, CNMComListenerEncDone *param, EncListenerContext *ctx);
-    void (*HandleEncCompleteSeqEvent)(Component com, CNMComListenerEncCompleteSeq *param, EncListenerContext *ctx);
-    void (*HandleEncGetEncCloseEvent)(Component com, CNMComListenerEncClose *param, EncListenerContext *ctx);
-    void (*EncoderListener)(Component com, Uint64 event, void *data, void *context);
-    void (*DecoderListener)(Component com, Uint64 event, void *data, void *context);
-    // Helper
-    void (*SetDefaultEncTestConfig)(TestEncConfig *testConfig);
-    void (*SetDefaultDecTestConfig)(TestDecConfig *testConfig);
-    Int32 (*LoadFirmware)(Int32 productId, Uint8 **retFirmware, Uint32 *retSizeInWord, const char *path);
-    BOOL(*SetupEncoderOpenParam)(EncOpenParam *param, TestEncConfig *config, ENC_CFG *encCfg);
-    RetCode (*SetUpDecoderOpenParam)(DecOpenParam *param, TestDecConfig *config);
-    // VPU
-    int (*VPU_GetProductId)(int coreIdx);
-    BOOL(*Queue_Enqueue)(Queue *queue, void *data);
-    Uint32 (*Queue_Get_Cnt)(Queue *queue);
-    RetCode (*VPU_DecClrDispFlag)(DecHandle handle, int index);
-    RetCode (*VPU_DecGetFrameBuffer)(DecHandle handle, int frameIdx, FrameBuffer* frameBuf);
-    void (*Render_DecClrDispFlag)(void *context, int index);
-    // VPU Log
-    int (*InitLog)(void);
-    void (*DeInitLog)(void);
-    void (*SetMaxLogLevel)(int level);
-    int (*GetMaxLogLevel)(void);
-    // FrameBuffer
-    void* (*AllocateFrameBuffer2)(ComponentImpl* com, Uint32 size);
-    BOOL (*AttachDMABuffer)(ComponentImpl* com, Uint64 virtAddress, Uint32 size);
-    void (*SetRenderTotalBufferNumber)(ComponentImpl* com, Uint32 number);
-    void (*WaitForExecoderReady)(ComponentImpl *com)
-} SF_COMPONENT_FUNCTIONS;
-
 typedef struct _SF_OMX_COMPONENT
 {
     OMX_STRING componentName;
@@ -112,22 +45,26 @@ typedef struct _SF_OMX_COMPONENT
     OMX_COMPONENTTYPE *pOMXComponent;
     OMX_ERRORTYPE (*SF_OMX_ComponentConstructor)(struct _SF_OMX_COMPONENT *hComponent);
     OMX_ERRORTYPE (*SF_OMX_ComponentClear)(struct _SF_OMX_COMPONENT *hComponent);
-    SF_COMPONENT_FUNCTIONS *functions;
-    Component *hSFComponentExecoder;
-    Component *hSFComponentFeeder;
-    Component *hSFComponentRender;
-    void *testConfig;
-    CNMComponentConfig *config;
-    void *lsnCtx;
     OMX_PTR soHandle;
-    Uint16 *pusBitCode;
+    // SF_COMPONENT_FUNCTIONS *functions;
+    OMX_PTR componentImpl;
+
+    // OMX_PTR functions;
+    // Component *hSFComponentExecoder;
+    // Component *hSFComponentFeeder;
+    // Component *hSFComponentRender;
+    // void *testConfig;
+    // CNMComponentConfig *config;
+    // void *lsnCtx;
+    // Uint16 *pusBitCode;
+    // CodStd bitFormat;
+    // OMX_VIDEO_PARAM_AVCTYPE AVCComponent[2];
+    // OMX_VIDEO_PARAM_HEVCTYPE HEVCComponent[2];
+
     OMX_CALLBACKTYPE *callbacks;
     OMX_PTR pAppData;
     OMX_PARAM_PORTDEFINITIONTYPE portDefinition[2];
-    OMX_VIDEO_PARAM_AVCTYPE AVCComponent[2];
-    OMX_VIDEO_PARAM_HEVCTYPE HEVCComponent[2];
     OMX_BUFFERHEADERTYPE *pBufferArray[64];
-    CodStd bitFormat;
     OMX_STRING fwPath;
     OMX_STRING componentRule;
     OMX_STATETYPE nextState;
@@ -161,9 +98,7 @@ typedef struct _SF_PORT_PRIVATE
 extern "C"
 {
 #endif
-
-    void sf_get_component_functions(SF_COMPONENT_FUNCTIONS *funcs, OMX_PTR *sohandle);
-    SF_OMX_COMPONENT *GetSFOMXComponrntByComponent(Component *pComponent);
+    
     OMX_BUFFERHEADERTYPE *GetOMXBufferByAddr(SF_OMX_COMPONENT *pSfOMXComponent, OMX_U8 *pAddr);
     OMX_ERRORTYPE StoreOMXBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_BUFFERHEADERTYPE *pBuffer);
     OMX_ERRORTYPE ClearOMXBuffer(SF_OMX_COMPONENT *pSfOMXComponent, OMX_BUFFERHEADERTYPE *pBuffer);

+ 3 - 3
soft_3rdpart/omx-il/tests/dec_test.c

@@ -94,7 +94,7 @@ static OMX_ERRORTYPE event_handler(
 
 static void help()
 {
-    printf("./video_dec_test -i <input file> -o <output file> \r\n");
+    printf("./omx_dec_test -i <input file> -o <output file> \r\n");
 }
 
 static OMX_ERRORTYPE fill_output_buffer_done_handler(
@@ -290,7 +290,7 @@ int main(int argc, char *argv)
            codecParameters->width, codecParameters->height);
 
     /*omx init*/
-    OMX_HANDLETYPE hComponentDecoder;
+    OMX_HANDLETYPE hComponentDecoder  = NULL;
     OMX_CALLBACKTYPE callbacks;
     int ret = OMX_ErrorNone;
     signal(SIGINT, signal_handle);
@@ -320,6 +320,7 @@ int main(int argc, char *argv)
         return 0;
     }
     decodeTestContext->hComponentDecoder = hComponentDecoder;
+     
     OMX_PARAM_PORTDEFINITIONTYPE pOutputPortDefinition;
     OMX_INIT_STRUCTURE(pOutputPortDefinition);
     pOutputPortDefinition.nPortIndex = 1;
@@ -354,7 +355,6 @@ int main(int argc, char *argv)
     pInputPortDefinition.format.video.nFrameWidth = codecParameters->width;
     pInputPortDefinition.format.video.nFrameHeight = codecParameters->height;
     OMX_SetParameter(hComponentDecoder, OMX_IndexParamPortDefinition, &pInputPortDefinition);
-
     /*Alloc input buffer*/
     OMX_U32 nInputWidth = codecParameters->width;
     OMX_U32 nInputHeight = codecParameters->height;

+ 1 - 1
soft_3rdpart/omx-il/tests/enc_test.c

@@ -276,7 +276,7 @@ int main(int argc, char *argv)
     }
 
     /*omx init*/
-    OMX_HANDLETYPE hComponentEncoder;
+    OMX_HANDLETYPE hComponentEncoder = NULL;
     OMX_CALLBACKTYPE callbacks;
     int ret = OMX_ErrorNone;
     signal(SIGINT, signal_handle);

+ 394 - 0
soft_3rdpart/omx-il/tests/mjpeg_dec_test.c

@@ -0,0 +1,394 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2021 StarFive Technology Co., Ltd.
+ */
+#include <stdio.h>
+#include <signal.h>
+#include <getopt.h>
+#include <fcntl.h>
+#include "libavformat/avformat.h"
+#include <OMX_Image.h>
+#include <OMX_Core.h>
+#include <OMX_Component.h>
+#include <OMX_Video.h>
+#include <OMX_IndexExt.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+
+#define OMX_INIT_STRUCTURE(a)         \
+    memset(&(a), 0, sizeof(a));       \
+    (a).nSize = sizeof(a);            \
+    (a).nVersion.nVersion = 1;        \
+    (a).nVersion.s.nVersionMajor = 1; \
+    (a).nVersion.s.nVersionMinor = 1; \
+    (a).nVersion.s.nRevision = 1;     \
+    (a).nVersion.s.nStep = 1
+
+typedef struct Message
+{
+    long msg_type;
+    OMX_S32 msg_flag;
+    OMX_BUFFERHEADERTYPE *pBuffer;
+} Message;
+
+typedef struct DecodeTestContext
+{
+    OMX_HANDLETYPE hComponentDecoder;
+    char sOutputFilePath[64];
+    char sInputFilePath[64];
+    OMX_BUFFERHEADERTYPE *pInputBufferArray[64];
+    OMX_BUFFERHEADERTYPE *pOutputBufferArray[64];
+    AVFormatContext *avContext;
+    int msgid;
+} DecodeTestContext;
+DecodeTestContext *decodeTestContext;
+static OMX_S32 FillInputBuffer(DecodeTestContext *decodeTestContext, OMX_BUFFERHEADERTYPE *pInputBuffer);
+
+static OMX_ERRORTYPE event_handler(
+    OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData,
+    OMX_EVENTTYPE eEvent,
+    OMX_U32 nData1,
+    OMX_U32 nData2,
+    OMX_PTR pEventData)
+{
+    DecodeTestContext *pDecodeTestContext = (DecodeTestContext *)pAppData;
+
+    switch (eEvent)
+    {
+    case OMX_EventPortSettingsChanged:
+    {
+        OMX_PARAM_PORTDEFINITIONTYPE pOutputPortDefinition;
+        OMX_INIT_STRUCTURE(pOutputPortDefinition);
+        pOutputPortDefinition.nPortIndex = 1;
+        OMX_GetParameter(pDecodeTestContext->hComponentDecoder, OMX_IndexParamPortDefinition, &pOutputPortDefinition);
+        OMX_U32 nOutputBufferSize = pOutputPortDefinition.nBufferSize;
+        OMX_U32 nOutputBufferCount = pOutputPortDefinition.nBufferCountMin;
+        printf("allocate %d output buffers size %d\r\n", nOutputBufferCount, nOutputBufferSize);
+        for (int i = 0; i < nOutputBufferCount; i++)
+        {
+            OMX_BUFFERHEADERTYPE *pBuffer = NULL;
+            OMX_AllocateBuffer(hComponent, &pBuffer, 1, NULL, nOutputBufferSize);
+            pDecodeTestContext->pOutputBufferArray[i] = pBuffer;
+            OMX_FillThisBuffer(hComponent, pBuffer);
+        }
+    }
+    break;
+    case OMX_EventBufferFlag:
+    {
+        Message data;
+        data.msg_type = 1;
+        data.msg_flag = -1;
+        if (msgsnd(pDecodeTestContext->msgid, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+        {
+            fprintf(stderr, "msgsnd failed\n");
+        }
+    }
+    break;
+    default:
+        break;
+    }
+    return OMX_ErrorNone;
+}
+
+static void help()
+{
+    printf("./omx_mjpeg_dec_test -i <input file> -o <output file> \r\n");
+}
+
+static OMX_ERRORTYPE fill_output_buffer_done_handler(
+    OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData,
+    OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    DecodeTestContext *pDecodeTestContext = (DecodeTestContext *)pAppData;
+
+    Message data;
+    data.msg_type = 1;
+    if (pBuffer->nFlags & OMX_BUFFERFLAG_EOS == OMX_BUFFERFLAG_EOS)
+    {
+        data.msg_flag = -1;
+    }
+    else
+    {
+        data.msg_flag = 1;
+        data.pBuffer = pBuffer;
+    }
+    if (msgsnd(pDecodeTestContext->msgid, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+    {
+        fprintf(stderr, "msgsnd failed\n");
+    }
+
+    return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE empty_buffer_done_handler(
+    OMX_HANDLETYPE hComponent,
+    OMX_PTR pAppData,
+    OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    DecodeTestContext *pDecodeTestContext = (DecodeTestContext *)pAppData;
+    Message data;
+    data.msg_type = 1;
+    data.msg_flag = 0;
+    data.pBuffer = pBuffer;
+    if (msgsnd(pDecodeTestContext->msgid, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+    {
+        fprintf(stderr, "msgsnd failed\n");
+    }
+    return OMX_ErrorNone;
+}
+
+static void signal_handle(int sig)
+{
+    printf("[%s,%d]: receive sig=%d \n", __FUNCTION__, __LINE__, sig);
+    Message data;
+    data.msg_type = 1;
+    data.msg_flag = -1;
+    if (msgsnd(decodeTestContext->msgid, (void *)&data, sizeof(data) - sizeof(data.msg_type), 0) == -1)
+    {
+        fprintf(stderr, "msgsnd failed\n");
+    }
+}
+
+static OMX_S32 FillInputBuffer(DecodeTestContext *decodeTestContext, OMX_BUFFERHEADERTYPE *pInputBuffer)
+{
+    AVFormatContext *avFormatContext = decodeTestContext->avContext;
+    AVPacket avpacket;
+    OMX_S32 error;
+    av_init_packet(&avpacket);
+    error = av_read_frame(avFormatContext, &avpacket);
+    if (error < 0)
+    {
+        if (error == AVERROR_EOF || avFormatContext->pb->eof_reached == OMX_TRUE)
+        {
+            pInputBuffer->nFlags = 0x1;
+            pInputBuffer->nFilledLen = 0;
+            return 0;
+        }
+        else
+        {
+            printf("%s:%d failed to av_read_frame error(0x%08x)\n", __FUNCTION__, __LINE__, error);
+            return 0;
+        }
+    }
+    pInputBuffer->nFlags = 0x10;
+    pInputBuffer->nFilledLen = avpacket.size;
+    memcpy(pInputBuffer->pBuffer, avpacket.data, avpacket.size);
+    printf("%s, address = %p, size = %d, flag = %x\r\n", 
+        __FUNCTION__, pInputBuffer->pBuffer, pInputBuffer->nFilledLen, pInputBuffer->nFlags);
+    return avpacket.size;
+}
+
+int main(int argc, char *argv)
+{
+    printf("=============================\r\n");
+    OMX_S32 error;
+    decodeTestContext = malloc(sizeof(DecodeTestContext));
+    memset(decodeTestContext, 0, sizeof(DecodeTestContext));
+
+    OMX_S32 msgid = -1;
+    msgid = msgget(IPC_PRIVATE, 0666 | IPC_CREAT);
+    if (msgid < 0)
+    {
+        perror("get ipc_id error");
+        return;
+    }
+    decodeTestContext->msgid = msgid;
+    struct option longOpt[] = {
+        {"output", required_argument, NULL, 'o'},
+        {"input", required_argument, NULL, 'f'},
+        {NULL, no_argument, NULL, 0},
+    };
+    OMX_S8 *shortOpt = "i:o:";
+    OMX_U32 c;
+    OMX_S32 l;
+
+    // if (argc == 0)
+    // {
+    //     help();
+    //     return;
+    // }
+
+    while ((c = getopt_long(argc, argv, shortOpt, longOpt, &l)) != -1)
+    {
+        switch (c)
+        {
+        case 'i':
+            printf("input: %s\r\n", optarg);
+            if (access(optarg, R_OK) != -1)
+            {
+                memcpy(decodeTestContext->sInputFilePath, optarg, strlen(optarg));
+            }
+            else
+            {
+                printf("input file not exist!\r\n");
+                return;
+            }
+            break;
+        case 'o':
+            printf("output: %s\r\n", optarg);
+            memcpy(decodeTestContext->sOutputFilePath, optarg, strlen(optarg));
+            break;
+        case 'h':
+        default:
+            help();
+            return;
+        }
+    }
+
+    if (decodeTestContext->sInputFilePath == NULL || decodeTestContext->sOutputFilePath == NULL)
+    {
+        help();
+        return;
+    }
+    /*ffmpeg init*/
+    printf("init ffmpeg\r\n");
+    AVFormatContext *avContext = NULL;
+    AVCodecParameters *codecParameters = NULL;
+    AVInputFormat *fmt = NULL;
+    OMX_S32 imageIndex;
+    if ((avContext = avformat_alloc_context()) == NULL)
+    {
+        printf("avformat_alloc_context fail\r\n");
+        return;
+    }
+    avContext->flags |= AV_CODEC_FLAG_TRUNCATED;
+
+    printf("avformat_open_input\r\n");
+    if ((error = avformat_open_input(&avContext, decodeTestContext->sInputFilePath, fmt, NULL)))
+    {
+        printf("%s:%d failed to av_open_input_file error(%d), %s\n",
+               __FILE__, __LINE__, error, decodeTestContext->sInputFilePath);
+        return;
+    }
+
+    printf("avformat_find_stream_info\r\n");
+    if ((error = avformat_find_stream_info(avContext, NULL)) < 0)
+    {
+        printf("%s:%d failed to avformat_find_stream_info. error(%d)\n",
+               __FUNCTION__, __LINE__, error);
+        return;
+    }
+
+    printf("av_find_best_stream\r\n");
+    imageIndex = av_find_best_stream(avContext, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
+    if (imageIndex < 0)
+    {
+        printf("%s:%d failed to av_find_best_stream.\n", __FUNCTION__, __LINE__);
+        return;
+    }
+    printf("image index = %d\r\n", imageIndex);
+    decodeTestContext->avContext = avContext;
+    /*get image info*/
+    codecParameters = avContext->streams[imageIndex]->codecpar;
+    printf("codec_id = %d, width = %d, height = %d\r\n", (int)codecParameters->codec_id,
+           codecParameters->width, codecParameters->height);
+
+    /*omx init*/
+    OMX_HANDLETYPE hComponentDecoder = NULL;
+    OMX_CALLBACKTYPE callbacks;
+    int ret = OMX_ErrorNone;
+    signal(SIGINT, signal_handle);
+    printf("init omx\r\n");
+    ret = OMX_Init();
+    if (ret != OMX_ErrorNone)
+    {
+        printf("[%s,%d]: run OMX_Init failed. ret is %d \n", __FUNCTION__, __LINE__, ret);
+        return 1;
+    }
+
+    callbacks.EventHandler = event_handler;
+    callbacks.FillBufferDone = fill_output_buffer_done_handler;
+    callbacks.EmptyBufferDone = empty_buffer_done_handler;
+    printf("get handle by codec id = %d\r\n", codecParameters->codec_id);
+    if (codecParameters->codec_id == AV_CODEC_ID_MJPEG)
+    {
+        OMX_GetHandle(&hComponentDecoder, "sf.dec.decoder.mjpeg", decodeTestContext, &callbacks);
+    }
+
+    if (hComponentDecoder == NULL)
+    {
+        printf("could not get handle\r\n");
+        return 0;
+    }
+    decodeTestContext->hComponentDecoder = hComponentDecoder;
+    OMX_SendCommand(hComponentDecoder, OMX_CommandStateSet, OMX_StateIdle, NULL);
+
+    OMX_PARAM_PORTDEFINITIONTYPE pInputPortDefinition;
+    OMX_INIT_STRUCTURE(pInputPortDefinition);
+    pInputPortDefinition.nPortIndex = 0;
+    OMX_GetParameter(hComponentDecoder, OMX_IndexParamPortDefinition, &pInputPortDefinition);
+    pInputPortDefinition.format.image.nFrameWidth = codecParameters->width;
+    pInputPortDefinition.format.image.nFrameHeight = codecParameters->height;
+    OMX_SetParameter(hComponentDecoder, OMX_IndexParamPortDefinition, &pInputPortDefinition);
+    /*Alloc input buffer*/
+    OMX_U32 nInputWidth = codecParameters->width;
+    OMX_U32 nInputHeight = codecParameters->height;
+    OMX_U32 nInputBufferSize = nInputWidth * nInputHeight * 2;
+    OMX_U32 nInputBufferCount = pInputPortDefinition.nBufferCountActual;
+    for (int i = 0; i < nInputBufferCount; i++)
+    {
+        OMX_BUFFERHEADERTYPE *pBuffer = NULL;
+        OMX_AllocateBuffer(hComponentDecoder, &pBuffer, 0, NULL, nInputBufferSize);
+        decodeTestContext->pInputBufferArray[i] = pBuffer;
+        /*Fill Input Buffer*/
+        FillInputBuffer(decodeTestContext, pBuffer);
+        OMX_EmptyThisBuffer(hComponentDecoder, pBuffer);
+    }
+
+    OMX_SendCommand(hComponentDecoder, OMX_CommandStateSet, OMX_StateExecuting, NULL);
+
+    /*wait until decode finished*/
+    Message data;
+    while (OMX_TRUE)
+    {
+        if (msgrcv(msgid, (void *)&data, BUFSIZ, 0, 0) == -1)
+        {
+            fprintf(stderr, "msgrcv failed with errno: %d\n", errno);
+            goto end;
+        }
+        switch (data.msg_flag)
+        {
+        case 0:
+        {
+            OMX_BUFFERHEADERTYPE *pBuffer = data.pBuffer;
+            FillInputBuffer(decodeTestContext, pBuffer);
+            OMX_EmptyThisBuffer(decodeTestContext->hComponentDecoder, pBuffer);
+        }
+        break;
+        case 1:
+        {
+            OMX_BUFFERHEADERTYPE *pBuffer = data.pBuffer;
+            OMX_STRING sFilePath = decodeTestContext->sOutputFilePath;
+            printf("write %d buffers to file\r\n", pBuffer->nFilledLen);
+            FILE *fb = fopen(sFilePath, "ab+");
+            size_t size = fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, fb);
+            int error = ferror(fb);
+            printf("write error = %d\r\n", error);
+            fclose(fb);
+            printf("write %d buffers finish\r\n", size);
+            if (pBuffer->nFlags & OMX_BUFFERFLAG_EOS == OMX_BUFFERFLAG_EOS)
+            {
+                goto end;
+            }
+            else
+            {
+                OMX_FillThisBuffer(decodeTestContext->hComponentDecoder, pBuffer);
+            }
+        }
+        break;
+        case 2:
+            break;
+        default:
+            goto end;
+        }
+    }
+
+end:
+    /*free resource*/
+    OMX_FreeHandle(hComponentDecoder);
+    OMX_Deinit();
+}

+ 1 - 1
soft_3rdpart/wave511/code/WaveDecode_buildroot.mak

@@ -65,7 +65,7 @@ CXX = $(CROSS_CC_PREFIX)g++
 LINKER=$(CC)
 AR  = $(CROSS_CC_PREFIX)ar
 
-INCLUDES = -I./vpuapi -I./ffmpeg/include -I./sample_v2/helper -I./sample_v2/helper/misc -I./sample_v2/component -I./vdi
+INCLUDES = -I./vpuapi -I./ffmpeg/include -I./sample_v2/helper -I./sample_v2/helper/misc -I./sample_v2/component -I./vdi -I../
 INCLUDES += -I./sample_v2/component_decoder
 ifeq ($(USE_RTL_SIM), yes)
 DEFINES += -DCNM_SIM_PLATFORM -DCNM_SIM_DPI_INTERFACE -DSUPPORT_DECODER

+ 7 - 2
soft_3rdpart/wave511/code/sample_v2/component/cnm_app.h

@@ -26,9 +26,14 @@
 #ifndef __CNM_APP_H__
 #define __CNM_APP_H__
 
-#include "vputypes.h"
-#include "component.h"
 
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+    #include "wave511/sample_v2/component/component.h"
+#else
+    #include "vputypes.h"
+    #include "component.h"
+#endif
 typedef void*       CNMTask;
 
 typedef enum {

+ 5 - 1
soft_3rdpart/wave511/code/sample_v2/component/cnm_app_internal.h

@@ -26,7 +26,11 @@
 #ifndef __CNM_APP_INTERNAL_H__
 #define __CNM_APP_INTERNAL_H__
 
-#include "vputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "vputypes.h"
+#endif
 
 #define MAX_TASKS_IN_APP            8
 #define MAX_COMPONENTS_IN_TASK      6

+ 10 - 3
soft_3rdpart/wave511/code/sample_v2/component/component.h

@@ -26,9 +26,16 @@
 #ifndef _COMPONENT_H_
 #define _COMPONENT_H_
 
-#include "config.h"
-#include "vpuapifunc.h"
-#include "main_helper.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/config.h"
+    #include "wave511/vpuapi/vpuapifunc.h"
+    #include "wave511/sample_v2/helper/main_helper.h"
+#else
+    #include "config.h"
+    #include "vpuapifunc.h"
+    #include "main_helper.h"
+#endif
+
 
 #define MAX_QUEUE_NUM 5
 

+ 7 - 2
soft_3rdpart/wave511/code/sample_v2/component_decoder/decoder_listener.h

@@ -23,8 +23,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include "cnm_app.h"
-#include "misc/bw_monitor.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/sample_v2/component/cnm_app.h"
+    #include "wave511/sample_v2/helper/misc/bw_monitor.h"
+#else
+    #include "cnm_app.h"
+    #include "misc/bw_monitor.h"
+#endif
 
 
 #ifdef __cplusplus

+ 7 - 2
soft_3rdpart/wave511/code/sample_v2/component_encoder/encoder_listener.h

@@ -23,8 +23,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include "cnm_app.h"
-#include "misc/bw_monitor.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/sample_v2/component/cnm_app.h"
+    #include "wave511/sample_v2/helper/misc/bw_monitor.h"
+#else
+    #include "cnm_app.h"
+    #include "misc/bw_monitor.h"
+#endif
 
 #ifdef __cplusplus
 extern "C" {

+ 12 - 4
soft_3rdpart/wave511/code/sample_v2/helper/main_helper.h

@@ -26,10 +26,18 @@
 #ifndef _MAIN_HELPER_H_
 #define _MAIN_HELPER_H_
 
-#include "config.h"
-#include "vpuapifunc.h"
-#include "vpuapi.h"
-#include "vputypes.h"
+
+#ifdef USE_FEEDING_METHOD_BUFFER
+   #include "wave511/config.h"
+   #include "wave511/vpuapi/vpuapifunc.h"
+   #include "wave511/vpuapi/vpuapi.h"
+   #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "config.h"
+    #include "vpuapifunc.h"
+    #include "vpuapi.h"
+    #include "vputypes.h"
+#endif
 #ifdef PLATFORM_QNX
     #include <sys/stat.h>
 #endif

+ 8 - 2
soft_3rdpart/wave511/code/sample_v2/helper/misc/debug.h

@@ -26,8 +26,14 @@
 #ifndef _DEBUG_H_
 #define _DEBUG_H_
 
-#include "config.h"
-#include "main_helper.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/config.h"
+    #include "wave511/sample_v2/helper/main_helper.h"
+#else
+    #include "config.h"
+    #include "main_helper.h"
+#endif
+
 
 enum {
     CNMQC_ENV_NONE,

+ 6 - 1
soft_3rdpart/wave511/code/sample_v2/helper/misc/pbu.h

@@ -26,7 +26,12 @@
 #ifndef __PBU_H__
 #define __PBU_H__
 
-#include <vputypes.h>
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include <vputypes.h>
+#endif
+
 
 typedef void* spp_enc_context;
 

+ 5 - 1
soft_3rdpart/wave511/code/vdi/mm.h

@@ -26,7 +26,11 @@
 #ifndef __CNM_VIDEO_MEMORY_ALLOCATOR_H_
 #define __CNM_VIDEO_MEMORY_ALLOCATOR_H_
 
-#include "vputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include <vputypes.h>
+#endif
 
 typedef struct _video_mm_info_struct {
 unsigned long   total_pages; 

+ 11 - 3
soft_3rdpart/wave511/code/vdi/vdi.h

@@ -26,9 +26,17 @@
 #ifndef _VDI_H_
 #define _VDI_H_
 
-#include "mm.h"
-#include "vpuconfig.h"
-#include "vputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vdi/mm.h"
+    #include "wave511/vpuapi/vpuconfig.h"
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "mm.h"
+    #include "vpuconfig.h"
+    #include "vputypes.h"
+#endif
+
+
 
 /************************************************************************/
 /* COMMON REGISTERS                                                     */

+ 5 - 1
soft_3rdpart/wave511/code/vdi/vdi_osal.h

@@ -29,7 +29,11 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
-#include "vputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "vputypes.h"
+#endif
 
 enum
 {

+ 8 - 2
soft_3rdpart/wave511/code/vpuapi/coda9/coda9.h

@@ -26,8 +26,14 @@
 #ifndef __CODA9_FUNCTION_H__
 #define __CODA9_FUNCTION_H__
 
-#include "vpuapi.h"
-#include "../product.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuapi.h"
+    #include "wave511/vpuapi/product.h"
+#else
+    #include "vpuapi.h"
+    #include "../product.h"
+#endif
+
 
 #ifdef __cplusplus
 extern "C" {

+ 7 - 2
soft_3rdpart/wave511/code/vpuapi/coda9/coda9_vpuconfig.h

@@ -26,8 +26,13 @@
 #ifndef __CODA9_VPU_CONFIG_H__
 #define __CODA9_VPU_CONFIG_H__
 
-#include "vpuconfig.h"
-#include "vputypes.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuconfig.h"
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "vpuconfig.h"
+    #include "vputypes.h"
+#endif
 
 
 #if MAX_DEC_PIC_WIDTH > 1920		// 4K		

+ 8 - 2
soft_3rdpart/wave511/code/vpuapi/product.h

@@ -26,8 +26,14 @@
 #ifndef __VPUAPI_PRODUCT_ABSTRACT_H__
 #define __VPUAPI_PRODUCT_ABSTRACT_H__
 
-#include "vpuapi.h"
-#include "vpuapifunc.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuapi.h"
+    #include "wave511/vpuapi/vpuapifunc.h"
+#else
+    #include "vpuapi.h"
+    #include "vpuapifunc.h"
+#endif
+
 
 #define IS_CODA_DECODER_HANDLE(_inst)      (_inst->codecMode < AVC_ENC)
 

+ 13 - 5
soft_3rdpart/wave511/code/vpuapi/vpuapi.h

@@ -26,11 +26,19 @@
 #ifndef VPUAPI_H_INCLUDED
 #define VPUAPI_H_INCLUDED
 
-#include "vpuconfig.h"
-#include "vputypes.h"
-#include "../vdi/vdi.h"
-#include "../vdi/vdi_osal.h"
-#include "vpuerror.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuconfig.h"
+    #include "wave511/vpuapi/vputypes.h"
+    #include "wave511/vdi/vdi.h"
+    #include "wave511/vdi/vdi_osal.h"
+    #include "wave511/vpuapi/vpuerror.h"
+#else
+    #include "vpuconfig.h"
+    #include "vputypes.h"
+    #include "../vdi/vdi.h"
+    #include "../vdi/vdi_osal.h"
+    #include "vpuerror.h"
+#endif
 
 
 

+ 5 - 1
soft_3rdpart/wave511/code/vpuapi/vpuapifunc.h

@@ -26,7 +26,11 @@
 #ifndef VPUAPI_UTIL_H_INCLUDED
 #define VPUAPI_UTIL_H_INCLUDED
 
-#include "vpuapi.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuapi.h"
+#else
+    #include "vpuapi.h"
+#endif
 
 // COD_STD
 enum {

+ 5 - 1
soft_3rdpart/wave511/code/vpuapi/vputypes.h

@@ -27,7 +27,11 @@
 #define _VPU_TYPES_H_
 
 #include <stdint.h>
-#include "vpuconfig.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vputypes.h"
+#else
+    #include "vputypes.h"
+#endif
 
 #define STATIC          static
 /**

+ 7 - 2
soft_3rdpart/wave511/code/vpuapi/wave/wave5.h

@@ -26,8 +26,13 @@
 #ifndef __WAVE5_FUNCTION_H__
 #define __WAVE5_FUNCTION_H__
 
-#include "vpuapi.h"
-#include "product.h"
+#ifdef USE_FEEDING_METHOD_BUFFER
+    #include "wave511/vpuapi/vpuapi.h"
+    #include "wave511/vpuapi/product.h"
+#else
+    #include "vpuapi.h"
+    #include "product.h"
+#endif
 
 #define WAVE5_TEMPBUF_OFFSET                (1024*1024)
 #define WAVE5_TEMPBUF_SIZE                  (1024*1024)