/*
 *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "rps_test.h"

#include <assert.h>
#include <string.h> // memcmp
#include <time.h>

#include "vp8.h"

VP8RpsTest::VP8RpsTest(float bitRate)
    : VP8NormalAsyncTest(bitRate),
      decoder2_(new webrtc::VP8Decoder),
      sli_(false) {
}

VP8RpsTest::VP8RpsTest()
    : VP8NormalAsyncTest("VP8 Reference Picture Selection Test",
                         "VP8 Reference Picture Selection Test", 1),
      decoder2_(new webrtc::VP8Decoder),
      sli_(false) {
}

VP8RpsTest::~VP8RpsTest() {
  if (decoder2_) {
    decoder2_->Release();
    delete decoder2_;
  }
  decoded_frame2_.Free();
}

void VP8RpsTest::Perform() {
  _inname = "test/testFiles/foreman_cif.yuv";
  CodecSettings(352, 288, 30, _bitRate);
  Setup();
  _inputVideoBuffer.VerifyAndAllocate(_lengthSourceFrame);
  _decodedVideoBuffer.VerifyAndAllocate(_lengthSourceFrame);
  decoded_frame2_.VerifyAndAllocate(_lengthSourceFrame);

  // Enable RPS functionality
  _inst.codecSpecific.VP8.pictureLossIndicationOn = true;
  _inst.codecSpecific.VP8.feedbackModeOn = true;

  if(_encoder->InitEncode(&_inst, 4, 1460) < 0)
    exit(EXIT_FAILURE);

  _decoder->InitDecode(&_inst,1);
  decoder2_->InitDecode(&_inst,1);

  FrameQueue frameQueue;
  VideoEncodeCompleteCallback encCallback(_encodedFile, &frameQueue, *this);
  RpsDecodeCompleteCallback decCallback(&_decodedVideoBuffer);
  RpsDecodeCompleteCallback decCallback2(&decoded_frame2_);
  _encoder->RegisterEncodeCompleteCallback(&encCallback);
  _decoder->RegisterDecodeCompleteCallback(&decCallback);
  decoder2_->RegisterDecodeCompleteCallback(&decCallback2);

  if (SetCodecSpecificParameters() != WEBRTC_VIDEO_CODEC_OK)
    exit(EXIT_FAILURE);

  _totalEncodeTime = _totalDecodeTime = 0;
  _totalEncodePipeTime = _totalDecodePipeTime = 0;
  bool complete = false;
  _framecnt = 0;
  _encFrameCnt = 0;
  _decFrameCnt = 0;
  _sumEncBytes = 0;
  _lengthEncFrame = 0;
  double starttime = clock()/(double)CLOCKS_PER_SEC;
  while (!complete) {
    CodecSpecific_InitBitrate();
    complete = EncodeRps(&decCallback2);
    if (!frameQueue.Empty() || complete) {
      while (!frameQueue.Empty()) {
        _frameToDecode =
            static_cast<FrameQueueTuple *>(frameQueue.PopFrame());
        int lost = DoPacketLoss();
        if (lost == 2) {
            // Lost the whole frame, continue
            _missingFrames = true;
            delete _frameToDecode;
            _frameToDecode = NULL;
            continue;
        }
        int ret = Decode(lost);
        delete _frameToDecode;
        _frameToDecode = NULL;
        if (ret < 0) {
            fprintf(stderr,"\n\nError in decoder: %d\n\n", ret);
            exit(EXIT_FAILURE);
        }
        else if (ret == 0) {
            _framecnt++;
        }
        else {
            fprintf(stderr,
                "\n\nPositive return value from decode!\n\n");
        }
      }
    }
  }
  double endtime = clock()/(double)CLOCKS_PER_SEC;
  double totalExecutionTime = endtime - starttime;
  printf("Total execution time: %.1f s\n", totalExecutionTime);
  _sumEncBytes = encCallback.EncodedBytes();
  double actualBitRate = ActualBitRate(_encFrameCnt) / 1000.0;
  double avgEncTime = _totalEncodeTime / _encFrameCnt;
  double avgDecTime = _totalDecodeTime / _decFrameCnt;
  printf("Actual bitrate: %f kbps\n", actualBitRate);
  printf("Average encode time: %.1f ms\n", 1000 * avgEncTime);
  printf("Average decode time: %.1f ms\n", 1000 * avgDecTime);
  printf("Average encode pipeline time: %.1f ms\n",
         1000 * _totalEncodePipeTime / _encFrameCnt);
  printf("Average decode pipeline  time: %.1f ms\n",
         1000 * _totalDecodePipeTime / _decFrameCnt);
  printf("Number of encoded frames: %u\n", _encFrameCnt);
  printf("Number of decoded frames: %u\n", _decFrameCnt);
  (*_log) << "Actual bitrate: " << actualBitRate << " kbps\tTarget: " <<
      _bitRate << " kbps" << std::endl;
  (*_log) << "Average encode time: " << avgEncTime << " s" << std::endl;
  (*_log) << "Average decode time: " << avgDecTime << " s" << std::endl;
  _encoder->Release();
  _decoder->Release();
  Teardown();
}

bool VP8RpsTest::EncodeRps(RpsDecodeCompleteCallback* decodeCallback) {
  _lengthEncFrame = 0;
  size_t bytes_read = fread(_sourceBuffer, 1, _lengthSourceFrame, _sourceFile);
  if (bytes_read < _lengthSourceFrame)
    return true;
  _inputVideoBuffer.CopyBuffer(_lengthSourceFrame, _sourceBuffer);
  _inputVideoBuffer.SetTimeStamp((unsigned int)
      (_encFrameCnt * 9e4 / _inst.maxFramerate));
  _inputVideoBuffer.SetWidth(_inst.width);
  _inputVideoBuffer.SetHeight(_inst.height);
  webrtc::RawImage rawImage;
  VideoBufferToRawImage(_inputVideoBuffer, rawImage);
  if (feof(_sourceFile) != 0) {
      return true;
  }
  _encodeCompleteTime = 0;
  _encodeTimes[rawImage._timeStamp] = tGetTime();
  webrtc::VideoFrameType frameType = webrtc::kDeltaFrame;

  webrtc::CodecSpecificInfo* codecSpecificInfo = CreateEncoderSpecificInfo();
  codecSpecificInfo->codecSpecific.VP8.pictureIdRPSI =
      decodeCallback->LastDecodedRefPictureId(
          &codecSpecificInfo->codecSpecific.VP8.hasReceivedRPSI);
  if (sli_) {
    codecSpecificInfo->codecSpecific.VP8.pictureIdSLI =
        decodeCallback->LastDecodedPictureId();
    codecSpecificInfo->codecSpecific.VP8.hasReceivedSLI = true;
    sli_ = false;
  }
  printf("Encoding: %u\n", _framecnt);
  int ret = _encoder->Encode(rawImage, codecSpecificInfo, &frameType);
  if (ret < 0)
    printf("Failed to encode: %u\n", _framecnt);

  if (codecSpecificInfo != NULL) {
      delete codecSpecificInfo;
      codecSpecificInfo = NULL;
  }
  if (_encodeCompleteTime > 0) {
      _totalEncodeTime += _encodeCompleteTime -
          _encodeTimes[rawImage._timeStamp];
  }
  else {
      _totalEncodeTime += tGetTime() - _encodeTimes[rawImage._timeStamp];
  }
  return false;
}

//#define FRAME_LOSS 1

int VP8RpsTest::Decode(int lossValue) {
  _sumEncBytes += _frameToDecode->_frame->GetLength();
  webrtc::EncodedImage encodedImage;
  VideoEncodedBufferToEncodedImage(*(_frameToDecode->_frame), encodedImage);
  encodedImage._completeFrame = !lossValue;
  _decodeCompleteTime = 0;
  _decodeTimes[encodedImage._timeStamp] = clock()/(double)CLOCKS_PER_SEC;
  int ret = _decoder->Decode(encodedImage, _missingFrames, NULL,
                             _frameToDecode->_codecSpecificInfo);
  // Drop every 10th frame for the second decoder
#if FRAME_LOSS
  if (_framecnt == 0 || _framecnt % 10 != 0) {
    printf("Decoding: %u\n", _framecnt);
    if (_framecnt > 1 && (_framecnt - 1) % 10 == 0)
      _missingFrames = true;
#else
  if (true) {
    if (_framecnt > 0 && _framecnt % 10 == 0) {
      encodedImage._length = std::rand() % encodedImage._length;
      printf("Decoding with loss: %u\n", _framecnt);
    }
    else
      printf("Decoding: %u\n", _framecnt);
#endif
    int ret2 = decoder2_->Decode(encodedImage, _missingFrames, NULL,
                                 _frameToDecode->_codecSpecificInfo,
                                 0 /* dummy */);

    // check return values
    if (ret < 0 || ret2 < 0) {
      return -1;
    } else if (ret2 == WEBRTC_VIDEO_CODEC_ERR_REQUEST_SLI ||
        ret2 == WEBRTC_VIDEO_CODEC_REQUEST_SLI) {
      sli_ = true;
    }

    // compare decoded images
