fix various minor issues

libheif/api/libheif/heif.cc

@@ -3317,7 +3317,7 @@ int heif_encoder_has_default(struct heif_encoder* encoder,
 }
 
 
-static void set_default_options(heif_encoding_options& options)
+void set_default_encoding_options(heif_encoding_options& options)
 {
  options.version = 7;
 
@@ -3368,7 +3368,7 @@ heif_encoding_options* heif_encoding_options_alloc()
 {
  auto options = new heif_encoding_options;
 
- set_default_options(*options);
+ set_default_encoding_options(*options);
 
  return options;
 }
@@ -3396,7 +3396,7 @@ struct heif_error heif_context_encode_image(struct heif_context* ctx,
 
  heif_encoding_options options;
  heif_color_profile_nclx nclx;
- set_default_options(options);
+ set_default_encoding_options(options);
  if (input_options) {
  copy_options(options, *input_options);
 
@@ -3462,7 +3462,7 @@ struct heif_error heif_context_encode_grid(struct heif_context* ctx,
  // TODO: Don't repeat this code from heif_context_encode_image()
  heif_encoding_options options;
  heif_color_profile_nclx nclx;
- set_default_options(options);
+ set_default_encoding_options(options);
  if (input_options) {
  copy_options(options, *input_options);
 
@@ -3710,7 +3710,7 @@ struct heif_error heif_context_encode_thumbnail(struct heif_context* ctx,
  std::shared_ptr<ImageItem> thumbnail_image;
 
  heif_encoding_options options;
- set_default_options(options);
+ set_default_encoding_options(options);
 
  if (input_options != nullptr) {
  copy_options(options, *input_options);

libheif/bitstream.cc

@@ -116,7 +116,7 @@ bool StreamReader_memory::read(void* data, size_t size)
 
 bool StreamReader_memory::seek(uint64_t position)
 {
- if (position > m_length || position < 0)
+ if (position > m_length)
  return false;
 
  m_position = position;

libheif/box.cc

@@ -1051,9 +1051,9 @@ std::string Box_Error::dump(Indent& indent) const
  sstr << indent << '\'' << fourcc_to_string(m_box_type_with_parse_error) << "' parse error: " << m_error.message << "\n";
  sstr << indent << "fatality: ";
  switch (m_fatality) {
- case parse_error_fatality::fatal: sstr << "fatal\n";
- case parse_error_fatality::ignorable: sstr << "ignorable\n";
- case parse_error_fatality::optional: sstr << "optional\n";
+ case parse_error_fatality::fatal: sstr << "fatal\n"; break;
+ case parse_error_fatality::ignorable: sstr << "ignorable\n"; break;
+ case parse_error_fatality::optional: sstr << "optional\n"; break;
  }
 
  return sstr.str();
@@ -3643,7 +3643,7 @@ void Box_iref::overwrite_reference(heif_item_id from_id, uint32_t type, uint32_t
 {
  for (auto& ref : m_references) {
  if (ref.from_item_ID == from_id && ref.header.get_short_type() == type) {
- assert(reference_idx >= 0 && reference_idx < ref.to_item_ID.size());
+ assert(reference_idx < ref.to_item_ID.size());
 
  ref.to_item_ID[reference_idx] = to_item;
  return;

libheif/box.h

@@ -1293,15 +1293,15 @@ class Box_cclv : public Box
  Error parse(BitstreamRange& range, const heif_security_limits*) override;
 
 private:
- bool m_ccv_primaries_valid;
- int32_t m_ccv_primaries_x[3];
- int32_t m_ccv_primaries_y[3];
- bool m_ccv_min_luminance_valid;
- uint32_t m_ccv_min_luminance_value;
- bool m_ccv_max_luminance_valid;
- uint32_t m_ccv_max_luminance_value;
- bool m_ccv_avg_luminance_valid;
- uint32_t m_ccv_avg_luminance_value;
+ bool m_ccv_primaries_valid = false;
+ int32_t m_ccv_primaries_x[3] {};
+ int32_t m_ccv_primaries_y[3] {};
+ bool m_ccv_min_luminance_valid = false;
+ uint32_t m_ccv_min_luminance_value = 0;
+ bool m_ccv_max_luminance_valid = false;
+ uint32_t m_ccv_max_luminance_value = 0;
+ bool m_ccv_avg_luminance_valid = false;
+ uint32_t m_ccv_avg_luminance_value = 0;
 };
 
 

libheif/codecs/uncompressed/decoder_abstract.cc

@@ -83,7 +83,7 @@ void AbstractDecoder::processComponentRow(ChannelListEntry& entry, UncompressedB
 
 void AbstractDecoder::processComponentTileSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_offset, uint32_t tile_x)
 {
- uint64_t dst_sample_offset = tile_x * entry.bytes_per_component_sample;
+ uint64_t dst_sample_offset = uint64_t{tile_x} * entry.bytes_per_component_sample;
  int val = srcBits.get_bits(entry.bits_per_component_sample);
  memcpy(entry.dst_plane + dst_offset + dst_sample_offset, &val, entry.bytes_per_component_sample);
 }

libheif/codecs/uncompressed/decoder_component_interleave.cc

@@ -51,7 +51,7 @@ Error ComponentInterleaveDecoder::decode_tile(const HeifContext* context,
 
  uint32_t bytes_per_tile_row = (bits_per_component * entry.tile_width + 7) / 8;
  skip_to_alignment(bytes_per_tile_row, m_uncC->get_row_align_size());
- uint64_t bytes_per_tile = bytes_per_tile_row * entry.tile_height;
+ uint64_t bytes_per_tile = uint64_t{bytes_per_tile_row} * entry.tile_height;
  total_tile_size += bytes_per_tile;
  }
 
@@ -82,7 +82,7 @@ Error ComponentInterleaveDecoder::decode_tile(const HeifContext* context,
  for (uint32_t y = 0; y < entry.tile_height; y++) {
  srcBits.markRowStart();
  if (entry.use_channel) {
- uint64_t dst_row_offset = (out_y0 + y) * entry.dst_plane_stride;
+ uint64_t dst_row_offset = uint64_t{(out_y0 + y)} * entry.dst_plane_stride;
  processComponentTileRow(entry, srcBits, dst_row_offset + out_x0 * entry.bytes_per_component_sample);
  }
  else {

libheif/codecs/uncompressed/decoder_mixed_interleave.cc

@@ -47,7 +47,7 @@ Error MixedInterleaveDecoder::decode_tile(const HeifContext* context,
  uint32_t bits_per_row = entry.bits_per_component_sample * entry.tile_width;
  bits_per_row = (bits_per_row + 7) & ~7U; // align to byte boundary
 
- tile_size += bits_per_row / 8 * entry.tile_height;
+ tile_size += uint64_t{bits_per_row} / 8 * entry.tile_height;
  }
  else {
  uint32_t bits_per_component = entry.bits_per_component_sample;
@@ -60,7 +60,7 @@ Error MixedInterleaveDecoder::decode_tile(const HeifContext* context,
  uint32_t bits_per_row = bits_per_component * entry.tile_width;
  bits_per_row = (bits_per_row + 7) & ~7U; // align to byte boundary
 
- tile_size += bits_per_row / 8 * entry.tile_height;
+ tile_size += uint64_t{bits_per_row} / 8 * entry.tile_height;
  }
  }
 

libheif/codecs/uncompressed/unc_boxes.cc

@@ -412,10 +412,10 @@ uint64_t Box_uncC::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t ti
  if (m_profile != 0) {
  switch (m_profile) {
  case fourcc("rgba"):
- return 4 * tile_width * tile_height;
+ return 4 * uint64_t{tile_width} * tile_height;
 
  case fourcc("rgb3"):
- return 3 * tile_width * tile_height;
+ return 3 * uint64_t{tile_width} * tile_height;
 
  default:
  assert(false);
@@ -433,7 +433,7 @@ uint64_t Box_uncC::compute_tile_data_size_bytes(uint32_t tile_width, uint32_t ti
  bytes_per_pixel += comp.component_bit_depth / 8;
  }
 
- return bytes_per_pixel * tile_width * tile_height;
+ return bytes_per_pixel * uint64_t{tile_width} * tile_height;
  }
  default:
  assert(false);
@@ -713,7 +713,7 @@ Error Box_cpat::parse(BitstreamRange& range, const heif_security_limits* limits)
  "Maximum Bayer pattern size exceeded."};
  }
 
- m_components.resize(m_pattern_width * m_pattern_height);
+ m_components.resize(size_t{m_pattern_width} * m_pattern_height);
 
  for (uint16_t i = 0; i < m_pattern_height; i++) {
  for (uint16_t j = 0; j < m_pattern_width; j++) {
@@ -747,7 +747,7 @@ Error Box_cpat::write(StreamWriter& writer) const
 {
  size_t box_start = reserve_box_header_space(writer);
 
- if (m_pattern_width * m_pattern_height != m_components.size()) {
+ if (m_pattern_width * size_t{m_pattern_height} != m_components.size()) {
  // needs to be rectangular
  return {heif_error_Usage_error,
  heif_suberror_Invalid_parameter_value,

libheif/image-items/grid.cc

@@ -143,15 +143,20 @@ std::string ImageGrid::dump() const
 }
 
 
+extern void set_default_encoding_options(heif_encoding_options& options);
+
+
 ImageItem_Grid::ImageItem_Grid(HeifContext* ctx)
  : ImageItem(ctx)
 {
+ set_default_encoding_options(m_encoding_options);
 }
 
 
 ImageItem_Grid::ImageItem_Grid(HeifContext* ctx, heif_item_id id)
  : ImageItem(ctx, id)
 {
+ set_default_encoding_options(m_encoding_options);
 }
 
 

libheif/image-items/grid.h

@@ -138,7 +138,7 @@ class ImageItem_Grid : public ImageItem
 
  const ImageGrid& get_grid_spec() const { return m_grid_spec; }
 
- void set_grid_spec(const ImageGrid& grid) { m_grid_spec = grid; m_grid_tile_ids.resize(grid.get_rows() * grid.get_columns()); }
+ void set_grid_spec(const ImageGrid& grid) { m_grid_spec = grid; m_grid_tile_ids.resize(size_t{grid.get_rows()} * grid.get_columns()); }
 
  const std::vector<heif_item_id>& get_grid_tiles() const { return m_grid_tile_ids; }
 

libheif/image-items/tiled.cc

@@ -68,6 +68,27 @@ uint32_t nTiles_v(const heif_tiled_image_parameters& params)
 }
 
 
+void Box_tilC::init_heif_tiled_image_parameters(heif_tiled_image_parameters& params)
+{
+ params.version = 1;
+
+ params.image_width = 0;
+ params.image_height = 0;
+ params.tile_width = 0;
+ params.tile_height = 0;
+ params.compression_format_fourcc = 0;
+ params.offset_field_length = 40;
+ params.size_field_length = 24;
+ params.number_of_extra_dimensions = 0;
+
+ for (uint32_t& dim : params.extra_dimensions) {
+ dim = 0;
+ }
+
+ params.tiles_are_sequential = false;
+}
+
+
 void Box_tilC::derive_box_version()
 {
  set_version(1);
@@ -249,7 +270,7 @@ Error Box_tilC::parse(BitstreamRange& range, const heif_security_limits* limits)
 }
 
 
-Error TildHeader::set_parameters(const heif_tiled_image_parameters& params)
+Error TiledHeader::set_parameters(const heif_tiled_image_parameters& params)
 {
  m_parameters = params;
 
@@ -271,7 +292,7 @@ Error TildHeader::set_parameters(const heif_tiled_image_parameters& params)
 }
 
 
-Error TildHeader::read_full_offset_table(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id, const heif_security_limits* limits)
+Error TiledHeader::read_full_offset_table(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id, const heif_security_limits* limits)
 {
  auto max_tiles = heif_get_global_security_limits()->max_number_of_tiles;
 
@@ -286,8 +307,8 @@ Error TildHeader::read_full_offset_table(const std::shared_ptr<HeifFile>& file,
 }
 
 
-Error TildHeader::read_offset_table_range(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id,
- uint64_t start, uint64_t end)
+Error TiledHeader::read_offset_table_range(const std::shared_ptr<HeifFile>& file, heif_item_id tild_id,
+  uint64_t start, uint64_t end)
 {
  const Error eofError(heif_error_Invalid_input,
  heif_suberror_Unspecified,
@@ -328,20 +349,20 @@ Error TildHeader::read_offset_table_range(const std::shared_ptr<HeifFile>& file,
 }
 
 
-size_t TildHeader::get_header_size() const
+size_t TiledHeader::get_header_size() const
 {
  assert(m_header_size);
  return m_header_size;
 }
 
 
-uint32_t TildHeader::get_offset_table_entry_size() const
+uint32_t TiledHeader::get_offset_table_entry_size() const
 {
  return (m_parameters.offset_field_length + m_parameters.size_field_length) / 8;
 }
 
 
-std::pair<uint32_t, uint32_t> TildHeader::get_tile_offset_table_range_to_read(uint32_t idx, uint32_t nEntries) const
+std::pair<uint32_t, uint32_t> TiledHeader::get_tile_offset_table_range_to_read(uint32_t idx, uint32_t nEntries) const
 {
  uint32_t start = idx;
  uint32_t end = idx+1;
@@ -369,9 +390,9 @@ std::pair<uint32_t, uint32_t> TildHeader::get_tile_offset_table_range_to_read(ui
 }
 
 
-void TildHeader::set_tild_tile_range(uint32_t tile_x, uint32_t tile_y, uint64_t offset, uint32_t size)
+void TiledHeader::set_tild_tile_range(uint32_t tile_x, uint32_t tile_y, uint64_t offset, uint32_t size)
 {
- uint64_t idx = tile_y * nTiles_h(m_parameters) + tile_x;
+ uint64_t idx = uint64_t{tile_y} * nTiles_h(m_parameters) + tile_x;
  m_offsets[idx].offset = offset;
  m_offsets[idx].size = size;
 }
@@ -388,7 +409,7 @@ void writevec(uint8_t* data, size_t& idx, I value, int len)
 }
 
 
-std::vector<uint8_t> TildHeader::write_offset_table()
+std::vector<uint8_t> TiledHeader::write_offset_table()
 {
  uint64_t nTiles = number_of_tiles(m_parameters);
 
@@ -416,7 +437,7 @@ std::vector<uint8_t> TildHeader::write_offset_table()
 }
 
 
-std::string TildHeader::dump() const
+std::string TiledHeader::dump() const
 {
  std::stringstream sstr;
 
@@ -529,7 +550,7 @@ ImageItem_Tiled::add_new_tiled_item(HeifContext* ctx, const heif_tiled_image_par
 
  // Create header + offset table
 
- TildHeader tild_header;
+ TiledHeader tild_header;
  tild_header.set_parameters(*parameters);
  tild_header.set_compression_format(encoder->plugin->compression_format);
 

libheif/image-items/tiled.h

@@ -51,6 +51,8 @@ class Box_tilC : public FullBox
  Box_tilC()
  {
  set_short_type(fourcc("tilC"));
+
+ init_heif_tiled_image_parameters(m_parameters);
  }
 
  bool is_essential() const override { return true; }
@@ -72,14 +74,16 @@ class Box_tilC : public FullBox
 
 private:
  heif_tiled_image_parameters m_parameters;
+
+ static void init_heif_tiled_image_parameters(heif_tiled_image_parameters& params);
 };
 
 
 #define TILD_OFFSET_NOT_AVAILABLE 0
 #define TILD_OFFSET_SEE_LOWER_RESOLUTION_LAYER 1
 #define TILD_OFFSET_NOT_LOADED 10
 
-class TildHeader
+class TiledHeader
 {
 public:
  Error set_parameters(const heif_tiled_image_parameters& params);
@@ -175,9 +179,9 @@ class ImageItem_Tiled : public ImageItem
 
  // --- tild
 
- void set_tild_header(const TildHeader& header) { m_tild_header = header; }
+ void set_tild_header(const TiledHeader& header) { m_tild_header = header; }
 
- TildHeader& get_tild_header() { return m_tild_header; }
+ TiledHeader& get_tild_header() { return m_tild_header; }
 
  uint64_t get_next_tild_position() const { return m_next_tild_position; }
 
@@ -188,7 +192,7 @@ class ImageItem_Tiled : public ImageItem
  void get_tile_size(uint32_t& w, uint32_t& h) const override;
 
 private:
- TildHeader m_tild_header;
+ TiledHeader m_tild_header;
  uint64_t m_next_tild_position = 0;
 
  uint32_t mReadChunkSize_bytes = 64*1024; // 64 kiB

libheif/image-items/unc_image.cc

@@ -333,6 +333,8 @@ Result<std::shared_ptr<ImageItem_uncompressed>> ImageItem_uncompressed::add_unci
 
  const unciHeaders& headers = *genHeadersResult;
 
+ assert(headers.uncC);
+
  if (headers.uncC) {
  file->add_property(unci_id, headers.uncC, true);
  }