1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include <assert.h> 12 #include <math.h> 13 #include <stdlib.h> 14 #include <string.h> 15 16 #include "testing/gtest/include/gtest/gtest.h" 17 #include "webrtc/modules/video_coding/codecs/test_framework/unit_test.h" 18 #include "webrtc/modules/video_coding/codecs/test_framework/video_source.h" 19 #include "webrtc/system_wrappers/interface/tick_util.h" 20 #include "webrtc/test/testsupport/fileutils.h" 21 22 using namespace webrtc; 23 24 UnitTest::UnitTest() 25 : 26 CodecTest("UnitTest", "Unit test"), 27 _tests(0), 28 _errors(0), 29 _source(NULL), 30 _refFrame(NULL), 31 _refEncFrame(NULL), 32 _refDecFrame(NULL), 33 _refEncFrameLength(0), 34 _sourceFile(NULL), 35 is_key_frame_(false), 36 _encodeCompleteCallback(NULL), 37 _decodeCompleteCallback(NULL) 38 { 39 } 40 41 UnitTest::UnitTest(std::string name, std::string description) 42 : 43 CodecTest(name, description), 44 _tests(0), 45 _errors(0), 46 _source(NULL), 47 _refFrame(NULL), 48 _refEncFrame(NULL), 49 _refDecFrame(NULL), 50 _refEncFrameLength(0), 51 _sourceFile(NULL), 52 is_key_frame_(false), 53 _encodeCompleteCallback(NULL), 54 _decodeCompleteCallback(NULL) 55 { 56 } 57 58 UnitTest::~UnitTest() 59 { 60 if (_encodeCompleteCallback) { 61 delete _encodeCompleteCallback; 62 } 63 64 if (_decodeCompleteCallback) { 65 delete _decodeCompleteCallback; 66 } 67 68 if (_source) { 69 delete _source; 70 } 71 72 if (_refFrame) { 73 delete [] _refFrame; 74 } 75 76 if (_refDecFrame) { 77 delete [] _refDecFrame; 78 } 79 80 if (_sourceBuffer) { 81 delete [] _sourceBuffer; 82 } 83 84 if (_sourceFile) { 85 fclose(_sourceFile); 86 } 87 88 if (_refEncFrame) { 89 delete [] _refEncFrame; 90 } 91 } 92 93 int32_t 94 UnitTestEncodeCompleteCallback::Encoded(EncodedImage& encodedImage, 95 const webrtc::CodecSpecificInfo* codecSpecificInfo, 96 const webrtc::RTPFragmentationHeader* 97 fragmentation) 98 { 99 _encodedVideoBuffer->VerifyAndAllocate(encodedImage._size); 100 _encodedVideoBuffer->CopyFrame(encodedImage._size, encodedImage._buffer); 101 _encodedVideoBuffer->SetLength(encodedImage._length); 102 // TODO(mikhal): Update frame type API. 103 // _encodedVideoBuffer->SetFrameType(encodedImage._frameType); 104 _encodedVideoBuffer->SetWidth( 105 (uint16_t)encodedImage._encodedWidth); 106 _encodedVideoBuffer->SetHeight( 107 (uint16_t)encodedImage._encodedHeight); 108 _encodedVideoBuffer->SetTimeStamp(encodedImage._timeStamp); 109 _encodeComplete = true; 110 _encodedFrameType = encodedImage._frameType; 111 return 0; 112 } 113 114 int32_t UnitTestDecodeCompleteCallback::Decoded(I420VideoFrame& image) 115 { 116 _decodedVideoBuffer->CopyFrame(image); 117 _decodeComplete = true; 118 return 0; 119 } 120 121 bool 122 UnitTestEncodeCompleteCallback::EncodeComplete() 123 { 124 if (_encodeComplete) 125 { 126 _encodeComplete = false; 127 return true; 128 } 129 return false; 130 } 131 132 VideoFrameType 133 UnitTestEncodeCompleteCallback::EncodedFrameType() const 134 { 135 return _encodedFrameType; 136 } 137 138 bool 139 UnitTestDecodeCompleteCallback::DecodeComplete() 140 { 141 if (_decodeComplete) 142 { 143 _decodeComplete = false; 144 return true; 145 } 146 return false; 147 } 148 149 uint32_t 150 UnitTest::WaitForEncodedFrame() const 151 { 152 int64_t startTime = TickTime::MillisecondTimestamp(); 153 while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitEncTimeMs) 154 { 155 if (_encodeCompleteCallback->EncodeComplete()) 156 { 157 return _encodedVideoBuffer.Length(); 158 } 159 } 160 return 0; 161 } 162 163 uint32_t 164 UnitTest::WaitForDecodedFrame() const 165 { 166 int64_t startTime = TickTime::MillisecondTimestamp(); 167 while (TickTime::MillisecondTimestamp() - startTime < kMaxWaitDecTimeMs) 168 { 169 if (_decodeCompleteCallback->DecodeComplete()) 170 { 171 return webrtc::CalcBufferSize(kI420, _decodedVideoBuffer.width(), 172 _decodedVideoBuffer.height()); 173 } 174 } 175 return 0; 176 } 177 178 uint32_t 179 UnitTest::CodecSpecific_SetBitrate(uint32_t bitRate, 180 uint32_t /* frameRate */) 181 { 182 return _encoder->SetRates(bitRate, _inst.maxFramerate); 183 } 184 185 void 186 UnitTest::Setup() 187 { 188 // Use _sourceFile as a check to prevent multiple Setup() calls. 189 if (_sourceFile != NULL) 190 { 191 return; 192 } 193 194 if (_encodeCompleteCallback == NULL) 195 { 196 _encodeCompleteCallback = 197 new UnitTestEncodeCompleteCallback(&_encodedVideoBuffer); 198 } 199 if (_decodeCompleteCallback == NULL) 200 { 201 _decodeCompleteCallback = 202 new UnitTestDecodeCompleteCallback(&_decodedVideoBuffer); 203 } 204 205 _encoder->RegisterEncodeCompleteCallback(_encodeCompleteCallback); 206 _decoder->RegisterDecodeCompleteCallback(_decodeCompleteCallback); 207 208 _source = new VideoSource(webrtc::test::ProjectRootPath() + 209 "resources/foreman_cif.yuv", kCIF); 210 211 _lengthSourceFrame = _source->GetFrameLength(); 212 _refFrame = new unsigned char[_lengthSourceFrame]; 213 _refDecFrame = new unsigned char[_lengthSourceFrame]; 214 _sourceBuffer = new unsigned char [_lengthSourceFrame]; 215 _sourceFile = fopen(_source->GetFileName().c_str(), "rb"); 216 ASSERT_TRUE(_sourceFile != NULL); 217 218 _inst.maxFramerate = _source->GetFrameRate(); 219 _bitRate = 300; 220 _inst.startBitrate = 300; 221 _inst.maxBitrate = 4000; 222 _inst.width = _source->GetWidth(); 223 _inst.height = _source->GetHeight(); 224 _inst.qpMax = 56; 225 _inst.codecSpecific.VP8.denoisingOn = true; 226 227 // Get input frame. 228 ASSERT_TRUE(fread(_refFrame, 1, _lengthSourceFrame, _sourceFile) 229 == _lengthSourceFrame); 230 int size_y = _inst.width * _inst.height; 231 int size_uv = ((_inst.width + 1) / 2) * ((_inst.height + 1) / 2); 232 _inputVideoBuffer.CreateFrame(size_y, _refFrame, 233 size_uv, _refFrame + size_y, 234 size_uv, _refFrame + size_y + size_uv, 235 _inst.width, _inst.height, 236 _inst.width, 237 (_inst.width + 1) / 2, (_inst.width + 1) / 2); 238 rewind(_sourceFile); 239 240 // Get a reference encoded frame. 241 _encodedVideoBuffer.VerifyAndAllocate(_lengthSourceFrame); 242 243 // Ensures our initial parameters are valid. 244 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 245 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 246 _refEncFrameLength = WaitForEncodedFrame(); 247 ASSERT_TRUE(_refEncFrameLength > 0); 248 _refEncFrame = new unsigned char[_refEncFrameLength]; 249 memcpy(_refEncFrame, _encodedVideoBuffer.Buffer(), _refEncFrameLength); 250 251 // Get a reference decoded frame. 252 _decodedVideoBuffer.CreateEmptyFrame(_inst.width, _inst.height, _inst.width, 253 (_inst.width + 1) / 2, 254 (_inst.width + 1) / 2); 255 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 256 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 257 258 unsigned int frameLength = 0; 259 int i = 0; 260 _inputVideoBuffer.CreateEmptyFrame(_inst.width, _inst.height, _inst.width, 261 (_inst.width + 1) / 2, 262 (_inst.width + 1) / 2); 263 while (frameLength == 0) 264 { 265 EncodedImage encodedImage; 266 if (i > 0) 267 { 268 // Insert yet another frame. 269 ASSERT_TRUE(fread(_refFrame, 1, _lengthSourceFrame, 270 _sourceFile) == _lengthSourceFrame); 271 EXPECT_EQ(0, ConvertToI420(kI420, _refFrame, 0, 0, _width, _height, 272 0, kRotateNone, &_inputVideoBuffer)); 273 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 274 ASSERT_TRUE(WaitForEncodedFrame() > 0); 275 } else { 276 // The first frame is always a key frame. 277 encodedImage._frameType = kKeyFrame; 278 } 279 280 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 281 ASSERT_TRUE(_decoder->Decode(encodedImage, 0, NULL) 282 == WEBRTC_VIDEO_CODEC_OK); 283 frameLength = WaitForDecodedFrame(); 284 _encodedVideoBuffer.SetLength(0); 285 i++; 286 } 287 rewind(_sourceFile); 288 EXPECT_TRUE(frameLength == _lengthSourceFrame); 289 ExtractBuffer(_decodedVideoBuffer, _lengthSourceFrame, _refDecFrame); 290 } 291 292 void 293 UnitTest::Teardown() 294 { 295 // Use _sourceFile as a check to prevent multiple Teardown() calls. 296 if (_sourceFile == NULL) 297 { 298 return; 299 } 300 301 _encoder->Release(); 302 _decoder->Release(); 303 304 fclose(_sourceFile); 305 _sourceFile = NULL; 306 delete [] _refFrame; 307 _refFrame = NULL; 308 delete [] _refEncFrame; 309 _refEncFrame = NULL; 310 delete [] _refDecFrame; 311 _refDecFrame = NULL; 312 delete [] _sourceBuffer; 313 _sourceBuffer = NULL; 314 } 315 316 void 317 UnitTest::Print() 318 { 319 } 320 321 int 322 UnitTest::DecodeWithoutAssert() 323 { 324 EncodedImage encodedImage; 325 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 326 int ret = _decoder->Decode(encodedImage, 0, NULL); 327 int frameLength = WaitForDecodedFrame(); 328 _encodedVideoBuffer.SetLength(0); 329 return ret == WEBRTC_VIDEO_CODEC_OK ? frameLength : ret; 330 } 331 332 int 333 UnitTest::Decode() 334 { 335 EncodedImage encodedImage; 336 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 337 if (encodedImage._length == 0) 338 { 339 return WEBRTC_VIDEO_CODEC_OK; 340 } 341 if (is_key_frame_) { 342 encodedImage._frameType = kKeyFrame; 343 } 344 345 int ret = _decoder->Decode(encodedImage, 0, NULL); 346 unsigned int frameLength = WaitForDecodedFrame(); 347 assert(ret == WEBRTC_VIDEO_CODEC_OK && (frameLength == 0 || frameLength 348 == _lengthSourceFrame)); 349 EXPECT_TRUE(ret == WEBRTC_VIDEO_CODEC_OK && (frameLength == 0 || frameLength 350 == _lengthSourceFrame)); 351 _encodedVideoBuffer.SetLength(0); 352 return ret == WEBRTC_VIDEO_CODEC_OK ? frameLength : ret; 353 } 354 355 // Test pure virtual VideoEncoder and VideoDecoder APIs. 356 void 357 UnitTest::Perform() 358 { 359 UnitTest::Setup(); 360 int frameLength; 361 I420VideoFrame inputImage; 362 EncodedImage encodedImage; 363 364 //----- Encoder parameter tests ----- 365 366 //-- Calls before InitEncode() -- 367 // We want to revert the initialization done in Setup(). 368 EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK); 369 EXPECT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, NULL) 370 == WEBRTC_VIDEO_CODEC_UNINITIALIZED); 371 372 //-- InitEncode() errors -- 373 // Null pointer. 374 EXPECT_TRUE(_encoder->InitEncode(NULL, 1, 1440) == 375 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 376 // bit rate exceeds max bit rate 377 int32_t tmpBitRate = _inst.startBitrate; 378 int32_t tmpMaxBitRate = _inst.maxBitrate; 379 _inst.startBitrate = 4000; 380 _inst.maxBitrate = 3000; 381 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 382 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 383 _inst.startBitrate = tmpBitRate; 384 _inst.maxBitrate = tmpMaxBitRate; //unspecified value 385 386 // Bad framerate. 387 _inst.maxFramerate = 0; 388 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 389 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 390 // Seems like we should allow any framerate in range [0, 255]. 391 //_inst.frameRate = 100; 392 //EXPECT_TRUE(_encoder->InitEncode(&_inst, 1) == -1); // FAILS 393 _inst.maxFramerate = 30; 394 395 // Bad bitrate. 396 _inst.startBitrate = static_cast<unsigned int>(-1); 397 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 398 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 399 _inst.maxBitrate = _inst.startBitrate - 1; 400 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 401 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 402 _inst.maxBitrate = 0; 403 _inst.startBitrate = 300; 404 405 // Bad maxBitRate. 406 _inst.maxBitrate = 200; 407 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 408 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 409 _inst.maxBitrate = 4000; 410 411 // Bad width. 412 _inst.width = 0; 413 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) < 0); 414 _inst.width = _source->GetWidth(); 415 416 // Bad height. 417 _inst.height = 0; 418 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) < 0); 419 _inst.height = _source->GetHeight(); 420 421 // Bad number of cores. 422 EXPECT_TRUE(_encoder->InitEncode(&_inst, -1, 1440) == 423 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 424 425 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 426 427 //-- Encode() errors -- 428 inputImage.ResetSize(); 429 EXPECT_TRUE(_encoder->Encode(inputImage, NULL, NULL) == 430 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 431 int width = _source->GetWidth(); 432 int half_width = (width + 1) / 2; 433 int height = _source->GetHeight(); 434 int half_height = (height + 1) / 2; 435 int size_y = width * height; 436 int size_uv = half_width * half_height; 437 _inputVideoBuffer.CreateFrame(size_y, _refFrame, 438 size_uv, _refFrame + size_y, 439 size_uv, _refFrame + size_y + size_uv, 440 width, height, 441 width, half_width, half_width); 442 //----- Encoder stress tests ----- 443 444 // Vary frame rate and I-frame request. 445 for (int i = 1; i <= 60; i++) 446 { 447 VideoFrameType frame_type = !(i % 2) ? kKeyFrame : kDeltaFrame; 448 std::vector<VideoFrameType> frame_types(1, frame_type); 449 EXPECT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, &frame_types) == 450 WEBRTC_VIDEO_CODEC_OK); 451 EXPECT_TRUE(WaitForEncodedFrame() > 0); 452 } 453 454 // Init then encode. 455 _encodedVideoBuffer.SetLength(0); 456 EXPECT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, NULL) == 457 WEBRTC_VIDEO_CODEC_OK); 458 EXPECT_TRUE(WaitForEncodedFrame() > 0); 459 460 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 461 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 462 frameLength = WaitForEncodedFrame(); 463 EXPECT_TRUE(frameLength > 0); 464 EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength, 465 _encodedVideoBuffer.Buffer(), frameLength) == true); 466 467 // Reset then encode. 468 _encodedVideoBuffer.SetLength(0); 469 EXPECT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, NULL) == 470 WEBRTC_VIDEO_CODEC_OK); 471 WaitForEncodedFrame(); 472 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 473 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 474 frameLength = WaitForEncodedFrame(); 475 EXPECT_TRUE(frameLength > 0); 476 EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength, 477 _encodedVideoBuffer.Buffer(), frameLength) == true); 478 479 // Release then encode. 480 _encodedVideoBuffer.SetLength(0); 481 EXPECT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, NULL) == 482 WEBRTC_VIDEO_CODEC_OK); 483 WaitForEncodedFrame(); 484 EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK); 485 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 486 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 487 frameLength = WaitForEncodedFrame(); 488 EXPECT_TRUE(frameLength > 0); 489 EXPECT_TRUE(CheckIfBitExact(_refEncFrame, _refEncFrameLength, 490 _encodedVideoBuffer.Buffer(), frameLength) == true); 491 492 //----- Decoder parameter tests ----- 493 494 //-- Calls before InitDecode() -- 495 // We want to revert the initialization done in Setup(). 496 EXPECT_TRUE(_decoder->Release() == WEBRTC_VIDEO_CODEC_OK); 497 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 498 EXPECT_TRUE(_decoder->Decode(encodedImage, false, NULL) == 499 WEBRTC_VIDEO_CODEC_UNINITIALIZED); 500 WaitForDecodedFrame(); 501 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_UNINITIALIZED); 502 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 503 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 504 505 //-- Decode() errors -- 506 // Unallocated encodedVideoBuffer. 507 _encodedVideoBuffer.Free(); 508 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 509 encodedImage._length = 10; // Buffer NULL but length > 0 510 EXPECT_EQ(_decoder->Decode(encodedImage, false, NULL), 511 WEBRTC_VIDEO_CODEC_ERR_PARAMETER); 512 _encodedVideoBuffer.VerifyAndAllocate(_lengthSourceFrame); 513 514 //----- Decoder stress tests ----- 515 unsigned char* tmpBuf = new unsigned char[_lengthSourceFrame]; 516 517 // "Random" and zero data. 518 // We either expect an error, or at the least, no output. 519 // This relies on the codec's ability to detect an erroneous bitstream. 520 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 521 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 522 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 523 for (int i = 0; i < 100; i++) 524 { 525 ASSERT_TRUE(fread(tmpBuf, 1, _refEncFrameLength, _sourceFile) 526 == _refEncFrameLength); 527 _encodedVideoBuffer.CopyFrame(_refEncFrameLength, tmpBuf); 528 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 529 int ret = _decoder->Decode(encodedImage, false, NULL); 530 EXPECT_TRUE(ret <= 0); 531 if (ret == 0) 532 { 533 EXPECT_TRUE(WaitForDecodedFrame() == 0); 534 } 535 536 memset(tmpBuf, 0, _refEncFrameLength); 537 _encodedVideoBuffer.CopyFrame(_refEncFrameLength, tmpBuf); 538 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 539 if (i == 0) { 540 // First frame is a key frame. 541 is_key_frame_ = true; 542 } 543 ret = _decoder->Decode(encodedImage, false, NULL); 544 EXPECT_TRUE(ret <= 0); 545 if (ret == 0) 546 { 547 EXPECT_TRUE(WaitForDecodedFrame() == 0); 548 } 549 } 550 rewind(_sourceFile); 551 552 _encodedVideoBuffer.SetLength(_refEncFrameLength); 553 _encodedVideoBuffer.CopyFrame(_refEncFrameLength, _refEncFrame); 554 555 // Init then decode. 556 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 557 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 558 frameLength = 0; 559 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 560 // first frame is a key frame. 561 encodedImage._frameType = kKeyFrame; 562 while (frameLength == 0) 563 { 564 _decoder->Decode(encodedImage, false, NULL); 565 frameLength = WaitForDecodedFrame(); 566 } 567 unsigned int length = CalcBufferSize(kI420, width, height); 568 scoped_ptr<uint8_t[]> decoded_buffer(new uint8_t[length]); 569 ExtractBuffer(_decodedVideoBuffer, _lengthSourceFrame, 570 decoded_buffer.get()); 571 EXPECT_TRUE(CheckIfBitExact(decoded_buffer.get(), frameLength, _refDecFrame, 572 _lengthSourceFrame) == true); 573 574 // Reset then decode. 575 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 576 frameLength = 0; 577 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 578 while (frameLength == 0) 579 { 580 _decoder->Decode(encodedImage, false, NULL); 581 frameLength = WaitForDecodedFrame(); 582 } 583 ExtractBuffer(_decodedVideoBuffer, _lengthSourceFrame, 584 decoded_buffer.get()); 585 EXPECT_TRUE(CheckIfBitExact(decoded_buffer.get(), frameLength, 586 _refDecFrame, _lengthSourceFrame) == true); 587 588 // Decode with other size, reset, then decode with original size again 589 // to verify that decoder is reset to a "fresh" state upon Reset(). 590 { 591 // Assert that input frame size is a factor of two, so that we can use 592 // quarter size below. 593 EXPECT_TRUE((_inst.width % 2 == 0) && (_inst.height % 2 == 0)); 594 595 VideoCodec tempInst; 596 memcpy(&tempInst, &_inst, sizeof(VideoCodec)); 597 tempInst.width /= 2; 598 tempInst.height /= 2; 599 int tmpHalfWidth = (tempInst.width + 1) / 2; 600 int tmpHalfHeight = (tempInst.height + 1) / 2; 601 602 int tmpSizeY = tempInst.width * tempInst.height; 603 int tmpSizeUv = tmpHalfWidth * tmpHalfHeight; 604 605 // Encode reduced (quarter) frame size. 606 EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK); 607 EXPECT_TRUE(_encoder->InitEncode(&tempInst, 1, 1440) == 608 WEBRTC_VIDEO_CODEC_OK); 609 webrtc::I420VideoFrame tempInput; 610 tempInput.CreateFrame(tmpSizeY, _inputVideoBuffer.buffer(kYPlane), 611 tmpSizeUv, _inputVideoBuffer.buffer(kUPlane), 612 tmpSizeUv, _inputVideoBuffer.buffer(kVPlane), 613 tempInst.width, tempInst.height, 614 tempInst.width, tmpHalfWidth, tmpHalfWidth); 615 _encoder->Encode(tempInput, NULL, NULL); 616 frameLength = WaitForEncodedFrame(); 617 EXPECT_TRUE(frameLength > 0); 618 // Reset then decode. 619 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 620 frameLength = 0; 621 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 622 while (frameLength == 0) 623 { 624 _decoder->Decode(encodedImage, false, NULL); 625 frameLength = WaitForDecodedFrame(); 626 } 627 628 // Encode original frame again 629 EXPECT_TRUE(_encoder->Release() == WEBRTC_VIDEO_CODEC_OK); 630 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == 631 WEBRTC_VIDEO_CODEC_OK); 632 _encoder->Encode(_inputVideoBuffer, NULL, NULL); 633 frameLength = WaitForEncodedFrame(); 634 EXPECT_TRUE(frameLength > 0); 635 636 // Reset then decode original frame again. 637 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 638 frameLength = 0; 639 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 640 while (frameLength == 0) 641 { 642 _decoder->Decode(encodedImage, false, NULL); 643 frameLength = WaitForDecodedFrame(); 644 } 645 646 // check that decoded frame matches with reference 647 unsigned int length = CalcBufferSize(kI420, width, height); 648 scoped_ptr<uint8_t[]> decoded_buffer(new uint8_t[length]); 649 ExtractBuffer(_decodedVideoBuffer, length, decoded_buffer.get()); 650 EXPECT_TRUE(CheckIfBitExact(decoded_buffer.get(), length, 651 _refDecFrame, _lengthSourceFrame) == true); 652 } 653 654 // Release then decode. 655 EXPECT_TRUE(_decoder->Release() == WEBRTC_VIDEO_CODEC_OK); 656 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 657 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 658 frameLength = 0; 659 VideoEncodedBufferToEncodedImage(_encodedVideoBuffer, encodedImage); 660 while (frameLength == 0) 661 { 662 _decoder->Decode(encodedImage, false, NULL); 663 frameLength = WaitForDecodedFrame(); 664 } 665 ExtractBuffer(_decodedVideoBuffer, length, decoded_buffer.get()); 666 EXPECT_TRUE(CheckIfBitExact(decoded_buffer.get(), frameLength, 667 _refDecFrame, _lengthSourceFrame) == true); 668 _encodedVideoBuffer.SetLength(0); 669 670 delete [] tmpBuf; 671 672 //----- Function tests ----- 673 int frames = 0; 674 // Do not specify maxBitRate (as in ViE). 675 _inst.maxBitrate = 0; 676 677 //-- Timestamp propagation -- 678 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 679 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 680 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 681 ASSERT_FALSE(SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK); 682 683 frames = 0; 684 int frameDelay = 0; 685 int encTimeStamp; 686 _decodedVideoBuffer.set_timestamp(0); 687 while (fread(_sourceBuffer, 1, _lengthSourceFrame, _sourceFile) == 688 _lengthSourceFrame) 689 { 690 _inputVideoBuffer.CreateFrame(size_y, _sourceBuffer, 691 size_uv, _sourceBuffer + size_y, 692 size_uv, _sourceBuffer + size_y + size_uv, 693 width, height, 694 width, half_width, half_width); 695 696 _inputVideoBuffer.set_timestamp(frames); 697 ASSERT_TRUE(_encoder->Encode(_inputVideoBuffer, NULL, NULL) == 698 WEBRTC_VIDEO_CODEC_OK); 699 frameLength = WaitForEncodedFrame(); 700 //ASSERT_TRUE(frameLength); 701 EXPECT_TRUE(frameLength > 0); 702 encTimeStamp = _encodedVideoBuffer.TimeStamp(); 703 EXPECT_TRUE(_inputVideoBuffer.timestamp() == 704 static_cast<unsigned>(encTimeStamp)); 705 if (frames == 0) { 706 // First frame is always a key frame. 707 is_key_frame_ = true; 708 } 709 710 frameLength = Decode(); 711 if (frameLength == 0) 712 { 713 frameDelay++; 714 } 715 716 encTimeStamp -= frameDelay; 717 if (encTimeStamp < 0) 718 { 719 encTimeStamp = 0; 720 } 721 EXPECT_TRUE(_decodedVideoBuffer.timestamp() == 722 static_cast<unsigned>(encTimeStamp)); 723 frames++; 724 } 725 ASSERT_TRUE(feof(_sourceFile) != 0); 726 rewind(_sourceFile); 727 728 RateControlTests(); 729 730 Teardown(); 731 } 732 733 void 734 UnitTest::RateControlTests() 735 { 736 int frames = 0; 737 VideoFrame inputImage; 738 uint32_t frameLength; 739 740 // Do not specify maxBitRate (as in ViE). 741 _inst.maxBitrate = 0; 742 // Verify rate control. For this test turn on codec frame dropper. 743 // At least one other test (BasicUnitTest) assumes frame dropper off, so 744 // for now we only set frame dropper on for this (rate control) test. 745 _inst.codecSpecific.VP8.frameDroppingOn = true; 746 EXPECT_TRUE(_encoder->InitEncode(&_inst, 1, 1440) == WEBRTC_VIDEO_CODEC_OK); 747 EXPECT_TRUE(_decoder->Reset() == WEBRTC_VIDEO_CODEC_OK); 748 EXPECT_TRUE(_decoder->InitDecode(&_inst, 1) == WEBRTC_VIDEO_CODEC_OK); 749 // add: should also be 0, and 1 750 const int bitRate[] = {100, 500}; 751 const int nBitrates = sizeof(bitRate)/sizeof(*bitRate); 752 753 printf("\nRate control test\n"); 754 for (int i = 0; i < nBitrates; i++) 755 { 756 _bitRate = bitRate[i]; 757 int totalBytes = 0; 758 _inst.startBitrate = _bitRate; 759 _encoder->InitEncode(&_inst, 4, 1440); 760 _decoder->Reset(); 761 _decoder->InitDecode(&_inst, 1); 762 frames = 0; 763 764 if (_bitRate > _inst.maxBitrate) 765 { 766 CodecSpecific_SetBitrate(_bitRate, _inst.maxFramerate); 767 } 768 else 769 { 770 CodecSpecific_SetBitrate(_bitRate, _inst.maxFramerate); 771 } 772 int width = _source->GetWidth(); 773 int half_width = (width + 1) / 2; 774 int height = _source->GetHeight(); 775 int half_height = (height + 1) / 2; 776 int size_y = width * height; 777 int size_uv = half_width * half_height; 778 while (fread(_sourceBuffer, 1, _lengthSourceFrame, _sourceFile) == 779 _lengthSourceFrame) 780 { 781 _inputVideoBuffer.CreateFrame(size_y, _sourceBuffer, 782 size_uv, _sourceBuffer + size_y, 783 size_uv, _sourceBuffer + size_y + 784 size_uv, 785 width, height, 786 width, half_width, half_width); 787 _inputVideoBuffer.set_timestamp(static_cast<uint32_t>(9e4 / 788 static_cast<float>(_inst.maxFramerate))); 789 ASSERT_EQ(_encoder->Encode(_inputVideoBuffer, NULL, NULL), 790 WEBRTC_VIDEO_CODEC_OK); 791 frameLength = WaitForEncodedFrame(); 792 ASSERT_GE(frameLength, 0u); 793 totalBytes += frameLength; 794 frames++; 795 796 _encodedVideoBuffer.SetLength(0); 797 } 798 uint32_t actualBitrate = 799 (totalBytes / frames * _inst.maxFramerate * 8)/1000; 800 printf("Target bitrate: %d kbps, actual bitrate: %d kbps\n", _bitRate, 801 actualBitrate); 802 // Test for close match over reasonable range. 803 EXPECT_TRUE(abs(int32_t(actualBitrate - _bitRate)) < 804 0.12 * _bitRate); 805 ASSERT_TRUE(feof(_sourceFile) != 0); 806 rewind(_sourceFile); 807 } 808 } 809 810 bool 811 UnitTest::CheckIfBitExact(const void* ptrA, unsigned int aLengthBytes, 812 const void* ptrB, unsigned int bLengthBytes) 813 { 814 if (aLengthBytes != bLengthBytes) 815 { 816 return false; 817 } 818 819 return memcmp(ptrA, ptrB, aLengthBytes) == 0; 820 } 821
