TMC3.cpp 32.7 KB
Newer Older
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
1
/* The copyright in this software is being made available under the BSD
David Flynn's avatar
David Flynn committed
2
3
4
 * Licence, included below.  This software may be subject to other third
 * party and contributor rights, including patent rights, and no such
 * rights are granted under this licence.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
5
 *
David Flynn's avatar
David Flynn committed
6
 * Copyright (c) 2017-2018, ISO/IEC
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
7
8
9
10
11
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
David Flynn's avatar
David Flynn committed
12
13
14
15
16
17
18
19
20
21
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 *
 * * Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * * Neither the name of the ISO/IEC nor the names of its contributors
 *   may be used to endorse or promote products derived from this
 *   software without specific prior written permission.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
22
23
24
25
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
David Flynn's avatar
David Flynn committed
26
27
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
28
29
30
31
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
David Flynn's avatar
David Flynn committed
32
33
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
34
35
36
 */

#include "TMC3.h"
David Flynn's avatar
David Flynn committed
37
38
39
40
41

#include <memory>

#include "PCCTMC3Encoder.h"
#include "PCCTMC3Decoder.h"
42
#include "constants.h"
43
#include "ply.h"
44
#include "program_options_lite.h"
45
#include "io_tlv.h"
46
#include "version.h"
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
47
48
49
50

using namespace std;
using namespace pcc;

51
52
53
54
55
//============================================================================

struct Parameters {
  bool isDecoder;

56
57
58
  // command line parsing should adjust dist2 values according to PQS
  bool positionQuantizationScaleAdjustsDist2;

59
60
61
  // output mode for ply writing (binary or ascii)
  bool outputBinaryPly;

62
63
64
  // when true, configure the encoder as if no attributes are specified
  bool disableAttributeCoding;

65
66
67
68
69
70
  // Frame number of first file in input sequence.
  int firstFrameNum;

  // Number of frames to process.
  int frameCount;

71
72
73
74
  std::string uncompressedDataPath;
  std::string compressedStreamPath;
  std::string reconstructedDataPath;

75
76
77
78
  // Filename for saving recoloured point cloud (encoder).
  std::string postRecolorPath;

  // Filename for saving pre inverse scaled point cloud (decoder).
79
80
  std::string preInvScalePath;

81
82
83
84
85
  pcc::EncoderParams encoder;
  pcc::DecoderParams decoder;

  // todo(df): this should be per-attribute
  ColorTransform colorTransform;
86
87
88

  // todo(df): this should be per-attribute
  int reflectanceScale;
89
90
};

91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
//----------------------------------------------------------------------------

class SequenceEncoder : public PCCTMC3Encoder3::Callbacks {
public:
  // NB: params must outlive the lifetime of the decoder.
  SequenceEncoder(Parameters* params);

  int compress(Stopwatch* clock);

protected:
  int compressOneFrame(Stopwatch* clock);

  void onOutputBuffer(const PayloadBuffer& buf) override;
  void onPostRecolour(const PCCPointSet3& cloud) override;

private:
  Parameters* params;
  PCCTMC3Encoder3 encoder;

  std::ofstream bytestreamFile;

  int frameNum;
};

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

class SequenceDecoder : public PCCTMC3Decoder3::Callbacks {
public:
  // NB: params must outlive the lifetime of the decoder.
  SequenceDecoder(const Parameters* params);

  int decompress(Stopwatch* clock);

protected:
  void onOutputCloud(const PCCPointSet3& decodedPointCloud) override;

private:
  const Parameters* params;
  PCCTMC3Decoder3 decoder;

  std::ofstream bytestreamFile;

  int frameNum;
  Stopwatch* clock;
};

137
138
//============================================================================

139
140
141
int
main(int argc, char* argv[])
{
142
  cout << "MPEG PCC tmc3 version " << ::pcc::version << endl;
143

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
144
145
146
147
  Parameters params;
  if (!ParseParameters(argc, argv, params)) {
    return -1;
  }
148
149
150
151
152
153
154

  // Timers to count elapsed wall/user time
  pcc::chrono::Stopwatch<std::chrono::steady_clock> clock_wall;
  pcc::chrono::Stopwatch<pcc::chrono::utime_inc_children_clock> clock_user;

  clock_wall.start();

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
155
  int ret = 0;
156
  if (params.isDecoder) {
157
    ret = SequenceDecoder(&params).decompress(&clock_user);
158
  } else {
159
    ret = SequenceEncoder(&params).compress(&clock_user);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
160
161
  }

162
163
164
165
166
167
168
169
  clock_wall.stop();

  using namespace std::chrono;
  auto total_wall = duration_cast<milliseconds>(clock_wall.count()).count();
  auto total_user = duration_cast<milliseconds>(clock_user.count()).count();
  std::cout << "Processing time (wall): " << total_wall / 1000.0 << " s\n";
  std::cout << "Processing time (user): " << total_user / 1000.0 << " s\n";

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
170
171
172
  return ret;
}

