Linux/DRA712: omapdrmtest-viddec3test questions

Hi xinyang,
This looks like customized version of viddec3test.
What have you modified in viddec3test ?
What is the SDK version and please share the commitID on omapdrmtest?
Can you check if the issue is reproduced when you use --fps option ?

Thanks
Ramprasad

Hi

   Thank you for  your reply !

   Yes .it is customized version of viddec3test .  we are modified the code base on it ,

   viddec3test version is 1.0.0-r19 ,SDK version is dra7xx-evm-03_02_00_03.

  I  did a test, i put the  video stream  stored into a H264 format video file, and then decoded and displayed  (on the wayland )by viddec3test  DEMO.it is no problem . But there is a problem with directly decoding and displaying the data. there is anther  phenomenon ,The higher the FPS value of the transmitted video, the greater the probability of error.

code:

#pragma once

#include <fcntl.h>
#include "decoder.h"
#include "util.h"
#include <fcntl.h>
extern "C" 
{
#include <libdce.h>
#include <xf86drm.h>
#include <omap_drm.h>
#include <omap_drmif.h>
}


/* Padding for width as per Codec Requirement (for h264) */
#define PADX  32
/* Padding for height as per Codec requirement (for h264)*/
#define PADY  24

class Decoder 
{
public:
	Decoder();
	~Decoder();

	bool Open(int imgWidth, int imgHeight, int scrnX, int scrnY, int scrnWidth, int scrnHeight);
	bool Decode(const void* data, int len);
	void Flush();
	void Close();

protected:
	void RetriveData();

	struct omap_device* m_dev;
	struct Display* m_disp;
	Engine_Handle m_engine;
	VIDDEC3_Handle m_codec;
	VIDDEC3_DynamicParams* m_dynParams;
	XDM2_BufDesc* m_inBufs;
	XDM2_BufDesc* m_outBufs;
	VIDDEC3_InArgs* m_inArgs;
	VIDDEC3_OutArgs* m_outArgs;
	struct omap_bo* m_input_bo;
	int m_input_sz;
	int m_padded_width;
	int m_padded_height;
	int m_num_outBuf;
	size_t* m_outBuf_fd;
};

Decoder::Decoder()
{
	m_dev = NULL;
	m_disp = NULL;
	m_dynParams = NULL;
	m_inBufs = NULL;
	m_outBufs = NULL;
	m_inArgs = NULL;
	m_outArgs = NULL;
	m_input_bo = NULL;
	m_outBuf_fd = NULL;
}

Decoder::~Decoder()
{
	Close();
}

void Decoder::Close()
{
//	printf("Close Decoder...\n");
	if(m_dynParams != NULL) { dce_free(m_dynParams); 					m_dynParams = NULL; }
	if(m_inBufs != NULL)		
	{
		dce_buf_unlock(1, (size_t*)&(m_inBufs->descs[0].buf));
		close((int)m_inBufs->descs[0].buf);
		dce_free(m_inBufs);
		m_inBufs = NULL;
	}
	if(m_outBufs != NULL)	{ dce_free(m_outBufs); 						m_outBufs = NULL; }
	if(m_inArgs != NULL)    { dce_free(m_inArgs); 						m_inArgs = NULL; }
	if(m_outArgs != NULL)   { dce_free(m_outArgs); 						m_outArgs = NULL; }
	if(m_codec != NULL)     { VIDDEC3_delete(m_codec); 					m_codec = NULL; }
	if(m_engine != NULL)    { Engine_close(m_engine); 					m_engine = NULL; }
    if(m_input_bo != NULL)  { omap_bo_del(m_input_bo); 					m_input_bo = NULL; }
	if(m_outBuf_fd != NULL)	{ free(m_outBuf_fd); 						m_outBuf_fd = NULL; }
	if(m_dev != NULL)	 	{ dce_deinit(m_dev); 						m_dev = NULL; }
	if(m_disp != NULL)    	
	{ 
		disp_free_buffers(m_disp,m_num_outBuf);
		disp_close(m_disp);
		free(m_disp);
		m_disp = NULL;
	}
}

