Alg_vidDec doesn't work (urgent)

Person Lin

Other Parts Discussed in Thread: TVP5158

Hi,

I designed our application based on MCVIP of av_capture framework. (UDWorks reference design)

Alg_vidEnc is ok and the recorded bitstream file (h264) can be decode by VLC or other player on windows without any warning.

I tried to design the decode_tsk to decode the bitstream file(h264).

There is no error message output from ALG_vidDecRun(), but Alg_vidDec doesn't work well.

The following message is one of our decoding cases. The input image is 704x480@h264 frame.

The size of first frame is "19787" bytes. After decoding by the Alg_vidDec, the runStatus.bytesUsed always is 115 bytes (if it is any Keyframe and start code is "00 00 00 01 27").

It doest not be a same small value and the decoded result is bad.

[output message]

Creating ALG_vidDec (codec=0, width=720, height=480)
DECODE: 0: 4a0c8000 (0, 19787) -> 4a113000 (800x576, 0)
00 00 00 01 27 64 00 1E AD 88 0E 43 98 20 E1 0C 29 0A 44 07 21 CC 10 70 86 14 85 22 03 90 E6 08
ALG: VidDec: XDM_GETBUFINFO: min out bufs:2,size:405504 202752
DECODE: 0:0:-1:0x0:0: 115 bytes (276, 5160941)
DECODE: 1: 4a0c8073 (115, 19672) -> 4a1f4000 (800x576, 1)
00 00 01 25 88 85 0B FF F0 A6 7A 41 70 3F 81 E8 B7 E9 57 DD 18 76 70 80 75 B6 6E 48 1A F1 9B 05
DECODE: 1:1:-1:0x0:0: 6 bytes (276, 5160941)
DECODE: 2: 4a0c8079 (121, 19666) -> 4a2d5000 (800x576, 2)
0B FF F0 A6 7A 41 70 3F 81 E8 B7 E9 57 DD 18 76 70 80 75 B6 6E 48 1A F1 9B 05 88 28 5B F4 CB B3
DECODE: 2:2:-1:0x0:0: 10372 bytes (276, 5160941)
DECODE: 3: 4a0ca8fd (10493, 9294) -> 4a113000 (800x576, 0)
00 00 01 21 88 86 7F F4 21 DE 9B 27 8B FC 17 08 4A 95 0C 00 5C 4D 12 BC CE DC 09 01 13 74 FB 2F
DECODE: 0:0:-1:0x0:0: 6 bytes (276, 5160941)
DECODE: 4: 4a0ca903 (10499, 9288) -> 4a1f4000 (800x576, 1)
7F F4 21 DE 9B 27 8B FC 17 08 4A 95 0C 00 5C 4D 12 BC CE DC 09 01 13 74 FB 2F 0A 85 FC CB FB EE
DECODE: 1:1:-1:0x0:0: 9288 bytes (276, 5160941)

[Alg_vidDec initial parameters]

    vidDecCreatePrm.codec = ALG_VID_CODEC_H264;
    vidDecCreatePrm.dataFormat = DRV_DATA_FORMAT_YUV420;
    vidDecCreatePrm.maxWidth        = 720;
    vidDecCreatePrm.maxHeight       = 480;

[source]

static int DECODE_decode(int inDataSize)
{
    int status = OSA_SOK, whOffset;
    ALG_VidDecRunPrm runPrm;
    ALG_VidDecRunStatus runStatus;
    Uint8 *inAddr;

    inAddr = gDECODE_ctrl.inBufVirtAddr;

    whOffset = 0;
    if(gDECODE_ctrl.createPrm.codec == ALG_VID_CODEC_H264)
        whOffset = 96;

    gDECODE_ctrl.inDataOffset = 0;
    do { // recursive decode if there is remained data

        runPrm.inAddr         = inAddr + gDECODE_ctrl.inDataOffset;
        runPrm.outAddr        = gDECODE_ctrl.decBufVirtAddr[gDECODE_ctrl.curDecBufId];
        runPrm.inDataSize     = inDataSize - gDECODE_ctrl.inDataOffset;
        runPrm.outOffsetH     = OSA_align(gDECODE_ctrl.createPrm.maxWidth + whOffset, 32);
        runPrm.outOffsetV     = gDECODE_ctrl.createPrm.maxHeight + whOffset;
        runPrm.inputBufId     = gDECODE_ctrl.curDecBufId;

        OSA_prfBegin(&gDECODE_ctrl.prfDec);

    #define DECODE_DEBUG_RUNNING
    #ifdef DECODE_DEBUG_RUNNING
        OSA_printf(" DECODE: %d: %08x (%d, %d) -> %08x (%dx%d, %d)\n",
                   gDECODE_ctrl.frameCount,
                   (Uint32)runPrm.inAddr,
                   gDECODE_ctrl.inDataOffset,
                   runPrm.inDataSize,
                   (Uint32)runPrm.outAddr,
                   runPrm.outOffsetH,
                   runPrm.outOffsetV,
                   runPrm.inputBufId
                  );
    #endif
        int i;
        for(i=0; i<32; ++i)
            printf("%02X ", runPrm.inAddr[i]);
        printf("\n");
        status = ALG_vidDecRun(gDECODE_ctrl.algVidDecHndl, &runPrm, &runStatus);
        printf("\n");

        OSA_prfEnd(&gDECODE_ctrl.prfDec, 1);

    #ifdef DECODE_DEBUG_RUNNING
        OSA_printf(" DECODE: %d:%d:%d:%dx%d:%d: %d bytes (%d, %d)\n",
                   runStatus.freeBufId,
                   runPrm.inputBufId,
                   runStatus.outputBufId,
                   runStatus.frameWidth, runStatus.frameHeight,
                   runStatus.isKeyFrame,
                   runStatus.bytesUsed,
                   runStatus.outStartX,
                   runStatus.outStartY
                  );
    #endif

        gDECODE_ctrl.frameCount++;

        if(status == OSA_SOK)
        {
            gDECODE_ctrl.inDataOffset += runStatus.bytesUsed;

            if(runStatus.outputBufId >= 0 && runStatus.outputBufId < gDECODE_ctrl.decBufNum)
            {
                DECODE_displayCopy(
                    gDECODE_ctrl.decBufVirtAddr[runStatus.outputBufId],
                    gDECODE_ctrl.decBufPhysAddr[runStatus.outputBufId],
                    &runStatus
                );
            }

            gDECODE_ctrl.curDecBufId = (gDECODE_ctrl.curDecBufId + 1) % (gDECODE_ctrl.decBufNum);
        }
    }while( gDECODE_ctrl.inDataOffset < inDataSize);

    return status;
}

