#include <gtest/gtest.h>#include "codec_def.h"#include "utils/BufferedData.h"#include "utils/FileInputStream.h"#include "BaseDecoderTest.h"#include "BaseEncoderTest.h"#include "wels_common_defs.h"#include "utils/HashFunctions.h"#include <string>#include <vector>#include "encode_decode_api_test.h"using namespace WelsCommon;  void EncodeDecodeTestBase::prepareParam (int iLayers, int iSlices, int width, int height, float framerate, SEncParamExt* pParam) {    pParam->iUsageType = CAMERA_VIDEO_REAL_TIME;    pParam->iPicWidth = width;    pParam->iPicHeight = height;    pParam->fMaxFrameRate = framerate;    pParam->iRCMode = RC_OFF_MODE; //rc off    pParam->iMultipleThreadIdc = 1; //single thread    pParam->iSpatialLayerNum = iLayers;    pParam->iNumRefFrame = AUTO_REF_PIC_COUNT;    for (int i = 0; i < iLayers; i++) {      pParam->sSpatialLayers[i].iVideoWidth = width >> (iLayers - i - 1);      pParam->sSpatialLayers[i].iVideoHeight = height >> (iLayers - i - 1);      pParam->sSpatialLayers[i].fFrameRate = framerate;      pParam->sSpatialLayers[i].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;      pParam->sSpatialLayers[i].sSliceArgument.uiSliceNum = iSlices;    }} void EncodeDecodeTestBase::prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam) {    //for encoder    //I420: 1(Y) + 1/4(U) + 1/4(V)    int frameSize = EncDecFileParam.width * EncDecFileParam.height * 3 / 2;    buf_.SetLength (frameSize);    ASSERT_TRUE (buf_.Length() == (size_t)frameSize);    memset (&EncPic, 0, sizeof (SSourcePicture));    EncPic.iPicWidth = EncDecFileParam.width;    EncPic.iPicHeight = EncDecFileParam.height;    EncPic.iColorFormat = videoFormatI420;    EncPic.iStride[0] = EncPic.iPicWidth;    EncPic.iStride[1] = EncPic.iStride[2] = EncPic.iPicWidth >> 1;    EncPic.pData[0] = buf_.data();    EncPic.pData[1] = EncPic.pData[0] + EncDecFileParam.width * EncDecFileParam.height;    EncPic.pData[2] = EncPic.pData[1] + (EncDecFileParam.width * EncDecFileParam.height >> 2);    //for decoder    memset (&info, 0, sizeof (SFrameBSInfo));    //set a fixed random value    iRandValue = rand() % 256;} void EncodeDecodeTestBase::encToDecData (const SFrameBSInfo& info, int& len) {    len = 0;    for (int i = 0; i < info.iLayerNum; ++i) {      const SLayerBSInfo& layerInfo = info.sLayerInfo[i];      for (int j = 0; j < layerInfo.iNalCount; ++j) {        len += layerInfo.pNalLengthInByte[j];      }    }} void EncodeDecodeTestBase::encToDecSliceData (const int iLayerNum, const int iSliceNum, const SFrameBSInfo& info, int& len) {    ASSERT_TRUE (iLayerNum < MAX_LAYER_NUM_OF_FRAME);    len = 0;    const SLayerBSInfo& layerInfo = info.sLayerInfo[iLayerNum];    if (iSliceNum < layerInfo.iNalCount)      len = layerInfo.pNalLengthInByte[iSliceNum];} void EncodeDecodeTestAPIBase::prepareParam0 (int iLayers, int iSlices, int width, int height, float framerate, SEncParamExt* pParam) {    memset (pParam, 0, sizeof (SEncParamExt));    EncodeDecodeTestBase::prepareParam (iLayers, iSlices, width, height, framerate, pParam);} void EncodeDecodeTestAPIBase::prepareParamDefault (int iLayers, int iSlices, int width, int height, float framerate, SEncParamExt* pParam) {    memset (pParam, 0, sizeof (SEncParamExt));    encoder_->GetDefaultParams (pParam);    EncodeDecodeTestBase::prepareParam (iLayers, iSlices, width, height, framerate, pParam);}  void EncodeDecodeTestAPIBase::EncodeOneFrame (int iCheckTypeIndex) {    int frameSize = EncPic.iPicWidth * EncPic.iPicHeight * 3 / 2;    memset (buf_.data(), iRandValue, (frameSize >> 2));    memset (buf_.data() + (frameSize >> 2), rand() % 256, (frameSize - (frameSize >> 2)));    int rv = encoder_->EncodeFrame (&EncPic, &info);    if (0 == iCheckTypeIndex)      ASSERT_TRUE (rv == cmResultSuccess);    else if (1 == iCheckTypeIndex)      ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnknownReason);} void EncodeDecodeTestAPIBase::EncDecOneFrame (const int iWidth, const int iHeight, const int iFrame, FILE* pfEnc) {    int iLen = 0, rv;    InitialEncDec (iWidth, iHeight);    EncodeOneFrame (iFrame);     //extract target layer data    encToDecData (info, iLen);    //call decoder    unsigned char* pData[3] = { NULL };    memset (&dstBufInfo_, 0, sizeof (SBufferInfo));    rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, iLen, pData, &dstBufInfo_);    EXPECT_TRUE (rv == cmResultSuccess) << " rv = " << rv << " iFrameIdx = " << iFrame;     if (NULL != pfEnc) {      fwrite (info.sLayerInfo[0].pBsBuf, iLen, 1, pfEnc);    }} void EncodeDecodeTestAPIBase::TestOneSimulcastAVC (SEncParamExt* pParam, ISVCDecoder** decoder, unsigned char** pBsBuf, int iSpatialLayerNum,                            int iEncFrameNum,                            int iCallTimes) {//#define DEBUG_FILE_SAVE4    int aLen[MAX_SPATIAL_LAYER_NUM] = {0, 0, 0, 0};#ifdef DEBUG_FILE_SAVE4    FILE* fEnc[MAX_SPATIAL_LAYER_NUM];    if (iCallTimes == 0) {      fEnc[0] = fopen ("enc00.264", "wb");      fEnc[1] = fopen ("enc01.264", "wb");      fEnc[2] = fopen ("enc02.264", "wb");      fEnc[3] = fopen ("enc03.264", "wb");    } else {      fEnc[0] = fopen ("enc10.264", "wb");      fEnc[1] = fopen ("enc11.264", "wb");      fEnc[2] = fopen ("enc12.264", "wb");      fEnc[3] = fopen ("enc13.264", "wb");    }#endif     int rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, pParam);    ASSERT_TRUE (rv == cmResultSuccess) << "SetOption Failed pParam: rv = " << rv;     int iIdx;    //begin testing    for (int iFrame = 0; iFrame < iEncFrameNum; iFrame++) {      int iResult;      int iLayerLen = 0;      unsigned char* pData[3] = { NULL };       InitialEncDec (pParam->iPicWidth, pParam->iPicHeight);      EncodeOneFrame (0);       // init      for (iIdx = 0; iIdx < iSpatialLayerNum; iIdx++) {        aLen[iIdx] = 0;      }      for (int iLayer = 0; iLayer < info.iLayerNum; ++iLayer) {        iLayerLen = 0;        const SLayerBSInfo& layerInfo = info.sLayerInfo[iLayer];        for (int iNal = 0; iNal < layerInfo.iNalCount; ++iNal) {          iLayerLen += layerInfo.pNalLengthInByte[iNal];        }         iIdx = layerInfo.uiSpatialId;        EXPECT_TRUE (iIdx < iSpatialLayerNum) << "iIdx = " << iIdx << ", iSpatialLayerNum = " << iSpatialLayerNum;        memcpy ((pBsBuf[iIdx] + aLen[iIdx]), layerInfo.pBsBuf, iLayerLen * sizeof (unsigned char));        aLen[iIdx] += iLayerLen;      }       for (iIdx = 0; iIdx < iSpatialLayerNum; iIdx++) {        pData[0] = pData[1] = pData[2] = 0;        memset (&dstBufInfo_, 0, sizeof (SBufferInfo)); #ifdef DEBUG_FILE_SAVE4        fwrite (pBsBuf[iIdx], aLen[iIdx], 1, fEnc[iIdx]);#endif        iResult = decoder[iIdx]->DecodeFrame2 (pBsBuf[iIdx], aLen[iIdx], pData, &dstBufInfo_);        EXPECT_TRUE (iResult == cmResultSuccess) << "iResult=" << iResult << ", LayerIdx=" << iIdx;         iResult = decoder[iIdx]->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_);        EXPECT_TRUE (iResult == cmResultSuccess) << "iResult=" << iResult << ", LayerIdx=" << iIdx;        EXPECT_EQ (dstBufInfo_.iBufferStatus, 1) << "LayerIdx=" << iIdx;      }    } #ifdef DEBUG_FILE_SAVE4    fclose (fEnc[0]);    fclose (fEnc[1]);    fclose (fEnc[2]);    fclose (fEnc[3]);#endif} void EncodeDecodeTestAPIBase::InitialEncDec (int iWidth, int iHeight) {   // for encoder  // I420: 1(Y) + 1/4(U) + 1/4(V)  int frameSize = iWidth * iHeight * 3 / 2;   buf_.SetLength (frameSize);  ASSERT_TRUE (buf_.Length() == (size_t)frameSize);   memset (&EncPic, 0, sizeof (SSourcePicture));  EncPic.iPicWidth    = iWidth;  EncPic.iPicHeight   =  iHeight;  EncPic.iColorFormat = videoFormatI420;  EncPic.iStride[0]   = EncPic.iPicWidth;  EncPic.iStride[1]   = EncPic.iStride[2] = EncPic.iPicWidth >> 1;  EncPic.pData[0]     = buf_.data();  EncPic.pData[1]     = EncPic.pData[0] + iWidth * iHeight;  EncPic.pData[2]     = EncPic.pData[1] + (iWidth * iHeight >> 2);   //for decoder  memset (&info, 0, sizeof (SFrameBSInfo));   //set a fixed random value  iRandValue = rand() % 256;} void EncodeDecodeTestAPIBase::RandomParamExtCombination() {   param_.iPicWidth  = WelsClip3 ((((rand() % MAX_WIDTH) >> 1)  + 1) << 1, 2, MAX_WIDTH);  param_.iPicHeight = WelsClip3 ((((rand() % MAX_HEIGHT) >> 1) + 1) << 1, 2, MAX_HEIGHT);   param_.fMaxFrameRate      = rand() % FRAME_RATE_RANGE + 0.5f;  param_.iUsageType         = static_cast<EUsageType> (rand() % 2);  param_.iTemporalLayerNum  = rand() % TEMPORAL_LAYER_NUM_RANGE;  param_.iSpatialLayerNum   = rand() % SPATIAL_LAYER_NUM_RANGE;   param_.uiIntraPeriod      = rand() - 1;  param_.iNumRefFrame       = AUTO_REF_PIC_COUNT;  param_.iMultipleThreadIdc = rand();   int iValue   = rand() % 7;  switch (iValue) {  case 0:    param_.eSpsPpsIdStrategy  = CONSTANT_ID;    break;  case 0x01:    param_.eSpsPpsIdStrategy  = INCREASING_ID;    break;  case 0x02:    param_.eSpsPpsIdStrategy  = SPS_LISTING;    break;  case 0x03:    param_.eSpsPpsIdStrategy  = SPS_LISTING_AND_PPS_INCREASING;    break;  case 0x06:    param_.eSpsPpsIdStrategy  = SPS_PPS_LISTING;    break;  default:    param_.eSpsPpsIdStrategy  = CONSTANT_ID;    break;  }  param_.bPrefixNalAddingCtrl      = (rand() % 2 == 0) ? false : true;  param_.bEnableSSEI               = (rand() % 2 == 0) ? false : true;  param_.iPaddingFlag              = rand() % 2;   //LTR  param_.bEnableLongTermReference  = (rand() % 2 == 0) ? false : true;  param_.bIsLosslessLink           = (rand() % 2 == 0) ? false : true;  param_.iLTRRefNum                = rand();  param_.iLtrMarkPeriod            = rand();   //loop filter  param_.iLoopFilterDisableIdc     = rand() % 7;  param_.iLoopFilterAlphaC0Offset  = rand();  param_.iLoopFilterBetaOffset     = rand();   param_.bEnableDenoise             = (rand() % 2 == 0) ? false : true;  param_.bEnableBackgroundDetection = (rand() % 2 == 0) ? false : true;  param_.bEnableAdaptiveQuant       = (rand() % 2 == 0) ? false : true;  param_.bEnableFrameCroppingFlag   = (rand() % 2 == 0) ? false : true;  param_.bEnableSceneChangeDetect   = (rand() % 2 == 0) ? false : true;   //for rc  param_.iRCMode            = static_cast<RC_MODES> (rand() % RC_MODE_RANGE - 1);  param_.iMaxBitrate        = rand() % BIT_RATE_RANGE;  param_.iTargetBitrate     = rand() % BIT_RATE_RANGE;  param_.iMaxQp             = rand() % QP_RANGE;  param_.iMinQp             = rand() % QP_RANGE;  param_.uiMaxNalSize       = rand();  param_.bEnableFrameSkip   = (rand() % 2 == 0) ? false : true;   for (int iSpatialIdx = 0; iSpatialIdx < param_.iSpatialLayerNum; iSpatialIdx++) {    if (iSpatialIdx < MAX_SPATIAL_LAYER_NUM) {      SSpatialLayerConfig* pSpatialLayer = &param_.sSpatialLayers[iSpatialIdx];       //to do: profile and level id      //pSpatialLayer->uiProfileIdc        = 0;      //pSpatialLayer->uiLevelIdc          = 0;      pSpatialLayer->iVideoWidth         = WelsClip3 ((((rand() % MAX_WIDTH) >> 1)  + 1) << 1, 2, MAX_WIDTH);      pSpatialLayer->iVideoHeight        = WelsClip3 ((((rand() % MAX_HEIGHT) >> 1) + 1) << 1, 2, MAX_HEIGHT);      pSpatialLayer->fFrameRate          = rand() % FRAME_RATE_RANGE + 0.5f;      pSpatialLayer->iMaxSpatialBitrate  = rand() % BIT_RATE_RANGE;      pSpatialLayer->iSpatialBitrate     = rand() % BIT_RATE_RANGE;        pSpatialLayer->sSliceArgument.uiSliceMode = static_cast<SliceModeEnum> (rand() % SLICE_MODE_NUM);      if (pSpatialLayer->sSliceArgument.uiSliceMode != SM_SIZELIMITED_SLICE) {        param_.uiMaxNalSize       = 0;      }      pSpatialLayer->sSliceArgument.uiSliceNum = rand();      pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = rand();    }  }} void EncodeDecodeTestAPIBase::ValidateParamExtCombination() {   bool bDynSliceModeFlag   = false;  unsigned int uiGOPSize   = 0;  unsigned int uiSliceNum  = 0;  int iTotalBitRate        = 0;  int iMinQP               = 0;   param_.iPicWidth          = WELS_CLIP3 (param_.iPicWidth,  2, MAX_WIDTH);  param_.iPicHeight         = WELS_CLIP3 (param_.iPicHeight, 2, MAX_HEIGHT);  param_.fMaxFrameRate      = WELS_CLIP3 (param_.fMaxFrameRate, MIN_FRAME_RATE, MAX_FRAME_RATE);  param_.iTemporalLayerNum  = WELS_CLIP3 (param_.iTemporalLayerNum, 1, MAX_TEMPORAL_LAYER_NUM);   if (CAMERA_VIDEO_REAL_TIME == param_.iUsageType)    param_.iSpatialLayerNum   = WELS_CLIP3 (param_.iSpatialLayerNum, 1, MAX_SPATIAL_LAYER_NUM);  else    param_.iSpatialLayerNum   = 1;   //IntraPeriod  uiGOPSize = 1 << (param_.iTemporalLayerNum - 1);  param_.uiIntraPeriod -= param_.uiIntraPeriod % uiGOPSize;   //RefNum  int32_t iRefUpperBound    = (param_.iUsageType == CAMERA_VIDEO_REAL_TIME) ?                              MAX_REFERENCE_PICTURE_COUNT_NUM_CAMERA : MAX_REFERENCE_PICTURE_COUNT_NUM_SCREEN;  param_.iNumRefFrame       = WELS_CLIP3 (param_.iNumRefFrame, MIN_REF_PIC_COUNT, iRefUpperBound);   //to do: will add more validate logic for thread number  param_.iMultipleThreadIdc = 1;   //LTR  //iLTRRefNum: not supported to set it arbitrary yet  if (true == param_.bEnableLongTermReference) {    param_.iLTRRefNum     = (SCREEN_CONTENT_REAL_TIME == param_.iUsageType) ? LONG_TERM_REF_NUM_SCREEN : LONG_TERM_REF_NUM;    param_.iLtrMarkPeriod = (0 == param_.iLtrMarkPeriod) ? 1 : param_.iLtrMarkPeriod;   } else {    param_.iLTRRefNum = 0;  }   //loop filter  param_.iLoopFilterDisableIdc    = param_.iLoopFilterDisableIdc    % LOOP_FILTER_IDC_NUM;  param_.iLoopFilterAlphaC0Offset = param_.iLoopFilterAlphaC0Offset % (2 * LOOF_FILTER_OFFSET_RANGE + 1) -                                    LOOF_FILTER_OFFSET_RANGE;  param_.iLoopFilterBetaOffset    = param_.iLoopFilterBetaOffset    % (2 * LOOF_FILTER_OFFSET_RANGE + 1) -                                    LOOF_FILTER_OFFSET_RANGE;   for (int iSpatialIdx = 0; iSpatialIdx < param_.iSpatialLayerNum; iSpatialIdx++) {    SSpatialLayerConfig* pSpatialLayer = &param_.sSpatialLayers[iSpatialIdx];    pSpatialLayer->iVideoWidth  = param_.iPicWidth >> (param_.iSpatialLayerNum - 1 - iSpatialIdx);    pSpatialLayer->iVideoHeight = param_.iPicHeight >> (param_.iSpatialLayerNum - 1 - iSpatialIdx);    pSpatialLayer->fFrameRate   = param_.fMaxFrameRate;     pSpatialLayer->iMaxSpatialBitrate  = WELS_CLIP3 (pSpatialLayer->iMaxSpatialBitrate, 1, BIT_RATE_RANGE);    pSpatialLayer->iSpatialBitrate     = WELS_CLIP3 (pSpatialLayer->iSpatialBitrate, 1, pSpatialLayer->iMaxSpatialBitrate);    iTotalBitRate += pSpatialLayer->iSpatialBitrate;     uiSliceNum  = pSpatialLayer->sSliceArgument.uiSliceNum;    pSpatialLayer->sSliceArgument.uiSliceNum = WELS_CLIP3 (uiSliceNum, 1, MAX_SLICES_NUM);    pSpatialLayer->sSliceArgument.uiSliceSizeConstraint = 0;      //for SM_FIXEDSLCNUM_SLICE    // to do will add this when GOM bug fixed    if (SM_FIXEDSLCNUM_SLICE == pSpatialLayer->sSliceArgument.uiSliceMode) {      pSpatialLayer->sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;    }     //for slice mode = SM_SIZELIMITED_SLICE    if (SM_SIZELIMITED_SLICE == pSpatialLayer->sSliceArgument.uiSliceMode) {      bDynSliceModeFlag = true;    }     //for slice mode = SM_RASTER_SLICE    if (SM_RASTER_SLICE == pSpatialLayer->sSliceArgument.uiSliceMode) {      if (0 != pSpatialLayer->sSliceArgument.uiSliceMbNum[0]) {        SliceParamValidationForMode2 (iSpatialIdx);      } else {        SliceParamValidationForMode3 (iSpatialIdx);      }    }  }   //for RC  if ((RC_QUALITY_MODE == param_.iRCMode) || (RC_BITRATE_MODE == param_.iRCMode)) {    param_.bEnableFrameSkip = true;  }  if (param_.iTargetBitrate < iTotalBitRate) {    param_.iTargetBitrate = iTotalBitRate;  }  if (param_.iMaxBitrate < param_.iTargetBitrate) {    param_.iMaxBitrate = param_.iTargetBitrate;  }  param_.iMaxQp       = WELS_CLIP3 (param_.iMaxQp, MIN_QP, MAX_QP);  param_.iMinQp       = WELS_CLIP3 (param_.iMinQp, MIN_QP, MAX_QP);  iMinQP              = (param_.iMaxQp < param_.iMinQp) ? param_.iMaxQp : param_.iMinQp;  param_.iMaxQp       = (param_.iMaxQp > param_.iMinQp) ? param_.iMaxQp : param_.iMinQp;  param_.iMinQp       = iMinQP;  param_.uiMaxNalSize = 0;   //for slice mode = SM_SIZELIMITED_SLICE  if (true == bDynSliceModeFlag) {    SliceParamValidationForMode4();  } }  void EncodeDecodeTestAPIBase::SliceParamValidationForMode2 (int iSpatialIdx) {   unsigned int uiMbWidth          = 0;  unsigned int uiMbHeight         = 0;  unsigned int uiMbNumInFrame     = 0;  unsigned int uiCountMb          = 0;  unsigned int uiSliceIdx         = 0;  unsigned int uiActualSliceCount = 0;   uiMbWidth      = (param_.iPicWidth  + 15) >> 4;  uiMbHeight     = (param_.iPicHeight + 15) >> 4;  uiMbNumInFrame = uiMbWidth * uiMbHeight;   uiSliceIdx = 0;  while (uiSliceIdx < MAX_SLICES_NUM) {    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMbNum[uiSliceIdx] = rand() % uiMbNumInFrame;    uiCountMb           += param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMbNum[uiSliceIdx];    uiActualSliceCount   =  uiSliceIdx + 1;     if (uiCountMb >= uiMbNumInFrame) {      break;    }     ++ uiSliceIdx;  }   if (uiCountMb >= uiMbNumInFrame) {    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMbNum[uiActualSliceCount - 1] -=      (uiCountMb - uiMbNumInFrame);   } else {    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMbNum[uiActualSliceCount - 1 ] +=      (uiMbNumInFrame - uiCountMb);  }  param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceNum = uiActualSliceCount; }void EncodeDecodeTestAPIBase::SliceParamValidationForMode3 (int iSpatialIdx) {   unsigned int uiMbHeight         = 0;   uiMbHeight = (param_.iPicHeight + 15) >> 4;   //change slice mode to SM_SINGLE_SLICE  if (uiMbHeight >  MAX_SLICES_NUM) {    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMode = SM_SINGLE_SLICE;  } } void EncodeDecodeTestAPIBase::SliceParamValidationForMode4() {  //slice mode of all spatial layer should be set as SM_SIZELIMITED_SLICE  for (int iSpatialIdx = 0; iSpatialIdx < param_.iSpatialLayerNum; iSpatialIdx++) {    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceSizeConstraint = 600;    param_.sSpatialLayers[iSpatialIdx].sSliceArgument.uiSliceMode = SM_SIZELIMITED_SLICE;  }  param_.uiMaxNalSize = 1500;} static const EncodeDecodeFileParamBase kFileParamArray[] = {  {300, 160, 96, 6.0f, 2, 1, "000000000000001010101010101010101010101001101010100000010101000011"},  {300, 140, 96, 6.0f, 4, 1, "000000000000001010101010101010101010101001101010100000010101000011"},  {300, 140, 96, 6.0f, 4, 1, "000000000000001010111010101011101010101001101010100000010101110011010101"},}; TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {  EncodeDecodeFileParamBase p = GetParam();  prepareParamDefault (1, p.slicenum, p.width, p.height, p.frameRate, &param_);  encoder_->Uninitialize();  int rv = encoder_->InitializeExt (&param_);  ASSERT_TRUE (rv == cmResultSuccess);   int32_t iTraceLevel = WELS_LOG_QUIET;  encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);  decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);   InitialEncDec (p.width, p.height);   int iIdx = 0;  while (iIdx <= p.numframes) {     EncodeOneFrame (0);     //decoding after each encoding frame    int vclNal, len = 0;    encToDecData (info, len);    unsigned char* pData[3] = { NULL };    memset (&dstBufInfo_, 0, sizeof (SBufferInfo));    rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);    ASSERT_TRUE (rv == cmResultSuccess);    rv = decoder_->GetOption (DECODER_OPTION_VCL_NAL, &vclNal);

Lines 1–500 of 3914. Load more