173
174
175
//---------------------------------------------------------------------------
// :: Command line / config parsing helpers

176
177
178
179
template<typename T>
static std::istream&
readUInt(std::istream& in, T& val)
{
180
181
182
183
184
185
  unsigned int tmp;
  in >> tmp;
  val = T(tmp);
  return in;
}

186
187
188
static std::istream&
operator>>(std::istream& in, ColorTransform& val)
{
189
190
191
  return readUInt(in, val);
}

192
namespace pcc {
193
static std::istream&
194
operator>>(std::istream& in, AttributeEncoding& val)
195
{
196
  return readUInt(in, val);
197
198
}
}  // namespace pcc
199

200
201
202
203
204
205
206
207
namespace pcc {
static std::istream&
operator>>(std::istream& in, PartitionMethod& val)
{
  return readUInt(in, val);
}
}  // namespace pcc

208
namespace pcc {
209
static std::ostream&
210
operator<<(std::ostream& out, const AttributeEncoding& val)
211
{
212
  switch (val) {
213
214
215
  case AttributeEncoding::kPredictingTransform: out << "0 (Pred)"; break;
  case AttributeEncoding::kRAHTransform: out << "1 (RAHT)"; break;
  case AttributeEncoding::kLiftingTransform: out << "2 (Lift)"; break;
216
217
  }
  return out;
218
219
}
}  // namespace pcc
220

221
222
223
224
225
226
namespace pcc {
static std::ostream&
operator<<(std::ostream& out, const PartitionMethod& val)
{
  switch (val) {
  case PartitionMethod::kNone: out << "0 (None)"; break;
227
228
  case PartitionMethod::kUniformGeom: out << "2 (UniformGeom)"; break;
  case PartitionMethod::kOctreeUniform: out << "3 (UniformOctree)"; break;
229
  default: out << int(val) << " (Unknown)"; break;
230
231
232
233
234
  }
  return out;
}
}  // namespace pcc

235
236
237
namespace df {
namespace program_options_lite {
  template<typename T>
238
  struct option_detail<pcc::Vec3<T>> {
239
240
241
242
    static constexpr bool is_container = true;
    static constexpr bool is_fixed_size = true;
    typedef T* output_iterator;

243
244
    static void clear(pcc::Vec3<T>& container){};
    static output_iterator make_output_iterator(pcc::Vec3<T>& container)
245
246
247
248
249
250
251
    {
      return &container[0];
    }
  };
}  // namespace program_options_lite
}  // namespace df

252
253
254
//---------------------------------------------------------------------------
// :: Command line / config parsing