over 15 years ago

0 Anshuman Saxena over 15 years ago

TI__Mastermind 19985 points

Hi,

Just to confirm, what is the version of encoder and decoder that you are using? Does the regular DVR application provided in the DVR Reference Design (uimain) work well for video playback?

Regards,

Anshuman

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

Hi,

We don't use the tvp5158, and I think that 'uimain' hardly runs on our EVM board without modifing.

I tried ALG_vidDecTestMain that provides by alg_vidDec.c still get same bad result.

I have been comparing the source code between us and udworks, but can't get any idea.

Or I missed the configuration for dvsdk, kernel or alg library?

Maybe I need a simple program that using the av_capture framework to decode 704x480@h264 correctly.

[our system information]

av_capture is grabbed from 1.0 udworks framework

dvsdk_2_10_01_18

linux-2.6.18_pro500

[encode and decode version]

I saw VIDENC1_xxx and VIDDEC2_xxx are used by alg_vidEnc and alg_vidDec.

How to check right version of codec?

0 Person Lin over 15 years ago in reply to Person Lin

Intellectual 610 points

[alg_server.cfg]

it is our layout of dvsdk directory.

0 Anshuman Saxena over 15 years ago in reply to Person Lin

TI__Mastermind 19985 points

Hi,

What is the displayDelay setting that you have done for H.264 Decoder Create time parameter?

Regards,

Anshuman

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

Hi,

pObj->h264Params.displayDelay = 0;

[It is the partial of source fromalg_vidDec.c]

void *ALG_vidDecCreate(ALG_VidDecCreate *create)
{
    ALG_VidDecObj *pObj;

    pObj = OSA_memAlloc(sizeof(*pObj));

    if(pObj == NULL)
        return NULL;

    memset(pObj, 0, sizeof(*pObj));

    memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));

    switch(create->codec)
    {
        case ALG_VID_CODEC_H264:
            strcpy(pObj->algName, ALG_VID_CODEC_H264_DEC_NAME);
            break;
        case ALG_VID_CODEC_MPEG4:
            strcpy(pObj->algName, ALG_VID_CODEC_MPEG4_DEC_NAME);
            break;
        case ALG_VID_CODEC_MJPEG:
        {
            ALG_JpgDecCreate jpgDecCreate;

            jpgDecCreate.dataFormat = create->dataFormat;
            jpgDecCreate.maxWidth = create->maxWidth;
            jpgDecCreate.maxHeight = create->maxHeight;

            pObj->hJpgDecode = ALG_jpgDecCreate(&jpgDecCreate);

            if(pObj->hJpgDecode == NULL)
                return NULL;

            return pObj;
        }
        break;
        default:
            OSA_memFree(pObj);
            return NULL;
    }

    pObj->params.size               = sizeof(VIDDEC2_Params);
    pObj->params.maxHeight          = create->maxHeight;
    pObj->params.maxWidth           = create->maxWidth;
    pObj->params.maxFrameRate       = 0;
    pObj->params.maxBitRate         = ALG_VID_DEC_MAX_BITRATE;
    pObj->params.dataEndianness     = XDM_BYTE;
    pObj->params.forceChromaFormat = 9;

    pObj->h264Params.displayDelay = 0;
    pObj->h264Params.hdvicpHandle = NULL;
// pObj->h264Params.resetHDVICPeveryFrame = TRUE;
    pObj->h264Params.disableHDVICPeveryFrame = 0;
    pObj->h264Params.viddecParams = pObj->params;
    pObj->h264Params.viddecParams.size = sizeof(pObj->h264Params);

    /* Create video decoder instance */
    pObj->hDecode = VIDDEC2_create(gALG_hEngine, pObj->algName, &pObj->h264Params);
    if (pObj->hDecode == NULL)
    {
        OSA_ERROR("Failed to open video decode algorithm (%s)\n", pObj->algName);
        OSA_memFree(pObj);
        return NULL;
    }

    return (void*)pObj;
}

