2018 lines
51 KiB
C
2018 lines
51 KiB
C
|
|
#include <linux/string.h>
|
|
#include <malloc.h>
|
|
#include <common.h>
|
|
|
|
#include "jpuapi.h"
|
|
#include "jpuapifunc.h"
|
|
#include "jpuhelper.h"
|
|
#include "jpulog.h"
|
|
#include "jputable.h"
|
|
#include "regdefine.h"
|
|
|
|
extern int sscanf(const char *str, const char *format, ...);
|
|
|
|
extern int __must_check kstrtoint(const char *s, unsigned int base, int *res);
|
|
|
|
static int FillSdramBurst(BufInfo *pBufInfo, Uint64 targetAddr,
|
|
PhysicalAddress bsBufStartAddr,
|
|
PhysicalAddress bsBufEndAddr, Uint32 size,
|
|
int checkeos, int *streameos, int endian);
|
|
static int StoreYuvImageBurstFormat(Uint8 *dst, int picWidth, int picHeight,
|
|
unsigned long addrY, unsigned long addrCb,
|
|
unsigned long addrCr, int stride,
|
|
int interLeave, int format, int endian,
|
|
int packed);
|
|
static void ProcessEncodedBitstreamBurst(osal_file_t *fp,
|
|
unsigned long targetAddr,
|
|
PhysicalAddress bsBufStartAddr,
|
|
PhysicalAddress bsBufEndAddr, int size,
|
|
int endian);
|
|
static int LoadYuvImageBurstFormat(unsigned char *src, int picWidth,
|
|
int picHeight, unsigned long addrY,
|
|
unsigned long addrCb, unsigned long addrCr,
|
|
int stride, int interLeave, int format,
|
|
int endian, int packed);
|
|
|
|
// Figure A.6 - Zig-zag sequence of quantized DCT coefficients
|
|
const int InvScanTable[64] = {
|
|
0, 1, 5, 6, 14, 15, 27, 28, 2, 4, 7, 13, 16, 26, 29, 42,
|
|
3, 8, 12, 17, 25, 30, 41, 43, 9, 11, 18, 24, 31, 40, 44, 53,
|
|
10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60,
|
|
21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63
|
|
};
|
|
|
|
const int ScanTable[64] = {
|
|
0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18,
|
|
11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20,
|
|
13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43,
|
|
36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45,
|
|
38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
|
|
};
|
|
|
|
JpgRet WriteJpgBsBufHelperStream(JpgDecHandle handle, BufInfo *pBufInfo,
|
|
PhysicalAddress paBsBufStart,
|
|
PhysicalAddress paBsBufEnd, int defaultsize,
|
|
int checkeos, int *pstreameos, int endian)
|
|
{
|
|
JpgRet ret = JPG_RET_SUCCESS;
|
|
int size = 0;
|
|
int fillSize = 0;
|
|
PhysicalAddress paRdPtr, paWrPtr;
|
|
|
|
ret = JPU_DecGetBitstreamBuffer(handle, &paRdPtr, &paWrPtr, &size);
|
|
JLOG(INFO, "rdPtr: 0x%lx, wrPtr: 0x%lx, size: %d\n", paRdPtr, paWrPtr, size);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecGetBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
if (size <= 0)
|
|
return JPG_RET_SUCCESS;
|
|
|
|
if (defaultsize) {
|
|
if (size < defaultsize)
|
|
fillSize = size;
|
|
else
|
|
fillSize = defaultsize;
|
|
} else {
|
|
fillSize = size;
|
|
}
|
|
|
|
JLOG(INFO, "Before fillSize: %d\n", fillSize);
|
|
|
|
fillSize = FillSdramBurst(pBufInfo, paWrPtr, paBsBufStart, paBsBufEnd,
|
|
fillSize, checkeos, pstreameos, endian);
|
|
|
|
if (fillSize == 0 && pBufInfo->fillendbs != 1)
|
|
return ret;
|
|
JLOG(INFO, "After fillSize :%d\n", fillSize);
|
|
if (*pstreameos == 0) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, fillSize);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
if (pBufInfo->fillendbs == 1) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, STREAM_END_SIZE);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
// pBufInfo->fillendbs = 1;
|
|
}
|
|
} else {
|
|
if (!pBufInfo->fillendbs) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, STREAM_END_SIZE);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
pBufInfo->fillendbs = 1;
|
|
}
|
|
}
|
|
|
|
FILL_BS_ERROR:
|
|
|
|
return ret;
|
|
}
|
|
|
|
JpgRet WriteJpgBsBufHelper(JpgDecHandle handle, BufInfo *pBufInfo,
|
|
PhysicalAddress paBsBufStart,
|
|
PhysicalAddress paBsBufEnd, int defaultsize,
|
|
int checkeos, int *pstreameos, int endian)
|
|
{
|
|
JpgRet ret = JPG_RET_SUCCESS;
|
|
int size = 0;
|
|
int fillSize = 0;
|
|
PhysicalAddress paRdPtr, paWrPtr;
|
|
|
|
ret = JPU_DecGetBitstreamBuffer(handle, &paRdPtr, &paWrPtr, &size);
|
|
|
|
JLOG(INFO, "rdPtr: 0x%lx, wrPtr: 0x%lx, size: %d\n", paRdPtr, paWrPtr, size);
|
|
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecGetBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
if (size <= 0)
|
|
return JPG_RET_SUCCESS;
|
|
|
|
if (defaultsize) {
|
|
if (size < defaultsize)
|
|
fillSize = size;
|
|
else
|
|
fillSize = defaultsize;
|
|
} else {
|
|
fillSize = size;
|
|
}
|
|
|
|
fillSize = FillSdramBurst(pBufInfo, paWrPtr, paBsBufStart, paBsBufEnd,
|
|
fillSize, checkeos, pstreameos, endian);
|
|
|
|
JLOG(INFO, "fillSize :%d\n", fillSize);
|
|
|
|
if (*pstreameos == 0) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, fillSize);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
if ((pBufInfo->size - pBufInfo->point) <= 0) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, STREAM_END_SIZE);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
|
|
pBufInfo->fillendbs = 1;
|
|
}
|
|
} else {
|
|
if (!pBufInfo->fillendbs) {
|
|
ret = JPU_DecUpdateBitstreamBuffer(handle, STREAM_END_SIZE);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_DecUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto FILL_BS_ERROR;
|
|
}
|
|
pBufInfo->fillendbs = 1;
|
|
}
|
|
}
|
|
|
|
FILL_BS_ERROR:
|
|
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* Bitstream Read for encoders
|
|
*/
|
|
JpgRet ReadJpgBsBufHelper(JpgEncHandle handle, osal_file_t *bsFp,
|
|
PhysicalAddress paBsBufStart,
|
|
PhysicalAddress paBsBufEnd, int encHeaderSize,
|
|
int endian)
|
|
{
|
|
JpgRet ret = JPG_RET_SUCCESS;
|
|
int loadSize = 0;
|
|
int stuffSize;
|
|
PhysicalAddress paRdPtr, paWrPtr;
|
|
int size = 0;
|
|
|
|
ret = JPU_EncGetBitstreamBuffer(handle, &paRdPtr, &paWrPtr, &size);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "JPU_EncGetBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto LOAD_BS_ERROR;
|
|
}
|
|
|
|
if (size > 0) {
|
|
stuffSize = 0;
|
|
if (encHeaderSize && (size + encHeaderSize) % 8) {
|
|
stuffSize = (size + encHeaderSize) - ((size + encHeaderSize) / 8) * 8;
|
|
stuffSize = 8 - stuffSize;
|
|
}
|
|
|
|
loadSize = size;
|
|
|
|
if (loadSize > 0) {
|
|
ProcessEncodedBitstreamBurst(bsFp, paRdPtr, paBsBufStart, paBsBufEnd, loadSize, endian);
|
|
|
|
ret = JPU_EncUpdateBitstreamBuffer(handle, loadSize);
|
|
if (ret != JPG_RET_SUCCESS) {
|
|
JLOG(ERR, "VPU_EncUpdateBitstreamBuffer failed Error code is 0x%x\n", ret);
|
|
goto LOAD_BS_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
LOAD_BS_ERROR:
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* DPB Image Data Control
|
|
******************************************************************************/
|
|
int LoadYuvImageHelperFormat(osal_file_t *yuvFp, Uint8 *pYuv,
|
|
PhysicalAddress addrY, PhysicalAddress addrCb,
|
|
PhysicalAddress addrCr, int picWidth,
|
|
int picHeight, int stride, int interleave,
|
|
int format, int endian, int packed)
|
|
{
|
|
int frameSize = 0;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
frameSize = picWidth * picHeight * 3 / 2;
|
|
break;
|
|
case FORMAT_224:
|
|
frameSize = picWidth * picHeight * 4 / 2;
|
|
break;
|
|
case FORMAT_422:
|
|
frameSize = picWidth * picHeight * 4 / 2;
|
|
break;
|
|
case FORMAT_444:
|
|
frameSize = picWidth * picHeight * 6 / 2;
|
|
break;
|
|
case FORMAT_400:
|
|
frameSize = picWidth * picHeight;
|
|
break;
|
|
}
|
|
|
|
if (packed == PACKED_FORMAT_NONE) {
|
|
frameSize = frameSize;
|
|
} else if (packed == PACKED_FORMAT_444) {
|
|
frameSize = picWidth * 3 * picHeight;
|
|
} else { // PACKED_FORMAT_422_XXXX
|
|
frameSize = picWidth * 2 * picHeight;
|
|
}
|
|
|
|
// Load source one picture image to encode to SDRAM frame buffer.
|
|
if (!OSAL_FREAD(pYuv, 1, frameSize, yuvFp)) {
|
|
if (!OSAL_FEOF(yuvFp))
|
|
JLOG(ERR, "Yuv Data fread failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
|
|
LoadYuvImageBurstFormat(pYuv, picWidth, picHeight, addrY, addrCb,
|
|
addrCr, stride, interleave, format, endian,
|
|
packed);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int LoadYuvPartialImageHelperFormat(osal_file_t *yuvFp, Uint8 *pYuv, PhysicalAddress addrY,
|
|
PhysicalAddress addrCb, PhysicalAddress addrCr, int picWidth, int picHeight,
|
|
int picHeightPartial, int stride, int interleave, int format, int endian,
|
|
int partPosIdx, int frameIdx, int packed)
|
|
{
|
|
int LumaPicSize;
|
|
int ChromaPicSize;
|
|
int LumaPartialSize;
|
|
int ChromaPartialSize;
|
|
int pos;
|
|
int divX, divY;
|
|
int frameSize = 0;
|
|
|
|
divX = format == FORMAT_420 || format == FORMAT_422 ? 2 : 1;
|
|
divY = format == FORMAT_420 || format == FORMAT_224 ? 2 : 1;
|
|
|
|
LumaPicSize = picWidth * picHeight;
|
|
ChromaPicSize = LumaPicSize / divX / divY;
|
|
|
|
LumaPartialSize = picWidth * picHeightPartial;
|
|
ChromaPartialSize = LumaPartialSize / divX / divY;
|
|
|
|
if (format == FORMAT_400)
|
|
frameSize = LumaPicSize;
|
|
else
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
// Load source one picture image to encode to SDRAM frame buffer.
|
|
|
|
if (packed) {
|
|
if (packed == PACKED_FORMAT_444) {
|
|
LumaPicSize = picWidth * 3 * picHeight;
|
|
LumaPartialSize = picWidth * 3 * picHeightPartial;
|
|
} else {
|
|
LumaPicSize = picWidth * 2 * picHeight;
|
|
LumaPartialSize = picWidth * 2 * picHeightPartial;
|
|
}
|
|
frameSize = LumaPicSize;
|
|
ChromaPicSize = 0;
|
|
ChromaPartialSize = 0;
|
|
}
|
|
|
|
// Y
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
|
|
if (!OSAL_FREAD(pYuv, 1, LumaPartialSize, yuvFp)) {
|
|
if (!OSAL_FEOF(yuvFp))
|
|
JLOG(ERR, "Yuv Data fread failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
|
|
if (format != FORMAT_400 && packed == 0) {
|
|
// Cb
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPicSize + ChromaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
|
|
if (!OSAL_FREAD(pYuv + LumaPartialSize, 1, ChromaPartialSize,
|
|
yuvFp)) {
|
|
if (!OSAL_FEOF(yuvFp))
|
|
JLOG(ERR, "Yuv Data fread failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
|
|
// Cr
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPicSize + ChromaPicSize + ChromaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
|
|
if (!OSAL_FREAD(pYuv + LumaPartialSize + ChromaPartialSize, 1, ChromaPartialSize, yuvFp)) {
|
|
if (!OSAL_FEOF(yuvFp))
|
|
JLOG(ERR, "Yuv Data fread failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
LoadYuvImageBurstFormat(pYuv, picWidth, picHeightPartial, addrY, addrCb,
|
|
addrCr, stride, interleave, format, endian,
|
|
packed);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int SaveYuvImageHelperFormat(osal_file_t *yuvFp, Uint8 *pYuv,
|
|
PhysicalAddress addrY, PhysicalAddress addrCb,
|
|
PhysicalAddress addrCr, int picWidth,
|
|
int picHeight, int stride, int interLeave,
|
|
int format, int endian, int packed)
|
|
{
|
|
int frameSize;
|
|
|
|
frameSize = StoreYuvImageBurstFormat(pYuv, picWidth, picHeight, addrY,
|
|
addrCb, addrCr, stride, interLeave,
|
|
format, endian, packed);
|
|
|
|
if (yuvFp) {
|
|
if (!OSAL_FWRITE(pYuv, sizeof(Uint8), frameSize, yuvFp)) {
|
|
JLOG(ERR, "Frame Data fwrite failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
OSAL_FFLUSH(yuvFp);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int SaveYuvPartialImageHelperFormat(osal_file_t *yuvFp, Uint8 *pYuv, PhysicalAddress addrY,
|
|
PhysicalAddress addrCb, PhysicalAddress addrCr, int picWidth, int picHeight,
|
|
int picHeightPartial, int stride, int interLeave, int format, int endian,
|
|
int partPosIdx, int frameIdx, int packed)
|
|
{
|
|
int LumaPicSize = 0;
|
|
int ChromaPicSize = 0;
|
|
int frameSize = 0;
|
|
|
|
int LumaPartialSize = 0;
|
|
int ChromaPartialSize = 0;
|
|
|
|
int pos = 0;
|
|
// int divX, divY;
|
|
|
|
// divX = format == FORMAT_420 || format == FORMAT_422 ? 2 : 1;
|
|
// divY = format == FORMAT_420 || format == FORMAT_224 ? 2 : 1;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
LumaPicSize = picWidth * ((picHeight + 1) / 2 * 2);
|
|
ChromaPicSize = ((picWidth + 1) / 2) * ((picHeight + 1) / 2);
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
|
|
LumaPartialSize = picWidth * ((picHeightPartial + 1) / 2 * 2);
|
|
ChromaPartialSize = ((picWidth + 1) / 2) * ((picHeightPartial + 1) / 2);
|
|
if (interLeave)
|
|
ChromaPartialSize = (((picWidth + 1) / 2) * 2) * ((picHeightPartial + 1) / 2);
|
|
break;
|
|
case FORMAT_224:
|
|
LumaPicSize = picWidth * ((picHeight + 1) / 2 * 2);
|
|
ChromaPicSize = picWidth * ((picHeight + 1) / 2);
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
|
|
LumaPartialSize = picWidth * ((picHeightPartial + 1) / 2 * 2);
|
|
ChromaPartialSize = picWidth * ((picHeightPartial + 1) / 2);
|
|
if (interLeave)
|
|
ChromaPartialSize = picWidth * 2 * ((picHeightPartial + 1) / 2);
|
|
break;
|
|
case FORMAT_422:
|
|
LumaPicSize = picWidth * picHeight;
|
|
ChromaPicSize = ((picWidth + 1) / 2) * picHeight;
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
|
|
LumaPartialSize = picWidth * picHeightPartial;
|
|
ChromaPartialSize = ((picWidth + 1) / 2) * picHeightPartial;
|
|
if (interLeave)
|
|
ChromaPartialSize = (((picWidth + 1) / 2) * 2) * picHeightPartial;
|
|
break;
|
|
case FORMAT_444:
|
|
LumaPicSize = picWidth * picHeight;
|
|
ChromaPicSize = picWidth * picHeight;
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
|
|
LumaPartialSize = picWidth * picHeightPartial;
|
|
ChromaPartialSize = picWidth * picHeightPartial;
|
|
if (interLeave)
|
|
ChromaPartialSize = picWidth * 2 * picHeightPartial;
|
|
break;
|
|
case FORMAT_400:
|
|
LumaPicSize = picWidth * picHeight;
|
|
ChromaPicSize = 0;
|
|
frameSize = LumaPicSize + ChromaPicSize * 2;
|
|
|
|
LumaPartialSize = picWidth * picHeightPartial;
|
|
ChromaPartialSize = 0;
|
|
break;
|
|
}
|
|
|
|
if (packed) {
|
|
if (packed == PACKED_FORMAT_444)
|
|
picWidth *= 3;
|
|
else
|
|
picWidth *= 2;
|
|
|
|
LumaPicSize = picWidth * picHeight;
|
|
ChromaPicSize = 0;
|
|
frameSize = LumaPicSize;
|
|
LumaPartialSize = picWidth * picHeightPartial;
|
|
ChromaPartialSize = 0;
|
|
}
|
|
|
|
StoreYuvImageBurstFormat(pYuv, picWidth, picHeightPartial, addrY,
|
|
addrCb, addrCr, stride, interLeave, format,
|
|
endian, packed);
|
|
|
|
if (yuvFp) {
|
|
// Y
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
if (!OSAL_FWRITE(pYuv, sizeof(Uint8), LumaPartialSize, yuvFp)) {
|
|
JLOG(ERR, "Frame Data fwrite failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
|
|
if (packed) {
|
|
OSAL_FFLUSH(yuvFp);
|
|
return 1;
|
|
}
|
|
|
|
if (format != FORMAT_400) {
|
|
// Cb
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPicSize + ChromaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
if (!OSAL_FWRITE(pYuv + LumaPartialSize, sizeof(Uint8), ChromaPartialSize, yuvFp)) {
|
|
JLOG(ERR, "Frame Data fwrite failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
|
|
if (interLeave) {
|
|
OSAL_FFLUSH(yuvFp);
|
|
return 1;
|
|
}
|
|
|
|
// Cr
|
|
OSAL_FSEEK(yuvFp, (frameIdx * frameSize), SEEK_SET);
|
|
pos = LumaPicSize + ChromaPicSize + ChromaPartialSize * partPosIdx;
|
|
OSAL_FSEEK(yuvFp, pos, SEEK_CUR);
|
|
if (!OSAL_FWRITE(pYuv + LumaPartialSize + ChromaPartialSize, sizeof(Uint8),
|
|
ChromaPartialSize, yuvFp)) {
|
|
JLOG(ERR, "Frame Data fwrite failed file handle is 0x%p\n", yuvFp);
|
|
return 0;
|
|
}
|
|
}
|
|
OSAL_FFLUSH(yuvFp);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* JPEG specific Helper
|
|
******************************************************************************/
|
|
static int getTblElement(osal_file_t *fp, char *str)
|
|
{
|
|
static int LineNum = 1;
|
|
|
|
while (1) {
|
|
if (!OSAL_FGETS(str, 256, fp))
|
|
return 0;
|
|
if ((str[0] != ';') && (str[0] != '/'))
|
|
break;
|
|
LineNum++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int parseHuffmanTable(osal_file_t *fp, EncMjpgParam *param)
|
|
{
|
|
int ret = 0;
|
|
char sLine[256] = {
|
|
0,
|
|
};
|
|
unsigned int h[8] = {
|
|
0,
|
|
};
|
|
BYTE *huffBit;
|
|
BYTE *huffVal;
|
|
int i, j;
|
|
|
|
huffBit = param->huffBits[DC_TABLE_INDEX0];
|
|
huffVal = param->huffVal[DC_TABLE_INDEX0];
|
|
|
|
for (i = 0; i < 2; i++) { // Luma DC BitLength
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
|
|
for (j = 0; j < 8; j++)
|
|
*huffBit++ = (BYTE)h[j];
|
|
}
|
|
|
|
for (i = 0; i < (16 / 8); i++) { // Luma DC HuffValue
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
|
|
for (j = 0; j < 8; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
}
|
|
|
|
huffBit = param->huffBits[AC_TABLE_INDEX0];
|
|
huffVal = param->huffVal[AC_TABLE_INDEX0];
|
|
|
|
for (i = 0; i < (16 / 8); i++) { // Luma AC BitLength
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffBit++ = (BYTE)h[j];
|
|
}
|
|
|
|
for (i = 0; i < (162 / 8); i++) { // Luma DC HuffValue
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
}
|
|
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2], &h[3],
|
|
&h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 2; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
|
|
huffBit = param->huffBits[DC_TABLE_INDEX1];
|
|
huffVal = param->huffVal[DC_TABLE_INDEX1];
|
|
|
|
for (i = 0; i < (16 / 8); i++) { // Chroma DC BitLength
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffBit++ = (BYTE)h[j];
|
|
}
|
|
|
|
for (i = 0; i < (16 / 8); i++) { // Chroma DC HuffValue
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
}
|
|
|
|
huffBit = param->huffBits[AC_TABLE_INDEX1];
|
|
huffVal = param->huffVal[AC_TABLE_INDEX1];
|
|
|
|
for (i = 0; i < (16 / 8); i++) { // Chroma DC BitLength
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffBit++ = (BYTE)h[j];
|
|
}
|
|
|
|
for (i = 0; i < (162 / 8); i++) {// Luma DC HuffValue
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 8; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
}
|
|
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2], &h[3],
|
|
&h[4], &h[5], &h[6], &h[7]);
|
|
for (j = 0; j < 2; j++)
|
|
*huffVal++ = (BYTE)h[j];
|
|
|
|
(void)ret;
|
|
return 1;
|
|
}
|
|
|
|
static int parseQMatrix(osal_file_t *fp, EncMjpgParam *param)
|
|
{
|
|
int ret = 0;
|
|
char sLine[256] = {
|
|
0,
|
|
};
|
|
int i, j;
|
|
unsigned int h[8] = {
|
|
0,
|
|
};
|
|
BYTE temp_dc[64], temp_ac[64];
|
|
BYTE *qTable_dc, *qTable_ac, *qTable;
|
|
|
|
qTable = temp_dc;
|
|
for (i = 0; i < (64 / 8); i++) {
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
|
|
for (j = 0; j < 8; j++)
|
|
*qTable++ = (BYTE)h[j];
|
|
}
|
|
|
|
qTable = temp_ac;
|
|
for (i = 0; i < (64 / 8); i++) {
|
|
if (getTblElement(fp, sLine) == 0)
|
|
return 0;
|
|
|
|
memset(h, 0x00, 8 * sizeof(unsigned int));
|
|
ret = sscanf(sLine, "%x %x %x %x %x %x %x %x", &h[0], &h[1], &h[2],
|
|
&h[3], &h[4], &h[5], &h[6], &h[7]);
|
|
|
|
for (j = 0; j < 8; j++)
|
|
*qTable++ = (BYTE)h[j];
|
|
}
|
|
|
|
qTable_dc = param->qMatTab[DC_TABLE_INDEX0];
|
|
qTable_ac = param->qMatTab[AC_TABLE_INDEX0];
|
|
|
|
for (i = 0; i < 64; i++) {
|
|
qTable_dc[InvScanTable[i]] = temp_dc[i];
|
|
qTable_ac[InvScanTable[i]] = temp_ac[i];
|
|
}
|
|
|
|
memcpy(param->qMatTab[DC_TABLE_INDEX1], param->qMatTab[DC_TABLE_INDEX0], 64);
|
|
memcpy(param->qMatTab[AC_TABLE_INDEX1], param->qMatTab[AC_TABLE_INDEX0], 64);
|
|
|
|
(void)ret;
|
|
return 1;
|
|
}
|
|
|
|
int jpgGetHuffTable(char *huffFileName, EncMjpgParam *param)
|
|
{
|
|
char huffFilePath[256];
|
|
osal_file_t *huffFp = NULL;
|
|
|
|
if (huffFileName && huffFileName[0] != 0) {
|
|
// strcpy(huffFilePath, huffFileName);
|
|
huffFp = OSAL_FOPEN(huffFilePath, "rt");
|
|
if (!huffFp) {
|
|
JLOG(ERR, "Can't open Huffman Table file %s\n", huffFilePath);
|
|
return 0;
|
|
}
|
|
parseHuffmanTable(huffFp, param);
|
|
OSAL_FCLOSE(huffFp);
|
|
} else {
|
|
// Rearrange and insert pre-defined Huffman table to deticated
|
|
// variable.
|
|
memcpy(param->huffBits[DC_TABLE_INDEX0], lumaDcBits, 16); // Luma DC BitLength
|
|
memcpy(param->huffVal[DC_TABLE_INDEX0], lumaDcValue, 16); // Luma DC HuffValue
|
|
|
|
memcpy(param->huffBits[AC_TABLE_INDEX0], lumaAcBits, 16); // Luma DC BitLength
|
|
memcpy(param->huffVal[AC_TABLE_INDEX0], lumaAcValue, 162); // Luma DC HuffValue
|
|
|
|
memcpy(param->huffBits[DC_TABLE_INDEX1], chromaDcBits, 16); // Chroma DC BitLength
|
|
memcpy(param->huffVal[DC_TABLE_INDEX1], chromaDcValue, 16); // Chroma DC HuffValue
|
|
|
|
memcpy(param->huffBits[AC_TABLE_INDEX1], chromaAcBits, 16); // Chroma AC BitLength
|
|
memcpy(param->huffVal[AC_TABLE_INDEX1], chromaAcValue, 162); // Chorma AC HuffValue
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
int jpgGetQMatrix(char *qMatFileName, EncMjpgParam *param)
|
|
{
|
|
char qMatFilePath[256];
|
|
osal_file_t *qMatFp = NULL;
|
|
|
|
if (qMatFileName && qMatFileName[0] != 0) {
|
|
// strcpy(qMatFilePath, qMatFileName);
|
|
qMatFp = OSAL_FOPEN(qMatFilePath, "rt");
|
|
if (!qMatFp) {
|
|
JLOG(ERR, "Can't open Q Matrix file %s\n", qMatFilePath);
|
|
return 0;
|
|
}
|
|
parseQMatrix(qMatFp, param);
|
|
OSAL_FCLOSE(qMatFp);
|
|
} else {
|
|
// Rearrange and insert pre-defined Q-matrix to deticated
|
|
// variable.
|
|
memcpy(param->qMatTab[DC_TABLE_INDEX0], lumaQ2, 64);
|
|
memcpy(param->qMatTab[AC_TABLE_INDEX0], chromaBQ2, 64);
|
|
|
|
memcpy(param->qMatTab[DC_TABLE_INDEX1], param->qMatTab[DC_TABLE_INDEX0], 64);
|
|
memcpy(param->qMatTab[AC_TABLE_INDEX1], param->qMatTab[AC_TABLE_INDEX0], 64);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* EncOpenParam Initialization
|
|
******************************************************************************/
|
|
int getJpgEncOpenParamDefault(JpgEncOpenParam *pEncOP,
|
|
EncConfigParam *pEncConfig)
|
|
{
|
|
int ret;
|
|
EncMjpgParam mjpgParam;
|
|
|
|
memset(&mjpgParam, 0x00, sizeof(EncMjpgParam));
|
|
|
|
pEncOP->picWidth = pEncConfig->picWidth;
|
|
pEncOP->picHeight = pEncConfig->picHeight;
|
|
pEncOP->sourceFormat = pEncConfig->mjpgChromaFormat;
|
|
pEncOP->restartInterval = 0;
|
|
pEncOP->chroma_interleave = pEncConfig->chroma_interleave;
|
|
pEncOP->packedFormat = pEncConfig->packedFormat;
|
|
mjpgParam.sourceFormat = pEncConfig->mjpgChromaFormat;
|
|
ret = jpgGetHuffTable(pEncConfig->huffFileName, &mjpgParam);
|
|
if (ret == 0)
|
|
return ret;
|
|
ret = jpgGetQMatrix(pEncConfig->qMatFileName, &mjpgParam);
|
|
if (ret == 0)
|
|
return ret;
|
|
|
|
memcpy(pEncOP->huffVal, mjpgParam.huffVal, 4 * 162);
|
|
memcpy(pEncOP->huffBits, mjpgParam.huffBits, 4 * 256);
|
|
memcpy(pEncOP->qMatTab, mjpgParam.qMatTab, 4 * 64);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* To init EncOpenParam by CFG file
|
|
* IN
|
|
* EncConfigParam *pEncConfig
|
|
* OUT
|
|
* EncOpenParam *pEncOP
|
|
* char *srcYuvFileName
|
|
*/
|
|
|
|
int getJpgEncOpenParam(JpgEncOpenParam *pEncOP, EncConfigParam *pEncConfig, char *srcYuvFileName)
|
|
{
|
|
ENC_CFG encCfg;
|
|
int ret;
|
|
EncMjpgParam mjpgParam;
|
|
char cfgFileName[MAX_FILE_PATH];
|
|
|
|
// Source YUV Image File to load
|
|
// strcpy(srcYuvFileName, encCfg.SrcFileName);
|
|
memset(&encCfg, 0x00, sizeof(ENC_CFG));
|
|
memset(&mjpgParam, 0x00, sizeof(EncMjpgParam));
|
|
|
|
if (strlen(pEncConfig->strCfgDir))
|
|
sprintf(cfgFileName, "%s%s", pEncConfig->strCfgDir, pEncConfig->cfgFileName);
|
|
// else
|
|
// strcpy(cfgFileName, pEncConfig->cfgFileName);
|
|
|
|
parseJpgCfgFile(&encCfg, cfgFileName);
|
|
|
|
if (srcYuvFileName) {
|
|
if (strlen(pEncConfig->strStmDir))
|
|
sprintf(srcYuvFileName, "%s%s", pEncConfig->strStmDir, encCfg.SrcFileName);
|
|
// else
|
|
// strcpy(srcYuvFileName, encCfg.SrcFileName);
|
|
}
|
|
|
|
if (encCfg.FrmFormat == 0)
|
|
pEncConfig->chroma_interleave = CBCR_SEPARATED;
|
|
else if (encCfg.FrmFormat == 1)
|
|
pEncConfig->chroma_interleave = CBCR_INTERLEAVE;
|
|
else if (encCfg.FrmFormat == 2)
|
|
pEncConfig->chroma_interleave = CRCB_INTERLEAVE;
|
|
else
|
|
pEncConfig->chroma_interleave = CBCR_SEPARATED;
|
|
|
|
pEncConfig->packedFormat = (encCfg.FrmFormat - 2);
|
|
if (pEncConfig->packedFormat < 0)
|
|
pEncConfig->packedFormat = 0;
|
|
|
|
pEncConfig->outNum = encCfg.NumFrame;
|
|
|
|
if (pEncOP) {
|
|
pEncOP->picWidth = encCfg.PicX;
|
|
pEncOP->picHeight = encCfg.PicY;
|
|
pEncOP->chroma_interleave = pEncConfig->chroma_interleave;
|
|
pEncOP->packedFormat = pEncConfig->packedFormat;
|
|
pEncOP->sourceFormat = encCfg.SrcFormat;
|
|
pEncOP->restartInterval = encCfg.RstIntval;
|
|
|
|
mjpgParam.sourceFormat = encCfg.SrcFormat;
|
|
ret = jpgGetHuffTable(encCfg.HuffTabName, &mjpgParam);
|
|
if (ret == 0)
|
|
return ret;
|
|
ret = jpgGetQMatrix(encCfg.QMatTabName, &mjpgParam);
|
|
if (ret == 0)
|
|
return ret;
|
|
|
|
memcpy(pEncOP->huffVal, mjpgParam.huffVal, 4 * 162);
|
|
memcpy(pEncOP->huffBits, mjpgParam.huffBits, 4 * 256);
|
|
memcpy(pEncOP->qMatTab, mjpgParam.qMatTab, 4 * 64);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// ENCODE PARAMETER PARSE FUNCSIONS
|
|
//------------------------------------------------------------------------------
|
|
// Parameter parsing helper
|
|
static int GetValue(osal_file_t *fp, char *para, char *value)
|
|
{
|
|
static int LineNum = 1;
|
|
char lineStr[256];
|
|
char paraStr[256];
|
|
int ret = 0;
|
|
|
|
OSAL_FSEEK(fp, 0, SEEK_SET);
|
|
|
|
while (1) {
|
|
if (!OSAL_FGETS(lineStr, 256, fp))
|
|
return 0;
|
|
ret = sscanf(lineStr, "%s %s", paraStr, value);
|
|
if (paraStr[0] != ';') {
|
|
if (strcmp(para, paraStr) == 0)
|
|
return 1;
|
|
}
|
|
LineNum++;
|
|
}
|
|
|
|
(void)ret;
|
|
return 1;
|
|
}
|
|
|
|
int parseJpgCfgFile(ENC_CFG *pEncCfg, char *FileName)
|
|
{
|
|
osal_file_t *Fp;
|
|
int ret = 0;
|
|
|
|
char sLine[256] = {
|
|
0,
|
|
};
|
|
|
|
Fp = OSAL_FOPEN(FileName, "rt");
|
|
|
|
if (!Fp) {
|
|
BM_DBG_ERR(" > ERROR: File not exist <%s>\n", FileName);
|
|
return 0;
|
|
}
|
|
|
|
// source file name
|
|
if (GetValue(Fp, "YUV_SRC_IMG", sLine) == 0)
|
|
return 0;
|
|
ret = sscanf(sLine, "%s", (char *)&pEncCfg->SrcFileName);
|
|
|
|
// frame format
|
|
// ; 0-planar, 1-NV12,NV16(CbCr interleave) 2-NV21,NV61(CbCr
|
|
// alternative) ; 3-YUYV, 4-UYVY, 5-YVYU, 6-VYUY, 7-YUV packed
|
|
// (444 only)
|
|
if (GetValue(Fp, "FRAME_FORMAT", sLine) == 0)
|
|
return 0;
|
|
pEncCfg->FrmFormat = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->FrmFormat);
|
|
|
|
// width
|
|
if (GetValue(Fp, "PICTURE_WIDTH", sLine) == 0)
|
|
return 0;
|
|
pEncCfg->PicX = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->PicX);
|
|
|
|
// height
|
|
if (GetValue(Fp, "PICTURE_HEIGHT", sLine) == 0)
|
|
return 0;
|
|
pEncCfg->PicY = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->PicY);
|
|
|
|
// frame_rate
|
|
if (GetValue(Fp, "FRAME_RATE", sLine) == 0)
|
|
return 0;
|
|
{
|
|
double frameRate = 0.0;
|
|
int timeRes, timeInc;
|
|
|
|
// frameRate = (double)(int)atoi(sLine);
|
|
|
|
timeInc = 1;
|
|
while ((int)frameRate != frameRate) {
|
|
timeInc *= 10;
|
|
frameRate *= 10;
|
|
}
|
|
timeRes = (int)frameRate;
|
|
// divide 2 or 5
|
|
if (timeInc % 2 == 0 && timeRes % 2 == 0)
|
|
timeInc /= 2, timeRes /= 2;
|
|
if (timeInc % 5 == 0 && timeRes % 5 == 0)
|
|
timeInc /= 5, timeRes /= 5;
|
|
|
|
if (timeRes == 2997 && timeInc == 100)
|
|
timeRes = 30000, timeInc = 1001;
|
|
pEncCfg->FrameRate = (timeInc - 1) << 16;
|
|
pEncCfg->FrameRate |= timeRes;
|
|
}
|
|
|
|
// frame count
|
|
if (GetValue(Fp, "FRAME_NUMBER_ENCODED", sLine) == 0)
|
|
return 0;
|
|
|
|
pEncCfg->NumFrame = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->NumFrame);
|
|
|
|
if (GetValue(Fp, "VERSION_ID", sLine) == 0)
|
|
return 0;
|
|
|
|
pEncCfg->VersionID = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->VersionID);
|
|
|
|
if (GetValue(Fp, "RESTART_INTERVAL", sLine) == 0)
|
|
return 0;
|
|
|
|
pEncCfg->RstIntval = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->RstIntval);
|
|
|
|
if (GetValue(Fp, "IMG_FORMAT", sLine) == 0)
|
|
return 0;
|
|
|
|
pEncCfg->SrcFormat = (int)simple_strtol(sLine, NULL, 10);//sscanf(sLine, "%d", &pEncCfg->SrcFormat);
|
|
|
|
if (GetValue(Fp, "QMATRIX_TABLE", sLine) == 0)
|
|
return 0;
|
|
|
|
ret = sscanf(sLine, "%s", (char *)&pEncCfg->QMatTabName);
|
|
|
|
if (GetValue(Fp, "HUFFMAN_TABLE", sLine) == 0)
|
|
return 0;
|
|
|
|
ret = sscanf(sLine, "%s", (char *)&pEncCfg->HuffTabName);
|
|
|
|
(void)ret;
|
|
OSAL_FCLOSE(Fp);
|
|
return 1;
|
|
}
|
|
|
|
int FillSdramBurst(BufInfo *pBufInfo, Uint64 targetAddr,
|
|
PhysicalAddress bsBufStartAddr, PhysicalAddress bsBufEndAddr,
|
|
Uint32 size, int checkeos, int *streameos, int endian)
|
|
{
|
|
Uint8 *pBuf;
|
|
int room;
|
|
|
|
pBufInfo->count = 0;
|
|
|
|
if (checkeos == 1 && pBufInfo->point >= pBufInfo->size) {
|
|
*streameos = 1;
|
|
return 0;
|
|
}
|
|
|
|
if ((pBufInfo->size - pBufInfo->point) < (int)size)
|
|
pBufInfo->count = (pBufInfo->size - pBufInfo->point);
|
|
else
|
|
pBufInfo->count = size;
|
|
|
|
pBuf = pBufInfo->buf + pBufInfo->point;
|
|
|
|
if ((targetAddr + pBufInfo->count) > bsBufEndAddr) {
|
|
room = bsBufEndAddr - targetAddr;
|
|
JpuWriteMem(targetAddr, pBuf, room, endian);
|
|
JpuWriteMem(bsBufStartAddr, pBuf + room, (pBufInfo->count - room), endian);
|
|
} else {
|
|
JpuWriteMem(targetAddr, pBuf, pBufInfo->count, endian);
|
|
}
|
|
|
|
pBufInfo->point += pBufInfo->count;
|
|
return pBufInfo->count;
|
|
}
|
|
|
|
int StoreYuvImageBurstFormat(Uint8 *dst, int picWidth, int picHeight,
|
|
unsigned long addrY, unsigned long addrCb,
|
|
unsigned long addrCr, int stride, int interLeave,
|
|
int format, int endian, int packed)
|
|
{
|
|
int size = 0;
|
|
int y = 0, nY = 0, nCb = 0, nCr = 0;
|
|
unsigned long addr = 0;
|
|
int lumaSize = 0, chromaSize = 0, chromaStride = 0, chromaWidth = 0, chromaHeight = 0;
|
|
|
|
Uint8 *puc;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
nY = (picHeight + 1) / 2 * 2;
|
|
nCb = (picHeight + 1) / 2;
|
|
nCr = (picHeight + 1) / 2;
|
|
chromaSize = ((picWidth + 1) / 2) * ((picHeight + 1) / 2);
|
|
chromaStride = stride / 2;
|
|
chromaWidth = (picWidth + 1) / 2;
|
|
chromaHeight = nY;
|
|
break;
|
|
case FORMAT_224:
|
|
nY = (picHeight + 1) / 2 * 2;
|
|
nCb = (picHeight + 1) / 2;
|
|
nCr = (picHeight + 1) / 2;
|
|
chromaSize = (picWidth) * ((picHeight + 1) / 2);
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
chromaHeight = nY;
|
|
break;
|
|
case FORMAT_422:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = ((picWidth + 1) / 2) * picHeight;
|
|
chromaStride = stride / 2;
|
|
chromaWidth = (picWidth + 1) / 2;
|
|
chromaHeight = nY * 2;
|
|
break;
|
|
case FORMAT_444:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = picWidth * picHeight;
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
chromaHeight = nY * 2;
|
|
break;
|
|
case FORMAT_400:
|
|
nY = picHeight;
|
|
nCb = 0;
|
|
nCr = 0;
|
|
chromaSize = 0;
|
|
chromaStride = 0;
|
|
chromaWidth = 0;
|
|
chromaHeight = 0;
|
|
break;
|
|
}
|
|
|
|
puc = dst;
|
|
addr = addrY;
|
|
|
|
if (packed) {
|
|
if (packed == PACKED_FORMAT_444)
|
|
picWidth *= 3;
|
|
else
|
|
picWidth *= 2;
|
|
|
|
chromaSize = 0;
|
|
}
|
|
|
|
lumaSize = picWidth * nY;
|
|
|
|
size = lumaSize + chromaSize * 2;
|
|
|
|
if (picWidth == stride) {
|
|
JpuReadMem(addr, (Uint8 *)(puc), lumaSize, endian);
|
|
|
|
if (packed)
|
|
return size;
|
|
|
|
if (interLeave) {
|
|
puc = dst + lumaSize;
|
|
addr = addrCb;
|
|
JpuReadMem(addr, (Uint8 *)(puc), chromaSize * 2,
|
|
endian);
|
|
} else {
|
|
puc = dst + lumaSize;
|
|
addr = addrCb;
|
|
JpuReadMem(addr, (Uint8 *)(puc), chromaSize, endian);
|
|
|
|
puc = dst + lumaSize + chromaSize;
|
|
addr = addrCr;
|
|
JpuReadMem(addr, (Uint8 *)(puc), chromaSize, endian);
|
|
}
|
|
} else {
|
|
for (y = 0; y < nY; ++y) {
|
|
JpuReadMem(addr + stride * y, (Uint8 *)(puc + y * picWidth), picWidth, endian);
|
|
}
|
|
|
|
if (packed)
|
|
return size;
|
|
|
|
if (interLeave) {
|
|
puc = dst + lumaSize;
|
|
addr = addrCb;
|
|
for (y = 0; y < (chromaHeight / 2); ++y) {
|
|
JpuReadMem(addr + (chromaStride * 2) * y,
|
|
(Uint8 *)(puc + y * (chromaWidth * 2)),
|
|
(chromaWidth * 2), endian);
|
|
}
|
|
} else {
|
|
puc = dst + lumaSize;
|
|
addr = addrCb;
|
|
for (y = 0; y < nCb; ++y) {
|
|
JpuReadMem(addr + chromaStride * y,
|
|
(Uint8 *)(puc + y * chromaWidth),
|
|
chromaWidth, endian);
|
|
}
|
|
|
|
puc = dst + lumaSize + chromaSize;
|
|
addr = addrCr;
|
|
for (y = 0; y < nCr; ++y) {
|
|
JpuReadMem(addr + chromaStride * y,
|
|
(Uint8 *)(puc + y * chromaWidth),
|
|
chromaWidth, endian);
|
|
}
|
|
}
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
void ProcessEncodedBitstreamBurst(osal_file_t *fp, unsigned long targetAddr,
|
|
PhysicalAddress bsBufStartAddr,
|
|
PhysicalAddress bsBufEndAddr, int size,
|
|
int endian)
|
|
{
|
|
Uint8 *val = 0;
|
|
int room = 0;
|
|
|
|
BM_DBG_TRACE("target addr :%lx\n", targetAddr);
|
|
BM_DBG_TRACE("start :%lx, end:%lx, size:%d\n", bsBufStartAddr, bsBufEndAddr, size);
|
|
|
|
val = (Uint8 *)OSAL_MALLOC(size);
|
|
if ((targetAddr + size) > (unsigned long)bsBufEndAddr) {
|
|
room = bsBufEndAddr - targetAddr;
|
|
JpuReadMem(targetAddr, val, room, endian);
|
|
JpuReadMem(bsBufStartAddr, val + room, (size - room), endian);
|
|
} else {
|
|
BM_DBG_TRACE("read target addr :%lx\n", targetAddr);
|
|
JpuReadMem(targetAddr, val, size, endian);
|
|
}
|
|
|
|
if (fp) {
|
|
OSAL_FWRITE(val, sizeof(Uint8), size, fp);
|
|
OSAL_FFLUSH(fp);
|
|
}
|
|
|
|
OSAL_FREE(val);
|
|
}
|
|
|
|
int LoadYuvImageBurstFormat(Uint8 *src, int picWidth, int picHeight,
|
|
unsigned long addrY, unsigned long addrCb,
|
|
unsigned long addrCr, int stride, int interLeave,
|
|
int format, int endian, int packed)
|
|
{
|
|
int y = 0, nY = 0, nCb = 0, nCr = 0;
|
|
unsigned long addr = 0;
|
|
int size = 0;
|
|
int lumaSize = 0, chromaSize = 0, chromaStride = 0, chromaWidth = 0;
|
|
Uint8 *puc = NULL;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
nY = picHeight;
|
|
nCb = picHeight / 2;
|
|
nCr = picHeight / 2;
|
|
chromaSize = picWidth * picHeight / 4;
|
|
chromaStride = stride / 2;
|
|
chromaWidth = picWidth / 2;
|
|
break;
|
|
case FORMAT_224:
|
|
nY = picHeight;
|
|
nCb = picHeight / 2;
|
|
nCr = picHeight / 2;
|
|
chromaSize = picWidth * picHeight / 2;
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
break;
|
|
case FORMAT_422:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = picWidth * picHeight / 2;
|
|
chromaStride = stride / 2;
|
|
chromaWidth = picWidth / 2;
|
|
break;
|
|
case FORMAT_444:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = picWidth * picHeight;
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
break;
|
|
case FORMAT_400:
|
|
nY = picHeight;
|
|
nCb = 0;
|
|
nCr = 0;
|
|
chromaSize = picWidth * picHeight / 4;
|
|
chromaStride = stride / 2;
|
|
chromaWidth = picWidth / 2;
|
|
break;
|
|
}
|
|
|
|
puc = src;
|
|
addr = addrY;
|
|
|
|
if (packed) {
|
|
if (packed == PACKED_FORMAT_444)
|
|
picWidth *= 3;
|
|
else
|
|
picWidth *= 2;
|
|
|
|
chromaSize = 0;
|
|
}
|
|
|
|
lumaSize = picWidth * nY;
|
|
|
|
size = lumaSize + chromaSize * 2;
|
|
|
|
if (picWidth == stride) { // for fast write
|
|
JpuWriteMem(addr, (Uint8 *)(puc), lumaSize, endian);
|
|
|
|
if (format == FORMAT_400)
|
|
return size;
|
|
|
|
if (packed)
|
|
return size;
|
|
|
|
if (interLeave) {
|
|
Uint8 t0, t1, t2, t3, t4, t5, t6, t7;
|
|
int i, height, width;
|
|
int stride;
|
|
Uint8 *pTemp;
|
|
Uint8 *dstAddrCb;
|
|
Uint8 *dstAddrCr;
|
|
|
|
addr = addrCb;
|
|
stride = chromaStride * 2;
|
|
height = nCb;
|
|
width = chromaWidth * 2;
|
|
|
|
dstAddrCb = (Uint8 *)(puc + picWidth * nY);
|
|
dstAddrCr = (Uint8 *)(dstAddrCb + chromaSize);
|
|
|
|
pTemp = OSAL_MALLOC(width);
|
|
if (!pTemp) {
|
|
return 0;
|
|
}
|
|
|
|
for (y = 0; y < height; ++y) {
|
|
for (i = 0; i < width; i += 8) {
|
|
t0 = *dstAddrCb++;
|
|
t2 = *dstAddrCb++;
|
|
t4 = *dstAddrCb++;
|
|
t6 = *dstAddrCb++;
|
|
t1 = *dstAddrCr++;
|
|
t3 = *dstAddrCr++;
|
|
t5 = *dstAddrCr++;
|
|
t7 = *dstAddrCr++;
|
|
if (interLeave == CBCR_INTERLEAVE) {
|
|
pTemp[i] = t0;
|
|
pTemp[i + 1] = t1;
|
|
pTemp[i + 2] = t2;
|
|
pTemp[i + 3] = t3;
|
|
pTemp[i + 4] = t4;
|
|
pTemp[i + 5] = t5;
|
|
pTemp[i + 6] = t6;
|
|
pTemp[i + 7] = t7;
|
|
} else { // CRCB_INTERLEAVE
|
|
pTemp[i] = t1;
|
|
pTemp[i + 1] = t0;
|
|
pTemp[i + 2] = t3;
|
|
pTemp[i + 3] = t2;
|
|
pTemp[i + 4] = t5;
|
|
pTemp[i + 5] = t4;
|
|
pTemp[i + 6] = t7;
|
|
pTemp[i + 7] = t6;
|
|
}
|
|
}
|
|
JpuWriteMem(addr + stride * y, (unsigned char *)pTemp, width, endian);
|
|
}
|
|
|
|
OSAL_FREE(pTemp);
|
|
} else {
|
|
puc = src + lumaSize;
|
|
addr = addrCb;
|
|
JpuWriteMem(addr, (Uint8 *)puc, chromaSize, endian);
|
|
|
|
puc = src + lumaSize + chromaSize;
|
|
addr = addrCr;
|
|
JpuWriteMem(addr, (Uint8 *)puc, chromaSize, endian);
|
|
}
|
|
} else {
|
|
for (y = 0; y < nY; ++y) {
|
|
JpuWriteMem(addr + stride * y, (Uint8 *)(puc + y * picWidth), picWidth, endian);
|
|
}
|
|
|
|
if (format == FORMAT_400)
|
|
return size;
|
|
|
|
if (packed)
|
|
return size;
|
|
|
|
if (interLeave == 1) {
|
|
Uint8 t0, t1, t2, t3, t4, t5, t6, t7;
|
|
int i, width, height, stride;
|
|
Uint8 *pTemp;
|
|
Uint8 *dstAddrCb;
|
|
Uint8 *dstAddrCr;
|
|
|
|
addr = addrCb;
|
|
stride = chromaStride * 2;
|
|
height = nCb / 2;
|
|
width = chromaWidth * 2;
|
|
|
|
dstAddrCb = (Uint8 *)(puc + picWidth * nY);
|
|
dstAddrCr = (Uint8 *)(dstAddrCb + chromaSize);
|
|
|
|
pTemp = OSAL_MALLOC((width + 7) & ~7);
|
|
if (!pTemp) {
|
|
return 0;
|
|
}
|
|
|
|
// it may be not occur that pic_width in not 8byte
|
|
// alined.
|
|
for (y = 0; y < height; ++y) {
|
|
for (i = 0; i < width; i += 8) {
|
|
t0 = *dstAddrCb++;
|
|
t2 = *dstAddrCb++;
|
|
t4 = *dstAddrCb++;
|
|
t6 = *dstAddrCb++;
|
|
t1 = *dstAddrCr++;
|
|
t3 = *dstAddrCr++;
|
|
t5 = *dstAddrCr++;
|
|
t7 = *dstAddrCr++;
|
|
|
|
if (interLeave == CBCR_INTERLEAVE) {
|
|
pTemp[i] = t0;
|
|
pTemp[i + 1] = t1;
|
|
pTemp[i + 2] = t2;
|
|
pTemp[i + 3] = t3;
|
|
pTemp[i + 4] = t4;
|
|
pTemp[i + 5] = t5;
|
|
pTemp[i + 6] = t6;
|
|
pTemp[i + 7] = t7;
|
|
} else { // CRCB_INTERLEAVE
|
|
pTemp[i] = t1;
|
|
pTemp[i + 1] = t0;
|
|
pTemp[i + 2] = t3;
|
|
pTemp[i + 3] = t2;
|
|
pTemp[i + 4] = t5;
|
|
pTemp[i + 5] = t3;
|
|
pTemp[i + 6] = t7;
|
|
pTemp[i + 7] = t6;
|
|
}
|
|
|
|
JpuWriteMem(addr + stride * y, (unsigned char *)pTemp, stride, endian);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
puc = src + lumaSize;
|
|
addr = addrCb;
|
|
for (y = 0; y < nCb; ++y) {
|
|
JpuWriteMem(addr + chromaStride * y,
|
|
(Uint8 *)(puc + y * chromaWidth),
|
|
chromaWidth, endian);
|
|
}
|
|
|
|
puc = src + lumaSize + chromaSize;
|
|
addr = addrCr;
|
|
for (y = 0; y < nCr; ++y) {
|
|
JpuWriteMem(addr + chromaStride * y,
|
|
(Uint8 *)(puc + y * chromaWidth),
|
|
chromaWidth, endian);
|
|
}
|
|
}
|
|
}
|
|
|
|
return size;
|
|
}
|
|
|
|
void GetMcuUnitSize(int format, int *mcuWidth, int *mcuHeight)
|
|
{
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
*mcuWidth = 16;
|
|
*mcuHeight = 16;
|
|
break;
|
|
case FORMAT_422:
|
|
*mcuWidth = 16;
|
|
*mcuHeight = 8;
|
|
break;
|
|
case FORMAT_224:
|
|
*mcuWidth = 8;
|
|
*mcuHeight = 16;
|
|
break;
|
|
default: // FORMAT_444,400
|
|
*mcuWidth = 8;
|
|
*mcuHeight = 8;
|
|
break;
|
|
}
|
|
}
|
|
|
|
unsigned int GetFrameBufSize(int framebufFormat, int picWidth, int picHeight)
|
|
{
|
|
unsigned int framebufSize = 0;
|
|
unsigned int framebufWidth, framebufHeight;
|
|
|
|
if (framebufFormat == FORMAT_420 || framebufFormat == FORMAT_422)
|
|
framebufWidth = ((picWidth + 15) / 16) * 16;
|
|
else
|
|
framebufWidth = ((picWidth + 7) / 8) * 8;
|
|
|
|
if (framebufFormat == FORMAT_420 || framebufFormat == FORMAT_224)
|
|
framebufHeight = ((picHeight + 15) / 16) * 16;
|
|
else
|
|
framebufHeight = ((picHeight + 7) / 8) * 8;
|
|
|
|
switch (framebufFormat) {
|
|
case FORMAT_420:
|
|
framebufSize =
|
|
framebufWidth * ((framebufHeight + 1) / 2 * 2) +
|
|
((framebufWidth + 1) / 2) * ((framebufHeight + 1) / 2) * 2;
|
|
break;
|
|
case FORMAT_224:
|
|
framebufSize = framebufWidth * ((framebufHeight + 1) / 2 * 2) +
|
|
framebufWidth * ((framebufHeight + 1) / 2) * 2;
|
|
break;
|
|
case FORMAT_422:
|
|
framebufSize = framebufWidth * framebufHeight +
|
|
((framebufWidth + 1) / 2) * framebufHeight * 2;
|
|
break;
|
|
case FORMAT_444:
|
|
framebufSize = framebufWidth * framebufHeight * 3;
|
|
break;
|
|
case FORMAT_400:
|
|
framebufSize = framebufWidth * framebufHeight;
|
|
break;
|
|
}
|
|
|
|
framebufSize = ((framebufSize + 7) & ~7);
|
|
|
|
return framebufSize;
|
|
}
|
|
|
|
// inteleave : 0 (chroma separate mode), 1 (cbcr interleave mode), 2 (crcb
|
|
// interleave mode)
|
|
yuv2rgb_color_format
|
|
convert_jpuapi_format_to_yuv2rgb_color_format(int planar_format,
|
|
int pack_format, int interleave)
|
|
{
|
|
yuv2rgb_color_format format = 0;
|
|
|
|
if (!pack_format) {
|
|
switch (planar_format) {
|
|
case FORMAT_400:
|
|
format = YUV400;
|
|
break;
|
|
case FORMAT_444:
|
|
format = YUV444;
|
|
break;
|
|
case FORMAT_224:
|
|
case FORMAT_422:
|
|
format = YUV422;
|
|
break;
|
|
case FORMAT_420:
|
|
if (interleave == 0)
|
|
format = YUV420;
|
|
else if (interleave == 1)
|
|
format = NV12;
|
|
else
|
|
format = NV21;
|
|
break;
|
|
}
|
|
} else {
|
|
switch (pack_format) {
|
|
case PACKED_FORMAT_422_YUYV:
|
|
format = YUYV;
|
|
break;
|
|
case PACKED_FORMAT_422_UYVY:
|
|
format = UYVY;
|
|
break;
|
|
case PACKED_FORMAT_422_YVYU:
|
|
format = YVYU;
|
|
break;
|
|
case PACKED_FORMAT_422_VYUY:
|
|
format = VYUY;
|
|
break;
|
|
case PACKED_FORMAT_444:
|
|
format = YYY;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return format;
|
|
}
|
|
|
|
void jpu_yuv2rgb(int width, int height, yuv2rgb_color_format format,
|
|
unsigned char *src, unsigned char *rgba, int cbcr_reverse)
|
|
{
|
|
#define jpu_clip(var) (((var) >= 255) ? 255 : ((var) <= 0) ? 0 : (var))
|
|
int j, i;
|
|
int c, d, e;
|
|
|
|
unsigned char *line = rgba;
|
|
unsigned char *cur = NULL;
|
|
unsigned char *y = NULL;
|
|
unsigned char *u = NULL;
|
|
unsigned char *v = NULL;
|
|
unsigned char *misc = NULL;
|
|
|
|
int frame_size_y;
|
|
int frame_size_uv;
|
|
int t_width;
|
|
|
|
frame_size_y = width * height;
|
|
|
|
if (format == YUV444 || format == RGB_PLANAR)
|
|
frame_size_uv = width * height;
|
|
else if (format == YUV422)
|
|
frame_size_uv = (width * height) >> 1;
|
|
else if (format == YUV420 || format == NV12 || format == NV21)
|
|
frame_size_uv = (width * height) >> 2;
|
|
else
|
|
frame_size_uv = 0;
|
|
|
|
t_width = width;
|
|
|
|
if (format == YUYV || format == YVYU || format == UYVY || format == VYUY) {
|
|
misc = src;
|
|
} else if (format == NV12 || format == NV21) {
|
|
y = src;
|
|
misc = src + frame_size_y;
|
|
} else if (format == RGB32 || format == RGB24 || format == RGB16) {
|
|
misc = src;
|
|
} else {
|
|
y = src;
|
|
u = src + frame_size_y;
|
|
v = src + frame_size_y + frame_size_uv;
|
|
}
|
|
|
|
if (format == YUV444) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
c = y[j * width + i] - 16;
|
|
d = u[j * width + i] - 128;
|
|
e = v[j * width + i] - 128;
|
|
|
|
if (!cbcr_reverse) {
|
|
d = u[j * width + i] - 128;
|
|
e = v[j * width + i] - 128;
|
|
} else {
|
|
e = u[j * width + i] - 128;
|
|
e = v[j * width + i] - 128;
|
|
}
|
|
(*cur) = jpu_clip((298 * c + 409 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c - 100 * d - 208 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c + 516 * d + 128) >> 8);
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == YUV422) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
c = y[j * width + i] - 16;
|
|
d = u[j * (width >> 1) + (i >> 1)] - 128;
|
|
e = v[j * (width >> 1) + (i >> 1)] - 128;
|
|
|
|
if (!cbcr_reverse) {
|
|
d = u[j * (width >> 1) + (i >> 1)] - 128;
|
|
e = v[j * (width >> 1) + (i >> 1)] - 128;
|
|
} else {
|
|
e = u[j * (width >> 1) + (i >> 1)] - 128;
|
|
d = v[j * (width >> 1) + (i >> 1)] - 128;
|
|
}
|
|
|
|
(*cur) = jpu_clip((298 * c + 409 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c - 100 * d - 208 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c + 516 * d + 128) >> 8);
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == YUYV || format == YVYU || format == UYVY || format == VYUY) {
|
|
unsigned char *t = misc;
|
|
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i += 2) {
|
|
switch (format) {
|
|
case YUYV:
|
|
c = *(t) - 16;
|
|
if (!cbcr_reverse) {
|
|
d = *(t + 1) - 128;
|
|
e = *(t + 3) - 128;
|
|
} else {
|
|
e = *(t + 1) - 128;
|
|
d = *(t + 3) - 128;
|
|
}
|
|
break;
|
|
case YVYU:
|
|
c = *(t) - 16;
|
|
if (!cbcr_reverse) {
|
|
d = *(t + 3) - 128;
|
|
e = *(t + 1) - 128;
|
|
} else {
|
|
e = *(t + 3) - 128;
|
|
d = *(t + 1) - 128;
|
|
}
|
|
break;
|
|
case UYVY:
|
|
c = *(t + 1) - 16;
|
|
if (!cbcr_reverse) {
|
|
d = *(t) - 128;
|
|
e = *(t + 2) - 128;
|
|
} else {
|
|
e = *(t) - 128;
|
|
d = *(t + 2) - 128;
|
|
}
|
|
break;
|
|
case VYUY:
|
|
c = *(t + 1) - 16;
|
|
if (!cbcr_reverse) {
|
|
d = *(t + 2) - 128;
|
|
e = *(t) - 128;
|
|
} else {
|
|
e = *(t + 2) - 128;
|
|
d = *(t) - 128;
|
|
}
|
|
break;
|
|
default: // like YUYV
|
|
c = *(t) - 16;
|
|
if (!cbcr_reverse) {
|
|
d = *(t + 1) - 128;
|
|
e = *(t + 3) - 128;
|
|
} else {
|
|
e = *(t + 1) - 128;
|
|
d = *(t + 3) - 128;
|
|
}
|
|
break;
|
|
}
|
|
|
|
(*cur) = jpu_clip((298 * c + 409 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c - 100 * d - 208 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c + 516 * d + 128) >> 8);
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
|
|
switch (format) {
|
|
case YUYV:
|
|
case YVYU:
|
|
c = *(t + 2) - 16;
|
|
break;
|
|
|
|
case VYUY:
|
|
case UYVY:
|
|
c = *(t + 3) - 16;
|
|
break;
|
|
default: // like YUYV
|
|
c = *(t + 2) - 16;
|
|
break;
|
|
}
|
|
|
|
(*cur) = jpu_clip((298 * c + 409 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c - 100 * d - 208 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c + 516 * d + 128) >> 8);
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
|
|
t += 4;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == YUV420 || format == NV12 || format == NV21) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
c = y[j * width + i] - 16;
|
|
if (format == YUV420) {
|
|
if (!cbcr_reverse) {
|
|
d = u[(j >> 1) * (width >> 1) + (i >> 1)] - 128;
|
|
e = v[(j >> 1) * (width >> 1) + (i >> 1)] - 128;
|
|
} else {
|
|
e = u[(j >> 1) * (width >> 1) + (i >> 1)] - 128;
|
|
d = v[(j >> 1) * (width >> 1) + (i >> 1)] - 128;
|
|
}
|
|
} else if (format == NV12) {
|
|
if (!cbcr_reverse) {
|
|
d = misc[(j >> 1) * width + (i >> 1 << 1)] - 128;
|
|
e = misc[(j >> 1) * width + (i >> 1 << 1) + 1] - 128;
|
|
} else {
|
|
e = misc[(j >> 1) * width + (i >> 1 << 1)] - 128;
|
|
d = misc[(j >> 1) * width + (i >> 1 << 1) + 1] - 128;
|
|
}
|
|
} else { // if (m_color == NV21)
|
|
if (!cbcr_reverse) {
|
|
d = misc[(j >> 1) * width + (i >> 1 << 1) + 1] - 128;
|
|
e = misc[(j >> 1) * width + (i >> 1 << 1)] - 128;
|
|
} else {
|
|
e = misc[(j >> 1) * width + (i >> 1 << 1) + 1] - 128;
|
|
d = misc[(j >> 1) * width + (i >> 1 << 1)] - 128;
|
|
}
|
|
}
|
|
(*cur) = jpu_clip((298 * c + 409 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c - 100 * d - 208 * e + 128) >> 8);
|
|
cur++;
|
|
(*cur) = jpu_clip((298 * c + 516 * d + 128) >> 8);
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == RGB_PLANAR) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
(*cur) = y[j * width + i];
|
|
cur++;
|
|
(*cur) = u[j * width + i];
|
|
cur++;
|
|
(*cur) = v[j * width + i];
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == RGB32) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
(*cur) = misc[j * width * 4 + i];
|
|
cur++; // R
|
|
(*cur) = misc[j * width * 4 + i + 1];
|
|
cur++; // G
|
|
(*cur) = misc[j * width * 4 + i + 2];
|
|
cur++; // B
|
|
(*cur) = misc[j * width * 4 + i + 3];
|
|
cur++; // A
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == RGB24) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
(*cur) = misc[j * width * 3 + i];
|
|
cur++; // R
|
|
(*cur) = misc[j * width * 3 + i + 1];
|
|
cur++; // G
|
|
(*cur) = misc[j * width * 3 + i + 2];
|
|
cur++; // B
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else if (format == RGB16) {
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
int tmp = misc[j * width * 2 + i] << 8 | misc[j * width * 2 + i + 1];
|
|
(*cur) = ((tmp >> 11) & 0x1F << 3);
|
|
cur++; // R(5bit)
|
|
(*cur) = ((tmp >> 5) & 0x3F << 2);
|
|
cur++; // G(6bit)
|
|
(*cur) = ((tmp) & 0x1F << 3);
|
|
cur++; // B(5bit)
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
} else { // YYY
|
|
for (j = 0; j < height; j++) {
|
|
cur = line;
|
|
for (i = 0; i < width; i++) {
|
|
(*cur) = y[j * width + i];
|
|
cur++;
|
|
(*cur) = y[j * width + i];
|
|
cur++;
|
|
(*cur) = y[j * width + i];
|
|
cur++;
|
|
(*cur) = 0;
|
|
cur++;
|
|
}
|
|
line += t_width << 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
int comparateYuv(Uint8 *pYuv, Uint8 *pRefYuv, int picWidth, int picHeight,
|
|
int stride, int interleave, int format, int endian, int packed)
|
|
{
|
|
int size = 0;
|
|
int y = 0, nY = 0, nCb = 0, nCr = 0;
|
|
Uint8 *pRef = NULL;
|
|
int lumaSize = 0, chromaSize = 0, chromaStride = 0, chromaWidth = 0, chromaHeight = 0;
|
|
|
|
Uint8 *pOrg = NULL;
|
|
|
|
switch (format) {
|
|
case FORMAT_420:
|
|
nY = (picHeight + 1) / 2 * 2;
|
|
nCb = (picHeight + 1) / 2;
|
|
nCr = (picHeight + 1) / 2;
|
|
chromaSize = ((picWidth + 1) / 2) * ((picHeight + 1) / 2);
|
|
chromaStride = stride / 2;
|
|
chromaWidth = (picWidth + 1) / 2;
|
|
chromaHeight = nY;
|
|
break;
|
|
case FORMAT_224:
|
|
nY = (picHeight + 1) / 2 * 2;
|
|
nCb = (picHeight + 1) / 2;
|
|
nCr = (picHeight + 1) / 2;
|
|
chromaSize = (picWidth) * ((picHeight + 1) / 2);
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
chromaHeight = nY;
|
|
break;
|
|
case FORMAT_422:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = ((picWidth + 1) / 2) * picHeight;
|
|
chromaStride = stride / 2;
|
|
chromaWidth = (picWidth + 1) / 2;
|
|
chromaHeight = nY * 2;
|
|
break;
|
|
case FORMAT_444:
|
|
nY = picHeight;
|
|
nCb = picHeight;
|
|
nCr = picHeight;
|
|
chromaSize = picWidth * picHeight;
|
|
chromaStride = stride;
|
|
chromaWidth = picWidth;
|
|
chromaHeight = nY * 2;
|
|
break;
|
|
case FORMAT_400:
|
|
nY = picHeight;
|
|
nCb = 0;
|
|
nCr = 0;
|
|
chromaSize = 0;
|
|
chromaStride = 0;
|
|
chromaWidth = 0;
|
|
chromaHeight = 0;
|
|
break;
|
|
}
|
|
|
|
pRef = pRefYuv;
|
|
pOrg = pYuv;
|
|
|
|
if (packed) {
|
|
if (packed == PACKED_FORMAT_444)
|
|
picWidth *= 3;
|
|
else
|
|
picWidth *= 2;
|
|
|
|
chromaSize = 0;
|
|
}
|
|
|
|
lumaSize = picWidth * nY;
|
|
|
|
size = lumaSize + chromaSize * 2;
|
|
|
|
if (picWidth == stride) {
|
|
if (OSAL_MEMCMP(pRef, pOrg, size)) {
|
|
JLOG(INFO, "pRef = 0x%lx, pOrg = 0x%lx, size:%d\n",
|
|
(unsigned long)pRef, (unsigned long)pOrg, size);
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
} else {
|
|
for (y = 0; y < nY; ++y) {
|
|
if (OSAL_MEMCMP(pOrg + stride * y, pRef + y * picWidth, picWidth)) {
|
|
JLOG(INFO, "pRef1 = 0x%lx, pOrg1 = 0x%lx\n",
|
|
(unsigned long)(pRef + y * picWidth),
|
|
(unsigned long)(pOrg + stride * y));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (packed)
|
|
return 0;
|
|
|
|
pRef = pRef + lumaSize;
|
|
pOrg = pOrg + nY * stride;
|
|
if (interleave) {
|
|
for (y = 0; y < (chromaHeight / 2); ++y) {
|
|
if (OSAL_MEMCMP(pOrg + (chromaStride * 2) * y,
|
|
pRef + y * (chromaWidth * 2),
|
|
(chromaWidth * 2))) {
|
|
JLOG(INFO, "pRef1 = 0x%lx\n", (unsigned long)(pOrg + (chromaStride * 2) * y));
|
|
JLOG(INFO, "pOrg2 = 0x%lx\n", (unsigned long)(pRef + y * (chromaWidth * 2)));
|
|
return 1;
|
|
}
|
|
}
|
|
} else {
|
|
for (y = 0; y < nCb; ++y) {
|
|
if (OSAL_MEMCMP(pOrg + chromaStride * y, pRef + y * chromaWidth, chromaWidth)) {
|
|
JLOG(INFO,
|
|
"pRef3 = 0x%lx, pOrg3 = 0x%lx\n",
|
|
(unsigned long)(pOrg + chromaStride * y),
|
|
(unsigned long)(pRef + y * chromaWidth));
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
pRef = pRef + chromaSize;
|
|
pOrg = pOrg + nCb * chromaStride;
|
|
for (y = 0; y < nCr; ++y) {
|
|
if (OSAL_MEMCMP(pOrg + chromaStride * y, pRef + y * chromaWidth, chromaWidth)) {
|
|
JLOG(INFO,
|
|
"pRef4 = 0x%lx, pOrg4 = 0x%lx\n",
|
|
(unsigned long)(pOrg + chromaStride * y),
|
|
(unsigned long)(pRef + y * chromaWidth));
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|