h264dec.c

This the source release kit for the following system configuration(s): - AMD Alchemy(TM) DBAu1200(

        DP_API((M_TEXT("DIUGetBuffer() pass DATADISCON\n")));
        *flags |= DIU_FLAG_DATADISCON;
      }
      pPInfo->m_inbuf.size -= BytesRead;
      pPInfo->m_inbuf.pbuf += BytesRead;
    }
    if (error == DIU_STATUS_OK)
    {
      //decode successful but still have data left
    } else if (error == DIU_STATUS_NEEDMOREINPUT)
    {
      //we need more input
      pPInfo->m_inbuf.size = 0;
    } else
    {
      DP_ERROR((M_TEXT("DIUGetBuffer do_process_input error %d\n"), error));
      pPInfo->m_inbuf.size = 0;
    }
  } else
  {
    //no input to process
    *size = 0;
    error = DIU_STATUS_NEEDMOREINPUT;
  }

  DP_API((M_TEXT("DIUGetBuffer done status %d\n"), error));
  return error;
}

STATIC_FUNC int DIUPutBuffer(DIUCompHandle_t hComp, unsigned char *pbuf, unsigned int size, LONGLONG pts, unsigned int flags, unsigned int dmoflags)
{
  ProcessorInfo_t *pPInfo = (ProcessorInfo_t *)DIUHCOMP_TO_USERINFO(hComp);
  int error = DIU_STATUS_OK;

  if (g_bH264DecOpened==FALSE)
  {
    DP_INFO((M_TEXT("DIUPutBuffer() init h264dec\n")));
    error = open_h264dec(hComp);
    if (error)
    {
      DP_ERROR((M_TEXT("DIUPutBuffer() failed init, exit\n")));
      return DIU_STATUS_ERROR;
    }
  }
  
  if (!pPInfo->m_inbuf.size && (flags&DIU_FLAG_FRAMEEND)!=0)
  {
    pPInfo->m_inbuf.dmoflags = dmoflags;
    pPInfo->m_inbuf.flags = flags;
    pPInfo->m_inbuf.pts = pts;
    pPInfo->m_inbuf.pbuf = pbuf;
    pPInfo->m_inbuf.size = size;
    DP_INFO((M_TEXT("DIUPutBuffer FRAMEEND size(%d), pts(%d)\n"), size, pts));
    return DIU_STATUS_OK;
  } 

  else
  {
    if (pPInfo->m_inbuf.size + size > pPInfo->m_nlocalbuf)
    {
      DP_ERROR((M_TEXT("DIUPutBuffer ERROR! frame size(%d) is larger than local buffer(%d)\n"), pPInfo->m_inbuf.size + size, pPInfo->m_nlocalbuf));
      return DIU_STATUS_ERROR;
    }

    if (pPInfo->m_inbuf.size == 0)
    {
      pPInfo->m_inbuf.pbuf = pPInfo->m_plocalbuf;
      pPInfo->m_inbuf.dmoflags = dmoflags;
      pPInfo->m_inbuf.flags = flags;
      pPInfo->m_inbuf.pts = pts;
    }

    MEMCPY(pPInfo->m_inbuf.pbuf+pPInfo->m_inbuf.size, pbuf, size);
    pPInfo->m_inbuf.flags |= flags;
    pPInfo->m_inbuf.size += size;

    if ((flags&DIU_FLAG_FRAMEEND)!=0)
      pPInfo->m_inbuf.size;

    DP_INFO((M_TEXT("DIUPutBuffer PARTIAL FRAME size(%d), total(%d), pts(%d)\n"), size, pPInfo->m_inbuf.size, pPInfo->m_inbuf.pts));
    return DIU_STATUS_OK;
  }
  
  return DIU_STATUS_ERROR;
}

STATIC_FUNC int DIUCompEnd(DIUCompHandle_t hComp)
{
  int eStatus = DIU_STATUS_OK;
  DP_API((M_TEXT("DIUCompEnd() enter\n")));

  close_h264dec(hComp);
  DP_API((M_TEXT("DIUCompEnd() exit: status=0x%X\n"), eStatus));
  return eStatus;
}

STATIC_FUNC int DIU_Empty(DIUCompHandle_t hComp)
{
  ProcessorInfo_t *pPInfo=(ProcessorInfo_t *)DIUHCOMP_TO_USERINFO(hComp);
  DP_H264((M_TEXT("DIU_Empty called")));
  
  // Issue a reset to the decoder so that it can flush out all its data
  Flush_Decoder(pPInfo);
  pPInfo->m_inbuf.size = 0;
  
  //Flush MAE
  request_mae_flush();

  return DIU_STATUS_OK;
}

STATIC_FUNC int DIU_UpdateSync(DIUCompHandle_t hComp, DWORD msTime)
{
  ProcessorInfo_t *pPInfo=(ProcessorInfo_t *)DIUHCOMP_TO_USERINFO(hComp);
  check_sync(pPInfo, msTime);
  return DIU_STATUS_OK;
}

