#include "Exynos_OSAL_SharedMemory.h"
#include "Exynos_OSAL_Mutex.h"
#include "Exynos_OSAL_ETC.h"
+#include "ExynosVideoApi.h"
#include "csc.h"
#ifdef USE_STOREMETADATA
-#include <system/window.h>
#include "Exynos_OSAL_Android.h"
#endif
return;
}
+void Exynos_Free_CodecBuffers(
+ OMX_COMPONENTTYPE *pOMXComponent,
+ OMX_U32 nPortIndex)
+{
+ OMX_ERRORTYPE ret = OMX_ErrorNone;
+ EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+ EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
+ CODEC_ENC_BUFFER **ppCodecBuffer = NULL;
+
+ OMX_U32 nPlaneCnt = 0;
+ int i, j;
+
+ FunctionIn();
+
+ if (nPortIndex == INPUT_PORT_INDEX) {
+ ppCodecBuffer = &(pVideoEnc->pMFCEncInputBuffer[0]);
+ nPlaneCnt = MFC_INPUT_BUFFER_PLANE;
+ } else {
+ ppCodecBuffer = &(pVideoEnc->pMFCEncOutputBuffer[0]);
+ nPlaneCnt = MFC_OUTPUT_BUFFER_PLANE;
+ }
+
+ for (i = 0; i < MFC_OUTPUT_BUFFER_NUM_MAX; i++) {
+ if (ppCodecBuffer[i] != NULL) {
+ for (j = 0; j < nPlaneCnt; j++) {
+ if (ppCodecBuffer[i]->pVirAddr[j] != NULL)
+ Exynos_OSAL_SharedMemory_Free(pVideoEnc->hSharedMemory, ppCodecBuffer[i]->pVirAddr[j]);
+ }
+
+ Exynos_OSAL_Free(ppCodecBuffer[i]);
+ ppCodecBuffer[i] = NULL;
+ }
+ }
+
+ FunctionOut();
+}
+
+OMX_ERRORTYPE Exynos_Allocate_CodecBuffers(
+ OMX_COMPONENTTYPE *pOMXComponent,
+ OMX_U32 nPortIndex,
+ OMX_U32 nBufferCnt,
+ OMX_U32 nPlaneSize[MFC_OUTPUT_BUFFER_PLANE])
+{
+ OMX_ERRORTYPE ret = OMX_ErrorNone;
+ EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
+ EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
+ MEMORY_TYPE eMemoryType = SYSTEM_MEMORY;
+ CODEC_ENC_BUFFER **ppCodecBuffer = NULL;
+
+ OMX_U32 nPlaneCnt = 0;
+ int i, j;
+
+ FunctionIn();
+
+ if (nPortIndex == INPUT_PORT_INDEX) {
+ ppCodecBuffer = &(pVideoEnc->pMFCEncInputBuffer[0]);
+ nPlaneCnt = MFC_INPUT_BUFFER_PLANE;
+ } else {
+ ppCodecBuffer = &(pVideoEnc->pMFCEncOutputBuffer[0]);
+ nPlaneCnt = MFC_OUTPUT_BUFFER_PLANE;
+#ifdef USE_CSC_HW
+ eMemoryType = NORMAL_MEMORY;
+#endif
+ }
+
+ for (i = 0; i < nBufferCnt; i++) {
+ ppCodecBuffer[i] = (CODEC_ENC_BUFFER *)Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
+ if (ppCodecBuffer[i] == NULL) {
+ Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc codec buffer");
+ ret = OMX_ErrorInsufficientResources;
+ goto EXIT;
+ }
+ Exynos_OSAL_Memset(ppCodecBuffer[i], 0, sizeof(CODEC_ENC_BUFFER));
+
+ for (j = 0; j < nPlaneCnt; j++) {
+ ppCodecBuffer[i]->pVirAddr[j] =
+ (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, nPlaneSize[j], eMemoryType);
+ if (ppCodecBuffer[i]->pVirAddr[j] == NULL) {
+ Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Failed to Alloc plane");
+ ret = OMX_ErrorInsufficientResources;
+ goto EXIT;
+ }
+
+ ppCodecBuffer[i]->fd[j] =
+ Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, ppCodecBuffer[i]->pVirAddr[j]);
+ ppCodecBuffer[i]->bufferSize[j] = nPlaneSize[j];
+ Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "PORT[%d]: pMFCCodecBuffer[%d]->pVirAddr[%d]: 0x%x", nPortIndex, i, j, ppCodecBuffer[i]->pVirAddr[j]);
+ }
+
+ ppCodecBuffer[i]->dataSize = 0;
+ }
+
+ return OMX_ErrorNone;
+
+EXIT:
+ Exynos_Free_CodecBuffers(pOMXComponent, nPortIndex);
+
+ FunctionOut();
+
+ return ret;
+}
+
OMX_BOOL Exynos_Check_BufferProcess_State(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_U32 nPortIndex)
{
OMX_BOOL ret = OMX_FALSE;
pData->buffer.multiPlaneBuffer.dataBuffer[0] = pInputCodecBuffer->pVirAddr[0];
pData->buffer.multiPlaneBuffer.dataBuffer[1] = pInputCodecBuffer->pVirAddr[1];
+ pData->buffer.multiPlaneBuffer.fd[0] = pInputCodecBuffer->fd[0];
+ pData->buffer.multiPlaneBuffer.fd[1] = pInputCodecBuffer->fd[1];
pData->allocSize = pInputCodecBuffer->bufferSize[0] + pInputCodecBuffer->bufferSize[1];
pData->dataLen = pInputCodecBuffer->dataSize;
pData->usedDataLen = 0;
return ret;
}
-OMX_ERRORTYPE Exynos_Output_CodecBufferToData(EXYNOS_OMX_BASECOMPONENT *pExynosComponent, OMX_PTR codecBuffer, EXYNOS_OMX_DATA *pData)
+OMX_ERRORTYPE Exynos_Output_CodecBufferToData(
+ CODEC_ENC_BUFFER *pCodecBuffer,
+ EXYNOS_OMX_DATA *pData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
- EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
- OMX_PTR pSrcBuf;
- OMX_U32 allocSize;
- pVideoEnc->exynos_codec_getCodecOutputPrivateData(codecBuffer, &pSrcBuf, &allocSize);
- pData->buffer.singlePlaneBuffer.dataBuffer = pSrcBuf;
- pData->allocSize = allocSize;
+ pData->buffer.singlePlaneBuffer.dataBuffer = pCodecBuffer->pVirAddr[0];
+ pData->buffer.singlePlaneBuffer.fd = pCodecBuffer->fd[0];
+ pData->allocSize = pCodecBuffer->bufferSize[0];
pData->dataLen = 0;
pData->usedDataLen = 0;
pData->remainDataLen = 0;
pData->nFlags = 0;
pData->timeStamp = 0;
- pData->pPrivate = codecBuffer;
+ pData->pPrivate = pCodecBuffer;
pData->bufferHeader = NULL;
return ret;
unsigned int csc_src_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
unsigned int csc_dst_color_format = omx_2_hal_pixel_format((unsigned int)OMX_COLOR_FormatYUV420SemiPlanar);
CSC_METHOD csc_method = CSC_METHOD_SW;
- unsigned int cacheable = 1;
+ unsigned int srcCacheable = 1, dstCacheable = 1;
unsigned char *pSrcBuf[3] = {NULL, };
unsigned char *pDstBuf[3] = {NULL, };
pDstBuf[2] = srcInputData->buffer.multiPlaneBuffer.dataBuffer[2];
csc_get_method(pVideoEnc->csc_handle, &csc_method);
- if (csc_method == CSC_METHOD_HW) {
- pDstBuf[0] = srcInputData->buffer.multiPlaneBuffer.fd[0];
- pDstBuf[1] = srcInputData->buffer.multiPlaneBuffer.fd[1];
- pDstBuf[2] = srcInputData->buffer.multiPlaneBuffer.fd[2];
- }
+ if (csc_method == CSC_METHOD_HW)
+ dstCacheable = 0;
#ifdef USE_METADATABUFFERTYPE
OMX_PTR ppBuf[MAX_BUFFER_PLANE];
OMX_U32 stride;
int imageSize;
- Exynos_OSAL_LockANBHandle((OMX_U32)ppBuf[0], nFrameWidth, nFrameHeight, OMX_COLOR_FormatAndroidOpaque, planes);
+ ret = Exynos_OSAL_LockANBHandle((OMX_U32)ppBuf[0], nFrameWidth, nFrameHeight, OMX_COLOR_FormatAndroidOpaque, planes);
+ if (ret != OMX_ErrorNone) {
+ Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "%s: Exynos_OSAL_LockANBHandle() failed", __FUNCTION__);
+ ret = OMX_FALSE;
+ goto EXIT;
+ }
+
imageSize = nFrameWidth * nFrameHeight * 3; /* RGB888 */
+#ifdef USE_GSC_RGB_ENCODER
+ if (pVideoEnc->csc_set_format == OMX_FALSE) {
+ cscRet = csc_set_method(pVideoEnc->csc_handle, CSC_METHOD_HW);
+ if (cscRet != CSC_ErrorNone) {
+ ret = OMX_FALSE;
+ goto EXIT;
+ }
+ }
+#endif
+
+#ifdef USE_DMA_BUF
if (csc_method == CSC_METHOD_HW)
pSrcBuf[0] = (unsigned char *)planes[0].fd;
else
- pSrcBuf[0] = planes[0].addr;
+#endif
+ pSrcBuf[0] = planes[0].addr;
pSrcBuf[1] = NULL;
pSrcBuf[2] = NULL;
}
} else
#endif
{
+#ifdef USE_DMA_BUF
if (csc_method == CSC_METHOD_HW) {
pSrcBuf[0] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, checkInputStream);
pSrcBuf[1] = NULL;
pSrcBuf[2] = NULL;
}
+#endif
switch (eColorFormat) {
case OMX_COLOR_FormatYUV420Planar:
}
}
+#ifdef USE_DMA_BUF
+ if (csc_method == CSC_METHOD_HW) {
+ pDstBuf[0] = srcInputData->buffer.multiPlaneBuffer.fd[0];
+ pDstBuf[1] = srcInputData->buffer.multiPlaneBuffer.fd[1];
+ pDstBuf[2] = srcInputData->buffer.multiPlaneBuffer.fd[2];
+ }
+#endif
+
csc_set_src_format(
pVideoEnc->csc_handle, /* handle */
nFrameWidth, /* width */
nFrameWidth, /* crop_width */
nFrameHeight, /* crop_height */
csc_src_color_format, /* color_format */
- cacheable); /* cacheable */
+ srcCacheable); /* cacheable */
csc_set_dst_format(
pVideoEnc->csc_handle, /* handle */
nFrameWidth, /* width */
nFrameWidth, /* crop_width */
nFrameHeight, /* crop_height */
csc_dst_color_format, /* color_format */
- cacheable); /* cacheable */
+ dstCacheable); /* cacheable */
csc_set_src_buffer(
pVideoEnc->csc_handle, /* handle */
- pSrcBuf); /* YUV Addr or FD */
+ pSrcBuf,
+ CSC_MEMORY_DMABUF); /* YUV Addr or FD */
csc_set_dst_buffer(
pVideoEnc->csc_handle, /* handle */
- pDstBuf); /* YUV Addr or FD */
+ pDstBuf,
+ CSC_MEMORY_DMABUF); /* YUV Addr or FD */
cscRet = csc_convert(pVideoEnc->csc_handle);
if (cscRet != CSC_ErrorNone)
ret = OMX_FALSE;
OMX_PTR ppBuf[MAX_BUFFER_PLANE];
OMX_PTR allocSize[MAX_BUFFER_PLANE];
int plane = 0;
+
if (eColorFormat == OMX_COLOR_FormatAndroidOpaque) {
Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)inputUseBuffer->bufferHeader->pBuffer, ppBuf);
ExynosVideoPlane planes[MAX_BUFFER_PLANE];
} else {
/* kMetadataBufferTypeCameraSource */
Exynos_OSAL_GetInfoFromMetaData((OMX_BYTE)inputUseBuffer->bufferHeader->pBuffer, ppBuf);
+#ifdef USE_DMA_BUF
srcInputData->buffer.multiPlaneBuffer.fd[0] = ppBuf[0];
srcInputData->buffer.multiPlaneBuffer.fd[1] = ppBuf[1];
allocSize[0] = nFrameWidth * nFrameHeight;
/* input buffers are 2 plane. */
srcInputData->buffer.multiPlaneBuffer.dataBuffer[2] = NULL;
srcInputData->buffer.multiPlaneBuffer.fd[2] = -1;
- Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s:%d YAddr: 0x%x CbCrAddr: 0x%x", __FUNCTION__, __LINE__, (unsigned int)ppBuf[0], (unsigned int)ppBuf[0]);
+#else
+ for (plane = 0; plane < MFC_INPUT_BUFFER_PLANE; plane++) {
+ srcInputData->buffer.multiPlaneBuffer.dataBuffer[plane] = ppBuf[plane];
+ }
+ srcInputData->buffer.multiPlaneBuffer.dataBuffer[2] = NULL;
+#endif
+ Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "%s:%d YAddr: 0x%x CbCrAddr: 0x%x", __FUNCTION__, __LINE__, (unsigned int)ppBuf[0], (unsigned int)ppBuf[1]);
}
}
#endif
Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "exynos_checkInputFrame : OMX_TRUE");
if (((srcInputData->allocSize) - (srcInputData->dataLen)) >= copySize) {
- Exynos_CSC_InputData(pOMXComponent, srcInputData);
+ ret = Exynos_CSC_InputData(pOMXComponent, srcInputData);
+ if (ret == OMX_FALSE)
+ goto EXIT;
inputUseBuffer->dataLen -= copySize;
inputUseBuffer->remainDataLen -= copySize;
FunctionIn();
if (exynosOutputPort->bufferProcessType & BUFFER_SHARE) {
- if (Exynos_Shared_DataToBuffer(dstOutputData, outputUseBuffer) == OMX_ErrorNone)
+ if (Exynos_Shared_DataToBuffer(dstOutputData, outputUseBuffer, OMX_FALSE) == OMX_ErrorNone)
outputUseBuffer->dataValid = OMX_TRUE;
}
}
if ((exynosInputPort->bufferProcessType & BUFFER_COPY) == BUFFER_COPY) {
+ OMX_U32 nPlaneSize[MFC_INPUT_BUFFER_PLANE] = {0, };
+ nPlaneSize[0] = DEFAULT_MFC_INPUT_YBUFFER_SIZE;
+ nPlaneSize[1] = DEFAULT_MFC_INPUT_CBUFFER_SIZE;
+
Exynos_OSAL_SemaphoreCreate(&exynosInputPort->codecSemID);
Exynos_OSAL_QueueCreate(&exynosInputPort->codecBufferQ, MAX_QUEUE_ELEMENTS);
- for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++) {
- pVideoEnc->pMFCEncInputBuffer[i] = Exynos_OSAL_Malloc(sizeof(CODEC_ENC_BUFFER));
- /* Use ION Allocator */
- /*Alloc Y-Buffer */
- pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_YBUFFER_SIZE, NORMAL_MEMORY);
- pVideoEnc->pMFCEncInputBuffer[i]->fd[0] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
- pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[0] = DEFAULT_MFC_INPUT_YBUFFER_SIZE;
- /*Alloc C-Buffer */
- pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] = (void *)Exynos_OSAL_SharedMemory_Alloc(pVideoEnc->hSharedMemory, DEFAULT_MFC_INPUT_CBUFFER_SIZE, NORMAL_MEMORY);
- pVideoEnc->pMFCEncInputBuffer[i]->fd[1] = Exynos_OSAL_SharedMemory_VirtToION(pVideoEnc->hSharedMemory, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
- pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[1] = DEFAULT_MFC_INPUT_CBUFFER_SIZE;
-
- pVideoEnc->pMFCEncInputBuffer[i]->dataSize = 0;
-
- if ((pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0] == NULL) ||
- (pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1] == NULL)) {
- Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Fail input buffer");
- ret = OMX_ErrorInsufficientResources;
- goto EXIT;
- }
-
- /* MFC input buffers are 1 plane. */
- pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[2] = NULL;
- pVideoEnc->pMFCEncInputBuffer[i]->fd[2] = -1;
- pVideoEnc->pMFCEncInputBuffer[i]->bufferSize[2] = 0;
+ ret = Exynos_Allocate_CodecBuffers(pOMXComponent, INPUT_PORT_INDEX, MFC_INPUT_BUFFER_NUM_MAX, nPlaneSize);
+ if (ret != OMX_ErrorNone)
+ goto EXIT;
- Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncInputBuffer[%d]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]);
- Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[0]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[0]);
- Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "pVideoEnc->pMFCEncInputBuffer[%d]->pVirAddr[1]: 0x%x", i, pVideoEnc->pMFCEncInputBuffer[i]->pVirAddr[1]);
-
- Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
- }
+ for (i = 0; i < MFC_INPUT_BUFFER_NUM_MAX; i++)
+ Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, pVideoEnc->pMFCEncInputBuffer[i]);
} else if (exynosInputPort->bufferProcessType == BUFFER_SHARE) {
/*************/
/* TBD */
}
}
-
EXIT:
return ret;
if (exynosInputPort->bufferProcessType & BUFFER_COPY) {
OMX_PTR codecBuffer;
if ((pSrcInputData->buffer.multiPlaneBuffer.dataBuffer[0] == NULL) || (pSrcInputData->pPrivate == NULL)) {
- Exynos_CodecBufferDeQueue(pExynosComponent, INPUT_PORT_INDEX, &codecBuffer);
+ Exynos_CodecBufferDequeue(pExynosComponent, INPUT_PORT_INDEX, &codecBuffer);
if (codecBuffer != NULL) {
Exynos_Input_CodecBufferToData(pExynosComponent, codecBuffer, pSrcInputData);
}
EXYNOS_OMX_VIDEOENC_COMPONENT *pVideoEnc = (EXYNOS_OMX_VIDEOENC_COMPONENT *)pExynosComponent->hComponentHandle;
EXYNOS_OMX_BASEPORT *exynosInputPort = &pExynosComponent->pExynosPort[INPUT_PORT_INDEX];
EXYNOS_OMX_DATABUFFER *srcOutputUseBuffer = &exynosInputPort->way.port2WayDataBuffer.outputDataBuffer;
- EXYNOS_OMX_DATA srcOutputData;
+ EXYNOS_OMX_DATA srcOutputData;
FunctionIn();
OMX_PTR codecBuffer;
codecBuffer = srcOutputData.pPrivate;
if (codecBuffer != NULL)
- Exynos_CodecBufferEnQueue(pExynosComponent, INPUT_PORT_INDEX, codecBuffer);
+ Exynos_CodecBufferEnqueue(pExynosComponent, INPUT_PORT_INDEX, codecBuffer);
}
if (exynosInputPort->bufferProcessType & BUFFER_SHARE) {
- Exynos_Shared_DataToBuffer(&srcOutputData, srcOutputUseBuffer);
+ OMX_BOOL bNeedUnlock = OMX_FALSE;
+ OMX_COLOR_FORMATTYPE eColorFormat = exynosInputPort->portDefinition.format.video.eColorFormat;
+ if (eColorFormat == OMX_COLOR_FormatAndroidOpaque)
+ bNeedUnlock = OMX_TRUE;
+ Exynos_Shared_DataToBuffer(&srcOutputData, srcOutputUseBuffer, bNeedUnlock);
Exynos_InputBufferReturn(pOMXComponent);
}
Exynos_ResetCodecData(&srcOutputData);
EXYNOS_OMX_BASEPORT *exynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
EXYNOS_OMX_DATABUFFER *dstInputUseBuffer = &exynosOutputPort->way.port2WayDataBuffer.inputDataBuffer;
EXYNOS_OMX_DATA dstInputData;
-
+
FunctionIn();
while (!pVideoEnc->bExitBufferProcessThread) {
Exynos_OSAL_MutexLock(dstInputUseBuffer->bufferMutex);
if (exynosOutputPort->bufferProcessType & BUFFER_COPY) {
- OMX_PTR codecBuffer;
- ret = Exynos_CodecBufferDeQueue(pExynosComponent, OUTPUT_PORT_INDEX, &codecBuffer);
+ CODEC_ENC_BUFFER *pCodecBuffer = NULL;
+ ret = Exynos_CodecBufferDequeue(pExynosComponent, OUTPUT_PORT_INDEX, (OMX_PTR *)&pCodecBuffer);
if (ret != OMX_ErrorNone) {
Exynos_OSAL_MutexUnlock(dstInputUseBuffer->bufferMutex);
break;
}
- Exynos_Output_CodecBufferToData(pExynosComponent, codecBuffer, &dstInputData);
+ Exynos_Output_CodecBufferToData(pCodecBuffer, &dstInputData);
}
if (exynosOutputPort->bufferProcessType & BUFFER_SHARE) {
EXYNOS_OMX_BASEPORT *exynosOutputPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
EXYNOS_OMX_DATABUFFER *dstOutputUseBuffer = &exynosOutputPort->way.port2WayDataBuffer.outputDataBuffer;
EXYNOS_OMX_DATA *pDstOutputData = &exynosOutputPort->processData;
-
+
FunctionIn();
while (!pVideoEnc->bExitBufferProcessThread) {
}
if (exynosOutputPort->bufferProcessType & BUFFER_COPY) {
- OMX_PTR codecBuffer;
- codecBuffer = pDstOutputData->pPrivate;
- if (codecBuffer != NULL) {
- Exynos_CodecBufferEnQueue(pExynosComponent, OUTPUT_PORT_INDEX, codecBuffer);
+ if (pDstOutputData->pPrivate != NULL) {
+ Exynos_CodecBufferEnqueue(pExynosComponent, OUTPUT_PORT_INDEX, pDstOutputData->pPrivate);
pDstOutputData->pPrivate = NULL;
}
}
projects / GitHub / LineageOS / android_hardware_samsung_slsi_openmax.git / blobdiff