bool Decoder::Open(int w, int h, int scrnX, int scrnY, int scrnWidth, int scrnHeight)
{
	m_disp = disp_open(scrnX, scrnY, scrnWidth, scrnHeight);
	if(m_disp == NULL)
		return false;		

	dce_set_fd(m_disp->fd);

	m_dev = (omap_device*)dce_init();
	if(m_dev == NULL) 
		return false;	

	/* calculate output buffer parameters: */
	w  = ALIGN2 (w, 4);        /* round up to macroblocks */
	h = ALIGN2 (h, 4);       /* round up to macroblocks */

	m_padded_width  = ALIGN2 (w + (2*PADX), 7);
	m_padded_height = h + 4*PADY;

	m_num_outBuf   = MIN(16, 32768 / ((w/16) * (h/16))) *2+1;
	//printf("Num = %d\n",m_num_outBuf);

	if (!disp_get_vid_buffers(m_disp, m_num_outBuf, FOURCC_STR("NV12"), m_padded_width, m_padded_height))
	{
		ERROR("could not allocate buffers");
		return false;
	}

	m_outBuf_fd = (size_t*)malloc(sizeof(int)*m_num_outBuf);
	m_input_sz = w * h;
	m_input_bo = omap_bo_new(m_dev,	m_input_sz, OMAP_BO_WC);

	Engine_Error ec;
	m_engine = Engine_open(String("ivahd_vidsvr"), NULL, &ec);
	if (m_engine == NULL) 
	{
		ERROR("could not open engine");
		return false;
	}

	VIDDEC3_Params* params = (VIDDEC3_Params*)dce_alloc(sizeof(IVIDDEC3_Params));
	params->size = sizeof(IVIDDEC3_Params);
	params->maxWidth         = w;
	params->maxHeight        = h;
	params->maxFrameRate     = 30000;
	params->maxBitRate       = 10000000;
	params->dataEndianness   = XDM_BYTE;
	params->forceChromaFormat= XDM_YUV_420SP;
	params->operatingMode    = IVIDEO_DECODE_ONLY;
	params->displayDelay     = 1;//IVIDDEC3_DISPLAY_DELAY_AUTO;
	params->displayBufsMode  = IVIDDEC3_DISPLAYBUFS_EMBEDDED;
	params->inputDataMode    = IVIDEO_ENTIREFRAME;
	params->metadataType[0]  = IVIDEO_METADATAPLANE_NONE;
	params->metadataType[1]  = IVIDEO_METADATAPLANE_NONE;
	params->metadataType[2]  = IVIDEO_METADATAPLANE_NONE;
	params->numInputDataUnits= 0;
	params->outputDataMode   = IVIDEO_ENTIREFRAME;
	params->numOutputDataUnits = 0;
	params->errorInfoMode    = IVIDEO_ERRORINFO_OFF;

	m_codec = VIDDEC3_create(m_engine, String("ivahd_h264dec"), params);
	dce_free(params);

	if(m_codec == NULL) 
	{
		ERROR("could not create codec");
		return false;
	}

	m_dynParams = (IVIDDEC3_DynamicParams*)dce_alloc(sizeof(IVIDDEC3_DynamicParams));
	m_dynParams->size = sizeof(IVIDDEC3_DynamicParams);
	m_dynParams->decodeHeader  = XDM_DECODE_AU;
	/*Not Supported: Set default*/
	m_dynParams->displayWidth  = 0;
	m_dynParams->frameSkipMode = IVIDEO_NO_SKIP;
	m_dynParams->newFrameFlag  = XDAS_TRUE;
	VIDDEC3_Status* status = (IVIDDEC3_Status*)dce_alloc(sizeof(IVIDDEC3_Status));
	status->size = sizeof(IVIDDEC3_Status);
	XDAS_Int32 err = VIDDEC3_control(m_codec, XDM_SETPARAMS, m_dynParams, status);
	dce_free(status);
	if (err != 0) 
	{
		ERROR("fail to control: %d", err);
		return false;
	}

	m_inBufs = (XDM2_BufDesc*)dce_alloc(sizeof(XDM2_BufDesc));
	m_inBufs->numBufs = 1;
	m_inBufs->descs[0].buf = (XDAS_Int8 *)omap_bo_dmabuf(m_input_bo);
	dce_buf_lock(1, (size_t*)&(m_inBufs->descs[0].buf));
	m_inBufs->descs[0].memType = XDM_MEMTYPE_RAW;

	m_outBufs = (XDM2_BufDesc*)dce_alloc(sizeof(XDM2_BufDesc));
	m_outBufs->numBufs = 2;
	m_outBufs->descs[0].memType = XDM_MEMTYPE_RAW;
	m_outBufs->descs[1].memType = XDM_MEMTYPE_RAW;

	m_inArgs = (IVIDDEC3_InArgs*)dce_alloc(sizeof(IVIDDEC3_InArgs));
	m_inArgs->size = sizeof(IVIDDEC3_InArgs);
	m_outArgs = (IVIDDEC3_OutArgs*)dce_alloc(sizeof(IVIDDEC3_OutArgs));
	m_outArgs->size = sizeof(IVIDDEC3_OutArgs);

	return true;
}

