History

Merge pull request #1380 from huili2/ec_option_free

add freely setoption for EC_idc and UT

HaiboZhu committed 12 years ago

Commit 06e56ec2 parents fd8db04 f6fb4594 files · +655 −9Browse files

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

Unified · Split

test/api/encode_decode_api_test.cpp+627−0
@@ -81,6 +81,14 @@ class EncodeDecodeTestBase : public ::testing::TestWithParam<EncodeDecodeFilePar · 80 unmodified lines
8181 }
8282 }
8383
84+ virtual void encToDecSliceData (const int iLayerNum, const int iSliceNum, const SFrameBSInfo& info, int& len) {
85+ ASSERT_TRUE (iLayerNum < MAX_LAYER_NUM_OF_FRAME);
86+ len = 0;
87+ const SLayerBSInfo& layerInfo = info.sLayerInfo[iLayerNum];
88+ if (iSliceNum < layerInfo.iNalCount)
89+ len = layerInfo.pNalLengthInByte[iSliceNum];
90+ }
91+
8492 protected:
8593 SEncParamExt param_;
8694 BufferedData buf_;
@@ -1208,3 +1216,622 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 1121 unmodified lines
12081216
12091217 INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,
12101218 ::testing::ValuesIn (kFileParamArray));
1219+
1220+TEST_P (EncodeDecodeTestAPI, SetOptionECIDC_GeneralSliceChange) {
1221+ uint32_t uiEcIdc;
1222+ uint32_t uiGet;
1223+ EncodeDecodeFileParamBase p = GetParam();
1224+ prepareParam (p.width, p.height, p.frameRate);
1225+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1226+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1227+ encoder_->Uninitialize();
1228+ int rv = encoder_->InitializeExt (&param_);
1229+ ASSERT_TRUE (rv == cmResultSuccess);
1230+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1231+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY); //default value should be ERROR_CON_SLICE_COPY
1232+
1233+ uiEcIdc = 0;
1234+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1235+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1236+ EXPECT_EQ (uiGet, uiEcIdc);
1237+
1238+ //Start for enc/dec
1239+ int frameSize = p.width * p.height * 3 / 2;
1240+ buf_.SetLength (frameSize);
1241+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1242+ SFrameBSInfo info;
1243+ memset (&info, 0, sizeof (SFrameBSInfo));
1244+
1245+ SSourcePicture pic;
1246+ memset (&pic, 0, sizeof (SSourcePicture));
1247+ pic.iPicWidth = p.width;
1248+ pic.iPicHeight = p.height;
1249+ pic.iColorFormat = videoFormatI420;
1250+ pic.iStride[0] = pic.iPicWidth;
1251+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1252+ pic.pData[0] = buf_.data();
1253+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1254+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1255+ int32_t iTraceLevel = WELS_LOG_QUIET;
1256+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1257+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1258+ int iIdx = 0;
1259+ bool bVCLLoss = false;
1260+ int iPacketNum;
1261+ int len;
1262+ int iTotalSliceSize;
1263+
1264+ //enc/dec pictures
1265+ while (iIdx <= p.numframes) {
1266+ memset (buf_.data(), rand() % 256, frameSize);
1267+ rv = encoder_->EncodeFrame (&pic, &info);
1268+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1269+ //decoding after each encoding frame
1270+ len = 0;
1271+ iPacketNum = 0;
1272+ iTotalSliceSize = 0;
1273+ unsigned char* pData[3] = { NULL };
1274+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1275+ while (iPacketNum < info.sLayerInfo[0].iNalCount) {
1276+ encToDecSliceData (0, iPacketNum, info, len);
1277+ uiEcIdc = (ERROR_CON_IDC) (rand() % 2);
1278+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1279+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1280+ EXPECT_EQ (uiGet, uiEcIdc);
1281+
1282+ bVCLLoss = rand() & 1; //loss or not
1283+ if (!bVCLLoss) { //not loss
1284+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf + iTotalSliceSize,
1285+ info.sLayerInfo[0].pNalLengthInByte[iPacketNum], pData, &dstBufInfo_);
1286+ if (uiEcIdc == ERROR_CON_DISABLE)
1287+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1288+ }
1289+ //EC_IDC should not change till now
1290+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1291+ EXPECT_EQ (uiGet, uiEcIdc);
1292+ //Set again inside
1293+ uiEcIdc = (ERROR_CON_IDC) (rand() % 2);
1294+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1295+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1296+ EXPECT_EQ (uiGet, uiEcIdc);
1297+
1298+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1299+ //EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1300+ if (uiEcIdc == ERROR_CON_DISABLE && rv != 0)
1301+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1302+
1303+ //deal with next slice
1304+ iTotalSliceSize += len;
1305+ iPacketNum++;
1306+ } //while slice
1307+ iIdx++;
1308+ } //while frame
1309+}
1310+
1311+//This case contain 1 slice per picture
1312+//coding order: 0 1 2 3 4 5 6 7
1313+//frame type: IDR P P P P P P P
1314+//EC_IDC: 0 0 0 2 0 0 1 1
1315+//loss: N Y N N N Y Y N
1316+
1317+TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificFrameChange) {
1318+ uint32_t uiEcIdc;
1319+ uint32_t uiGet;
1320+ EncodeDecodeFileParamBase p = kFileParamArray[0];
1321+ prepareParam (p.width, p.height, p.frameRate);
1322+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_SINGLE_SLICE;
1323+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = p.slicenum;
1324+ encoder_->Uninitialize();
1325+ int rv = encoder_->InitializeExt (&param_);
1326+ ASSERT_TRUE (rv == cmResultSuccess);
1327+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1328+ EXPECT_EQ (uiGet, (ERROR_CON_IDC) ERROR_CON_SLICE_COPY); //default value should be ERROR_CON_SLICE_COPY
1329+ int32_t iTraceLevel = WELS_LOG_QUIET;
1330+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1331+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1332+
1333+ //set EC=DISABLE
1334+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1335+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1336+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1337+ EXPECT_EQ (uiGet, uiEcIdc);
1338+
1339+ //Start for enc/dec
1340+ int frameSize = p.width * p.height * 3 / 2;
1341+ buf_.SetLength (frameSize);
1342+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1343+ SFrameBSInfo info;
1344+ memset (&info, 0, sizeof (SFrameBSInfo));
1345+
1346+ SSourcePicture pic;
1347+ memset (&pic, 0, sizeof (SSourcePicture));
1348+ pic.iPicWidth = p.width;
1349+ pic.iPicHeight = p.height;
1350+ pic.iColorFormat = videoFormatI420;
1351+ pic.iStride[0] = pic.iPicWidth;
1352+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1353+ pic.pData[0] = buf_.data();
1354+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1355+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1356+ int iIdx = 0;
1357+ int len = 0;
1358+ unsigned char* pData[3] = { NULL };
1359+
1360+ //Frame 0: IDR, EC_IDC=DISABLE, loss = 0
1361+ memset (buf_.data(), rand() % 256, frameSize);
1362+ rv = encoder_->EncodeFrame (&pic, &info);
1363+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1364+ encToDecData (info, len);
1365+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1366+ EXPECT_EQ (uiGet, (ERROR_CON_IDC) ERROR_CON_DISABLE);
1367+ pData[0] = pData[1] = pData[2] = 0;
1368+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1369+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1370+ EXPECT_EQ (rv, 0);
1371+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1372+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1373+ EXPECT_EQ (rv, 0);
1374+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);
1375+ iIdx++;
1376+
1377+ //Frame 1: P, EC_IDC=DISABLE, loss = 1
1378+ memset (buf_.data(), rand() % 256, frameSize);
1379+ rv = encoder_->EncodeFrame (&pic, &info);
1380+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1381+ iIdx++;
1382+
1383+ //Frame 2: P, EC_IDC=DISABLE, loss = 0
1384+ memset (buf_.data(), rand() % 256, frameSize);
1385+ rv = encoder_->EncodeFrame (&pic, &info);
1386+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1387+ encToDecData (info, len);
1388+ pData[0] = pData[1] = pData[2] = 0;
1389+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1390+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1391+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1392+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1393+ EXPECT_EQ (rv, 0); //parse correct
1394+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //no output
1395+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1396+ EXPECT_TRUE (rv != 0); //construction error due to data loss
1397+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //no output due to EC DISABLE
1398+ iIdx++;
1399+
1400+ //set EC=SLICE_COPY
1401+ uiEcIdc = (uint32_t) (ERROR_CON_SLICE_COPY);
1402+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1403+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1404+ EXPECT_EQ (uiGet, uiEcIdc);
1405+ //Frame 3: P, EC_IDC=SLICE_COPY, loss = 0
1406+ memset (buf_.data(), rand() % 256, frameSize);
1407+ rv = encoder_->EncodeFrame (&pic, &info);
1408+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1409+ encToDecData (info, len);
1410+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1411+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY);
1412+ pData[0] = pData[1] = pData[2] = 0;
1413+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1414+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1415+ EXPECT_EQ (rv, 0); //parse correct
1416+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //no output
1417+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1418+ EXPECT_TRUE (rv != 0); //construction error due to data loss
1419+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);
1420+ iIdx++;
1421+
1422+ //set EC=DISABLE
1423+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1424+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1425+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1426+ EXPECT_EQ (uiGet, uiEcIdc);
1427+ //Frame 4: P, EC_IDC=DISABLE, loss = 0
1428+ memset (buf_.data(), rand() % 256, frameSize);
1429+ rv = encoder_->EncodeFrame (&pic, &info);
1430+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1431+ encToDecData (info, len);
1432+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1433+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1434+ pData[0] = pData[1] = pData[2] = 0;
1435+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1436+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1437+ EXPECT_EQ (rv, 0); //parse correct
1438+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //no output
1439+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1440+ if (rv == 0) //TODO: should depend on if ref-frame is OK.
1441+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);
1442+ else
1443+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1444+ iIdx++;
1445+
1446+ //Frame 5: P, EC_IDC=DISABLE, loss = 1
1447+ memset (buf_.data(), rand() % 256, frameSize);
1448+ rv = encoder_->EncodeFrame (&pic, &info);
1449+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1450+ iIdx++;
1451+
1452+ //set EC=FRAME_COPY
1453+ uiEcIdc = (uint32_t) (ERROR_CON_FRAME_COPY);
1454+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1455+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1456+ EXPECT_EQ (uiGet, uiEcIdc);
1457+ //Frame 6: P, EC_IDC=FRAME_COPY, loss = 1
1458+ memset (buf_.data(), rand() % 256, frameSize);
1459+ rv = encoder_->EncodeFrame (&pic, &info);
1460+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1461+ EXPECT_EQ (uiGet, uiEcIdc);
1462+ iIdx++;
1463+
1464+ //Frame 7: P, EC_IDC=FRAME_COPY, loss = 0
1465+ memset (buf_.data(), rand() % 256, frameSize);
1466+ rv = encoder_->EncodeFrame (&pic, &info);
1467+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1468+ encToDecData (info, len);
1469+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1470+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_FRAME_COPY);
1471+ pData[0] = pData[1] = pData[2] = 0;
1472+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1473+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1474+ EXPECT_TRUE (rv != 0); //parse correct, but previous decoding error, ECed
1475+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //no output
1476+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1477+ EXPECT_TRUE (rv != 0); //not sure if previous data drop would be detected in construction
1478+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);
1479+ iIdx++;
1480+
1481+}
1482+
1483+//This case contain 2 slices per picture for IDR loss
1484+//coding order: 0 1 2 3 4
1485+//frame type IDR P P P P
1486+//EC_IDC 2 2 0 1 0
1487+//loss (2 slice: 1,2): 2 0 0 1 0
1488+
1489+TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRLoss) {
1490+ uint32_t uiEcIdc;
1491+ uint32_t uiGet;
1492+ EncodeDecodeFileParamBase p = kFileParamArray[0];
1493+ prepareParam (p.width, p.height, p.frameRate);
1494+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1495+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2;
1496+ encoder_->Uninitialize();
1497+ int rv = encoder_->InitializeExt (&param_);
1498+ ASSERT_TRUE (rv == cmResultSuccess);
1499+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1500+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY); //default value should be ERROR_CON_SLICE_COPY
1501+ int32_t iTraceLevel = WELS_LOG_QUIET;
1502+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1503+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1504+
1505+ //Start for enc/dec
1506+ int frameSize = p.width * p.height * 3 / 2;
1507+ buf_.SetLength (frameSize);
1508+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1509+ SFrameBSInfo info;
1510+ memset (&info, 0, sizeof (SFrameBSInfo));
1511+
1512+ SSourcePicture pic;
1513+ memset (&pic, 0, sizeof (SSourcePicture));
1514+ pic.iPicWidth = p.width;
1515+ pic.iPicHeight = p.height;
1516+ pic.iColorFormat = videoFormatI420;
1517+ pic.iStride[0] = pic.iPicWidth;
1518+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1519+ pic.pData[0] = buf_.data();
1520+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1521+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1522+ int iIdx = 0;
1523+ int len = 0;
1524+ unsigned char* pData[3] = { NULL };
1525+ int iTotalSliceSize = 0;
1526+
1527+ //Frame 0: IDR, EC_IDC=2, loss = 2
1528+ memset (buf_.data(), rand() % 256, frameSize);
1529+ rv = encoder_->EncodeFrame (&pic, &info);
1530+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1531+ iTotalSliceSize = 0;
1532+ encToDecSliceData (0, 0, info, len); //SPS
1533+ iTotalSliceSize = len;
1534+ encToDecSliceData (0, 1, info, len); //PPS
1535+ iTotalSliceSize += len;
1536+ encToDecSliceData (1, 0, info, len); //first slice
1537+ iTotalSliceSize += len;
1538+ //second slice loss
1539+ pData[0] = pData[1] = pData[2] = 0;
1540+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1541+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1542+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY);
1543+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, iTotalSliceSize, pData, &dstBufInfo_);
1544+ EXPECT_EQ (rv, 0); //parse correct
1545+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1546+ EXPECT_EQ (rv, 0); //parse correct
1547+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //slice incomplete, no output
1548+ iIdx++;
1549+
1550+ //Frame 1: P, EC_IDC=2, loss = 0
1551+ //will clean SPS/PPS status
1552+ memset (buf_.data(), rand() % 256, frameSize);
1553+ rv = encoder_->EncodeFrame (&pic, &info);
1554+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1555+ encToDecData (info, len); //all slice together
1556+ pData[0] = pData[1] = pData[2] = 0;
1557+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1558+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1559+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY);
1560+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1561+ EXPECT_TRUE (rv & 32); //parse correct, but reconstruct ECed
1562+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //ECed output for frame 0
1563+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //ECed status, reconstruction current frame 1
1564+ EXPECT_TRUE (rv & 32); //decoder ECed status
1565+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //ECed output for frame 1
1566+ iIdx++;
1567+
1568+ //set EC=DISABLE
1569+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1570+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1571+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1572+ EXPECT_EQ (uiGet, uiEcIdc);
1573+ //Frame 2: P, EC_IDC=0, loss = 0
1574+ /////will clean SPS/PPS status
1575+ memset (buf_.data(), rand() % 256, frameSize);
1576+ rv = encoder_->EncodeFrame (&pic, &info);
1577+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1578+ encToDecData (info, len); //all slice together
1579+ pData[0] = pData[1] = pData[2] = 0;
1580+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1581+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1582+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1583+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1584+ EXPECT_EQ (rv, 0); //parse correct
1585+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1586+ if (rv == 0) //TODO: should depend on if ref-frame is OK.
1587+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1);
1588+ else
1589+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1590+ iIdx++;
1591+
1592+ //set EC=SLICE_COPY
1593+ uiEcIdc = (uint32_t) (ERROR_CON_FRAME_COPY);
1594+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1595+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1596+ EXPECT_EQ (uiGet, uiEcIdc);
1597+ //Frame 3: P, EC_IDC=2, loss = 1
1598+ memset (buf_.data(), rand() % 256, frameSize);
1599+ rv = encoder_->EncodeFrame (&pic, &info);
1600+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1601+ encToDecSliceData (0, 0, info, iTotalSliceSize); //slice 1 lost
1602+ encToDecSliceData (0, 1, info, len); //slice 2
1603+ pData[0] = pData[1] = pData[2] = 0;
1604+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1605+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1606+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_FRAME_COPY);
1607+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf + iTotalSliceSize, len, pData, &dstBufInfo_);
1608+ EXPECT_TRUE (rv & 32);
1609+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1610+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1611+ EXPECT_TRUE (rv & 32);
1612+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //slice loss
1613+ iIdx++;
1614+
1615+ //set EC=DISABLE
1616+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1617+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1618+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1619+ EXPECT_EQ (uiGet, uiEcIdc);
1620+ //Frame 4: P, EC_IDC=0, loss = 0
1621+ memset (buf_.data(), rand() % 256, frameSize);
1622+ rv = encoder_->EncodeFrame (&pic, &info);
1623+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1624+ encToDecData (info, len); //all slice
1625+ pData[0] = pData[1] = pData[2] = 0;
1626+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1627+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1628+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1629+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1630+ EXPECT_TRUE (rv != 0);
1631+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //output previous pic
1632+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1633+ EXPECT_TRUE (rv != 0);
1634+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //output previous pic
1635+ iIdx++;
1636+
1637+}
1638+
1639+
1640+
1641+//This case contain 2 slices per picture for no IDR loss
1642+//coding order: 0 1 2 3 4 5
1643+//frame type IDR P P P P IDR
1644+//EC_IDC 0 2 0 2 0 ^2^
1645+//loss (2 slice: 1,2): 0 0 1 2 0 0
1646+
1647+TEST_F (EncodeDecodeTestAPI, SetOptionECIDC_SpecificSliceChange_IDRNoLoss) {
1648+ uint32_t uiEcIdc;
1649+ uint32_t uiGet;
1650+ EncodeDecodeFileParamBase p = kFileParamArray[0];
1651+ prepareParam (p.width, p.height, p.frameRate);
1652+ param_.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
1653+ param_.sSpatialLayers[0].sSliceCfg.sSliceArgument.uiSliceNum = 2;
1654+ encoder_->Uninitialize();
1655+ int rv = encoder_->InitializeExt (&param_);
1656+ ASSERT_TRUE (rv == cmResultSuccess);
1657+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1658+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY); //default value should be ERROR_CON_SLICE_COPY
1659+ int32_t iTraceLevel = WELS_LOG_QUIET;
1660+ encoder_->SetOption (ENCODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1661+ decoder_->SetOption (DECODER_OPTION_TRACE_LEVEL, &iTraceLevel);
1662+
1663+ //Start for enc/dec
1664+ int frameSize = p.width * p.height * 3 / 2;
1665+ buf_.SetLength (frameSize);
1666+ ASSERT_TRUE (buf_.Length() == (size_t)frameSize);
1667+ SFrameBSInfo info;
1668+ memset (&info, 0, sizeof (SFrameBSInfo));
1669+
1670+ SSourcePicture pic;
1671+ memset (&pic, 0, sizeof (SSourcePicture));
1672+ pic.iPicWidth = p.width;
1673+ pic.iPicHeight = p.height;
1674+ pic.iColorFormat = videoFormatI420;
1675+ pic.iStride[0] = pic.iPicWidth;
1676+ pic.iStride[1] = pic.iStride[2] = pic.iPicWidth >> 1;
1677+ pic.pData[0] = buf_.data();
1678+ pic.pData[1] = pic.pData[0] + p.width * p.height;
1679+ pic.pData[2] = pic.pData[1] + (p.width * p.height >> 2);
1680+ int iIdx = 0;
1681+ int len = 0;
1682+ unsigned char* pData[3] = { NULL };
1683+ int iTotalSliceSize = 0;
1684+
1685+ //set EC=DISABLE
1686+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1687+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1688+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1689+ EXPECT_EQ (uiGet, uiEcIdc);
1690+ //Frame 0: IDR, EC_IDC=0, loss = 0
1691+ //Expected result: all OK, 2nd Output
1692+ memset (buf_.data(), rand() % 256, frameSize);
1693+ rv = encoder_->EncodeFrame (&pic, &info);
1694+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1695+ encToDecData (info, len); //all slice
1696+ pData[0] = pData[1] = pData[2] = 0;
1697+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1698+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1699+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1700+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1701+ EXPECT_EQ (rv, 0); //parse correct
1702+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1703+ EXPECT_EQ (rv, 0); //parse correct
1704+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //output frame 0
1705+ iIdx++;
1706+
1707+ //Frame 1: P, EC_IDC=0, loss = 0
1708+ //Expected result: all OK, 2nd Output
1709+ memset (buf_.data(), rand() % 256, frameSize);
1710+ rv = encoder_->EncodeFrame (&pic, &info);
1711+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1712+ encToDecData (info, len); //all slice together
1713+ pData[0] = pData[1] = pData[2] = 0;
1714+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1715+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1716+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1717+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1718+ EXPECT_EQ (rv, 0); //parse correct
1719+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //ECed output for frame 0
1720+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction current frame 1
1721+ EXPECT_EQ (rv, 0); //parse correct
1722+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //ECed output for frame 1
1723+ iIdx++;
1724+
1725+ //Frame 2: P, EC_IDC=0, loss = 1
1726+ //Expected result: all OK, no Output
1727+ memset (buf_.data(), rand() % 256, frameSize);
1728+ rv = encoder_->EncodeFrame (&pic, &info);
1729+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1730+ encToDecSliceData (0, 0, info, iTotalSliceSize); // slice 1 lost
1731+ encToDecSliceData (0, 1, info, len); // slice 2 only
1732+ pData[0] = pData[1] = pData[2] = 0;
1733+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1734+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1735+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1736+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf + iTotalSliceSize, len, pData, &dstBufInfo_);
1737+ EXPECT_EQ (rv, 0); //parse correct
1738+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1739+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1740+ EXPECT_EQ (rv, 0); //parse correct
1741+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0);
1742+ iIdx++;
1743+
1744+ //set EC=SLICE_COPY
1745+ uiEcIdc = (uint32_t) (ERROR_CON_SLICE_COPY);
1746+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1747+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1748+ EXPECT_EQ (uiGet, uiEcIdc);
1749+ //Frame 3: P, EC_IDC=2, loss = 2
1750+ //Expected result: neither OK, 1st Output
1751+ memset (buf_.data(), rand() % 256, frameSize);
1752+ rv = encoder_->EncodeFrame (&pic, &info);
1753+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1754+ encToDecSliceData (0, 0, info, len); //slice 1 only
1755+ pData[0] = pData[1] = pData[2] = 0;
1756+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1757+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1758+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_SLICE_COPY);
1759+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1760+ EXPECT_TRUE (rv & 32); //ECed
1761+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //slice loss but ECed output Frame 2
1762+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction
1763+ EXPECT_TRUE (rv & 32);
1764+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //slice loss
1765+ iIdx++;
1766+
1767+ //set EC=DISABLE
1768+ uiEcIdc = (uint32_t) (ERROR_CON_DISABLE);
1769+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1770+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1771+ EXPECT_EQ (uiGet, uiEcIdc);
1772+ //Frame 4: P, EC_IDC=0, loss = 0
1773+ //Expected result: depends on DecodeFrame2 result. If OK, output; else ,no output
1774+ memset (buf_.data(), rand() % 256, frameSize);
1775+ rv = encoder_->EncodeFrame (&pic, &info);
1776+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1777+ encToDecData (info, len); //all slice
1778+ pData[0] = pData[1] = pData[2] = 0;
1779+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1780+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1781+ EXPECT_EQ (uiGet, (uint32_t) ERROR_CON_DISABLE);
1782+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, len, pData, &dstBufInfo_);
1783+ EXPECT_TRUE (rv != 0); //previous slice not outputted, will return error due to incomplete frame
1784+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //output previous pic
1785+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction,
1786+ //not sure if current frame can be correctly decoded
1787+ if (rv == 0)
1788+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //output previous pic
1789+ else
1790+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //output previous pic
1791+ iIdx++;
1792+
1793+ //Frame 5: IDR, EC_IDC=2->0, loss = 0
1794+ //Expected result: depends on DecodeFrame2 result. If OK, output; else ,no output
1795+ int32_t iIDRPeriod = 1;
1796+ encoder_->SetOption (ENCODER_OPTION_IDR_INTERVAL, &iIDRPeriod);
1797+ memset (buf_.data(), rand() % 256, frameSize);
1798+ rv = encoder_->EncodeFrame (&pic, &info);
1799+ ASSERT_TRUE (rv == cmResultSuccess || rv == cmUnkonwReason);
1800+ EXPECT_TRUE (info.eFrameType == videoFrameTypeIDR);
1801+ encToDecSliceData (0, 0, info, len); //SPS
1802+ iTotalSliceSize = len;
1803+ encToDecSliceData (0, 1, info, len); //PPS
1804+ iTotalSliceSize += len;
1805+ encToDecSliceData (1, 0, info, len); //slice 1
1806+ iTotalSliceSize += len;
1807+ //set EC=SLICE_COPY for slice 1
1808+ uiEcIdc = (uint32_t) (ERROR_CON_SLICE_COPY);
1809+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1810+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1811+ EXPECT_EQ (uiGet, uiEcIdc);
1812+ pData[0] = pData[1] = pData[2] = 0;
1813+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1814+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf, iTotalSliceSize, pData, &dstBufInfo_);
1815+ EXPECT_TRUE (rv != 0); //TODO: should be correct, now ECed status will return error
1816+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //frame incomplete
1817+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction,
1818+ EXPECT_TRUE (rv != 0); //TODO: as above
1819+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //output previous pic
1820+ //set EC=DISABLE for slice 2
1821+ encToDecSliceData (1, 1, info, len); //slice 1
1822+ uiEcIdc = (int) (ERROR_CON_DISABLE);
1823+ decoder_->SetOption (DECODER_OPTION_ERROR_CON_IDC, &uiEcIdc);
1824+ decoder_->GetOption (DECODER_OPTION_ERROR_CON_IDC, &uiGet);
1825+ EXPECT_EQ (uiGet, uiEcIdc);
1826+ pData[0] = pData[1] = pData[2] = 0;
1827+ memset (&dstBufInfo_, 0, sizeof (SBufferInfo));
1828+ rv = decoder_->DecodeFrame2 (info.sLayerInfo[0].pBsBuf + iTotalSliceSize, len, pData, &dstBufInfo_);
1829+ EXPECT_EQ (rv, 0); //Parse correct under no EC
1830+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 0); //frame incomplete
1831+ rv = decoder_->DecodeFrame2 (NULL, 0, pData, &dstBufInfo_); //reconstruction,
1832+ EXPECT_EQ (rv, 0); //Parse correct under no EC
1833+ EXPECT_EQ (dstBufInfo_.iBufferStatus, 1); //output previous pic
1834+ iIdx++;
1835+
1836+}
1837+

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