History

add UT for sim-SVC switch

dong zhang committed 12 years ago

Commit 769c38d1 parent 195d1361 file · +204 −77Browse files

Showing the changes to test/api/encode_decode_api_test.cpp (1 of 1 file). Show all

Unified · Split

test/api/encode_decode_api_test.cpp+204−77
@@ -57,7 +57,7 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 56 unmodified lines
57 BaseDecoderTest::TearDown();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 memset (&param_, 0, sizeof (SEncParamExt));61 memset (&param_, 0, sizeof (SEncParamExt));
62 param_.iUsageType = CAMERA_VIDEO_REAL_TIME;62 param_.iUsageType = CAMERA_VIDEO_REAL_TIME;
63 param_.iPicWidth = width;63 param_.iPicWidth = width;
@@ -65,10 +65,15 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 1 unmodified line
65 param_.fMaxFrameRate = framerate;65 param_.fMaxFrameRate = framerate;
66 param_.iRCMode = RC_OFF_MODE; //rc off66 param_.iRCMode = RC_OFF_MODE; //rc off
67 param_.iMultipleThreadIdc = 1; //single thread67 param_.iMultipleThreadIdc = 1; //single thread
68 param_.sSpatialLayers[0].iVideoWidth = width;68 for (int i = 0; i < iLayers; i++) {
69 param_.sSpatialLayers[0].iVideoHeight = height;69 param_.sSpatialLayers[i].iVideoWidth = width >> (iLayers - i - 1);
70 param_.sSpatialLayers[0].fFrameRate = framerate;70 param_.sSpatialLayers[i].iVideoHeight = height >> (iLayers - i - 1);
71 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;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 virtual void encToDecData (const SFrameBSInfo& info, int& len) {79 virtual void encToDecData (const SFrameBSInfo& info, int& len) {
@@ -113,8 +118,8 @@ class EncodeDecodeTestAPI : public EncodeDecodeTestBase { · 38 unmodified lines
113 EncodeDecodeTestBase::TearDown();118 EncodeDecodeTestBase::TearDown();
114 }119 }
115 120
116 void prepareParam (int width, int height, float framerate) {121 void prepareParam (int iLayers, int iSlices, int width, int height, float framerate) {
117 EncodeDecodeTestBase::prepareParam (width, height, framerate);122 EncodeDecodeTestBase::prepareParam (iLayers, iSlices, width, height, framerate);
118 }123 }
119 124
120 void prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam);125 void prepareEncDecParam (const EncodeDecodeFileParamBase EncDecFileParam);
@@ -161,7 +166,7 @@ static const EncodeDecodeFileParamBase kFileParamArray[] = { · 40 unmodified lines
161 166
162TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {167TEST_P (EncodeDecodeTestAPI, DecoderVclNal) {
163 EncodeDecodeFileParamBase p = GetParam();168 EncodeDecodeFileParamBase p = GetParam();
164 prepareParam (p.width, p.height, p.frameRate);169 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
165 encoder_->Uninitialize();170 encoder_->Uninitialize();
166 int rv = encoder_->InitializeExt (&param_);171 int rv = encoder_->InitializeExt (&param_);
167 ASSERT_TRUE (rv == cmResultSuccess);172 ASSERT_TRUE (rv == cmResultSuccess);
@@ -197,7 +202,7 @@ TEST_P (EncodeDecodeTestAPI, DecoderVclNal) { · 29 unmodified lines
197 202
198TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) {203TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) {
199 EncodeDecodeFileParamBase p = GetParam();204 EncodeDecodeFileParamBase p = GetParam();
200 prepareParam (p.width, p.height, p.frameRate);205 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
201 encoder_->Uninitialize();206 encoder_->Uninitialize();
202 int rv = encoder_->InitializeExt (&param_);207 int rv = encoder_->InitializeExt (&param_);
203 ASSERT_TRUE (rv == cmResultSuccess);208 ASSERT_TRUE (rv == cmResultSuccess);
@@ -234,7 +239,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionFramenum) { · 30 unmodified lines
234 239
235TEST_P (EncodeDecodeTestAPI, GetOptionIDR) {240TEST_P (EncodeDecodeTestAPI, GetOptionIDR) {
236 EncodeDecodeFileParamBase p = GetParam();241 EncodeDecodeFileParamBase p = GetParam();
237 prepareParam (p.width, p.height, p.frameRate);242 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
238 encoder_->Uninitialize();243 encoder_->Uninitialize();
239 int rv = encoder_->InitializeExt (&param_);244 int rv = encoder_->InitializeExt (&param_);
240 ASSERT_TRUE (rv == cmResultSuccess);245 ASSERT_TRUE (rv == cmResultSuccess);
@@ -319,10 +324,8 @@ bool IsLTRMarking (ISVCDecoder* pDecoder) { · 78 unmodified lines
319}324}
320 325
321void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecoverRequest* p_LTR_Recover_Request,326void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecoverRequest* p_LTR_Recover_Request,
322 long hr) {327 long hr, bool m_P2PmodeFlag) {
323
324 long bKLost = IsKeyFrameLost (pDecoder, p_LTR_Recover_Request, hr);328 long bKLost = IsKeyFrameLost (pDecoder, p_LTR_Recover_Request, hr);
325 bool m_P2PmodeFlag = true;
326 if (m_P2PmodeFlag) {329 if (m_P2PmodeFlag) {
327 if (bKLost == IDR_RECOVERY_REQUEST) {330 if (bKLost == IDR_RECOVERY_REQUEST) {
328 pEncoder->ForceIntraFrame (true);331 pEncoder->ForceIntraFrame (true);
@@ -335,9 +338,7 @@ void LTRRecoveryRequest (ISVCDecoder* pDecoder, ISVCEncoder* pEncoder, SLTRRecov · 6 unmodified lines
335 } else {338 } else {
336 if (bKLost == IDR_RECOVERY_REQUEST || bKLost == LTR_RECOVERY_REQUEST) {339 if (bKLost == IDR_RECOVERY_REQUEST || bKLost == LTR_RECOVERY_REQUEST) {
337 p_LTR_Recover_Request->uiFeedbackType = IDR_RECOVERY_REQUEST;340 p_LTR_Recover_Request->uiFeedbackType = IDR_RECOVERY_REQUEST;
338 pDecoder->GetOption (DECODER_OPTION_FRAME_NUM, &p_LTR_Recover_Request->iCurrentFrameNum);341 pEncoder->ForceIntraFrame (true);
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 }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
480TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLIDR) {481TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLIDR) {
481 EncodeDecodeFileParamBase p = GetParam();482 EncodeDecodeFileParamBase p = GetParam();
482 prepareParam (p.width, p.height, p.frameRate);483 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
483 encoder_->Uninitialize();484 encoder_->Uninitialize();
484 int rv = encoder_->InitializeExt (&param_);485 int rv = encoder_->InitializeExt (&param_);
485 ASSERT_TRUE (rv == cmResultSuccess);486 ASSERT_TRUE (rv == cmResultSuccess);
@@ -512,7 +513,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_ALLLTR) { · 26 unmodified lines
512 SLTRMarkingFeedback m_LTR_Marking_Feedback;513 SLTRMarkingFeedback m_LTR_Marking_Feedback;
513 SLTRRecoverRequest m_LTR_Recover_Request;514 SLTRRecoverRequest m_LTR_Recover_Request;
514 EncodeDecodeFileParamBase p = GetParam();515 EncodeDecodeFileParamBase p = GetParam();
515 prepareParam (p.width, p.height, p.frameRate);516 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
516 encoder_->Uninitialize();517 encoder_->Uninitialize();
517 int rv = encoder_->InitializeExt (&param_);518 int rv = encoder_->InitializeExt (&param_);
518 ASSERT_TRUE (rv == cmResultSuccess);519 ASSERT_TRUE (rv == cmResultSuccess);
@@ -571,9 +572,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_Engine) { · 52 unmodified lines
571 SLTRRecoverRequest m_LTR_Recover_Request;572 SLTRRecoverRequest m_LTR_Recover_Request;
572 m_LTR_Recover_Request.uiIDRPicId = 0;573 m_LTR_Recover_Request.uiIDRPicId = 0;
573 EncodeDecodeFileParamBase p = GetParam();574 EncodeDecodeFileParamBase p = GetParam();
574 prepareParam (p.width, p.height, p.frameRate);575 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
575 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
576 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
577 encoder_->Uninitialize();576 encoder_->Uninitialize();
578 int rv = encoder_->InitializeExt (&param_);577 int rv = encoder_->InitializeExt (&param_);
579 ASSERT_TRUE (rv == cmResultSuccess);578 ASSERT_TRUE (rv == cmResultSuccess);
@@ -610,9 +609,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionLTR_Engine) { · 30 unmodified lines
610 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);609 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
611 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);610 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
612 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction613 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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);615 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
617 iIdx++;616 iIdx++;
618 }617 }
@@ -623,9 +622,7 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_DISABLE) { · 4 unmodified lines
623 SLTRRecoverRequest m_LTR_Recover_Request;622 SLTRRecoverRequest m_LTR_Recover_Request;
624 m_LTR_Recover_Request.uiIDRPicId = 0;623 m_LTR_Recover_Request.uiIDRPicId = 0;
625 EncodeDecodeFileParamBase p = GetParam();624 EncodeDecodeFileParamBase p = GetParam();
626 prepareParam (p.width, p.height, p.frameRate);625 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
627 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
628 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
629 param_.bEnableLongTermReference = true;626 param_.bEnableLongTermReference = true;
630 param_.iLTRRefNum = 1;627 param_.iLTRRefNum = 1;
631 encoder_->Uninitialize();628 encoder_->Uninitialize();
@@ -676,9 +673,9 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_DISABLE) { · 44 unmodified lines
676 bVCLLoss);673 bVCLLoss);
677 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);674 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
678 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction677 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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);679 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
683 if (iSkipedBytes && bVCLLoss) {680 if (iSkipedBytes && bVCLLoss) {
684 ASSERT_TRUE (dstBufInfo_.iBufferStatus == 0);681 ASSERT_TRUE (dstBufInfo_.iBufferStatus == 0);
@@ -692,9 +689,7 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 7 unmodified lines
692 SLTRRecoverRequest m_LTR_Recover_Request;689 SLTRRecoverRequest m_LTR_Recover_Request;
693 m_LTR_Recover_Request.uiIDRPicId = 0;690 m_LTR_Recover_Request.uiIDRPicId = 0;
694 EncodeDecodeFileParamBase p = GetParam();691 EncodeDecodeFileParamBase p = GetParam();
695 prepareParam (p.width, p.height, p.frameRate);692 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
696 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
697 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
698 encoder_->Uninitialize();693 encoder_->Uninitialize();
699 int rv = encoder_->InitializeExt (&param_);694 int rv = encoder_->InitializeExt (&param_);
700 ASSERT_TRUE (rv == cmResultSuccess);695 ASSERT_TRUE (rv == cmResultSuccess);
@@ -734,9 +729,9 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECFlag_ERROR_CON_SLICE_COPY) { · 33 unmodified lines
734 decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);729 decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
735 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);730 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
736 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction733 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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);735 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
741 iIdx++;736 iIdx++;
742 }737 }
@@ -748,11 +743,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 5 unmodified lines
748 SLTRRecoverRequest m_LTR_Recover_Request;743 SLTRRecoverRequest m_LTR_Recover_Request;
749 m_LTR_Recover_Request.uiIDRPicId = 0;744 m_LTR_Recover_Request.uiIDRPicId = 0;
750 EncodeDecodeFileParamBase p = GetParam();745 EncodeDecodeFileParamBase p = GetParam();
751 prepareParam (p.width, p.height, p.frameRate);746 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
752 param_.bPrefixNalAddingCtrl = false;747 param_.bPrefixNalAddingCtrl = false;
753 param_.iTemporalLayerNum = (rand() % 4) + 1;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 encoder_->Uninitialize();749 encoder_->Uninitialize();
757 int rv = encoder_->InitializeExt (&param_);750 int rv = encoder_->InitializeExt (&param_);
758 ASSERT_TRUE (rv == cmResultSuccess);751 ASSERT_TRUE (rv == cmResultSuccess);
@@ -792,7 +785,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 33 unmodified lines
792 ASSERT_EQ (iTid, 0);785 ASSERT_EQ (iTid, 0);
793 }786 }
794 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction789 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
797 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);790 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
798 std::vector<SLostSim>::iterator iter = m_SLostSim.begin();791 std::vector<SLostSim>::iterator iter = m_SLostSim.begin();
@@ -808,7 +801,7 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_NOPREFIX) { · 9 unmodified lines
808 if (iTid != -1) {801 if (iTid != -1) {
809 ASSERT_EQ (iTid, 0);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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);805 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
813 iIdx++;806 iIdx++;
814 }807 }
@@ -819,12 +812,10 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) { · 4 unmodified lines
819 SLTRRecoverRequest m_LTR_Recover_Request;812 SLTRRecoverRequest m_LTR_Recover_Request;
820 m_LTR_Recover_Request.uiIDRPicId = 0;813 m_LTR_Recover_Request.uiIDRPicId = 0;
821 EncodeDecodeFileParamBase p = GetParam();814 EncodeDecodeFileParamBase p = GetParam();
822 prepareParam (p.width, p.height, p.frameRate);815 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
823 param_.bPrefixNalAddingCtrl = true;816 param_.bPrefixNalAddingCtrl = true;
824 param_.iTemporalLayerNum = (rand() % 4) + 1;817 param_.iTemporalLayerNum = (rand() % 4) + 1;
825 param_.iSpatialLayerNum = 1;818 param_.iSpatialLayerNum = 1;
826 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
827 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
828 encoder_->Uninitialize();819 encoder_->Uninitialize();
829 int rv = encoder_->InitializeExt (&param_);820 int rv = encoder_->InitializeExt (&param_);
830 ASSERT_TRUE (rv == cmResultSuccess);821 ASSERT_TRUE (rv == cmResultSuccess);
@@ -861,11 +852,11 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_AVC_WITH_PREFIX_NOLOSS) { · 30 unmodified lines
861 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);852 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
862 ASSERT_EQ (iTid, -1);853 ASSERT_EQ (iTid, -1);
863 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction856 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
866 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);857 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
867 ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);860 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
870 iIdx++;861 iIdx++;
871 }862 }
@@ -876,17 +867,9 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) { · 4 unmodified lines
876 SLTRRecoverRequest m_LTR_Recover_Request;867 SLTRRecoverRequest m_LTR_Recover_Request;
877 m_LTR_Recover_Request.uiIDRPicId = 0;868 m_LTR_Recover_Request.uiIDRPicId = 0;
878 EncodeDecodeFileParamBase p = GetParam();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 param_.iTemporalLayerNum = (rand() % 4) + 1;871 param_.iTemporalLayerNum = (rand() % 4) + 1;
881 param_.iSpatialLayerNum = 2;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 encoder_->Uninitialize();873 encoder_->Uninitialize();
891 int rv = encoder_->InitializeExt (&param_);874 int rv = encoder_->InitializeExt (&param_);
892 ASSERT_TRUE (rv == cmResultSuccess);875 ASSERT_TRUE (rv == cmResultSuccess);
@@ -923,11 +906,11 @@ TEST_P (EncodeDecodeTestAPI, GetOptionTid_SVC_L1_NOLOSS) { · 30 unmodified lines
923 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);906 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
924 ASSERT_EQ (iTid, -1);907 ASSERT_EQ (iTid, -1);
925 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction910 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
928 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);911 decoder_->GetOption (DECODER_OPTION_TEMPORAL_ID, &iTid);
929 ASSERT_EQ (iTid, info.sLayerInfo[0].uiTemporalId);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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);914 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
932 iIdx++;915 iIdx++;
933 }916 }
@@ -940,10 +923,8 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace) { · 6 unmodified lines
940 SLTRRecoverRequest m_LTR_Recover_Request;923 SLTRRecoverRequest m_LTR_Recover_Request;
941 m_LTR_Recover_Request.uiIDRPicId = 0;924 m_LTR_Recover_Request.uiIDRPicId = 0;
942 EncodeDecodeFileParamBase p = GetParam();925 EncodeDecodeFileParamBase p = GetParam();
943 prepareParam (p.width, p.height, p.frameRate);926 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
944 param_.iSpatialLayerNum = 1;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 int rv = encoder_->InitializeExt (&param_);929 int rv = encoder_->InitializeExt (&param_);
949 ASSERT_TRUE (rv == cmResultSuccess);930 ASSERT_TRUE (rv == cmResultSuccess);
@@ -992,9 +973,9 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace) { · 42 unmodified lines
992 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);973 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
993 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);974 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
994 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction977 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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);979 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
999 iIdx++;980 iIdx++;
1000 }981 }
@@ -1005,11 +986,8 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 4 unmodified lines
1005 SLTRRecoverRequest m_LTR_Recover_Request;986 SLTRRecoverRequest m_LTR_Recover_Request;
1006 m_LTR_Recover_Request.uiIDRPicId = 0;987 m_LTR_Recover_Request.uiIDRPicId = 0;
1007 EncodeDecodeFileParamBase p = GetParam();988 EncodeDecodeFileParamBase p = GetParam();
1008 prepareParam (p.width, p.height, p.frameRate);989 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
1009 param_.iSpatialLayerNum = 1;990 param_.iSpatialLayerNum = 1;
1010 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1011 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1012
1013 int rv = encoder_->InitializeExt (&param_);991 int rv = encoder_->InitializeExt (&param_);
1014 ASSERT_TRUE (rv == cmResultSuccess);992 ASSERT_TRUE (rv == cmResultSuccess);
1015 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;993 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;
@@ -1056,9 +1034,9 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 40 unmodified lines
1056 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);1034 SimulateNALLoss (info.sLayerInfo[0].pBsBuf, len, &m_SLostSim, p.pLossSequence, p.bLostPara, iLossIdx, bVCLLoss);
1057 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);1035 rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1058 m_LTR_Recover_Request.uiFeedbackType = NO_RECOVERY_REQUSET;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 rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction1038 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 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);1040 LTRMarkFeedback (decoder_, encoder_, &m_LTR_Marking_Feedback, rv);
1063 iIdx++;1041 iIdx++;
1064 }1042 }
@@ -1071,9 +1049,8 @@ TEST_P (EncodeDecodeTestAPI, SetOptionECIDC_GeneralSliceChange) { · 6 unmodified lines
1071 uint32_t uiEcIdc;1049 uint32_t uiEcIdc;
1072 uint32_t uiGet;1050 uint32_t uiGet;
1073 EncodeDecodeFileParamBase p = GetParam();1051 EncodeDecodeFileParamBase p = GetParam();
1074 prepareParam (p.width, p.height, p.frameRate);1052 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
1075 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;1053 param_.iSpatialLayerNum = 1;
1076 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1077 encoder_->Uninitialize();1054 encoder_->Uninitialize();
1078 int rv = encoder_->InitializeExt (&param_);1055 int rv = encoder_->InitializeExt (&param_);
1079 ASSERT_TRUE (rv == cmResultSuccess);1056 ASSERT_TRUE (rv == cmResultSuccess);
@@ -1152,9 +1129,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificFrameChange) { · 72 unmodified lines
1152 uint32_t uiEcIdc;1129 uint32_t uiEcIdc;
1153 uint32_t uiGet;1130 uint32_t uiGet;
1154 EncodeDecodeFileParamBase p = kFileParamArray[0];1131 EncodeDecodeFileParamBase p = kFileParamArray[0];
1155 prepareParam (p.width, p.height, p.frameRate);1132 prepareParam (1, p.slicenum, p.width, p.height, p.frameRate);
1156 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;1133 param_.iSpatialLayerNum = 1;
1157 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1158 encoder_->Uninitialize();1134 encoder_->Uninitialize();
1159 int rv = encoder_->InitializeExt (&param_);1135 int rv = encoder_->InitializeExt (&param_);
1160 ASSERT_TRUE (rv == cmResultSuccess);1136 ASSERT_TRUE (rv == cmResultSuccess);
@@ -1292,9 +1268,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRLoss) { · 131 unmodified lines
1292 uint32_t uiEcIdc;1268 uint32_t uiEcIdc;
1293 uint32_t uiGet;1269 uint32_t uiGet;
1294 EncodeDecodeFileParamBase p = kFileParamArray[0];1270 EncodeDecodeFileParamBase p = kFileParamArray[0];
1295 prepareParam (p.width, p.height, p.frameRate);1271 prepareParam (1, 2, p.width, p.height, p.frameRate);
1296 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;1272 param_.iSpatialLayerNum = 1;
1297 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2;
1298 encoder_->Uninitialize();1273 encoder_->Uninitialize();
1299 int rv = encoder_->InitializeExt (&param_);1274 int rv = encoder_->InitializeExt (&param_);
1300 ASSERT_TRUE (rv == cmResultSuccess);1275 ASSERT_TRUE (rv == cmResultSuccess);
@@ -1425,9 +1400,8 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRNoLoss) { · 124 unmodified lines
1425 uint32_t uiEcIdc;1400 uint32_t uiEcIdc;
1426 uint32_t uiGet;1401 uint32_t uiGet;
1427 EncodeDecodeFileParamBase p = kFileParamArray[0];1402 EncodeDecodeFileParamBase p = kFileParamArray[0];
1428 prepareParam (p.width, p.height, p.frameRate);1403 prepareParam (1, 2, p.width, p.height, p.frameRate);
1429 param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;1404 param_.iSpatialLayerNum = 1;
1430 param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2;
1431 encoder_->Uninitialize();1405 encoder_->Uninitialize();
1432 int rv = encoder_->InitializeExt (&param_);1406 int rv = encoder_->InitializeExt (&param_);
1433 ASSERT_TRUE (rv == cmResultSuccess);1407 ASSERT_TRUE (rv == cmResultSuccess);
@@ -1584,3 +1558,156 @@ TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRNoLoss) { · 150 unmodified lines
1584 1558
1585}1559}
1586 1560
1561static const EncodeDecodeFileParamBase kSVCSwitch[] = {
1562 {300, 160, 96, 6.0f, 2, 1, "120012130101012311201221323"},
1563};
1564
1565TEST_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 (&param_);
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
1628TEST_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 (&param_);
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}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t