Best Regards,

Person

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

I tried to change the displayDelay to 16.

It seems still gets same bad result. I am stuck.

0 Anshuman Saxena over 15 years ago in reply to Person Lin

TI__Mastermind 19985 points

Hi,

I have couple of recommendations for you:

1. Switch to ver 1.8 of DVR RDK. I have checked the alg_vidDec.c test code to ensure it works for the H.264 decoder.

2. Refer to the attached alg_vidDec.c file and build it in your application. I just built and used it and it works reliably. You can use "moduletest.out alg_vidDec" and try decoding D1 stream. You might have to port this file for your software package.

3. Share your stream with us and i can try decoding it in our setup, to ensure that the stream is fine.

Regards,

Anshuman

alg_vidDec.c

Fullscreen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <alg_priv.h>
#include <alg_vidDec.h>
#include <alg_jpgDec.h>
#include <osa_cmem.h>
#include <osa_file.h>
#include <drv_display.h>
#include <drv_frameCopy.h>
#include <ti/sdo/codecs/h264dec/ih264vdec.h>
//#define ALG_VID_DEC_DEBUG
//#define ALG_VID_DEC_TEST_DEBUG
#define ALG_VID_DEC_MAX_BITRATE (4*1024*1024)
typedef struct {
  VIDDEC2_Handle          hDecode;
  VIDDEC2_Status          decStatus;
  VIDDEC2_Params          params;
  VIDDEC2_DynamicParams   dynamicParams;
  IH264VDEC_Params    h264Params;
  char                    algName[20];
  
  ALG_VidDecCreate        createPrm;
  
  int curFrameNum;
  int outStartX;
  int outStartY;
  
  void *hJpgDecode;
  
} ALG_VidDecObj;
void *ALG_vidDecCreate(ALG_VidDecCreate *create)
{
  ALG_VidDecObj *pObj;   
  pObj = OSA_memAlloc(sizeof(*pObj));
  
  if(pObj==NULL)
    return NULL;
    
  memset(pObj, 0, sizeof(*pObj)); 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

#include <alg_priv.h>
#include <alg_vidDec.h>
#include <alg_jpgDec.h>
#include <osa_cmem.h>
#include <osa_file.h>
#include <drv_display.h>
#include <drv_frameCopy.h>
#include <ti/sdo/codecs/h264dec/ih264vdec.h>

//#define ALG_VID_DEC_DEBUG
//#define ALG_VID_DEC_TEST_DEBUG

#define ALG_VID_DEC_MAX_BITRATE (4*1024*1024)

typedef struct {

  VIDDEC2_Handle          hDecode;
  VIDDEC2_Status          decStatus;
  VIDDEC2_Params          params;
  VIDDEC2_DynamicParams   dynamicParams;
  IH264VDEC_Params    h264Params;
  char                    algName[20];
  
  ALG_VidDecCreate        createPrm;
  
  int curFrameNum;
  int outStartX;
  int outStartY;
  
  void *hJpgDecode;
  
} ALG_VidDecObj;

void *ALG_vidDecCreate(ALG_VidDecCreate *create)
{
  ALG_VidDecObj *pObj;   

  pObj = OSA_memAlloc(sizeof(*pObj));
  
  if(pObj==NULL)
    return NULL;
    
  memset(pObj, 0, sizeof(*pObj)); 

  memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));

  switch(create->codec)
  {
    case ALG_VID_CODEC_H264:
      strcpy(pObj->algName, ALG_VID_CODEC_H264_DEC_NAME);
      break;
    case ALG_VID_CODEC_MPEG4:
      strcpy(pObj->algName, ALG_VID_CODEC_MPEG4_DEC_NAME);
      break;
    case ALG_VID_CODEC_MJPEG:
    {
      ALG_JpgDecCreate jpgDecCreate;
    
      jpgDecCreate.dataFormat = create->dataFormat;
      jpgDecCreate.maxWidth = create->maxWidth;
      jpgDecCreate.maxHeight = create->maxHeight;
            
      pObj->hJpgDecode = ALG_jpgDecCreate(&jpgDecCreate);
      
      if(pObj->hJpgDecode==NULL)
        return NULL;
      
      return pObj;
    }    
      break;
    default:
      OSA_memFree(pObj);
      return NULL;
  }

    memcpy(&pObj->h264Params, &IH264VDEC_PARAMS, sizeof(pObj->h264Params));
    
  pObj->params.size               = sizeof(VIDDEC2_Params);
  pObj->params.maxHeight          = create->maxHeight;
  pObj->params.maxWidth           = create->maxWidth;
  pObj->params.maxFrameRate       = 0;
  pObj->params.maxBitRate         = ALG_VID_DEC_MAX_BITRATE;
  pObj->params.dataEndianness     = XDM_BYTE;
  pObj->params.forceChromaFormat  = 9;

  pObj->h264Params.displayDelay = 0;
  pObj->h264Params.hdvicpHandle = NULL;