#if FRAME_LOSS
    if (!_missingFrames) {
      if (!CheckIfBitExact(_decodedVideoBuffer.GetBuffer(),
        _decodedVideoBuffer.GetLength(),
        decoded_frame2_.GetBuffer(), _decodedVideoBuffer.GetLength())) {
        fprintf(stderr,"\n\nRPS decoder different from master: %u\n\n",
                _framecnt);
        return -1;
      }
    }
#else
    if (_framecnt > 0 && _framecnt % 10 != 0) {
      if (!CheckIfBitExact(_decodedVideoBuffer.GetBuffer(),
        _decodedVideoBuffer.GetLength(),
        decoded_frame2_.GetBuffer(), _decodedVideoBuffer.GetLength())) {
        fprintf(stderr,"\n\nRPS decoder different from master: %u\n\n",
                _framecnt);
        return -1;
      }
    }
#endif
  }
#if FRAME_LOSS
  else
    printf("Dropping %u\n", _framecnt);
#endif
  _missingFrames = false;
  return 0;
}


bool
VP8RpsTest::CheckIfBitExact(const void* ptrA, unsigned int aLengthBytes,
                            const void* ptrB, unsigned int bLengthBytes) {
  if (aLengthBytes != bLengthBytes)
    return false;
  return memcmp(ptrA, ptrB, aLengthBytes) == 0;
}

