TMC3.cpp

    if (params->colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
      convertYCbCrBt709ToGbr(*reconPointCloud);
    }

    if (params->reflectanceScale > 1 && reconPointCloud->hasReflectances()) {
      const auto pointCount = reconPointCloud->getPointCount();
      for (size_t i = 0; i < pointCount; ++i) {
        int val =
          reconPointCloud->getReflectance(i) * params->reflectanceScale;
        reconPointCloud->setReflectance(i, val);
      }
    }

    std::string recName{expandNum(params->reconstructedDataPath, frameNum)};
    ply::write(
      *reconPointCloud, _plyAttrNames, recName, !params->outputBinaryPly);
  }

  return 0;
}

//----------------------------------------------------------------------------

void
SequenceEncoder::onOutputBuffer(const PayloadBuffer& buf)
{
  writeTlv(buf, bytestreamFile);
}

//----------------------------------------------------------------------------

void
SequenceEncoder::onPostRecolour(const PCCPointSet3& cloud)
{
  if (params->postRecolorPath.empty()) {
    return;
  }

  std::string plyName{expandNum(params->postRecolorPath, frameNum)};

  // todo(df): stop the clock
  if (params->colorTransform != COLOR_TRANSFORM_RGB_TO_YCBCR) {
    ply::write(cloud, _plyAttrNames, plyName, !params->outputBinaryPly);
    return;
  }

  PCCPointSet3 tmpCloud(cloud);
  convertYCbCrBt709ToGbr(tmpCloud);
  ply::write(tmpCloud, _plyAttrNames, plyName, !params->outputBinaryPly);
}

//============================================================================

SequenceDecoder::SequenceDecoder(const Parameters* params)
  : params(params), decoder(params->decoder)
{}

//----------------------------------------------------------------------------

int
SequenceDecoder::decompress(Stopwatch* clock)
{
  ifstream fin(params->compressedStreamPath, ios::binary);
  if (!fin.is_open()) {
    return -1;
  }

  frameNum = params->firstFrameNum;
  this->clock = clock;

  PayloadBuffer buf;

  clock->start();

  while (true) {
    PayloadBuffer* buf_ptr = &buf;
    readTlv(fin, &buf);

    // at end of file (or other error), flush decoder
    if (!fin)
      buf_ptr = nullptr;

    if (decoder.decompress(buf_ptr, this)) {
      cout << "Error: can't decompress point cloud!" << endl;
      return -1;
    }

    if (!buf_ptr)
      break;
  }

  fin.clear();
  fin.seekg(0, ios_base::end);
  std::cout << "Total bitstream size " << fin.tellg() << " B" << std::endl;

  clock->stop();

  return 0;
}

//----------------------------------------------------------------------------

void
SequenceDecoder::onOutputCloud(
  const SequenceParameterSet& sps, const PCCPointSet3& decodedPointCloud)
{
  // copy the point cloud in order to modify it according to the output options
  PCCPointSet3 pointCloud(decodedPointCloud);

  if (params->colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
    convertYCbCrBt709ToGbr(pointCloud);
  }

  if (params->reflectanceScale > 1 && pointCloud.hasReflectances()) {
    const auto pointCount = pointCloud.getPointCount();
    for (size_t i = 0; i < pointCount; ++i) {
      int val = pointCloud.getReflectance(i) * params->reflectanceScale;
      pointCloud.setReflectance(i, val);
    }
  }

  // the order of the property names must be determined from the sps
  ply::PropertyNameMap attrNames;
  attrNames.position = axisOrderToPropertyNames(sps.geometry_axis_order);

  // Dump the decoded colour using the pre inverse scaled geometry
  if (!params->preInvScalePath.empty()) {
    std::string filename{expandNum(params->preInvScalePath, frameNum)};
    ply::write(
      pointCloud, attrNames, params->preInvScalePath,
      !params->outputBinaryPly);
  }

  decoder.inverseQuantization(pointCloud);

  clock->stop();

  std::string decName{expandNum(params->reconstructedDataPath, frameNum)};
  if (!ply::write(pointCloud, attrNames, decName, !params->outputBinaryPly)) {
    cout << "Error: can't open output file!" << endl;
  }

  clock->start();

  // todo(df): frame number should be derived from the bitstream
  frameNum++;
}