//  pObj->h264Params.resetHDVICPeveryFrame = TRUE;
  pObj->h264Params.disableHDVICPeveryFrame = 0;
  pObj->h264Params.frame_closedloop_flag = 1;
  pObj->h264Params.inputDataMode = 1;
  pObj->h264Params.sliceFormat = 1;
  pObj->h264Params.viddecParams = pObj->params;
  pObj->h264Params.viddecParams.size = sizeof(pObj->h264Params);

  /* Create video decoder instance */
  pObj->hDecode = VIDDEC2_create(gALG_hEngine, pObj->algName, &pObj->h264Params);
  if (pObj->hDecode == NULL) {
    OSA_ERROR("Failed to open video decode algorithm (%s)\n", pObj->algName);
    OSA_memFree(pObj);
    return NULL; 
  }
  
  return (void*)pObj;
}

int ALG_vidDecRun(void *hndl, ALG_VidDecRunPrm *prm, ALG_VidDecRunStatus *runStatus)
{
  VIDDEC2_InArgs  inArgs;
  VIDDEC2_OutArgs outArgs;
  XDM1_BufDesc    inBufDesc;
  XDM_BufDesc     outBufDesc;
  XDAS_Int32      outBufSizeArray[2];
  XDAS_Int32      status;
  XDAS_Int8		    *outBufPtrs[2]; 
  ALG_VidDecObj   *pObj;
  IH264VDEC_DynamicParams h264DynParams;
  
  pObj = (ALG_VidDecObj *)hndl;
  if(pObj==NULL)
    return OSA_EFAIL;

  if(pObj->createPrm.codec == ALG_VID_CODEC_MJPEG) {
  
    ALG_JpgDecRunPrm jpgDecRun;
    ALG_JpgDecRunStatus jpgDecStatus;
    
    jpgDecRun.inAddr = prm->inAddr;
    jpgDecRun.inDataSize = prm->inDataSize;
    jpgDecRun.outAddr = prm->outAddr;    
    jpgDecRun.outOffsetH = prm->outOffsetH;    
    jpgDecRun.outOffsetV = prm->outOffsetV;                    
    jpgDecRun.outStartX = 0;
    jpgDecRun.outStartY = 0;    

    status = ALG_jpgDecRun(pObj->hJpgDecode, &jpgDecRun, &jpgDecStatus);
    if(status!=OSA_SOK)
      return OSA_EFAIL;
      
    runStatus->bytesUsed  = jpgDecStatus.bytesUsed; 
    runStatus->isKeyFrame = TRUE;
    runStatus->frameWidth = jpgDecStatus.frameWidth;
    runStatus->frameHeight= jpgDecStatus.frameHeight;
    runStatus->outputBufId= prm->inputBufId;
    runStatus->freeBufId  = prm->inputBufId; 
    runStatus->outStartX  = jpgDecRun.outStartX; 
    runStatus->outStartY  = jpgDecRun.outStartY; 
    runStatus->outOffsetH = jpgDecRun.outOffsetH;
    runStatus->outOffsetV = jpgDecRun.outOffsetV;
    
    return OSA_SOK;    
  }
  if(pObj->hDecode==NULL)
    return OSA_EFAIL;

  if(pObj->curFrameNum==0) 
  {
    pObj->dynamicParams.size          = sizeof(VIDDEC2_DynamicParams);
    pObj->dynamicParams.decodeHeader  = XDM_DECODE_AU;
    pObj->dynamicParams.displayWidth  = prm->outOffsetH;
    pObj->dynamicParams.frameSkipMode = IVIDEO_NO_SKIP;
    pObj->dynamicParams.frameOrder    = IVIDDEC2_DECODE_ORDER;

    pObj->decStatus.size     = sizeof(VIDDEC2_Status);
    pObj->decStatus.data.buf = NULL;
    h264DynParams.viddecDynamicParams = pObj->dynamicParams;
    h264DynParams.viddecDynamicParams.size = sizeof(h264DynParams);
    h264DynParams.resetHDVICPeveryFrame = 1;
    h264DynParams.dataSyncHandle = NULL;
    h264DynParams.getDataFxn = NULL;    
        
    status = VIDDEC2_control(pObj->hDecode, XDM_SETPARAMS, &h264DynParams, &pObj->decStatus);
    if (status != VIDDEC2_EOK) {
      OSA_ERROR("XDM_SETPARAMS failed, status=%ld\n", status);
      return OSA_EFAIL;
    }

    /* Get buffer information from video decoder */
    pObj->decStatus.size     = sizeof(VIDDEC2_Status);
    pObj->decStatus.data.buf = NULL;
    
    pObj->dynamicParams.size = sizeof(VIDDEC2_DynamicParams);
    status = VIDDEC2_control(pObj->hDecode, XDM_GETBUFINFO, &pObj->dynamicParams, &pObj->decStatus);
    if (status != VIDDEC2_EOK) {
      OSA_ERROR("XDM_GETBUFINFO failed, status=%ld\n", status);
      return OSA_EFAIL;
    }
   
    #ifdef ALG_VID_DEC_DEBUG
    OSA_printf(" ALG: VidDec: XDM_GETBUFINFO: min out bufs:%ld,size:%ld %ld\n",pObj->decStatus.bufInfo.minNumOutBufs,pObj->decStatus.bufInfo.minOutBufSize[0], pObj->decStatus.bufInfo.minOutBufSize[1]);
    #endif
  } 
 
  pObj->dynamicParams.size      = sizeof(VIDDEC2_DynamicParams);
  
  pObj->decStatus.size          = sizeof(VIDDEC2_Status);
  pObj->decStatus.data.buf      = NULL;

  outBufSizeArray[0] = (prm->outOffsetH)*(prm->outOffsetV);  
  outBufSizeArray[1] = outBufSizeArray[0]/2;

  inBufDesc.descs[0].bufSize = prm->inDataSize;
  inBufDesc.descs[0].buf  = (XDAS_Int8 *)prm->inAddr;
  inBufDesc.numBufs       = 1;

  outBufPtrs[0] = (XDAS_Int8 *)prm->outAddr; 
  outBufPtrs[1] = (XDAS_Int8 *)(prm->outAddr + outBufSizeArray[0]) ; 

  outBufDesc.bufSizes     = outBufSizeArray;
  outBufDesc.bufs         = (XDAS_Int8 **) &outBufPtrs;
  outBufDesc.numBufs      = 2;

  inArgs.size             = sizeof(VIDDEC2_InArgs);
  inArgs.numBytes         = prm->inDataSize;
  inArgs.inputID          = prm->inputBufId+1; // must be greater than 0
  outArgs.size            = sizeof(VIDDEC2_OutArgs);
  outArgs.outBufsInUseFlag=0;   
  status = VIDDEC2_process(pObj->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs);

  status = VIDDEC2_control(pObj->hDecode, XDM_GETSTATUS, &pObj->dynamicParams, &pObj->decStatus);
  if (status != VIDDEC2_EOK) {
    OSA_ERROR("XDM_GETSTATUS failed, status=%ld\n", status);
    return OSA_EFAIL;
  }

  runStatus->bytesUsed = outArgs.bytesConsumed;

  if (status != VIDDEC2_EOK) {
    OSA_ERROR("status=%ld\n", status);
    return OSA_EFAIL;
  }

  switch (outArgs.displayBufs[0].frameType) {
    case IVIDEO_I_FRAME:
      runStatus->isKeyFrame = TRUE;
      break;
    case IVIDEO_P_FRAME:
      runStatus->isKeyFrame = FALSE;
      break;
    case IVIDEO_B_FRAME:
      runStatus->isKeyFrame = FALSE;
      break;
    case IVIDEO_IDR_FRAME:
      runStatus->isKeyFrame = TRUE;
      break;
    case IVIDEO_II_FRAME:
      runStatus->isKeyFrame = TRUE;
      break;  
    case IVIDEO_PP_FRAME:
      runStatus->isKeyFrame = FALSE;
      break;      
    default:  
      runStatus->isKeyFrame = FALSE;
      break;
  }

  runStatus->frameWidth = pObj->decStatus.outputWidth;
  runStatus->frameHeight = pObj->decStatus.outputHeight;

if(outArgs.outBufsInUseFlag == 1)
{
  inBufDesc.descs[0].buf  = (XDAS_Int8 *)prm->inAddr + runStatus->bytesUsed;

  status = VIDDEC2_process(pObj->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs);

  runStatus->bytesUsed += outArgs.bytesConsumed;
  if (status != VIDDEC2_EOK) {
    OSA_ERROR("status=%ld\n", status);
//    return OSA_EFAIL;
  }

    VIDDEC2_control(pObj->hDecode, XDM_GETSTATUS, &pObj->dynamicParams, &pObj->decStatus);
  if (status != VIDDEC2_EOK) {
    OSA_ERROR("XDM_GETSTATUS failed with error code = 0x%x , status=%ld\n", pObj->decStatus.extendedError,status);
//    OSA_fileWriteFile("InputBitstream.dat", (XDAS_Int8 *)prm->inAddr, prm->inDataSize);
    OSA_printf("\r\n Bytes Consumed so far = %d ",runStatus->bytesUsed);
    return OSA_EFAIL;
  }
}
  if(outArgs.displayBufs[0].bufDesc[0].buf == NULL) {
      return OSA_EFAIL;
  }
  else {
    runStatus->outputBufId = outArgs.outputID[0]-1; // to adjust for +1 done in inputID  
    runStatus->freeBufId = outArgs.freeBufID[0]-1;

    if(pObj->curFrameNum==0) {
      pObj->outStartY = ((Uint32)outArgs.displayBufs[0].bufDesc[0].buf - (Uint32)prm->outAddr)/prm->outOffsetH;
      pObj->outStartX = ((Uint32)outArgs.displayBufs[0].bufDesc[0].buf - (Uint32)prm->outAddr)%prm->outOffsetH;    
    }
    runStatus->outStartX = pObj->outStartX;
    runStatus->outStartY = pObj->outStartY;    
    runStatus->outOffsetH= prm->outOffsetH;
    runStatus->outOffsetV= prm->outOffsetV;    
  }  
  
  pObj->curFrameNum++;  
  
  return OSA_SOK;
}