RpsDecodeCompleteCallback::RpsDecodeCompleteCallback(TestVideoBuffer* buffer)
    : decoded_frame_(buffer),
      decode_complete_(false),
      last_decoded_picture_id_(0),
      last_decoded_ref_picture_id_(0),
      updated_ref_picture_id_(false) {
}

WebRtc_Word32 RpsDecodeCompleteCallback::Decoded(webrtc::RawImage& image) {
  decoded_frame_->VerifyAndAllocate(image._length);
  decoded_frame_->CopyBuffer(image._length, image._buffer);
  decoded_frame_->SetWidth(image._width);
  decoded_frame_->SetHeight(image._height);
  decoded_frame_->SetTimeStamp(image._timeStamp);
  decode_complete_ = true;
  return 0;
}

bool RpsDecodeCompleteCallback::DecodeComplete() {
  if (decode_complete_)
  {
    decode_complete_ = false;
    return true;
  }
  return false;
}

WebRtc_Word32 RpsDecodeCompleteCallback::ReceivedDecodedReferenceFrame(
    const WebRtc_UWord64 picture_id) {
  last_decoded_ref_picture_id_ = picture_id & 0x7FFF;
  updated_ref_picture_id_ = true;
  return 0;
}

WebRtc_Word32 RpsDecodeCompleteCallback::ReceivedDecodedFrame(
    const WebRtc_UWord64 picture_id) {
  last_decoded_picture_id_ = picture_id & 0x3F;
  return 0;
}

WebRtc_UWord64 RpsDecodeCompleteCallback::LastDecodedPictureId() const {
  return last_decoded_picture_id_;
}

WebRtc_UWord64 RpsDecodeCompleteCallback::LastDecodedRefPictureId(
    bool *updated) {
  if (updated)
    *updated = updated_ref_picture_id_;
  updated_ref_picture_id_ = false;
  return last_decoded_ref_picture_id_;
}