#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 <string>#include <vector>#include "encode_decode_api_test.h"using namespace WelsCommon; bool 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);  if (buf_.Length() != (size_t)frameSize) { //include memory fail (-1) case    printf ("buf_.Length() failed! frameSize = %d\n", frameSize);    return false;  }   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;  memset (buf_.data(), iRandValue, frameSize);  return true;} 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;} TEST_F (EncodeDecodeTestAPI, SetOptionEncParamExt) {  int iSpatialLayerNum = 4;  int iWidth       = WelsClip3 ((((rand() % MAX_WIDTH) >> 1)  + 1) << 1, 1 << iSpatialLayerNum, MAX_WIDTH);  int iHeight      = WelsClip3 ((((rand() % MAX_HEIGHT) >> 1)  + 1) << 1, 1 << iSpatialLayerNum, MAX_HEIGHT);  float fFrameRate = rand() + 0.5f;  int iEncFrameNum = WelsClip3 ((rand() % ENCODE_FRAME_NUM) + 1, 1, ENCODE_FRAME_NUM);  int iSliceNum        = 1;  encoder_->GetDefaultParams (&param_);  prepareParamDefault (iSpatialLayerNum, iSliceNum, iWidth, iHeight, fFrameRate, &param_);   int rv = encoder_->InitializeExt (&param_);  ASSERT_TRUE (rv == cmResultSuccess);   int iTraceLevel = WELS_LOG_QUIET;  rv = encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);  ASSERT_TRUE (rv == cmResultSuccess);   for (int i = 0; i < iEncFrameNum; i++) {    int iResult;    int len = 0;    unsigned char* pData[3] = { NULL };     RandomParamExtCombination();    iResult = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &param_);    //ValidateParamExtCombination();    //ASSERT_TRUE (iResult == cmResultSuccess);    //to do    // currently, there are still some error cases even though under condition cmResultSuccess == iResult    // so need to enhance the validation check for any random value of each variable in ParamExt     if (cmResultSuccess == iResult) {      ASSERT_TRUE (InitialEncDec (param_.iPicWidth, param_.iPicHeight));      EncodeOneFrame (0);      encToDecData (info, len);      pData[0] = pData[1] = pData[2] = 0;      memset (&dstBufInfo_, 0, sizeof (SBufferInfo));       iResult = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);      ASSERT_TRUE (iResult == cmResultSuccess);      iResult = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_);      ASSERT_TRUE (iResult == cmResultSuccess);      EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);    }  }   iTraceLevel = WELS_LOG_ERROR;  encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);}  TEST_F (EncodeDecodeTestAPI, SetOptionEncParamBase) {  int iSpatialLayerNum = 4;  int iWidth       = WelsClip3 ((((rand() % MAX_WIDTH) >> 1)  + 1) << 1, 1 << iSpatialLayerNum, MAX_WIDTH);  int iHeight      = WelsClip3 ((((rand() % MAX_HEIGHT) >> 1)  + 1) << 1, 1 << iSpatialLayerNum, MAX_HEIGHT);  float fFrameRate = rand() + 0.5f;  int iEncFrameNum = WelsClip3 ((rand() % ENCODE_FRAME_NUM) + 1, 1, ENCODE_FRAME_NUM);  int iSliceNum        = 1;  encoder_->GetDefaultParams (&param_);  prepareParamDefault (iSpatialLayerNum, iSliceNum, iWidth, iHeight, fFrameRate, &param_);   int rv = encoder_->InitializeExt (&param_);  ASSERT_TRUE (rv == cmResultSuccess);   int iTraceLevel = WELS_LOG_QUIET;  rv = encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);  ASSERT_TRUE (rv == cmResultSuccess);   for (int i = 0; i < iEncFrameNum; i++) {    int iResult;    int len = 0;    unsigned char* pData[3] = { NULL };     param_.iTargetBitrate     = rand() % BIT_RATE_RANGE;    iResult = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_BASE, &param_);     if (cmResultSuccess == iResult) {      ASSERT_TRUE (InitialEncDec (param_.iPicWidth, param_.iPicHeight));      EncodeOneFrame (0);      encToDecData (info, len);      pData[0] = pData[1] = pData[2] = 0;      memset (&dstBufInfo_, 0, sizeof (SBufferInfo));       iResult = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);      ASSERT_TRUE (iResult == cmResultSuccess);      iResult = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_);      ASSERT_TRUE (iResult == cmResultSuccess);      EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);    }  }   iTraceLevel = WELS_LOG_ERROR;  encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);} struct EncodeDecodeParamBase {  int width;  int height;  float frameRate;  int iTarBitrate;}; //#define DEBUG_FILE_SAVE_INCREASING_IDTEST_F (EncodeDecodeTestAPI, ParameterSetStrategy_INCREASING_ID) {   int iWidth       = GetRandWidth();  int iHeight      = GetRandHeight();  float fFrameRate = rand() + 0.5f;  int iEncFrameNum = 0;  int iSpatialLayerNum = 1;  int iSliceNum        = 1;   // prepare params  SEncParamExt   sParam1;  SEncParamExt   sParam2;  SEncParamExt   sParam3;  encoder_->GetDefaultParams (&sParam1);  prepareParamDefault (iSpatialLayerNum, iSliceNum, iWidth, iHeight, fFrameRate, &sParam1);  sParam1.bSimulcastAVC = 1;  sParam1.eSpsPpsIdStrategy = INCREASING_ID;  //prepare param2  memcpy (&sParam2, &sParam1, sizeof (SEncParamExt));  while (GET_MB_WIDTH (sParam2.iPicWidth) == GET_MB_WIDTH (sParam1.iPicWidth)) {    sParam2.iPicWidth = GetRandWidth();  }  prepareParamDefault (iSpatialLayerNum, iSliceNum, sParam2.iPicWidth, sParam2.iPicHeight, fFrameRate, &sParam2);  sParam2.bSimulcastAVC = 1;  sParam2.eSpsPpsIdStrategy = INCREASING_ID;  //prepare param3  memcpy (&sParam3, &sParam1, sizeof (SEncParamExt));  while (GET_MB_WIDTH (sParam3.iPicHeight) == GET_MB_WIDTH (sParam1.iPicHeight)) {    sParam3.iPicHeight = GetRandHeight();  }  prepareParamDefault (iSpatialLayerNum, iSliceNum, sParam3.iPicWidth, sParam3.iPicHeight, fFrameRate, &sParam3);  sParam3.bSimulcastAVC = 1;  sParam3.eSpsPpsIdStrategy = INCREASING_ID;   //prepare output if needed  FILE* fEnc =  NULL;#ifdef DEBUG_FILE_SAVE_INCREASING_ID  fEnc = fopen ("enc_INCREASING_ID.264", "wb");#endif   // Test part#1  // step#1: pParam1  //int TraceLevel = WELS_LOG_INFO;  //encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &TraceLevel);  int rv = encoder_->InitializeExt (&sParam1);  ASSERT_TRUE (rv == cmResultSuccess) << "InitializeExt: rv = " << rv << " at " << sParam1.iPicWidth << "x" <<                                      sParam1.iPicHeight;  ASSERT_TRUE (EncDecOneFrame (sParam1.iPicWidth, sParam1.iPicHeight, iEncFrameNum++, fEnc));   // new IDR  rv = encoder_->ForceIntraFrame (true);  ASSERT_TRUE (rv == cmResultSuccess) << "rv = " << rv;  ASSERT_TRUE (EncDecOneFrame (sParam1.iPicWidth, sParam1.iPicHeight, iEncFrameNum++, fEnc));   // step#2: pParam2  rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam2);  ASSERT_TRUE (rv == cmResultSuccess) << "SetOption: rv = " << rv << " at " << sParam2.iPicWidth << "x" <<                                      sParam2.iPicHeight;  ASSERT_TRUE (EncDecOneFrame (sParam2.iPicWidth, sParam2.iPicHeight, iEncFrameNum++, fEnc));   // new IDR  rv = encoder_->ForceIntraFrame (true);  ASSERT_TRUE (rv == cmResultSuccess) << "rv = " << rv;  ASSERT_TRUE (EncDecOneFrame (sParam2.iPicWidth, sParam2.iPicHeight, iEncFrameNum++, fEnc));   // step#3: back to pParam1  rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam1);  ASSERT_TRUE (rv == cmResultSuccess) << "SetOption: rv = " << rv << " at " << sParam1.iPicWidth << "x" <<                                      sParam1.iPicHeight;  ASSERT_TRUE (EncDecOneFrame (sParam1.iPicWidth, sParam1.iPicHeight, iEncFrameNum++, fEnc));   // step#4: back to pParam2  rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam2);  ASSERT_TRUE (rv == cmResultSuccess) << "rv = " << rv << sParam2.iPicWidth << sParam2.iPicHeight;  ASSERT_TRUE (EncDecOneFrame (sParam2.iPicWidth, sParam2.iPicHeight, iEncFrameNum++, fEnc)); #ifdef DEBUG_FILE_SAVE_INCREASING_ID  fclose (fEnc);#endif  rv = encoder_->Uninitialize();  ASSERT_TRUE (rv == cmResultSuccess) << "rv = " << rv;   // Test part#2  // step#1: pParam1  rv = encoder_->InitializeExt (&sParam1);  ASSERT_TRUE (rv == cmResultSuccess) << "InitializeExt Failed: rv = " << rv;  rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam2);  ASSERT_TRUE (rv == cmResultSuccess) << "SetOption Failed sParam2: rv = " << rv;  rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam3);  ASSERT_TRUE (rv == cmResultSuccess) << "SetOption Failed sParam3: rv = " << rv; #ifdef DEBUG_FILE_SAVE_INCREASING_ID  fEnc = fopen ("enc_INCREASING_ID2.264", "wb");#endif  iEncFrameNum = 0;  ASSERT_TRUE (EncDecOneFrame (sParam3.iPicWidth, sParam3.iPicHeight, iEncFrameNum++, fEnc));   rv = encoder_->SetOption (ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sParam2);  ASSERT_TRUE (rv == cmResultSuccess) << "SetOption Failed sParam2: rv = " << rv;  ASSERT_TRUE (EncDecOneFrame (sParam2.iPicWidth, sParam2.iPicHeight, iEncFrameNum++, fEnc));

Lines 1–500 of 2388. Load more