int ALG_vidDecDelete(void *hndl)
{
  ALG_VidDecObj *pObj;
  
  pObj = (ALG_VidDecObj *)hndl;
  
  if(pObj==NULL)
    return OSA_EFAIL;
    
  if(pObj->createPrm.codec == ALG_VID_CODEC_MJPEG) {
  
    ALG_jpgDecDelete(pObj->hJpgDecode);
  
  } else {
    
    if(pObj->hDecode==NULL)
      return OSA_EFAIL;
      
    VIDDEC2_delete(pObj->hDecode);
  }

  OSA_memFree(pObj);
  
  return OSA_SOK;
}


static DRV_DisplayWinHndl gDRV_displayHndl;
static DRV_DisplayBufInfo gDRV_displayInfo;
static int                gDRV_displayBufId;

static int ALG_vidDecTestDisplayCreate() {

  DRV_DisplayWinConfig  displayConfig;
  int status;
  
  displayConfig.winId       = DRV_DISPLAY_VID_WIN_0;
  displayConfig.numBuf      = 3;
  displayConfig.dataFormat  = DRV_DATA_FORMAT_YUV420;
  displayConfig.startX      = 0;
  displayConfig.startY      = 0;
  displayConfig.width       = 720;
  displayConfig.height      = 480;
  displayConfig.offsetH     = OSA_align(displayConfig.width, 32);
  displayConfig.offsetV     = displayConfig.height;
  displayConfig.zoomH       = 0;  
  displayConfig.zoomV       = 0;

  gDRV_displayBufId=0;
  
  OSA_printf(" ALG: VidDec: Opening display.\n");  
  
  status = DRV_displaySetMode(DRV_DISPLAY_MODE_NTSC);
  if(status!=OSA_SOK)
    goto error_exit;

  status = DRV_displayOpen(&gDRV_displayHndl, &displayConfig);
  if(status!=OSA_SOK)
    goto error_exit;

  DRV_displayOsdWinEnable(&gDRV_displayHndl, 0, FALSE);

  DRV_displayGetBufInfo(&gDRV_displayHndl, &gDRV_displayInfo);    
  
error_exit:
  if(status!=OSA_SOK)
    OSA_ERROR("Display Init!!!\n");
    
  return status;  
}

