Showing the changes to test/api/encode_decode_api_test.cpp (1 of 1 file). Show all
Unified · Split
| @@ -57,7 +57,7 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 56 unmodified lines | ||
| 57 | 57 | BaseDecoderTest::TearDown(); |
| 58 | 58 | } |
| 59 | 59 | |
| 60 | − virtual void prepareParam (int width, int height, float framerate) { | |
| 60 | + virtual void prepareParam (int iLayers, int iSlices, int width, int height, float framerate) { | |
| 61 | 61 | memset (¶m_, 0, sizeof (SEncParamExt)); |
| 62 | 62 | param_.iUsageType = CAMERA_VIDEO_REAL_TIME; |
| 63 | 63 | param_.iPicWidth = width; |
| @@ -65,10 +65,15 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 1 unmodified line | ||
| 65 | 65 | param_.fMaxFrameRate = framerate; |
| 66 | 66 | param_.iRCMode = RC_OFF_MODE; //rc off |
| 67 | 67 | param_.iMultipleThreadIdc = 1; //single thread |
| 68 | − param_.sSpatialLayers[0].iVideoWidth = width; | |
| 69 | − param_.sSpatialLayers[0].iVideoHeight = height; | |
| 70 | − param_.sSpatialLayers[0].fFrameRate = framerate; | |
| 71 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; | |
| 68 | + for (int i = 0; i < iLayers; i++) { | |
| 69 | + param_.sSpatialLayers[i].iVideoWidth = width >> (iLayers - i - 1); | |
| 70 | + param_.sSpatialLayers[i].iVideoHeight = height >> (iLayers - i - 1); | |
| 71 | + param_.sSpatialLayers[i].fFrameRate = framerate; | |
| 72 | + param_.sSpatialLayers[i].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 73 | + param_.sSpatialLayers[i].sSliceCfg.sSliceArgument.uiSliceNum = iSlices; | |
| 74 | + } | |
| 75 | + | |
| 76 | + | |
| 72 | 77 | } |
| 73 | 78 | |
| 74 | 79 | virtual void encToDecData (const SFrameBSInfo& info, int& len) { |
| @@ -113,8 +118,8 @@ class EncodeDecodeTestAPI : public EncodeDecodeTestBase { · 38 unmodified lines | ||
| 113 | 118 | EncodeDecodeTestBase::TearDown(); |
| 114 | 119 | } |
| 115 | 120 | |
| 116 | − void prepareParam (int width, int height, float framerate) { | |
| 117 | − EncodeDecodeTestBase::prepareParam (width, height, framerate); | |
| 121 | + void prepareParam (int iLayers, int iSlices, int width, int height, float framerate) { | |
| 122 | + EncodeDecodeTestBase::prepareParam (iLayers, iSlices, width, height, framerate); | |
| 118 | 123 | } |
| 119 | 124 | |
| 120 | 125 | void prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam); |
| @@ -161,7 +166,7 @@ static const EncodeDecodeFileParamBase kFileParamArray[] = { · 40 unmodified lines | ||
| 161 | 166 | |
| 162 | 167 | TEST_P (EncodeDecodeTestAPI, DecoderVclNal) { |
| 163 | 168 | EncodeDecodeFileParamBase p = GetParam(); |
| 164 | − prepareParam (p.width, p.height, p.frameRate); | |
| 169 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 165 | 170 | encoder_->Uninitialize(); |
| 166 | 171 | int rv = encoder_->InitializeExt (¶m_); |
| 167 | 172 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -197,7 +202,7 @@ TEST_P (EncodeDecodeTestAPI, DecoderVclNal) { · 29 unmodified lines | ||
| 197 | 202 | |
| 198 | 203 | TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) { |
| 199 | 204 | EncodeDecodeFileParamBase p = GetParam(); |
| 200 | − prepareParam (p.width, p.height, p.frameRate); | |
| 205 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 201 | 206 | encoder_->Uninitialize(); |
| 202 | 207 | int rv = encoder_->InitializeExt (¶m_); |
| 203 | 208 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -234,7 +239,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) { · 30 unmodified lines | ||
| 234 | 239 | |
| 235 | 240 | TEST_P (EncodeDecodeTestAPI, GetOptionIDR) { |
| 236 | 241 | EncodeDecodeFileParamBase p = GetParam(); |
| 237 | − prepareParam (p.width, p.height, p.frameRate); | |
| 242 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 238 | 243 | encoder_->Uninitialize(); |
| 239 | 244 | int rv = encoder_->InitializeExt (¶m_); |
| 240 | 245 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -319,10 +324,8 @@ bool IsLTRMarking (ISVCDecoder* pDecoder) { · 78 unmodified lines | ||
| 319 | 324 | } |
| 320 | 325 | |
| 321 | 326 | void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecoverRequest* p_LTR_Recover_Request, |
| 322 | − long hr) { | |
| 323 | − | |
| 327 | + long hr, bool m_P2PmodeFlag) { | |
| 324 | 328 | long bKLost = IsKeyFrameLost (pDecoder, p_LTR_Recover_Request, hr); |
| 325 | − bool m_P2PmodeFlag = true; | |
| 326 | 329 | if (m_P2PmodeFlag) { |
| 327 | 330 | if (bKLost == IDR_RECOVERY_REQUEST) { |
| 328 | 331 | pEncoder->ForceIntraFrame (true); |
| @@ -335,9 +338,7 @@ void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecov · 6 unmodified lines | ||
| 335 | 338 | } else { |
| 336 | 339 | if (bKLost == IDR_RECOVERY_REQUEST || bKLost == LTR_RECOVERY_REQUEST) { |
| 337 | 340 | p_LTR_Recover_Request->uiFeedbackType = IDR_RECOVERY_REQUEST; |
| 338 | − pDecoder->GetOption (DECODER_OPTION_FRAME_NUM, &p_LTR_Recover_Request->iCurrentFrameNum); | |
| 339 | − pDecoder->GetOption (DECODER_OPTION_IDR_PIC_ID, &p_LTR_Recover_Request->uiIDRPicId); | |
| 340 | − pEncoder->SetOption (ENCODER_LTR_RECOVERY_REQUEST, p_LTR_Recover_Request); | |
| 341 | + pEncoder->ForceIntraFrame (true); | |
| 341 | 342 | } |
| 342 | 343 | } |
| 343 | 344 | } |
| @@ -479,7 +480,7 @@ int SimulateNALLoss (const unsigned char* pSrc, int& iSrcLen, std::vector<SLost · 135 unmodified lines | ||
| 479 | 480 | |
| 480 | 481 | TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLIDR) { |
| 481 | 482 | EncodeDecodeFileParamBase p = GetParam(); |
| 482 | − prepareParam (p.width, p.height, p.frameRate); | |
| 483 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 483 | 484 | encoder_->Uninitialize(); |
| 484 | 485 | int rv = encoder_->InitializeExt (¶m_); |
| 485 | 486 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -512,7 +513,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLLTR) { · 26 unmodified lines | ||
| 512 | 513 | SLTRMarkingFeedback m_LTR_Marking_Feedback; |
| 513 | 514 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 514 | 515 | EncodeDecodeFileParamBase p = GetParam(); |
| 515 | − prepareParam (p.width, p.height, p.frameRate); | |
| 516 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 516 | 517 | encoder_->Uninitialize(); |
| 517 | 518 | int rv = encoder_->InitializeExt (¶m_); |
| 518 | 519 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -571,9 +572,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_Engine) { · 52 unmodified lines | ||
| 571 | 572 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 572 | 573 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 573 | 574 | EncodeDecodeFileParamBase p = GetParam(); |
| 574 | − prepareParam (p.width, p.height, p.frameRate); | |
| 575 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 576 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 575 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 577 | 576 | encoder_->Uninitialize(); |
| 578 | 577 | int rv = encoder_->InitializeExt (¶m_); |
| 579 | 578 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -610,9 +609,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_Engine) { · 30 unmodified lines | ||
| 610 | 609 | SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss); |
| 611 | 610 | rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); |
| 612 | 611 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 613 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 612 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 614 | 613 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 615 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 614 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 616 | 615 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 617 | 616 | iIdx++; |
| 618 | 617 | } |
| @@ -623,9 +622,7 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_DISABLE) { · 4 unmodified lines | ||
| 623 | 622 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 624 | 623 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 625 | 624 | EncodeDecodeFileParamBase p = GetParam(); |
| 626 | − prepareParam (p.width, p.height, p.frameRate); | |
| 627 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 628 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 625 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 629 | 626 | param_.bEnableLongTermReference = true; |
| 630 | 627 | param_.iLTRRefNum = 1; |
| 631 | 628 | encoder_->Uninitialize(); |
| @@ -676,9 +673,9 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_DISABLE) { · 44 unmodified lines | ||
| 676 | 673 | bVCLLoss); |
| 677 | 674 | rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); |
| 678 | 675 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 679 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 676 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 680 | 677 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 681 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 678 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 682 | 679 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 683 | 680 | if (iSkipedBytes && bVCLLoss) { |
| 684 | 681 | ASSERT_TRUE (dstBufInfo_.iBufferStatus == 0); |
| @@ -692,9 +689,7 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 7 unmodified lines | ||
| 692 | 689 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 693 | 690 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 694 | 691 | EncodeDecodeFileParamBase p = GetParam(); |
| 695 | − prepareParam (p.width, p.height, p.frameRate); | |
| 696 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 697 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 692 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 698 | 693 | encoder_->Uninitialize(); |
| 699 | 694 | int rv = encoder_->InitializeExt (¶m_); |
| 700 | 695 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -734,9 +729,9 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 33 unmodified lines | ||
| 734 | 729 | decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc); |
| 735 | 730 | rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); |
| 736 | 731 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 737 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 732 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 738 | 733 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 739 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 734 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 740 | 735 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 741 | 736 | iIdx++; |
| 742 | 737 | } |
| @@ -748,11 +743,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 5 unmodified lines | ||
| 748 | 743 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 749 | 744 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 750 | 745 | EncodeDecodeFileParamBase p = GetParam(); |
| 751 | − prepareParam (p.width, p.height, p.frameRate); | |
| 746 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 752 | 747 | param_.bPrefixNalAddingCtrl = false; |
| 753 | 748 | param_.iTemporalLayerNum = (rand() % 4) + 1; |
| 754 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 755 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 756 | 749 | encoder_->Uninitialize(); |
| 757 | 750 | int rv = encoder_->InitializeExt (¶m_); |
| 758 | 751 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -792,7 +785,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 33 unmodified lines | ||
| 792 | 785 | ASSERT_EQ (iTid, 0); |
| 793 | 786 | } |
| 794 | 787 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 795 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 788 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 796 | 789 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 797 | 790 | decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); |
| 798 | 791 | std::vector<SLostSim>::iterator iter = m_SLostSim.begin(); |
| @@ -808,7 +801,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 9 unmodified lines | ||
| 808 | 801 | if (iTid != -1) { |
| 809 | 802 | ASSERT_EQ (iTid, 0); |
| 810 | 803 | } |
| 811 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 804 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 812 | 805 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 813 | 806 | iIdx++; |
| 814 | 807 | } |
| @@ -819,12 +812,10 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) { · 4 unmodified lines | ||
| 819 | 812 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 820 | 813 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 821 | 814 | EncodeDecodeFileParamBase p = GetParam(); |
| 822 | − prepareParam (p.width, p.height, p.frameRate); | |
| 815 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 823 | 816 | param_.bPrefixNalAddingCtrl = true; |
| 824 | 817 | param_.iTemporalLayerNum = (rand() % 4) + 1; |
| 825 | 818 | param_.iSpatialLayerNum = 1; |
| 826 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 827 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 828 | 819 | encoder_->Uninitialize(); |
| 829 | 820 | int rv = encoder_->InitializeExt (¶m_); |
| 830 | 821 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -861,11 +852,11 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) { · 30 unmodified lines | ||
| 861 | 852 | decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); |
| 862 | 853 | ASSERT_EQ (iTid, -1); |
| 863 | 854 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 864 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 855 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 865 | 856 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 866 | 857 | decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); |
| 867 | 858 | ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId); |
| 868 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 859 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 869 | 860 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 870 | 861 | iIdx++; |
| 871 | 862 | } |
| @@ -876,17 +867,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) { · 4 unmodified lines | ||
| 876 | 867 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 877 | 868 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 878 | 869 | EncodeDecodeFileParamBase p = GetParam(); |
| 879 | − prepareParam (p.width / 2, p.height / 2, p.frameRate); | |
| 870 | + prepareParam (2, p.slicenum, p.width, p.height, p.frameRate); | |
| 880 | 871 | param_.iTemporalLayerNum = (rand() % 4) + 1; |
| 881 | 872 | param_.iSpatialLayerNum = 2; |
| 882 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 883 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 884 | − param_.sSpatialLayers[1].iVideoWidth = p.width; | |
| 885 | − param_.sSpatialLayers[1].iVideoHeight = p.height; | |
| 886 | − param_.sSpatialLayers[1].fFrameRate = p.frameRate; | |
| 887 | − param_.sSpatialLayers[1].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 888 | − param_.sSpatialLayers[1].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 889 | − | |
| 890 | 873 | encoder_->Uninitialize(); |
| 891 | 874 | int rv = encoder_->InitializeExt (¶m_); |
| 892 | 875 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -923,11 +906,11 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) { · 30 unmodified lines | ||
| 923 | 906 | decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); |
| 924 | 907 | ASSERT_EQ (iTid, -1); |
| 925 | 908 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 926 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 909 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 927 | 910 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 928 | 911 | decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); |
| 929 | 912 | ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId); |
| 930 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 913 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 931 | 914 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 932 | 915 | iIdx++; |
| 933 | 916 | } |
| @@ -940,10 +923,8 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace) { · 6 unmodified lines | ||
| 940 | 923 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 941 | 924 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 942 | 925 | EncodeDecodeFileParamBase p = GetParam(); |
| 943 | − prepareParam (p.width, p.height, p.frameRate); | |
| 926 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 944 | 927 | param_.iSpatialLayerNum = 1; |
| 945 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 946 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 947 | 928 | |
| 948 | 929 | int rv = encoder_->InitializeExt (¶m_); |
| 949 | 930 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -992,9 +973,9 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace) { · 42 unmodified lines | ||
| 992 | 973 | SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss); |
| 993 | 974 | rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); |
| 994 | 975 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 995 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 976 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 996 | 977 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 997 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 978 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 998 | 979 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 999 | 980 | iIdx++; |
| 1000 | 981 | } |
| @@ -1005,11 +986,8 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 4 unmodified lines | ||
| 1005 | 986 | SLTRRecoverRequest m_LTR_Recover_Request; |
| 1006 | 987 | m_LTR_Recover_Request.uiIDRPicId = 0; |
| 1007 | 988 | EncodeDecodeFileParamBase p = GetParam(); |
| 1008 | − prepareParam (p.width, p.height, p.frameRate); | |
| 989 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 1009 | 990 | param_.iSpatialLayerNum = 1; |
| 1010 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 1011 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 1012 | − | |
| 1013 | 991 | int rv = encoder_->InitializeExt (¶m_); |
| 1014 | 992 | ASSERT_TRUE (rv == cmResultSuccess); |
| 1015 | 993 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| @@ -1056,9 +1034,9 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 40 unmodified lines | ||
| 1056 | 1034 | SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss); |
| 1057 | 1035 | rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); |
| 1058 | 1036 | m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; |
| 1059 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 1037 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 1060 | 1038 | rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction |
| 1061 | − LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv); | |
| 1039 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 1062 | 1040 | LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); |
| 1063 | 1041 | iIdx++; |
| 1064 | 1042 | } |
| @@ -1071,9 +1049,8 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECIDC_GeneralSliceChange) { · 6 unmodified lines | ||
| 1071 | 1049 | uint32_t uiEcIdc; |
| 1072 | 1050 | uint32_t uiGet; |
| 1073 | 1051 | EncodeDecodeFileParamBase p = GetParam(); |
| 1074 | − prepareParam (p.width, p.height, p.frameRate); | |
| 1075 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 1076 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 1052 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 1053 | + param_.iSpatialLayerNum = 1; | |
| 1077 | 1054 | encoder_->Uninitialize(); |
| 1078 | 1055 | int rv = encoder_->InitializeExt (¶m_); |
| 1079 | 1056 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -1152,9 +1129,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificFrameChange) { · 72 unmodified lines | ||
| 1152 | 1129 | uint32_t uiEcIdc; |
| 1153 | 1130 | uint32_t uiGet; |
| 1154 | 1131 | EncodeDecodeFileParamBase p = kFileParamArray[0]; |
| 1155 | − prepareParam (p.width, p.height, p.frameRate); | |
| 1156 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE; | |
| 1157 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum; | |
| 1132 | + prepareParam (1, p.slicenum, p.width, p.height, p.frameRate); | |
| 1133 | + param_.iSpatialLayerNum = 1; | |
| 1158 | 1134 | encoder_->Uninitialize(); |
| 1159 | 1135 | int rv = encoder_->InitializeExt (¶m_); |
| 1160 | 1136 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -1292,9 +1268,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRLoss) { · 131 unmodified lines | ||
| 1292 | 1268 | uint32_t uiEcIdc; |
| 1293 | 1269 | uint32_t uiGet; |
| 1294 | 1270 | EncodeDecodeFileParamBase p = kFileParamArray[0]; |
| 1295 | − prepareParam (p.width, p.height, p.frameRate); | |
| 1296 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 1297 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2; | |
| 1271 | + prepareParam (1, 2, p.width, p.height, p.frameRate); | |
| 1272 | + param_.iSpatialLayerNum = 1; | |
| 1298 | 1273 | encoder_->Uninitialize(); |
| 1299 | 1274 | int rv = encoder_->InitializeExt (¶m_); |
| 1300 | 1275 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -1425,9 +1400,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRNoLoss) { · 124 unmodified lines | ||
| 1425 | 1400 | uint32_t uiEcIdc; |
| 1426 | 1401 | uint32_t uiGet; |
| 1427 | 1402 | EncodeDecodeFileParamBase p = kFileParamArray[0]; |
| 1428 | − prepareParam (p.width, p.height, p.frameRate); | |
| 1429 | − param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE; | |
| 1430 | − param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2; | |
| 1403 | + prepareParam (1, 2, p.width, p.height, p.frameRate); | |
| 1404 | + param_.iSpatialLayerNum = 1; | |
| 1431 | 1405 | encoder_->Uninitialize(); |
| 1432 | 1406 | int rv = encoder_->InitializeExt (¶m_); |
| 1433 | 1407 | ASSERT_TRUE (rv == cmResultSuccess); |
| @@ -1584,3 +1558,156 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRNoLoss) { · 150 unmodified lines | ||
| 1584 | 1558 | |
| 1585 | 1559 | } |
| 1586 | 1560 | |
| 1561 | +static const EncodeDecodeFileParamBase kSVCSwitch[] = { | |
| 1562 | + {300, 160, 96, 6.0f, 2, 1, "120012130101012311201221323"}, | |
| 1563 | +}; | |
| 1564 | + | |
| 1565 | +TEST_F (EncodeDecodeTestAPI, Engine_SVC_Switch_I) { | |
| 1566 | + SLTRMarkingFeedback m_LTR_Marking_Feedback; | |
| 1567 | + SLTRRecoverRequest m_LTR_Recover_Request; | |
| 1568 | + m_LTR_Recover_Request.uiIDRPicId = 0; | |
| 1569 | + EncodeDecodeFileParamBase p = kSVCSwitch[0]; | |
| 1570 | + p.width = p.width << 2; | |
| 1571 | + p.height = p.height << 2; | |
| 1572 | + prepareParam (4, p.slicenum, p.width, p.height, p.frameRate); | |
| 1573 | + param_.iTemporalLayerNum = (rand() % 4) + 1; | |
| 1574 | + param_.iSpatialLayerNum = 4; | |
| 1575 | + encoder_->Uninitialize(); | |
| 1576 | + int rv = encoder_->InitializeExt (¶m_); | |
| 1577 | + ASSERT_TRUE (rv == cmResultSuccess); | |
| 1578 | + m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; | |
| 1579 | + | |
| 1580 | + prepareEncDecParam (p); | |
| 1581 | + int32_t iTraceLevel = WELS_LOG_QUIET; | |
| 1582 | + encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel); | |
| 1583 | + decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel); | |
| 1584 | + int32_t iSpsPpsIdAddition = 1; | |
| 1585 | + encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition); | |
| 1586 | + int32_t iIDRPeriod = 15; | |
| 1587 | + encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod); | |
| 1588 | + SLTRConfig sLtrConfigVal; | |
| 1589 | + sLtrConfigVal.bEnableLongTermReference = 1; | |
| 1590 | + sLtrConfigVal.iLTRRefNum = 1; | |
| 1591 | + encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal); | |
| 1592 | + int32_t iLtrPeriod = 2; | |
| 1593 | + encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod); | |
| 1594 | + int iIdx = 0; | |
| 1595 | + int iTarDid = 0; | |
| 1596 | + while (iIdx <= p.numframes) { | |
| 1597 | + EncodeOneFrame(); | |
| 1598 | + if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) { | |
| 1599 | + ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR); | |
| 1600 | + } | |
| 1601 | + if (info.eFrameType == videoFrameTypeIDR) { | |
| 1602 | + iTarDid = rand() % 4; | |
| 1603 | + } | |
| 1604 | + //decoding after each encoding frame | |
| 1605 | + int len = 0; | |
| 1606 | + encToDecData (info, len); | |
| 1607 | + unsigned char* pData[3] = { NULL }; | |
| 1608 | + memset (&dstBufInfo_, 0, sizeof (SBufferInfo)); | |
| 1609 | + | |
| 1610 | + ExtractDidNal (&info, len, &m_SLostSim, iTarDid); | |
| 1611 | + rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); | |
| 1612 | + ASSERT_EQ (rv, 0); | |
| 1613 | + int iTid = -1; | |
| 1614 | + decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); | |
| 1615 | + ASSERT_EQ (iTid, -1); | |
| 1616 | + m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; | |
| 1617 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 1618 | + rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction | |
| 1619 | + ASSERT_EQ (rv, 0); | |
| 1620 | + decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); | |
| 1621 | + ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId); | |
| 1622 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, true); | |
| 1623 | + LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); | |
| 1624 | + iIdx++; | |
| 1625 | + } | |
| 1626 | +} | |
| 1627 | + | |
| 1628 | +TEST_F (EncodeDecodeTestAPI, Engine_SVC_Switch_P) { | |
| 1629 | + SLTRMarkingFeedback m_LTR_Marking_Feedback; | |
| 1630 | + SLTRRecoverRequest m_LTR_Recover_Request; | |
| 1631 | + m_LTR_Recover_Request.uiIDRPicId = 0; | |
| 1632 | + EncodeDecodeFileParamBase p = kSVCSwitch[0]; | |
| 1633 | + int iTarDid = 0; | |
| 1634 | + int iLastDid = 0; | |
| 1635 | + p.width = p.width << 2; | |
| 1636 | + p.height = p.height << 2; | |
| 1637 | + prepareParam (4, p.slicenum, p.width, p.height, p.frameRate); | |
| 1638 | + param_.iTemporalLayerNum = (rand() % 4) + 1; | |
| 1639 | + param_.iSpatialLayerNum = 4; | |
| 1640 | + encoder_->Uninitialize(); | |
| 1641 | + int rv = encoder_->InitializeExt (¶m_); | |
| 1642 | + ASSERT_TRUE (rv == cmResultSuccess); | |
| 1643 | + m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; | |
| 1644 | + | |
| 1645 | + prepareEncDecParam (p); | |
| 1646 | + int32_t iTraceLevel = WELS_LOG_QUIET; | |
| 1647 | + encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel); | |
| 1648 | + decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel); | |
| 1649 | + int32_t iSpsPpsIdAddition = 1; | |
| 1650 | + encoder_->SetOption (ENCODER_OPTION_ENABLE_SPS_PPS_ID_ADDITION, &iSpsPpsIdAddition); | |
| 1651 | + int32_t iIDRPeriod = 60; | |
| 1652 | + encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod); | |
| 1653 | + SLTRConfig sLtrConfigVal; | |
| 1654 | + sLtrConfigVal.bEnableLongTermReference = 1; | |
| 1655 | + sLtrConfigVal.iLTRRefNum = 1; | |
| 1656 | + encoder_->SetOption (ENCODER_OPTION_LTR, &sLtrConfigVal); | |
| 1657 | + int32_t iLtrPeriod = 2; | |
| 1658 | + encoder_->SetOption (ENCODER_LTR_MARKING_PERIOD, &iLtrPeriod); | |
| 1659 | + int iIdx = 0; | |
| 1660 | + | |
| 1661 | + while (iIdx <= p.numframes) { | |
| 1662 | + EncodeOneFrame(); | |
| 1663 | + if (m_LTR_Recover_Request.uiFeedbackType == IDR_RECOVERY_REQUEST) { | |
| 1664 | + ASSERT_TRUE (info.eFrameType == videoFrameTypeIDR); | |
| 1665 | + } | |
| 1666 | + //decoding after each encoding frame | |
| 1667 | + int len = 0; | |
| 1668 | + encToDecData (info, len); | |
| 1669 | + unsigned char* pData[3] = { NULL }; | |
| 1670 | + memset (&dstBufInfo_, 0, sizeof (SBufferInfo)); | |
| 1671 | + if (iIdx < strlen (p.pLossSequence)) { | |
| 1672 | + switch (p.pLossSequence[iIdx]) { | |
| 1673 | + case '0': | |
| 1674 | + iTarDid = 0; | |
| 1675 | + break; | |
| 1676 | + case '1': | |
| 1677 | + iTarDid = 1; | |
| 1678 | + break; | |
| 1679 | + case '2': | |
| 1680 | + iTarDid = 2; | |
| 1681 | + break; | |
| 1682 | + case '3': | |
| 1683 | + iTarDid = 3; | |
| 1684 | + break; | |
| 1685 | + default : | |
| 1686 | + iTarDid = rand() % 4; | |
| 1687 | + break; | |
| 1688 | + } | |
| 1689 | + } else { | |
| 1690 | + iTarDid = rand() % 4; | |
| 1691 | + } | |
| 1692 | + | |
| 1693 | + ExtractDidNal (&info, len, &m_SLostSim, iTarDid); | |
| 1694 | + rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_); | |
| 1695 | + int iTid = -1; | |
| 1696 | + decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); | |
| 1697 | + ASSERT_EQ (iTid, -1); | |
| 1698 | + m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET; | |
| 1699 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, false); | |
| 1700 | + rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction | |
| 1701 | + if (info.eFrameType == videoFrameTypeP && iIdx > 0 && iLastDid != iTarDid) { | |
| 1702 | + ASSERT_NE (rv, 0); | |
| 1703 | + } else if (info.eFrameType == videoFrameTypeIDR) { | |
| 1704 | + ASSERT_EQ (rv, 0); | |
| 1705 | + } | |
| 1706 | + decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid); | |
| 1707 | + ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId); | |
| 1708 | + LTRRecoveryRequest (decoder_, encoder_, &m_LTR_Recover_Request, rv, false); | |
| 1709 | + LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv); | |
| 1710 | + iIdx++; | |
| 1711 | + iLastDid = iTarDid; | |
| 1712 | + } | |
| 1713 | +} | |