static DIUCompHandleInfo_t _CompTemplate =
{
  /* CompInfo #1 - H264 Video Decoder */  
  DECLARE_DIUCOMPINFO(
    /* _eType */ DIUCOMP_TYPE_DECODE | DIUCOMP_TYPE_VIDEO,
    /* _uiCompVer */ 0x0001,
    /* _uiBuildVer */ DIUBUILD_VERSION,
    /* _GUID */ DIUCOMP_GUID(0x00, 0x10, 0xef, 0x00, 0x00, 0x00, 0x00, 0x28),
    /* _pszName */ "H264DEC", /* _pszDesc */ "AVC1 Video Decoder",
    /* _uiMaxInputs */ 1, /* _MaxOutputs */ 1,
    /* _MaxInstances */ 1,
    /* _uiFlags */ 0
  ),
  /* CompHandle fields */
  DIUCompEnd,             /* pfCompEnd_t         pfEnd */
  DIUGetBuffer,
  DIU_Empty,
  DIUPutBuffer,
  DIU_UpdateSync
};
    
//remove the defines from av_malloc and av_free
#undef malloc
#undef free

int CreateHandle(DIUCompHandleInfo_t *pCompInfo, unsigned int uiSizeOfPrivateInfo, DIUCompHandle_t *phCompOut)
{
  int eResult = DIU_STATUS_OK;
  DIUPrivateCompHandleInfo_t *pPrivCompInfo=M_NULL;
  unsigned int uiHandleSize=sizeof(DIUPrivateCompHandleInfo_t)+uiSizeOfPrivateInfo;
  unsigned char *pucInfoMem = (unsigned char *)malloc(uiHandleSize);

  if (pucInfoMem)
  {
    DIUCompBaseHandleInfo_t *pInfo;
    memset(pucInfoMem, 0, uiHandleSize);
    pPrivCompInfo = (DIUPrivateCompHandleInfo_t *)pucInfoMem;
    pInfo = &pPrivCompInfo->m_CompBaseInfo;
    pPrivCompInfo->m_pUserInfo = pucInfoMem+sizeof(DIUPrivateCompHandleInfo_t);
    
    // copy component info from template
    MEMCPY(&(pPrivCompInfo->m_CompInfo), pCompInfo, sizeof(DIUCompHandleInfo_t));
    
    // return handle
    *phCompOut = (DIUCompHandle_t)pPrivCompInfo;
  }
  else
    eResult = DIU_STATUS_MEMORY;

  DP_API((M_TEXT("CreateHandle() done: hComp=%p\n"), pPrivCompInfo));
  return eResult;
}

int CompCreate(unsigned char *pucGUID, unsigned int uiSizeOfPrivateInfo, DIUCompHandle_t *phCompOut)
{
  int eResult = DIU_STATUS_ERROR;
  DIUCompHandleInfo_t *pTemplate = NULL;

  if (!pucGUID) // NULL - just select first comp in this library
    pTemplate = &_CompTemplate;
  else // search for comp matching GUID
  {
    if (memcmp(pucGUID, _CompTemplate.Info.GUID, 8)==0)
    {
      // found matching GUID
      pTemplate = &_CompTemplate;
    }
  }

  if (pTemplate)
    eResult = CreateHandle(pTemplate, uiSizeOfPrivateInfo, phCompOut);

  DP_API((M_TEXT("CompCreate() done: hComp=%p\n"), *phCompOut));
  return eResult;
}

int CompRelease(DIUCompHandle_t hComp)
{
  DIUCompBaseHandleInfo_t *pCompInfo = &((DIUPrivateCompHandleInfo_t *)hComp)->m_CompBaseInfo;
  DP_API((M_TEXT("CompRelease(%p) \n"), hComp));

  if (pCompInfo)
  {
    free(hComp);
    return DIU_STATUS_OK;
  }
  else
    return DIU_STATUS_ERROR;
}

/* DIUCompCreate - create an instance of a specific component */
PUBLIC_EXTERN int DIUCompCreate(unsigned char *pucGUID, DIUCompHandle_t *phCompOut)
{
  int eStatus;
  DIUCompHandle_t hComp = M_HANDLE_INVALID;
  eStatus = CompCreate(pucGUID, sizeof(ProcessorInfo_t), &hComp);
  if (eStatus == DIU_STATUS_OK)
  {
    /* init private component info */
    ProcessorInfo_t *pPInfo=(ProcessorInfo_t *)DIUHCOMP_TO_USERINFO(hComp);

    pPInfo->m_uiFrameCount=0;
    pPInfo->m_bDecoderInit = FALSE;
    pPInfo->m_plocalbuf = malloc(MAX_FRAME_SIZE);
    pPInfo->m_nlocalbuf = MAX_FRAME_SIZE;
    pPInfo->m_inbuf.size = 0;

    // return handle
    *phCompOut = (DIUCompHandle_t)hComp;
  }
  return eStatus;
}

/* DIUCompRelease - release an instance of a specific component */
PUBLIC_EXTERN int DIUCompRelease(DIUCompHandle_t hComp)
{
  int eStatus;
  if (hComp!=M_HANDLE_INVALID)
  {
    ProcessorInfo_t *pPInfo=(ProcessorInfo_t *)DIUHCOMP_TO_USERINFO(hComp);
    free(pPInfo->m_plocalbuf);
    pPInfo->m_plocalbuf = M_NULL;
    pPInfo->m_nlocalbuf = 0;
    pPInfo->m_inbuf.size = 0;

    // call base release
    eStatus = CompRelease(hComp);
  }
  else
    eStatus = DIU_STATUS_ERROR;

  return eStatus;
}