static int ALG_vidDecTestDisplayCopy(Uint8 *outVirtAddr, Uint8 *outPhysAddr, ALG_VidDecRunStatus *vidDecStatus) {

  int status;
  DRV_FrameCopyPrm frameCopy;
  
  frameCopy.srcPhysAddr = outPhysAddr;
  frameCopy.srcVirtAddr = outVirtAddr;
  frameCopy.dstPhysAddr = gDRV_displayInfo.physAddr[gDRV_displayBufId];
  frameCopy.dstVirtAddr = gDRV_displayInfo.virtAddr[gDRV_displayBufId];
  frameCopy.srcOffsetH  = vidDecStatus->outOffsetH;
  frameCopy.srcOffsetV  = vidDecStatus->outOffsetV;
  frameCopy.dstOffsetH  = gDRV_displayInfo.offsetH;
  frameCopy.dstOffsetV  = gDRV_displayInfo.offsetV;
  frameCopy.copyWidth   = vidDecStatus->frameWidth;
  frameCopy.copyHeight  = vidDecStatus->frameHeight;
  frameCopy.dataFormat  = gDRV_displayInfo.dataFormat;
  frameCopy.srcStartX   = vidDecStatus->outStartX;
  frameCopy.srcStartY   = vidDecStatus->outStartY;
  frameCopy.dstStartX   = 0;
  frameCopy.dstStartY   = 0;
    
  status = DRV_frameCopy(NULL, &frameCopy);
  if(status!=OSA_SOK) {
    OSA_ERROR("DRV_frameCopy(A)\n");
  }

  DRV_displaySwitchBuf( &gDRV_displayHndl, &gDRV_displayBufId);
  
  return status;
}

static int ALG_vidDecTestDisplayDelete() {

  DRV_displayOsdWinEnable(&gDRV_displayHndl, 0, TRUE);
  DRV_displayClose(&gDRV_displayHndl);
  
  return OSA_SOK;
}

