DvevmStRetCode
dvtb_MPEG4Enc1Init(DvevmStMPEG4Enc1Info *ve)
{
DvevmStRetCode retCode = DVEVM_ST_SUCCESS;
ASSERT(ve != NULL);
ASSERT(ve->ceHdl != NULL);
ASSERT(ve->venc1Name[0] != 0);
dvtb_MPEG4Enc1InitDebug(&ve->venc1Params);
if (NULL == (ve->venc1Hdl = VIDENC1_create(ve->ceHdl, ve->venc1Name, (IVIDENC1_Params *) (&ve->venc1Params))))
{
dvtb_MPEG4Enc1InitDebug(&ve->venc1Params);
SYS_ERROR("Unable to initialize Video Encoder\n");
retCode = DVEVM_ST_FAIL;
}
else
{
ve->venc1Cmd = XDM_GETSTATUS;
if (DVEVM_ST_FAIL == dvtb_MPEG4Enc1Control(ve))
{
SYS_ERROR("Unable to get status \n");
retCode = DVEVM_ST_FAIL;
}
else
{
ve->venc1Cmd = XDM_SETPARAMS;
if (DVEVM_ST_FAIL == dvtb_MPEG4Enc1Control(ve))
{
SYS_ERROR("Unable to set encoder dynamic parameters\n");
retCode = DVEVM_ST_FAIL;
}
else
{
ve->venc1Cmd = XDM_GETBUFINFO;
if (DVEVM_ST_FAIL == dvtb_MPEG4Enc1Control(ve))
{
SYS_ERROR("Unable to get encoder buffer requirements\n");
retCode = DVEVM_ST_FAIL;
}
else
{
SYS_DEBUG("Video Encoder <%s> initialized\n", ve->venc1Name);
dvtb_MPEG4Enc1InitDebug(&ve->venc1Params);
}
}
}
}
if(DVEVM_ST_FAIL == retCode)
dvtb_MPEG4Enc1Cleanup(ve);
return retCode;
}
void *ALG_vidEncCreate(ALG_VidEncCreate *create)
{
XDAS_Int32 status;
ALG_VidEncObj *pObj;
if(gALG_hEngine==NULL)
return NULL;
pObj = OSA_memAlloc(sizeof(ALG_VidEncObj));
if(pObj==NULL)
return NULL;
memset(pObj, 0, sizeof(ALG_VidEncObj));
switch(create->codec) {
case ALG_VID_CODEC_H264:
strcpy(pObj->algName, ALG_VID_CODEC_H264_ENC_NAME);
break;
case ALG_VID_CODEC_MPEG4:
strcpy(pObj->algName, ALG_VID_CODEC_MPEG4_ENC_NAME);
break;
case ALG_VID_CODEC_MJPEG:
strcpy(pObj->algName, ALG_VID_CODEC_JPEG_ENC_NAME);
break;
default:
OSA_memFree(pObj);
return NULL;
}
memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));
if(create->codec==ALG_VID_CODEC_MJPEG)
{
ALG_JpgEncCreate jpgCreate;
jpgCreate.dataFormat = create->dataFormat;
jpgCreate.width = create->width;
jpgCreate.height = create->height;
jpgCreate.offsetH = create->offsetH;
jpgCreate.offsetV = create->offsetV;
jpgCreate.encDataFormat = ALG_VID_DATA_FORMAT_YUV420;
jpgCreate.qValue = create->qValue;
pObj->hJpgEncode = ALG_jpgEncCreate(&jpgCreate);
if(pObj->hJpgEncode==NULL) {
OSA_memFree(pObj);
return NULL;
}
return pObj;
}
pObj->params.maxHeight = create->height;
pObj->params.maxWidth = create->width;
pObj->params.maxFrameRate = ALD_VID_ENC_MAX_FRAMERATE;
pObj->params.maxBitRate = ALD_VID_ENC_MAX_BITRATE;
pObj->params.inputChromaFormat = XDM_YUV_420SP;
pObj->params.dataEndianness = XDM_BYTE;
pObj->params.maxInterFrameInterval = 1;
pObj->params.inputContentType = IVIDEO_PROGRESSIVE;
pObj->params.reconChromaFormat = XDM_YUV_420SP;
if(create->codec==ALG_VID_CODEC_MPEG4)
{
pObj->params.size = sizeof(IMP4VENC_Params);
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params.maxHeight = create->height;
pObj->params.maxWidth = (create->offsetH>create->width)?create->offsetH:create->width;
pObj->params_mpeg4.subWindowHeight = create->height;
pObj->params_mpeg4.subWindowWidth = create->width;
pObj->params_mpeg4.rotation = 0;
pObj->params_mpeg4.vbvSize = 0;
pObj->params_mpeg4.svhMode = 0;
pObj->params_mpeg4.IFrameBitRateBiasFactor = 256;
pObj->params_mpeg4.PFrameBitRateBiasFactor = 256;
pObj->params_mpeg4.peakBufWindow = 2;
pObj->params_mpeg4.minBitRate = 64000; //set to 64kbps
switch(create->rateControlType) {
case ALG_VID_ENC_RATE_CONTROL_RCOFF:
pObj->params.rateControlPreset = IVIDEO_NONE;
break;
default:
case ALG_VID_ENC_RATE_CONTROL_VBR:
pObj->params.rateControlPreset = IVIDEO_STORAGE;
break;
case ALG_VID_ENC_RATE_CONTROL_CBR:
pObj->params.rateControlPreset = IVIDEO_LOW_DELAY;
break;
}
}
else if(create->codec==ALG_VID_CODEC_H264)
{
if(77 == create->profileIdc)
{
pObj->params_h264.profileIdc = 77;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = 0;
pObj->params_h264.seqScalingFlag = 0;
pObj->params_h264.entropyMode = 1;
printf("[alg_vidEnc]zeng Main profile --------------create->profileIdc=%d\n" , create->profileIdc);
}
else if(66 == create->profileIdc)
{
pObj->params_h264.profileIdc = 66;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = 0;
pObj->params_h264.seqScalingFlag = 0;
pObj->params_h264.entropyMode = 0;
printf("[alg_vidEnc]zeng baseline profile--------------create->profileIdc=%d\n" , create->profileIdc);
}
else
{
pObj->params_h264.profileIdc = 100;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = (create->width>2048)?0:1;
pObj->params_h264.seqScalingFlag = 1;
pObj->params_h264.entropyMode = 1;
printf("[alg_vidEnc]zeng hight profile--------------create->profileIdc=%d\n" , create->profileIdc);
}
pObj->params.size = sizeof(IH264VENC_Params);
pObj->params.rateControlPreset = IVIDEO_USER_DEFINED;
pObj->params_h264.levelIdc = IH264VENC_LEVEL_40;
pObj->params_h264.Log2MaxFrameNumMinus4 = 0;
pObj->params_h264.ConstraintSetFlag = 0;
pObj->params_h264.enableVUIparams = 7;
pObj->params_h264.meAlgo = 0;
pObj->params_h264.enableARM926Tcm = 0;
pObj->params_h264.enableDDRbuff = (create->ddrEnable) ? 1 : 0;
pObj->params_h264.sliceMode = 3;
pObj->params_h264.EnableLongTermFrame = 0;
pObj->params_h264.outputDataMode = IH264VENC_TI_ENTIREFRAME;
pObj->params_h264.sliceFormat = IH264VENC_TI_BYTESTREAM;
printf("[alg_vidEnc]zeng afdfafdasfdasf--------create->profileIdc=%d\n" , create->profileIdc);
if((create->encodePreset&ALG_VID_ENC_PRESET_MASK) == ALG_VID_ENC_PRESET_AUTO)
{
if((create->width<320)||(create->height<128))
{
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params_h264.encQuality = 0;
}
else {
if(create->mode == ALG_VID_ENC_MODE_STANDARD) {
pObj->params.encodingPreset = XDM_HIGH_QUALITY;
pObj->params_h264.encQuality = 2;
}
else {
pObj->params.encodingPreset = XDM_HIGH_SPEED;
pObj->params_h264.encQuality = 3;
}
}
}
else {
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params_h264.encQuality = 0;
}
if((create->encodePreset&ALG_VID_ENC_SVC_MASK) == ALG_VID_ENC_PRESET_SVC)
{
pObj->params_h264.numTemporalLayers = 3;
pObj->params_h264.svcSyntaxEnable = XDAS_FALSE;
/*
To disable svcSyntaxEnable as most player cant play this SVC syntax,
if player is comptatible, please change the value to XDAS_TRUE;
*/
}
else {
pObj->params_h264.numTemporalLayers = 0;
pObj->params_h264.svcSyntaxEnable = XDAS_FALSE;
}
}
/*enable mv when initialize for get memory information*/
pObj->createPrm.mbMvOutEnable = 1;
pObj->createPrm.forceKeyFrame = FALSE;
/* Create video encoder instance */
pObj->hEncode = VIDENC1_create(gALG_hEngine, pObj->algName, &pObj->params);
if (pObj->hEncode == NULL) {
OSA_ERROR("Failed to open video encode algorithm: %s (0x%x)\n", pObj->algName, Engine_getLastError(gALG_hEngine));
OSA_memFree(pObj);
return NULL;
}
status = ALG_vidEncSetDynamicParams(pObj);
if(status!=OSA_SOK) {
ALG_vidEncDelete(pObj);
return NULL;
}
return pObj;
}
/*
* ======== smain ========
*/
Int smain(String progName, String procId, String engineName,
String inFile, String outFile)
{
Engine_Handle ce = NULL;
Engine_Attrs attrs;
VIDDEC2_Handle dec = NULL;
VIDENC1_Handle enc = NULL;
FILE *in = NULL;
FILE *out = NULL;
Memory_AllocParams allocParams;
createInFileIfMissing(inFile);
Log_print4(Diags_USER1, "[+1] App-> Application started, procId %s "
"engineName %s input-file %s output-file %s.",
(IArg)procId, (IArg)engineName, (IArg)inFile, (IArg)outFile);
/* allocate input, encoded, and output buffers */
allocParams.type = Memory_CONTIGPOOL;
allocParams.flags = Memory_NONCACHED;
allocParams.align = BUFALIGN;
allocParams.seg = 0;
inBuf = (XDAS_Int8 *)Memory_alloc(IFRAMESIZE, &allocParams);
encodedBuf = (XDAS_Int8 *)Memory_alloc(EFRAMESIZE, &allocParams);
outBuf = (XDAS_Int8 *)Memory_alloc(OFRAMESIZE, &allocParams);
versionBuf = (XDAS_Int8 *)Memory_alloc(MAXVERSIONSIZE, &allocParams);
if ((inBuf == NULL) || (encodedBuf == NULL) || (outBuf == NULL) ||
(versionBuf == NULL)) {
goto end;
}
/* open file streams for input and output */
if ((in = fopen(inFile, "rb")) == NULL) {
printf("App-> ERROR: can't read file %s\n", inFile);
goto end;
}
if ((out = fopen(outFile, "wb")) == NULL) {
printf("App-> ERROR: can't write to file %s\n", outFile);
goto end;
}
/* Initialize attrs fields to default values, and set the procId */
Engine_initAttrs(&attrs);
attrs.procId = procId;
/* reset, load, and start DSP Engine */
if ((ce = Engine_open(engineName, &attrs, NULL)) == NULL) {
fprintf(stderr, "%s: error: can't open engine %s\n",
progName, engineName);
goto end;
}
/* allocate and initialize video decoder on the engine */
dec = VIDDEC2_create(ce, decoderName, NULL);
if (dec == NULL) {
printf( "App-> ERROR: can't open codec %s\n", decoderName);
goto end;
}
/* allocate and initialize video encoder on the engine */
enc = VIDENC1_create(ce, encoderName, NULL);
if (enc == NULL) {
fprintf(stderr, "%s: error: can't open codec %s\n",
progName, encoderName);
goto end;
}
/* use engine to encode, then decode the data */
encode_decode(enc, dec, in, out);
end:
/* teardown the codecs */
if (enc) {
VIDENC1_delete(enc);
}
if (dec) {
VIDDEC2_delete(dec);
}
/* close the engine */
if (ce) {
Engine_close(ce);
}
/* close the files */
if (in) {
fclose(in);
}
if (out) {
fclose(out);
}
/* free buffers */
if (inBuf) {
Memory_free(inBuf, IFRAMESIZE, &allocParams);
}
if (encodedBuf) {
Memory_free(encodedBuf, EFRAMESIZE, &allocParams);
}
if (outBuf) {
Memory_free(outBuf, OFRAMESIZE, &allocParams);
}
if (versionBuf) {
Memory_free(versionBuf, MAXVERSIONSIZE, &allocParams);
}
Log_print0(Diags_USER1, "[+1] app done.");
return (0);
}
Void *deiThrFxn(Void *arg)
{
DeiEnv *envp = (DeiEnv *) arg;
Void *status = THREAD_SUCCESS;
Uint32 sysRegBase = 0;
VIDENC1_Handle hDei = NULL;
IDEI_Params deiParams;
Uint16 frame_width = 0, frame_height = 0;
Uint16 threshold_low = 0, threshold_high = 0;
IVIDEO1_BufDescIn inBufDesc;
XDM_BufDesc outBufDesc;
XDAS_Int8 *outbufs[2];
XDAS_Int32 outBufSizeArray[2];
VIDENC1_InArgs inArgs;
IDEI_OutArgs outArgs;
Uint32 bufferSize;
CMEM_AllocParams cmemPrm;
Uint32 prevBufAddr, outBufAddr;
Buffer_Handle cBuf, dBuf;
Int ret = 0;
int fd = -1;
dm365mmap_params_t dm365mmap_params;
pthread_mutex_t Dmai_DM365dmaLock = PTHREAD_MUTEX_INITIALIZER;
/* ▼▼▼▼▼ Initialization ▼▼▼▼▼ */
DM365MM_init(); printf("\n"); /* dm365mm issue */
sysRegBase = DM365MM_mmap(0x01C40000, 0x4000);
CMEM_init();
cmemPrm.type = CMEM_HEAP;
cmemPrm.flags = CMEM_NONCACHED;
cmemPrm.alignment = 32;
prevBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm);
outBufAddr = (Uint32)CMEM_alloc(IN_OUT_BUF_SIZE, &cmemPrm);
frame_width = 720;
frame_height = 576;
threshold_low = 16;
threshold_high = 20;
/* Create DEI instance */
deiParams.videncParams.size = sizeof(IDEI_Params);
deiParams.frameHeight = frame_height;
deiParams.frameWidth = frame_width;
deiParams.inLineOffset = frame_width;
deiParams.outLineOffset = (frame_width - 8);
deiParams.threshold_low = threshold_low;
deiParams.threshold_high = threshold_high;
deiParams.inputFormat = XDM_YUV_422ILE;
deiParams.outputFormat = XDM_YUV_420SP;
deiParams.q_num = 1;
deiParams.askIMCOPRes = 0;
deiParams.sysBaseAddr = sysRegBase;
hDei = VIDENC1_create(envp->hEngine, "dei", (VIDENC1_Params *)&deiParams);
if(hDei == NULL)
{
ERR("DEI alg creation failed\n");
cleanup(THREAD_FAILURE);
}
fd = open("/dev/dm365mmap", O_RDWR | O_SYNC);
Rendezvous_meet(envp->hRendezvousInit);
/* ▲▲▲▲▲ Initialization ▲▲▲▲▲ */
while (1) {
if (Fifo_get(envp->hFromCaptureFifo, &cBuf) < 0) {
ERR("Failed to get buffer from capture thread\n");
cleanup(THREAD_FAILURE);
}
if (Fifo_get(envp->hFromDisplayFifo, &dBuf) < 0) {
ERR("Failed to get buffer from display thread\n");
cleanup(THREAD_FAILURE);
}
inBufDesc.numBufs = 4;
bufferSize = (frame_width * frame_height);
inBufDesc.bufDesc[0].bufSize = bufferSize;
inBufDesc.bufDesc[0].buf = (XDAS_Int8 *)Buffer_getUserPtr(cBuf);
inBufDesc.bufDesc[0].accessMask = 0;
inBufDesc.bufDesc[1].bufSize = bufferSize;
inBufDesc.bufDesc[1].buf = (XDAS_Int8 *)(Buffer_getUserPtr(cBuf) + bufferSize);
inBufDesc.bufDesc[1].accessMask = 0;
inBufDesc.bufDesc[2].bufSize = bufferSize;
inBufDesc.bufDesc[2].buf = (XDAS_Int8 *)prevBufAddr;
inBufDesc.bufDesc[2].accessMask = 0;
inBufDesc.bufDesc[3].bufSize = bufferSize;
inBufDesc.bufDesc[3].buf = (XDAS_Int8 *)(prevBufAddr + bufferSize);
inBufDesc.bufDesc[3].accessMask = 0;
/* Output buffers */
outBufDesc.numBufs = 2;
outbufs[0] = (XDAS_Int8*)outBufAddr;
outbufs[1] = (XDAS_Int8*)(outBufAddr + bufferSize);
outBufSizeArray[0] = bufferSize;
outBufSizeArray[1] = bufferSize / 2;
outBufDesc.bufSizes = outBufSizeArray;
outBufDesc.bufs = outbufs;
inArgs.size = sizeof(VIDENC1_InArgs);
outArgs.videncOutArgs.size = sizeof(IDEI_OutArgs);
ret = VIDENC1_process((VIDENC1_Handle)hDei,
&inBufDesc,
&outBufDesc,
&inArgs,
(IVIDENC1_OutArgs *)&outArgs);
if (ret != VIDENC1_EOK) {
ERR("DEI process failed\n");
cleanup(THREAD_FAILURE);
}
dm365mmap_params.src = CMEM_getPhys(outbufs[0]);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf);
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 712;
dm365mmap_params.dstbidx = 704;
dm365mmap_params.acnt = 704;
dm365mmap_params.bcnt = 576;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
dm365mmap_params.src = CMEM_getPhys(outbufs[1]);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = Buffer_getPhysicalPtr(dBuf) + (Buffer_getSize(dBuf) * 2 / 3);
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 712;
dm365mmap_params.dstbidx = 704;
dm365mmap_params.acnt = 712;
dm365mmap_params.bcnt = 570 / 2;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
Buffer_setNumBytesUsed(dBuf, 704 * 576 * 3 / 2);
dm365mmap_params.src = Buffer_getPhysicalPtr(cBuf);
dm365mmap_params.srcmode = 0;
dm365mmap_params.dst = prevBufAddr;
dm365mmap_params.dstmode = 0;
dm365mmap_params.srcbidx = 1440;
dm365mmap_params.dstbidx = 1440;
dm365mmap_params.acnt = 1440;
dm365mmap_params.bcnt = 576;
dm365mmap_params.ccnt = 1;
dm365mmap_params.bcntrld = dm365mmap_params.bcnt;
dm365mmap_params.syncmode = 1;
pthread_mutex_lock(&Dmai_DM365dmaLock);
if (ioctl(fd, DM365MMAP_IOCMEMCPY, &dm365mmap_params) == -1) {
ERR("memcpy: Failed to do memcpy\n");
cleanup(THREAD_FAILURE);
}
pthread_mutex_unlock(&Dmai_DM365dmaLock);
/* Send buffer to display thread */
if (Fifo_put(envp->hToDisplayFifo, dBuf) < 0) {
ERR("Failed to send buffer to dei thread\n");
cleanup(THREAD_FAILURE);
}
/* Send buffer to display thread */
if (Fifo_put(envp->hToCaptureFifo, cBuf) < 0) {
ERR("Failed to send buffer to dei thread\n");
cleanup(THREAD_FAILURE);
}
}
cleanup:
Rendezvous_force(envp->hRendezvousInit);
Rendezvous_meet(envp->hRendezvousCleanup);
/* Delete DEI ALG instance */
VIDENC1_delete(hDei);
DM365MM_ummap(sysRegBase,0x4000);
DM365MM_exit();
if (fd > 0) {
close(fd);
}
return status;
}
