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
81 }81 }
82 }82 }
83 83
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
84 protected:92 protected:
85 SEncParamExt param_;93 SEncParamExt param_;
86 BufferedData buf_;94 BufferedData buf_;
@@ -1208,3 +1216,622 @@ TEST_P (EncodeDecodeTestAPI, SetOption_Trace_NULL) { · 1121 unmodified lines
1208 1216
1209INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,1217INSTANTIATE_TEST_CASE_P (EncodeDecodeTestBase, EncodeDecodeTestAPI,
1210 ::testing::ValuesIn (kFileParamArray));1218 ::testing::ValuesIn (kFileParamArray));
1219
1220TEST_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
1317TEST_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
1489TEST_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
1647TEST_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