int ALG_vidDecTestMain(int argc, char **argv)
{
  int status, bufId, count, whOffset, frameWidth, frameHeight;
  Uint8 *inVirtAddr=NULL, *inPhysAddr, *outVirtAddr[2], *outPhysAddr[2], *curInAddr;
  OSA_PrfHndl prfVidDec;
  Uint32 size=10*MB, fileSize, totalDecSize;
  void *algVidDecHndl;
  ALG_VidDecCreate createPrm;
  ALG_VidDecRunPrm runPrm;
  ALG_VidDecRunStatus runStatus;
  char filename[100];
  int runCount=0;

  if(argc>0) {      
    status = DRV_init();
    if(status!=OSA_SOK) {
      OSA_ERROR("DRV_init()\n");
      return status;
    }
  
    status = ALG_sysInit();
    if(status!=OSA_SOK)  {
      DRV_exit();
      return status;
    }
  }
  
  strcpy(filename, "test.264");
  frameWidth = 720;
  frameHeight = 480;
  
  if(argc > 2) {
    strcpy(filename, argv[2]);
    
    if(argc>3)
      frameWidth = atoi(argv[3]);
      
    if(argc>4)
      frameHeight = atoi(argv[4]);
  }
  
  if(frameWidth==0||frameHeight==0) {
    OSA_ERROR("Illegal parameters!!!\n");
  }
  
  inVirtAddr     = OSA_cmemAlloc(size, 32); 
  outVirtAddr[0] = OSA_cmemAlloc(2*MB, 32);
  outVirtAddr[1] = OSA_cmemAlloc(2*MB, 32);  
  
  inPhysAddr     = OSA_cmemGetPhysAddr(inVirtAddr);
  outPhysAddr[0] = OSA_cmemGetPhysAddr(outVirtAddr[0]);
  outPhysAddr[1] = OSA_cmemGetPhysAddr(outVirtAddr[1]);      
  
  memset(outVirtAddr[0], 0xFF, 2*MB);
  memset(outVirtAddr[1], 0xFF, 2*MB);  
  
  if(   inVirtAddr==NULL || outVirtAddr[0] == NULL || outVirtAddr[1] == NULL  
     || inPhysAddr==NULL || outPhysAddr[0] == NULL || outPhysAddr[1] == NULL 
    ) {
    OSA_ERROR("OSA_cmemAlloc()\n");  
    goto error_exit;
  }
  
  status = OSA_fileReadFile(filename, inVirtAddr, size,0, &fileSize);
  if(status!=OSA_SOK) {
    OSA_ERROR("OSA_fileReadFile()\n");    
    goto error_exit;
  }

test_again:
  OSA_prfReset(&prfVidDec);

  createPrm.codec           = ALG_VID_CODEC_H264;          
  createPrm.dataFormat      = DRV_DATA_FORMAT_YUV420;     
  createPrm.maxWidth        = frameWidth;          
  createPrm.maxHeight       = frameHeight;         

  algVidDecHndl = ALG_vidDecCreate(&createPrm);
  if(algVidDecHndl==NULL) {
    OSA_ERROR("ALG_vidDecCreate()\n");
    goto error_exit;
  }
    
  curInAddr = inVirtAddr;
  totalDecSize = 0;
  bufId=0;
  count=0;

  ALG_vidDecTestDisplayCreate();

  whOffset = 0;
  if(createPrm.codec==ALG_VID_CODEC_H264)
    whOffset = 96;
    
  OSA_printf(" ALG: VidDec: Decode in progress!!!\n");

  while(totalDecSize < fileSize) {  

    runPrm.inAddr         = curInAddr;        
    runPrm.outAddr        = outVirtAddr[bufId];       
    runPrm.inDataSize     = 100*KB;
    runPrm.outOffsetH     = OSA_align(createPrm.maxWidth+whOffset, 32);
    runPrm.outOffsetV     = createPrm.maxHeight+whOffset;
    runPrm.inputBufId     = bufId;
      
    OSA_prfBegin(&prfVidDec);  
    status = ALG_vidDecRun(algVidDecHndl, &runPrm, &runStatus);
    OSA_prfEnd(&prfVidDec, 1);        
    
    #ifdef ALG_VID_DEC_TEST_DEBUG
    OSA_printf(" ALG: VidDec: %ld:%ld:%ld:%dx%d:%ld: %ld bytes (%ld, %ld)\n", 
          runStatus.freeBufId,
          runPrm.inputBufId,   
          runStatus.outputBufId, 
          runStatus.frameWidth, runStatus.frameHeight, 
          runStatus.isKeyFrame,
          runStatus.bytesUsed,
          runStatus.outStartX,
          runStatus.outStartY        
          );
    #endif
    
    if(status==OSA_SOK) {
      //runStatus.bytesUsed += 3;
      curInAddr += runStatus.bytesUsed; 
      totalDecSize += runStatus.bytesUsed;
    } else {
      OSA_printf(" ALG: VidDec: ALG_vidDecRun() ERROR !!!\n");
      break;
    }
    
    ALG_vidDecTestDisplayCopy(
            outVirtAddr[runStatus.outputBufId], 
            outPhysAddr[runStatus.outputBufId],
            &runStatus
            );
    
    bufId ^= 1;
    count++;
    if(count>1000)
      break;
  }
  
  OSA_printf(" ALG: VidDec: Decode DONE!!!\n");  
  
  ALG_vidDecTestDisplayDelete();
  
  ALG_vidDecDelete(algVidDecHndl);
  
  OSA_prfPrint(&prfVidDec, "VID DEC", 0);   
  
  runCount++;
  #if 0
  if(runCount<10)
    goto test_again;
  #endif
    
error_exit:
  if(inVirtAddr)  
    OSA_cmemFree(inVirtAddr);

  if(outVirtAddr[0])  
    OSA_cmemFree(outVirtAddr[0]);

  if(outVirtAddr[1])  
    OSA_cmemFree(outVirtAddr[1]);

  if(argc>0) {
    ALG_sysExit();
    DRV_exit();
  }
  return status;
}

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

Hi,

I will try your suggestion.

The file is too big. How to send it for you.

file size:2.40 MB

0 Anshuman Saxena over 15 years ago in reply to Person Lin

TI__Mastermind 19985 points

You can attach it to the forum post itself.

Regards,

Anshuman

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

Hi,