255
256
257
bool
ParseParameters(int argc, char* argv[], Parameters& params)
{
258
259
  namespace po = df::program_options_lite;

260
261
262
  struct {
    AttributeDescription desc;
    AttributeParameterSet aps;
263
    EncoderAttributeParams encoder;
264
265
  } params_attr;

266
267
268
269
270
271
272
273
274
275
276
277
278
  bool print_help = false;

  // a helper to set the attribute
  std::function<po::OptionFunc::Func> attribute_setter =
    [&](po::Options&, const std::string& name, po::ErrorReporter) {
      // copy the current state of parsed attribute parameters
      //
      // NB: this does not cause the default values of attr to be restored
      // for the next attribute block.  A side-effect of this is that the
      // following is allowed leading to attribute foo having both X=1 and
      // Y=2:
      //   "--attr.X=1 --attribute foo --attr.Y=2 --attribute foo"
      //
279
280
281
282
283
284
285
286

      // NB: insert returns any existing element
      const auto& it = params.encoder.attributeIdxMap.insert(
        {name, int(params.encoder.attributeIdxMap.size())});

      if (it.second) {
        params.encoder.sps.attributeSets.push_back(params_attr.desc);
        params.encoder.aps.push_back(params_attr.aps);
287
        params.encoder.attr.push_back(params_attr.encoder);
288
289
290
291
292
293
        return;
      }

      // update existing entry
      params.encoder.sps.attributeSets[it.first->second] = params_attr.desc;
      params.encoder.aps[it.first->second] = params_attr.aps;
294
      params.encoder.attr[it.first->second] = params_attr.encoder;
295
296
    };

297
  /* clang-format off */
298
299
300
301
302
303
304
305
306
307
308
  // The definition of the program/config options, along with default values.
  //
  // NB: when updating the following tables:
  //      (a) please keep to 80-columns for easier reading at a glance,
  //      (b) do not vertically align values -- it breaks quickly
  //
  po::Options opts;
  opts.addOptions()
  ("help", print_help, false, "this help text")
  ("config,c", po::parseConfigFile, "configuration file name")

309
310
  (po::Section("General"))

311
  ("mode", params.isDecoder, false,
312
313
    "The encoding/decoding mode:\n"
    "  0: encode\n"
314
    "  1: decode")
315
316

  // i/o parameters
317
318
319
320
321
322
323
324
325
  ("firstFrameNum",
     params.firstFrameNum, 0,
     "Frame number for use with interpolating %d format specifiers"
     "in input/output filenames")

  ("frameCount",
     params.frameCount, 1,
     "Number of frames to encode")

326
  ("reconstructedDataPath",
327
328
    params.reconstructedDataPath, {},
    "The ouput reconstructed pointcloud file path (decoder only)")
329
330

  ("uncompressedDataPath",
331
332
    params.uncompressedDataPath, {},
    "The input pointcloud file path")
333
334

  ("compressedStreamPath",
335
336
    params.compressedStreamPath, {},
    "The compressed bitstream path (encoder=output, decoder=input)")
337

338
  ("postRecolorPath",
339
    params.postRecolorPath, {},
340
    "Recolored pointcloud file path (encoder only)")
341
342

  ("preInvScalePath",
343
    params.preInvScalePath, {},
344
    "Pre inverse scaled pointcloud file path (decoder only)")
345

346
347
348
349
  ("outputBinaryPly",
    params.outputBinaryPly, false,
    "Output ply files using binary (or otherwise ascii) format")

350
  // general
351
  // todo(df): this should be per-attribute
352
  ("colorTransform",
353
354
355
356
    params.colorTransform, COLOR_TRANSFORM_RGB_TO_YCBCR,
    "The colour transform to be applied:\n"
    "  0: none\n"
    "  1: RGB to YCbCr (Rec.709)")
357

358
359
360
361
362
363
  // todo(df): this should be per-attribute
  ("hack.reflectanceScale",
    params.reflectanceScale, 1,
    "scale factor to be applied to reflectance "
    "pre encoding / post reconstruction")

364
365
366
367
368
369
370
  (po::Section("Decoder"))

  ("skipOctreeLayers",
    params.decoder.minGeomNodeSizeLog2, 0,
    " 0   : Full decode. \n"
    " N>0 : Skip the bottom N layers in decoding process.\n"
    " skipLayerNum indicates the number of skipped lod layers from leaf lod.")
371
372
373

  (po::Section("Encoder"))

374
375
376
377
378
379
380
381
382
  ("seq_bounding_box_xyz0",
    params.encoder.sps.seq_bounding_box_xyz0, {0},
    "seq_bounding_box_xyz0.  NB: seq_bounding_box_whd must be set for this "
    "parameter to have an effect")

  ("seq_bounding_box_whd",
    params.encoder.sps.seq_bounding_box_whd, {0},
    "seq_bounding_box_whd")

383
  ("positionQuantizationScale",
384
    params.encoder.sps.seq_source_geom_scale_factor, 1.f,
385
    "Scale factor to be applied to point positions during quantization process")
386

387
388
389
390
  ("positionQuantizationScaleAdjustsDist2",
    params.positionQuantizationScaleAdjustsDist2, false,
    "Scale dist2 values by squared positionQuantizationScale")

391
  ("mergeDuplicatedPoints",
392
    params.encoder.gps.geom_unique_points_flag, true,
393
    "Enables removal of duplicated points")
394

395
  ("partitionMethod",
396
    params.encoder.partition.method, PartitionMethod::kUniformGeom,
397
    "Method used to partition input point cloud into slices/tiles:\n"
398
399
    "  0: none\n"
    "  1: none (deprecated)\n"
400
401
    "  2: n Uniform-Geometry partition bins along the longest edge\n"
    "  3: Uniform Geometry partition at n octree depth")
402

403
  ("partitionOctreeDepth",
404
405
406
407
408
409
410
411
412
413
414
415
416
417
    params.encoder.partition.octreeDepth, 1,
    "Depth of octree partition for partitionMethod=4")

  ("sliceMaxPoints",
    params.encoder.partition.sliceMaxPoints, 1100000,
    "Maximum number of points per slice")

  ("sliceMinPoints",
    params.encoder.partition.sliceMinPoints, 550000,
    "Minimum number of points per slice (soft limit)")

  ("tileSize",
    params.encoder.partition.tileSize, 0,
    "Partition input into cubic tiles of given size")
418

419
420
421
422
  ("cabac_bypass_stream_enabled_flag",
    params.encoder.sps.cabac_bypass_stream_enabled_flag, false,
    "Controls coding method for ep(bypass) bins")

423
424
425
426
  ("disableAttributeCoding",
    params.disableAttributeCoding, false,
    "Ignore attribute coding configuration")

427
  (po::Section("Geometry"))
428

429
  // tools
430
431
432
433
434
435
  ("bitwiseOccupancyCoding",
    params.encoder.gps.bitwise_occupancy_coding_flag, true,
    "Selects between bitwise and bytewise occupancy coding:\n"
    "  0: bytewise\n"
    "  1: bitwise")

436
  ("neighbourContextRestriction",
437
    params.encoder.gps.neighbour_context_restriction_flag, false,
438
    "Limit geometry octree occupancy contextualisation to sibling nodes")
439

440
  ("neighbourAvailBoundaryLog2",
441
    params.encoder.gps.neighbour_avail_boundary_log2, 0,
442
443
444
    "Defines the avaliability volume for neighbour occupancy lookups."
    " 0: unconstrained")

445
  ("inferredDirectCodingMode",
446
    params.encoder.gps.inferred_direct_coding_mode_enabled_flag, true,
447
    "Permits early termination of the geometry octree for isolated points")
448

449
450
451
452
  ("adjacentChildContextualization",
    params.encoder.gps.adjacent_child_contextualization_enabled_flag, true,
    "Occupancy contextualization using neighbouring adjacent children")

453
454
455
456
  ("intra_pred_max_node_size_log2",
    params.encoder.gps.intra_pred_max_node_size_log2, 0,
    "octree nodesizes eligible for occupancy intra prediction")

457
458
459
460
  ("ctxOccupancyReductionFactor",
     params.encoder.gps.geom_occupancy_ctx_reduction_factor, 3,
     "Adjusts the number of contexts used in occupancy coding")

461
462
463
464
  ("trisoup_node_size_log2",
    params.encoder.gps.trisoup_node_size_log2, 0,
    "Size of nodes for surface triangulation.\n"
    "  0: disabled\n")
465

466
467
  (po::Section("Attributes"))

468
469
470
  // attribute processing
  //   NB: Attribute options are special in the way they are applied (see above)
  ("attribute",
471
472
473
    attribute_setter,
    "Encode the given attribute (NB, must appear after the"
    "following attribute parameters)")
474

475
476
477
478
  ("bitdepth",
    params_attr.desc.attr_bitdepth, 8,
    "Attribute bitdepth")

479
  ("transformType",
480
    params_attr.aps.attr_encoding, AttributeEncoding::kPredictingTransform,
481
    "Coding method to use for attribute:\n"
482
    "  0: Hierarchical neighbourhood prediction\n"
483
    "  1: Region Adaptive Hierarchical Transform (RAHT)\n"
484
    "  2: Hierarichical neighbourhood prediction as lifting transform")
485
486

  ("rahtDepth",
487
    params_attr.aps.raht_depth, 21,
488
489
    "Number of bits for morton representation of an RAHT co-ordinate"
    "component")
490

491
492
493
494
  ("rahtPredictionEnabled",
    params_attr.aps.raht_prediction_enabled_flag, true,
    "Controls the use of transform-domain prediction")

495
  ("numberOfNearestNeighborsInPrediction",
496
    params_attr.aps.num_pred_nearest_neighbours, 3,
497
    "Attribute's maximum number of nearest neighbors to be used for prediction")
498

499
500
501
502
503
504
  ("adaptivePredictionThreshold",
    params_attr.aps.adaptive_prediction_threshold, -1,
    "Neighbouring attribute value difference that enables choice of "
    "single|multi predictors. Applies to transformType=2 only.\n"
    "  -1: auto = 2**(bitdepth-2)")

505
506
507
508
  ("attributeSearchRange",
    params_attr.aps.search_range, 128,
    "Range for nearest neighbor search")

509
510
511
512
513
514
  ("lodDecimation",
    params_attr.aps.lod_decimation_enabled_flag, false,
    "Controls LoD generation method:\n"
    " 0: distance based subsampling\n"
    " 1: decimation by 1:3")

515
516
517
518
519
  ("max_num_direct_predictors",
    params_attr.aps.max_num_direct_predictors, 3,
    "Maximum number of nearest neighbour candidates used in direct"
    "attribute prediction")

520
  ("levelOfDetailCount",
521
    params_attr.aps.num_detail_levels, 1,
522
    "Attribute's number of levels of detail")
523

524
525
  ("dist2",
    params_attr.aps.dist2, {},
526
527
    "Attribute's list of squared distances, or initial value for automatic"
    "derivation")
528

529
530
531
532
  ("intraLodPredictionEnabled",
    params_attr.aps.intra_lod_prediction_enabled_flag, false,
    "Permits referring to points in same LoD")

533
534
535
536
  ("aps_scalable_enable_flag",
    params_attr.aps.scalable_lifting_enabled_flag, false,
    "Enable scalable attritube coding")

537
538
539
540
541
542
543
  ("qp",
    params_attr.aps.init_qp, 4,
    "Attribute's luma quantisation parameter")

  ("qpChromaOffset",
    params_attr.aps.aps_chroma_qp_offset, 0,
    "Attribute's chroma quantisation parameter offset (relative to luma)")
544
545
546
547

  ("aps_slice_qp_deltas_present_flag",
    params_attr.aps.aps_slice_qp_deltas_present_flag, false,
    "Enable signalling of per-slice QP values")
548

549
  ("qpLayerOffsetsLuma",
550
551
    params_attr.encoder.abh.attr_layer_qp_delta_luma, {},
      "Attribute's per layer luma QP offsets")
552
553

  ("qpLayerOffsetsChroma",
554
555
      params_attr.encoder.abh.attr_layer_qp_delta_chroma, {},
      "Attribute's per layer chroma QP offsets")
556

557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
  // This section is just dedicated to attribute recolouring (encoder only).
  // parameters are common to all attributes.
  (po::Section("Recolouring"))

  ("recolourSearchRange",
    params.encoder.recolour.searchRange, 8,
    "")

  ("recolourNumNeighboursFwd",
    params.encoder.recolour.numNeighboursFwd, 8,
    "")

  ("recolourNumNeighboursBwd",
    params.encoder.recolour.numNeighboursBwd, 1,
    "")

  ("recolourUseDistWeightedAvgFwd",
    params.encoder.recolour.useDistWeightedAvgFwd, true,
    "")

  ("recolourUseDistWeightedAvgBwd",
    params.encoder.recolour.useDistWeightedAvgBwd, true,
    "")

  ("recolourSkipAvgIfIdenticalSourcePointPresentFwd",
    params.encoder.recolour.skipAvgIfIdenticalSourcePointPresentFwd, true,
    "")

  ("recolourSkipAvgIfIdenticalSourcePointPresentBwd",
    params.encoder.recolour.skipAvgIfIdenticalSourcePointPresentBwd, false,
    "")

  ("recolourDistOffsetFwd",
    params.encoder.recolour.distOffsetFwd, 4.,
    "")

  ("recolourDistOffsetBwd",
    params.encoder.recolour.distOffsetBwd, 4.,
    "")

  ("recolourMaxGeometryDist2Fwd",
    params.encoder.recolour.maxGeometryDist2Fwd, 1000.,
    "")

  ("recolourMaxGeometryDist2Bwd",
    params.encoder.recolour.maxGeometryDist2Bwd, 1000.,
    "")

  ("recolourMaxAttributeDist2Fwd",
    params.encoder.recolour.maxAttributeDist2Fwd, 1000.,
    "")

  ("recolourMaxAttributeDist2Bwd",
    params.encoder.recolour.maxAttributeDist2Bwd, 1000.,
    "")

613
  ;
614
  /* clang-format on */
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629

  po::setDefaults(opts);
  po::ErrorReporter err;
  const list<const char*>& argv_unhandled =
    po::scanArgv(opts, argc, (const char**)argv, err);

  for (const auto arg : argv_unhandled) {
    err.warn() << "Unhandled argument ignored: " << arg << "\n";
  }

  if (argc == 1 || print_help) {
    po::doHelp(std::cout, opts, 78);
    return false;
  }

630
631
  // Certain coding modes are not available when trisoup is enabled.
  // Disable them, and warn if set (they may be set as defaults).
632
  if (params.encoder.gps.trisoup_node_size_log2 > 0) {
633
634
635
636
637
638
639
640
641
642
    if (!params.encoder.gps.geom_unique_points_flag)
      err.warn() << "TriSoup geometry does not preserve duplicated points\n";

    if (params.encoder.gps.inferred_direct_coding_mode_enabled_flag)
      err.warn() << "TriSoup geometry is incompatable with IDCM\n";

    params.encoder.gps.geom_unique_points_flag = true;
    params.encoder.gps.inferred_direct_coding_mode_enabled_flag = false;
  }

643
644
645
646
647
648
649
  // support disabling attribute coding (simplifies configuration)
  if (params.disableAttributeCoding) {
    params.encoder.attributeIdxMap.clear();
    params.encoder.sps.attributeSets.clear();
    params.encoder.aps.clear();
  }

650
  // fixup any per-attribute settings
651
  for (const auto& it : params.encoder.attributeIdxMap) {
652
    auto& attr_sps = params.encoder.sps.attributeSets[it.second];
653
    auto& attr_aps = params.encoder.aps[it.second];
654
    auto& attr_enc = params.encoder.attr[it.second];
655

656
657
    // Avoid wasting bits signalling chroma quant step size for reflectance
    if (it.first == "reflectance") {
658
      attr_aps.aps_chroma_qp_offset = 0;
659
      attr_enc.abh.attr_layer_qp_delta_chroma.clear();
660
661
    }

662
663
664
665
666
    bool isLifting =
      attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform
      || attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform;

    // derive the dist2 values based on an initial value
667
668
    if (isLifting) {
      if (attr_aps.dist2.size() > attr_aps.num_detail_levels) {
669
        attr_aps.dist2.resize(attr_aps.num_detail_levels);
670
671
672
673
674
675
676
677
678
679
680
      } else if (
        attr_aps.dist2.size() < attr_aps.num_detail_levels
        && !attr_aps.dist2.empty()) {
        if (attr_aps.dist2.size() < attr_aps.num_detail_levels) {
          attr_aps.dist2.resize(attr_aps.num_detail_levels);
          const double distRatio = 4.0;
          uint64_t d2 = attr_aps.dist2[0];
          for (int i = 0; i < attr_aps.num_detail_levels; ++i) {
            attr_aps.dist2[i] = d2;
            d2 = uint64_t(std::round(distRatio * d2));
          }
681
682
683
        }
      }
    }
684
685
686
687
688
689
690
691
692
693
694
    // In order to simplify specification of dist2 values, which are
    // depending on the scale of the coded point cloud, the following
    // adjust the dist2 values according to PQS.  The user need only
    // specify the unquantised PQS value.
    if (params.positionQuantizationScaleAdjustsDist2) {
      double pqs = params.encoder.sps.seq_source_geom_scale_factor;
      double pqs2 = pqs * pqs;
      for (auto& dist2 : attr_aps.dist2)
        dist2 = int64_t(std::round(pqs2 * dist2));
    }

695
696
697
698
699
700
701
702
    // Set default threshold based on bitdepth
    if (attr_aps.adaptive_prediction_threshold == -1) {
      attr_aps.adaptive_prediction_threshold = 1
        << (attr_sps.attr_bitdepth - 2);
    }

    if (attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform) {
      attr_aps.adaptive_prediction_threshold = 0;
703
      attr_aps.intra_lod_prediction_enabled_flag = false;
704
705
706
    }

    // For RAHT, ensure that the unused lod count = 0 (prevents mishaps)
707
    if (attr_aps.attr_encoding == AttributeEncoding::kRAHTransform) {
708
      attr_aps.num_detail_levels = 0;
709
      attr_aps.adaptive_prediction_threshold = 0;
710
711
712
    }
  }

713
  // sanity checks
714

715
716
717
718
719
720
  if (
    params.encoder.partition.sliceMaxPoints
    < params.encoder.partition.sliceMinPoints)
    err.error()
      << "sliceMaxPoints must be greater than or equal to sliceMinPoints\n";

721
722
723
724
725
  if (params.encoder.gps.intra_pred_max_node_size_log2)
    if (!params.encoder.gps.neighbour_avail_boundary_log2)
      err.error() << "Geometry intra prediction requires finite"
                     "neighbour_avail_boundary_log2\n";

726
727
728
  for (const auto& it : params.encoder.attributeIdxMap) {
    const auto& attr_sps = params.encoder.sps.attributeSets[it.second];
    const auto& attr_aps = params.encoder.aps[it.second];
729
730
731
732
733
734
735
736
737
738
    auto& attr_enc = params.encoder.attr[it.second];

    if (it.first == "color") {
      if (
        attr_enc.abh.attr_layer_qp_delta_luma.size()
        != attr_enc.abh.attr_layer_qp_delta_chroma.size()) {
        err.error() << it.first
                    << ".qpLayerOffsetsLuma length != .qpLayerOffsetsChroma\n";
      }
    }
739
740
741
742
743

    bool isLifting =
      attr_aps.attr_encoding == AttributeEncoding::kPredictingTransform
      || attr_aps.attr_encoding == AttributeEncoding::kLiftingTransform;

744
745
746
747
748
749
750
751
752
753
754
    if (it.first == "color") {
      // todo(??): permit relaxing of the following constraint
      if (attr_sps.attr_bitdepth > 8)
        err.error() << it.first << ".bitdepth must be less than 9\n";
    }

    if (it.first == "reflectance") {
      if (attr_sps.attr_bitdepth > 16)
        err.error() << it.first << ".bitdepth must be less than 17\n";
    }

755
    if (isLifting) {
756
      int lod = attr_aps.num_detail_levels;
757
      if (lod > 255 || lod < 0) {
758
        err.error() << it.first
759
                    << ".levelOfDetailCount must be in the range [0,255]\n";
760
      }
761
762
      if (attr_aps.dist2.size() != lod) {
        err.error() << it.first << ".dist2 does not have " << lod
763
                    << " entries\n";
764
      }
765

766
767
768
769
770
      if (attr_aps.adaptive_prediction_threshold < 0) {
        err.error() << it.first
                    << ".adaptivePredictionThreshold must be positive\n";
      }

771
      if (
772
        attr_aps.num_pred_nearest_neighbours
773
        > kAttributePredictionMaxNeighbourCount) {
774
775
        err.error() << it.first
                    << ".numberOfNearestNeighborsInPrediction must be <= "
776
                    << kAttributePredictionMaxNeighbourCount << "\n";
777
      }
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
      if (attr_aps.scalable_lifting_enabled_flag) {
        if (attr_aps.attr_encoding != AttributeEncoding::kLiftingTransform) {
          err.error() << it.first << "AttributeEncoding must be "
                      << (int)AttributeEncoding::kLiftingTransform << "\n";
        }

        if (attr_aps.lod_decimation_enabled_flag) {
          err.error() << it.first
                      << ".lod_decimation_enabled_flag must be = 0 \n";
        }

        if (params.encoder.gps.trisoup_node_size_log2 > 0) {
          err.error() << it.first
                      << "trisoup_node_size_log2 must be disabled \n";
        }
      }
794
    }
795
796
797
798
799
800
801
802

    if (attr_aps.init_qp < 4)
      err.error() << it.first << ".qp must be greater than 3\n";

    if (attr_aps.init_qp + attr_aps.aps_chroma_qp_offset < 4) {
      err.error() << it.first << ".qpChromaOffset must be greater than "
                  << attr_aps.init_qp - 5 << "\n";
    }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
803
804
  }

805
806
  // check required arguments are specified

807
  if (!params.isDecoder && params.uncompressedDataPath.empty())
808
809
    err.error() << "uncompressedDataPath not set\n";

810
  if (params.isDecoder && params.reconstructedDataPath.empty())
811
812
813
814
815
816
817
818
819
820
    err.error() << "reconstructedDataPath not set\n";

  if (params.compressedStreamPath.empty())
    err.error() << "compressedStreamPath not set\n";

  // report the current configuration (only in the absence of errors so
  // that errors/warnings are more obvious and in the same place).
  if (err.is_errored)
    return false;

821
822
  // Dump the complete derived configuration
  cout << "+ Effective configuration parameters\n";
823

824
  po::dumpCfg(cout, opts, "General", 4);
825
  if (params.isDecoder) {
826
    po::dumpCfg(cout, opts, "Decoder", 4);
827
  } else {
828
829
    po::dumpCfg(cout, opts, "Encoder", 4);
    po::dumpCfg(cout, opts, "Geometry", 4);
830
    po::dumpCfg(cout, opts, "Recolouring", 4);
831

832
    for (const auto& it : params.encoder.attributeIdxMap) {
833
      // NB: when dumping the config, opts references params_attr
834
835
      params_attr.desc = params.encoder.sps.attributeSets[it.second];
      params_attr.aps = params.encoder.aps[it.second];
836
      params_attr.encoder = params.encoder.attr[it.second];
837
838
839
      cout << "    " << it.first << "\n";
      po::dumpCfg(cout, opts, "Attributes", 8);
    }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
840
841
  }

842
843
  cout << endl;

Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
844
845
  return true;
}
846

