Timestamp Properties

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required (VERSION 3.16.3) # Oldest Ubuntu LTS (20.04 currently)
 
-project(libheif LANGUAGES C CXX VERSION 1.17.1)
+project(libheif LANGUAGES C CXX VERSION 1.17.2)
 
 # compatibility_version is never allowed to be decreased for any specific SONAME.
 # Libtool in the libheif-1.15.1 release had set it to 17.0.0, so we have to use this for the v1.x.y versions.

examples/decoder_png.cc

@@ -213,6 +213,7 @@ InputImage loadPNG(const char* filename, int output_bit_depth)
 
   // --- read XMP data
 
+#ifdef PNG_iTXt_SUPPORTED
   png_textp textPtr = nullptr;
   const png_uint_32 nTextChunks = png_get_text(png_ptr, info_ptr, &textPtr, nullptr);
   for (png_uint_32 i = 0; i < nTextChunks; i++, textPtr++) {
@@ -231,6 +232,7 @@ InputImage loadPNG(const char* filename, int output_bit_depth)
       }
     }
   }
+#endif
 
   int band = png_get_channels(png_ptr, info_ptr);
 

examples/encoder_png.cc

@@ -134,6 +134,7 @@ bool PngEncoder::Encode(const struct heif_image_handle* handle,
 
   // --- write XMP metadata
 
+#ifdef PNG_iTXt_SUPPORTED
   // spec: https://raw.githubusercontent.com/adobe/xmp-docs/master/XMPSpecifications/XMPSpecificationPart3.pdf
   std::vector<uint8_t> xmp = get_xmp_metadata(handle);
   if (!xmp.empty()) {
@@ -156,6 +157,7 @@ bool PngEncoder::Encode(const struct heif_image_handle* handle,
     xmp_text.itxt_length = text_length;
     png_set_text(png_ptr, info_ptr, &xmp_text, 1);
   }
+#endif
 
   png_write_info(png_ptr, info_ptr);
 

examples/heif_convert.cc

@@ -171,7 +171,7 @@ void list_all_decoders()
   std::cout << "JPEG decoders:\n";
   list_decoders(heif_compression_JPEG);
 
-  std::cout << "JPEG-2000 decoders:\n";
+  std::cout << "JPEG 2000 decoders:\n";
   list_decoders(heif_compression_JPEG2000);
 
 #if WITH_UNCOMPRESSED_CODEC

examples/heif_enc.cc

@@ -64,9 +64,9 @@ int metadata_compression = 0;
 const char* encoderId = nullptr;
 std::string chroma_downsampling;
 
+uint16_t nclx_colour_primaries = 1;
+uint16_t nclx_transfer_characteristic = 13;
 uint16_t nclx_matrix_coefficients = 6;
-uint16_t nclx_colour_primaries = 2;
-uint16_t nclx_transfer_characteristic = 2;
 int nclx_full_range = true;
 
 std::string property_pitm_description;
@@ -160,7 +160,7 @@ void show_help(const char* argv0)
             << "  -p                    set encoder parameter (NAME=VALUE)\n"
             << "  -A, --avif            encode as AVIF (not needed if output filename with .avif suffix is provided)\n"
             << "      --jpeg            encode as JPEG\n"
-            << "      --jpeg2000        encode as JPEG-2000 (experimental)\n"
+            << "      --jpeg2000        encode as JPEG 2000 (experimental)\n"
 #if WITH_UNCOMPRESSED_CODEC
             << "  -U, --uncompressed    encode as uncompressed image (according to ISO 23001-17) (EXPERIMENTAL)\n"
 #endif
@@ -349,6 +349,30 @@ static void show_list_of_encoders(const heif_encoder_descriptor* const* encoder_
 }
 
 
+static const char* get_compression_format_name(heif_compression_format format)
+{
+  switch (format) {
+    case heif_compression_AV1:
+      return "AV1";
+      break;
+    case heif_compression_HEVC:
+      return "HEVC";
+      break;
+    case heif_compression_JPEG:
+      return "JPEG";
+      break;
+    case heif_compression_JPEG2000:
+      return "JPEG 2000";
+      break;
+    case heif_compression_uncompressed:
+      return "Uncompressed";
+      break;
+    default:
+      assert(false);
+      return "unknown";
+  }
+}
+
 static void show_list_of_all_encoders()
 {
   for (auto compression_format : {heif_compression_HEVC, heif_compression_AV1, heif_compression_JPEG, heif_compression_JPEG2000
@@ -368,7 +392,7 @@ static void show_list_of_all_encoders()
         std::cout << "JPEG";
         break;
       case heif_compression_JPEG2000:
-        std::cout << "JPEG-2000";
+        std::cout << "JPEG 2000";
         break;
       case heif_compression_uncompressed:
         std::cout << "Uncompressed";
@@ -687,7 +711,7 @@ int main(int argc, char** argv)
     active_encoder_descriptor = encoder_descriptors[idx];
   }
   else {
-    std::cerr << "No " << (compressionFormat == heif_compression_AV1 ? "AV1" : "HEVC") << " encoder available.\n";
+    std::cerr << "No " << get_compression_format_name(compressionFormat) << " encoder available.\n";
     return 5;
   }
 

libheif/box.cc

@@ -85,7 +85,7 @@ Fraction::Fraction(int64_t num, int64_t den)
 Fraction Fraction::operator+(const Fraction& b) const
 {
   if (denominator == b.denominator) {
-    int64_t n = numerator + b.numerator;
+    int64_t n = int64_t{numerator} + b.numerator;
     int64_t d = denominator;
     return Fraction{n,d};
   }
@@ -99,7 +99,7 @@ Fraction Fraction::operator+(const Fraction& b) const
 Fraction Fraction::operator-(const Fraction& b) const
 {
   if (denominator == b.denominator) {
-    int64_t n = numerator - b.numerator;
+    int64_t n = int64_t{numerator} - b.numerator;
     int64_t d = denominator;
     return Fraction{n,d};
   }
@@ -3087,3 +3087,74 @@ Error Box_udes::write(StreamWriter& writer) const
   prepend_header(writer, box_start);
   return Error::Ok;
 }
+
+
+
+std::string Box_taic::dump(Indent& indent) const {
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "time_uncertainty: " << m_time_uncertainty << "\n";
+  sstr << indent << "correction_offset: " << m_correction_offset << "\n";
+  sstr << indent << "clock_drift_rate: " << m_clock_drift_rate << "\n";
+  sstr << indent << "clock_source: " << m_clock_source << "\n";
+  return sstr.str();
+}
+
+Error Box_taic::write(StreamWriter& writer) const {
+  uint32_t cdr_uint32;
+  std::memcpy(&cdr_uint32, &m_clock_drift_rate, sizeof(float)); 
+
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write64(m_time_uncertainty);
+  writer.write64(m_correction_offset);
+  writer.write32(cdr_uint32);
+  writer.write8(m_clock_source);
+
+  prepend_header(writer, box_start);
+
+  return Error::Ok;
+}
+
+Error Box_taic::parse(BitstreamRange& range) {
+  parse_full_box_header(range);
+
+  uint64_t high = range.read32();
+  uint64_t low = range.read32();
+  m_time_uncertainty = (high << 32) | low;
+
+  high = range.read32();
+  low = range.read32();
+  m_correction_offset = (high << 32) | low;
+
+  m_clock_drift_rate = (float) range.read32();
+  m_clock_source = range.read8();
+  return range.get_error();
+}
+
+std::string Box_itai::dump(Indent& indent) const {
+  std::ostringstream sstr;
+  sstr << Box::dump(indent);
+  sstr << indent << "TAI_timestamp: " << m_TAI_timestamp << "\n";
+  sstr << indent << "status_bits: " << m_status_bits << "\n";
+  return sstr.str();
+}
+
+Error Box_itai::write(StreamWriter& writer) const {
+  size_t box_start = reserve_box_header_space(writer);
+  writer.write64(m_TAI_timestamp);
+  writer.write8(m_status_bits);
+
+  prepend_header(writer, box_start);
+  return Error::Ok;
+}
+
+Error Box_itai::parse(BitstreamRange& range) {
+  parse_full_box_header(range);
+
+  uint64_t high = range.read32();
+  uint64_t low = range.read32();
+  m_TAI_timestamp = (high << 32) | low;
+
+  m_status_bits = range.read8();
+  return range.get_error();
+}

libheif/box.h

@@ -1058,4 +1058,112 @@ class Box_udes : public FullBox
   std::string m_tags;
 };
 
+
+
+class Box_taic : public FullBox
+{
+public:
+  Box_taic()
+  {
+    set_short_type(fourcc("taic"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  /**
+   * time_uncertainty.
+   * 
+   * The standard deviation measurement uncertainty in nanoseconds
+   * for the timestamp generation process. 
+   */
+  void set_time_uncertainty(uint64_t time_uncertainty) { m_time_uncertainty = time_uncertainty;}
+
+  /**
+   * correction_offset.
+   * 
+   * The difference in nanoseconds between the clock’s reported
+   * timestamp and true time value of the measurement event. 
+   */
+  void set_correction_offset(int64_t correction_offset) { m_correction_offset = correction_offset; }
+
+  /**
+   * clock_drift_rate.
+   * 
+   * The difference between the synchronized and unsynchronized
+   * time, over a period of one second. 
+   */
+  void set_clock_drift_rate(float clock_drift_rate) { m_clock_drift_rate = clock_drift_rate; }
+
+  /**
+   * clock_source.
+   * 
+   * 0 = Clock type is unkown
+   * 1 = The clock does not synchronize to an atomic source of absolute TAI time
+   * 2 = The clock can synchronize to an atomic source of absolute TAI time
+   */
+  void set_clock_source(uint8_t clock_source) { m_clock_source = clock_source; }
+
+  uint64_t get_time_uncertainty() const { return m_time_uncertainty; }
+
+  int64_t get_correction_offset() const { return m_correction_offset; }
+
+  float get_clock_drift_rate() const { return m_clock_drift_rate; }
+
+  uint8_t get_clock_source() const { return m_clock_source; }
+
+protected:
+  Error parse(BitstreamRange& range) override;
+
+private:
+  // Initialized to "unknown" 
+  uint64_t m_time_uncertainty = 0xFFFFFFFFFFFFFFFF;
+  int64_t m_correction_offset = 0x7FFFFFFFFFFFFFFF;
+  float m_clock_drift_rate = std::numeric_limits<float>::quiet_NaN();
+  uint8_t m_clock_source = 0;
+};
+
+
+class Box_itai : public FullBox 
+{
+public:
+  Box_itai()
+  {
+    set_short_type(fourcc("itai"));
+  }
+
+  std::string dump(Indent&) const override;
+
+  Error write(StreamWriter& writer) const override;
+
+  /**
+   * timestamp.
+   * 
+   * The number of nanoseconds since the TAI epoch of 1958-01-01T00:00:00.0Z.
+   */
+  void set_TAI_timestamp(uint64_t timestamp) { m_TAI_timestamp = timestamp; }
+
+  /**
+   * status_bits.
+   * 
+   * Bit 0: Synchronization Status (0=unsynchronized, 1=synchronized)
+   * Bit 1: Timestamp validity (0=invalid, 1=valid)
+   * Bits 2-7: Reserved
+   */
+  void set_status_bits(uint8_t status_bits) { m_status_bits = status_bits; }
+
+  uint64_t get_TAI_timestamp() const { return m_TAI_timestamp; }
+
+  uint8_t get_status_bits() const { return m_status_bits; }
+
+protected:
+  Error parse(BitstreamRange& range) override;
+
+private:
+  // Initialized to "unknown" 
+  uint64_t m_TAI_timestamp = 0xFFFFFFFFFFFFFFFF;
+  uint8_t m_status_bits = 0;
+};
+
 #endif

libheif/color-conversion/colorconversion.cc

@@ -446,8 +446,7 @@ std::shared_ptr<HeifPixelImage> ColorConversionPipeline::convert_image(const std
 
     // --- pass the color profiles to the new image
 
-    auto output_nclx = std::make_shared<color_profile_nclx>();
-    *output_nclx = step.output_state.nclx_profile;
+    auto output_nclx = std::make_shared<color_profile_nclx>(step.output_state.nclx_profile);
     out->set_color_profile_nclx(output_nclx);
     out->set_color_profile_icc(in->get_color_profile_icc());
 
@@ -521,19 +520,7 @@ std::shared_ptr<HeifPixelImage> convert_colorspace(const std::shared_ptr<HeifPix
     input_state.nclx_profile = *input->get_color_profile_nclx();
   }
 
-  // If some input nclx values are unspecified, use CCIR-601 values as default.
-
-  if (input_state.nclx_profile.get_matrix_coefficients() == heif_matrix_coefficients_unspecified) {
-    input_state.nclx_profile.set_matrix_coefficients(heif_matrix_coefficients_ITU_R_BT_601_6);
-  }
-
-  if (input_state.nclx_profile.get_colour_primaries() == heif_color_primaries_unspecified) {
-    input_state.nclx_profile.set_colour_primaries(heif_color_primaries_ITU_R_BT_601_6);
-  }
-
-  if (input_state.nclx_profile.get_transfer_characteristics() == heif_color_primaries_unspecified) {
-    input_state.nclx_profile.set_transfer_characteristics(heif_transfer_characteristic_ITU_R_BT_601_6);
-  }
+  input_state.nclx_profile.replace_undefined_values_with_sRGB_defaults();
 
   std::set<enum heif_channel> channels = input->get_channel_set();
   assert(!channels.empty());
@@ -546,7 +533,7 @@ std::shared_ptr<HeifPixelImage> convert_colorspace(const std::shared_ptr<HeifPix
     output_state.nclx_profile = *target_profile;
   }
 
-  // If some output nclx values are unspecified, set the to the same as the input.
+  // If some output nclx values are unspecified, set them to the same as the input.
 
   if (output_state.nclx_profile.get_matrix_coefficients() == heif_matrix_coefficients_unspecified) {
     output_state.nclx_profile.set_matrix_coefficients(input_state.nclx_profile.get_matrix_coefficients());
@@ -556,7 +543,7 @@ std::shared_ptr<HeifPixelImage> convert_colorspace(const std::shared_ptr<HeifPix
     output_state.nclx_profile.set_colour_primaries(input_state.nclx_profile.get_colour_primaries());
   }
 
-  if (output_state.nclx_profile.get_transfer_characteristics() == heif_color_primaries_unspecified) {
+  if (output_state.nclx_profile.get_transfer_characteristics() == heif_transfer_characteristic_unspecified) {
     output_state.nclx_profile.set_transfer_characteristics(input_state.nclx_profile.get_transfer_characteristics());
   }