I don't know how to attach the file. The image is ok, but the bistream file is not.

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

I tried the moduletest.out of DVRRDK_v1.0 and get result as following.

[result]

root@192.168.4.13:/dvr# ./moduletest.out alg_vidDec
csl initialize
vpss initialize

CLK Hz,
ARM Hz = 297000000
DDR Hz = 243000000
VPSS Hz = 243000000
IMCOP Hz = 243000000

cmem initialize
DavinciDisplay DavinciDisplay.1: Before finishing with S_FMT:
layer.pix_fmt.bytesperline = 736,
layer.pix_fmt.width = 720,
layer.pix_fmt.height = 480,
layer.pix_fmt.sizeimage =529920
[OSA_FILE ] ReaDavinciDisplay DavinciDisplay.1: pixfmt->width = 720,
layer->layer_info.config.line_length= 736
ding file [test.264] ... Done. [2522727 bytes]
ALG: VidDec: Opening display.
ALG: VidDec: Decode in progress!!!
ALG: VidDec: 0:0:-1:0x0:0: 115 bytes (436, 5147664)
ERROR (drv_frameCopy.c|DRV_frameCopy|59): Invalid Parameters!!!
ERROR (alg_vidDec.c|ALG_vidDecTestDisplayCopy|390): DRV_frameCopy(A)
ALG: VidDec: 1:1:-1:0x0:0: 6 bytes (436, 5147664)
ERROR (drv_frameCopy.c|DRV_frameCopy|59): Invalid Parameters!!!
ERROR (alg_vidDec.c|ALG_vidDecTestDisplayCopy|390): DRV_frameCopy(A)
ALG: VidDec: 0:0:-1:0x0:0: 10372 bytes (436, 5147664)
ERROR (drv_frameCopy.c|DRV_frameCopy|59): Invalid Parameters!!!
ERROR (alg_vidDec.c|ALG_vidDecTestDisplayCopy|390): DRV_frameCopy(A)
ALG: VidDec: 1:1:-1:0x0:0: 6 bytes (436, 5147664)
ERROR (drv_frameCopy.c|DRV_frameCopy|59): Invalid Parameters!!!
ERROR (alg_vidDec.c|ALG_vidDecTestDisplayCopy|390): DRV_frameCopy(A)

I get more errors with DVRRDK_v1.8, and I think that need more modifies for my enviroment.

[result]

root@192.168.4.13:/dvr# ./moduletest.out alg_vidDec
CMEMK Error: Failed to find a pool which fits 28672

CLK Hz,
ARMCMEMK Error: get_phys: Unable to find phys addr for 0x00000000
Hz = 2970000CMEMK Error: get_phys: get_user_pages() failed: -14
00
DDR Hz = CMEMK Error: GETPHYS: Failed to convert virtual 0x0 to physical.
243000000
VPSCMEMK Error: get_phys: Unable to find phys addr for 0x00000000
S Hz = 2430000CMEMK Error: get_phys: get_user_pages() failed: -14
00
IMCOP Hz = CMEMK Error: FREE: Failed to convert virtual 0x0 to physical
243000000

CMEM Error: getPool: Failed to get a pool fitting a size 28672
CMEM Error: getPhys: Failed to get physical address of 0
CMEM Error: free: failed to free 0
ERROR (alg.c|ALG_sysInit|41): VICP Protocol regn failed

0 Person Lin over 15 years ago in reply to Anshuman Saxena

Intellectual 610 points

Hi,

It works. I have a mistak.

To change the legacy dvsdk to udworks one.

Thank you very much!!

0 sunny chen over 15 years ago in reply to Anshuman Saxena

Prodigy 10 points

Hello, I use your attached "alg_vidDec.c"file to decode h.264 file,that recorded by dm365,it's ok. but,if I to decode other h.264 avi file ,that converted by other software ,It's only can decode 8MB,then no respone. died. why? An other question is alg_vidDec.c 's line 219 to line 232: ------------------------------ status = VIDDEC2_process(pObj->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs); status = VIDDEC2_control(pObj->hDecode, XDM_GETSTATUS, &pObj->dynamicParams, &pObj->decStatus); if (status != VIDDEC2_EOK) { OSA_ERROR("XDM_GETSTATUS failed, status=%ld\n", status); return OSA_EFAIL; } runStatus->bytesUsed = outArgs.bytesConsumed; if (status != VIDDEC2_EOK) { OSA_ERROR("status=%ld\n", status); return OSA_EFAIL; } ----------------------------- I think the code is error,so I modify to : ------------------- status = VIDDEC2_process(pObj->hDecode, &inBufDesc, &outBufDesc, &inArgs, &outArgs); if (status != VIDDEC2_EOK) { OSA_ERROR("status=%ld\n", status); return OSA_EFAIL; } status = VIDDEC2_control(pObj->hDecode, XDM_GETSTATUS, &pObj->dynamicParams, &pObj->decStatus); if (status != VIDDEC2_EOK) { OSA_ERROR("XDM_GETSTATUS failed, status=%ld\n", status); return OSA_EFAIL; } runStatus->bytesUsed = outArgs.bytesConsumed; -------------------- It's run error. why? Sunny

Processors

Processors forum

Alg_vidDec doesn't work (urgent)