847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
//============================================================================

SequenceEncoder::SequenceEncoder(Parameters* params) : params(params)
{}

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

int
SequenceEncoder::compress(Stopwatch* clock)
{
  bytestreamFile.open(params->compressedStreamPath, ios::binary);
  if (!bytestreamFile.is_open()) {
    return -1;
  }

  const int lastFrameNum = params->firstFrameNum + params->frameCount;
  for (frameNum = params->firstFrameNum; frameNum < lastFrameNum; frameNum++) {
    if (compressOneFrame(clock))
      return -1;
  }

  std::cout << "Total bitstream size " << bytestreamFile.tellp() << " B\n";
  bytestreamFile.close();

  return 0;
}

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

876
int
877
SequenceEncoder::compressOneFrame(Stopwatch* clock)
878
{
879
  std::string srcName{expandNum(params->uncompressedDataPath, frameNum)};
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
880
  PCCPointSet3 pointCloud;
881
  if (!ply::read(srcName, pointCloud) || pointCloud.getPointCount() == 0) {
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
882
883
884
885
    cout << "Error: can't open input file!" << endl;
    return -1;
  }

886
887
  // Sanitise the input point cloud
  // todo(df): remove the following with generic handling of properties
888
  bool codeColour = params->encoder.attributeIdxMap.count("color");
889
890
891
892
  if (!codeColour)
    pointCloud.removeColors();
  assert(codeColour == pointCloud.hasColors());

893
  bool codeReflectance = params->encoder.attributeIdxMap.count("reflectance");
894
895
896
897
  if (!codeReflectance)
    pointCloud.removeReflectances();
  assert(codeReflectance == pointCloud.hasReflectances());

898
  clock->start();
899

900
  if (params->colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
901
902
    pointCloud.convertRGBToYUV();
  }
903

904
  if (params->reflectanceScale > 1 && pointCloud.hasReflectances()) {
905
906
    const auto pointCount = pointCloud.getPointCount();
    for (size_t i = 0; i < pointCount; ++i) {
907
      int val = pointCloud.getReflectance(i) / params->reflectanceScale;
908
909
910
911
912
913
      pointCloud.setReflectance(i, val);
    }
  }

  // The reconstructed point cloud
  std::unique_ptr<PCCPointSet3> reconPointCloud;
914
  if (!params->reconstructedDataPath.empty()) {
915
    reconPointCloud.reset(new PCCPointSet3);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
916
917
  }

918
919
  auto bytestreamLenFrameStart = bytestreamFile.tellp();

920
  int ret = encoder.compress(
921
    pointCloud, &params->encoder, this, reconPointCloud.get());
922
  if (ret) {
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
923
924
925
    cout << "Error: can't compress point cloud!" << endl;
    return -1;
  }
926

927
928
  auto bytestreamLenFrameEnd = bytestreamFile.tellp();
  int frameLen = bytestreamLenFrameEnd - bytestreamLenFrameStart;
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
929

930
  std::cout << "Total frame size " << frameLen << " B" << std::endl;
931

932
933
934
935
  clock->stop();

  if (!params->reconstructedDataPath.empty()) {
    if (params->colorTransform == COLOR_TRANSFORM_RGB_TO_YCBCR) {
936
937
938
      reconPointCloud->convertYUVToRGB();
    }

939
    if (params->reflectanceScale > 1 && reconPointCloud->hasReflectances()) {
940
941
      const auto pointCount = reconPointCloud->getPointCount();
      for (size_t i = 0; i < pointCount; ++i) {
942
943
        int val =
          reconPointCloud->getReflectance(i) * params->reflectanceScale;
944
945
        reconPointCloud->setReflectance(i, val);
      }
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
946
    }
947

948
    std::string recName{expandNum(params->reconstructedDataPath, frameNum)};
949
    ply::write(*reconPointCloud, recName, !params->outputBinaryPly);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
950
951
952
953
  }

  return 0;
}
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975

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

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) {
976
    ply::write(cloud, plyName, !params->outputBinaryPly);
977
978
979
980
981
    return;
  }

  PCCPointSet3 tmpCloud(cloud);
  tmpCloud.convertYUVToRGB();
982
  ply::write(tmpCloud, plyName, !params->outputBinaryPly);
983
984
985
986
987
988
989
990
991
992
}

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

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

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

993
int
994
SequenceDecoder::decompress(Stopwatch* clock)
995
{
996
  ifstream fin(params->compressedStreamPath, ios::binary);
Khaled Mammou's avatar
TMC3v0  
Khaled Mammou committed
997
998
999
1000
  if (!fin.is_open()) {
    return -1;
  }

For faster browsing, not all history is shown. View entire blame