bool Decoder::Decode(const void* data, int len)
{
//	printf("decode...\n");
	struct Buffer *buf = disp_get_vid_buffer(m_disp);

	if(buf == NULL)
	{
		ERROR("Out of buffers.");
		return false;
	}

	m_inBufs->descs[0].bufSize.bytes = len;
	m_inArgs->numBytes = len;

	char* input = (char*)omap_bo_map(m_input_bo);
	memcpy(input, data, len);	

	m_inArgs->inputID = (XDAS_Int32)buf;
	m_outBufs->descs[0].buf = (XDAS_Int8*)buf->fd[0];
	m_outBufs->descs[1].buf = (XDAS_Int8*)((m_outBufs->descs[0].buf));

	m_outBuf_fd[0] = buf->fd[0];
	dce_buf_lock(1, m_outBuf_fd);

	m_outBufs->descs[0].bufSize.bytes = m_padded_width*m_padded_height;
	m_outBufs->descs[1].bufSize.bytes = m_padded_width*m_padded_height/2;

	XDAS_Int32 err = VIDDEC3_process(m_codec, m_inBufs, m_outBufs, m_inArgs, m_outArgs);

	RetriveData();

/*	if (err != 0) 
	{
		ERROR("process returned error: %d", err);
		return false;
	}
*/
	return true;
}

void Decoder::Flush()
{
//	printf("Flush...\n");
	VIDDEC3_Status* status = (IVIDDEC3_Status*)dce_alloc(sizeof(IVIDDEC3_Status));
	status->size = sizeof(IVIDDEC3_Status);
	VIDDEC3_control(m_codec, XDM_FLUSH, m_dynParams, status);
	dce_free(status);

	m_inBufs->numBufs = 0;
	m_outBufs->numBufs = 0;
	m_inArgs->inputID = 0;

	while(true)
	{
		if(VIDDEC3_process(m_codec, m_inBufs, m_outBufs, m_inArgs, m_outArgs) != 0)
			break;

		RetriveData();	
	}
}

void Decoder::RetriveData()
{
	struct Buffer* buf;
	int freeBufCount = 0;

	for (int i = 0; m_outArgs->outputID[i]; i++) 
	{
		// calculate offset to region of interest 
		XDM_Rect *r = &(m_outArgs->displayBufs.bufDesc[0].activeFrameRegion);

		// get the output buffer and render it
		buf = (struct Buffer *)m_outArgs->outputID[i];

		disp_post_vid_buffer(m_disp, buf, r->topLeft.x, r->topLeft.y, r->bottomRight.x - r->topLeft.x, r->bottomRight.y - r->topLeft.y);

	//	printf("rect = %d %d %d %d\n",r->topLeft.x, r->topLeft.y, r->bottomRight.x - r->topLeft.x, r->bottomRight.y - r->topLeft.y);
	}

	for (int i = 0; m_outArgs->freeBufID[i]; i++)
	{
		buf = (struct Buffer *)m_outArgs->freeBufID[i];
		disp_put_vid_buffer(m_disp, buf);

		m_outBuf_fd[freeBufCount++] = buf->fd[0];
	}

	if(freeBufCount != 0)
		dce_buf_unlock(freeBufCount,m_outBuf_fd);
}

void main()
{
	
	/*video stream which mobile phone mirror video ransport by usb ,we are do some init usb and connect phone  work before decoderopen*/
	DecoderOpen(1552,576,0,0,1552,576);
	/*Transfer mirrored video stream  to callback function */
	Decode(data, len);
	
	
}