uncompressed: pulled AbstractDecoder into its own file

libheif/CMakeLists.txt

@@ -191,7 +191,9 @@ if (WITH_UNCOMPRESSED_CODEC)
             codecs/uncompressed/unc_codec.h
             codecs/uncompressed/unc_codec.cc
             codecs/uncompressed/unc_dec.h
-            codecs/uncompressed/unc_dec.cc)
+            codecs/uncompressed/unc_dec.cc
+            codecs/uncompressed/decoder_abstract.h
+            codecs/uncompressed/decoder_abstract.cc)
 endif ()
 
 write_basic_package_version_file(${PROJECT_NAME}-config-version.cmake COMPATIBILITY ExactVersion)

libheif/codecs/uncompressed/decoder_abstract.cc

@@ -0,0 +1,288 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2023 Dirk Farin <[email protected]>
+ *
+ * This file is part of libheif.
+ *
+ * libheif is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * libheif is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <cstdint>
+#include <cstring>
+#include <algorithm>
+#include <map>
+#include <iostream>
+#include <cassert>
+#include <utility>
+
+#include "common_utils.h"
+#include "context.h"
+#include "compression.h"
+#include "error.h"
+#include "libheif/heif.h"
+#include "unc_types.h"
+#include "unc_boxes.h"
+#include "unc_codec.h"
+#include "decoder_abstract.h"
+
+
+template<typename T>
+T nAlignmentSkipBytes(uint32_t alignment, T size)
+{
+  if (alignment == 0) {
+    return 0;
+  }
+
+  T residual = size % alignment;
+  if (residual == 0) {
+    return 0;
+  }
+
+  return alignment - residual;
+}
+
+
+AbstractDecoder::AbstractDecoder(uint32_t width, uint32_t height, const std::shared_ptr<Box_cmpd> cmpd, const std::shared_ptr<Box_uncC> uncC) :
+    m_width(width),
+    m_height(height),
+    m_cmpd(std::move(cmpd)),
+    m_uncC(std::move(uncC))
+{
+  m_tile_height = m_height / m_uncC->get_number_of_tile_rows();
+  m_tile_width = m_width / m_uncC->get_number_of_tile_columns();
+
+  assert(m_tile_width > 0);
+  assert(m_tile_height > 0);
+}
+
+void AbstractDecoder::buildChannelList(std::shared_ptr<HeifPixelImage>& img)
+{
+  for (Box_uncC::Component component : m_uncC->get_components()) {
+    ChannelListEntry entry = buildChannelListEntry(component, img);
+    channelList.push_back(entry);
+  }
+}
+
+void AbstractDecoder::processComponentSample(UncompressedBitReader& srcBits, const ChannelListEntry& entry, uint64_t dst_row_offset, uint32_t tile_column, uint32_t tile_x)
+{
+  uint64_t dst_col_number = tile_column * entry.tile_width + tile_x;
+  uint64_t dst_column_offset = dst_col_number * entry.bytes_per_component_sample;
+  int val = srcBits.get_bits(entry.bits_per_component_sample);
+  memcpy(entry.dst_plane + dst_row_offset + dst_column_offset, &val, entry.bytes_per_component_sample);
+}
+
+// Handles the case where a row consists of a single component type
+// Not valid for Pixel interleave
+// Not valid for the Cb/Cr channels in Mixed Interleave
+// Not valid for multi-Y pixel interleave
+void AbstractDecoder::processComponentRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_row_offset, uint32_t tile_column)
+{
+  for (uint32_t tile_x = 0; tile_x < entry.tile_width; tile_x++) {
+    if (entry.component_alignment != 0) {
+      srcBits.skip_to_byte_boundary();
+      int numPadBits = (entry.component_alignment * 8) - entry.bits_per_component_sample;
+      srcBits.skip_bits(numPadBits);
+    }
+    processComponentSample(srcBits, entry, dst_row_offset, tile_column, tile_x);
+  }
+  srcBits.skip_to_byte_boundary();
+}
+
+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;
+  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);
+}
+
+// Handles the case where a row consists of a single component type
+// Not valid for Pixel interleave
+// Not valid for the Cb/Cr channels in Mixed Interleave
+// Not valid for multi-Y pixel interleave
+void AbstractDecoder::processComponentTileRow(ChannelListEntry& entry, UncompressedBitReader& srcBits, uint64_t dst_offset)
+{
+  for (uint32_t tile_x = 0; tile_x < entry.tile_width; tile_x++) {
+    if (entry.component_alignment != 0) {
+      srcBits.skip_to_byte_boundary();
+      int numPadBits = (entry.component_alignment * 8) - entry.bits_per_component_sample;
+      srcBits.skip_bits(numPadBits);
+    }
+    processComponentTileSample(srcBits, entry, dst_offset, tile_x);
+  }
+  srcBits.skip_to_byte_boundary();
+}
+
+
+AbstractDecoder::ChannelListEntry AbstractDecoder::buildChannelListEntry(Box_uncC::Component component,
+                                                                         std::shared_ptr<HeifPixelImage>& img)
+{
+  ChannelListEntry entry;
+  entry.use_channel = map_uncompressed_component_to_channel(m_cmpd, m_uncC, component, &(entry.channel));
+  entry.dst_plane = img->get_plane(entry.channel, &(entry.dst_plane_stride));
+  entry.tile_width = m_tile_width;
+  entry.tile_height = m_tile_height;
+  if ((entry.channel == heif_channel_Cb) || (entry.channel == heif_channel_Cr)) {
+    if (m_uncC->get_sampling_type() == sampling_mode_422) {
+      entry.tile_width /= 2;
+    }
+    else if (m_uncC->get_sampling_type() == sampling_mode_420) {
+      entry.tile_width /= 2;
+      entry.tile_height /= 2;
+    }
+    if (entry.channel == heif_channel_Cb) {
+      entry.other_chroma_dst_plane = img->get_plane(heif_channel_Cr, &(entry.other_chroma_dst_plane_stride));
+    }
+    else if (entry.channel == heif_channel_Cr) {
+      entry.other_chroma_dst_plane = img->get_plane(heif_channel_Cb, &(entry.other_chroma_dst_plane_stride));
+    }
+  }
+  entry.bits_per_component_sample = component.component_bit_depth;
+  entry.component_alignment = component.component_align_size;
+  entry.bytes_per_component_sample = (component.component_bit_depth + 7) / 8;
+  entry.bytes_per_tile_row_src = entry.tile_width * entry.bytes_per_component_sample;
+  return entry;
+}
+
+
+// generic compression and uncompressed, per 23001-17
+const Error AbstractDecoder::get_compressed_image_data_uncompressed(const HeifContext* context, heif_item_id ID,
+                                                                    std::vector<uint8_t>* data,
+                                                                    uint64_t range_start_offset, uint64_t range_size,
+                                                                    uint32_t tile_idx,
+                                                                    const Box_iloc::Item* item) const
+{
+  // --- get codec configuration
+
+  std::shared_ptr<const Box_cmpC> cmpC_box = context->get_heif_file()->get_property<const Box_cmpC>(ID);
+  std::shared_ptr<const Box_icef> icef_box = context->get_heif_file()->get_property<const Box_icef>(ID);
+
+  if (!cmpC_box) {
+    // assume no generic compression
+    return context->get_heif_file()->append_data_from_iloc(ID, *data, range_start_offset, range_size);
+  }
+
+  if (icef_box && cmpC_box->get_compressed_unit_type() == heif_cmpC_compressed_unit_type_image_tile) {
+    const auto& units = icef_box->get_units();
+    if (tile_idx >= units.size()) {
+      return {heif_error_Invalid_input,
+              heif_suberror_Unspecified,
+              "no icef-box entry for tile index"};
+    }
+
+    const auto unit = units[tile_idx];
+
+    // get all data and decode all
+    std::vector<uint8_t> compressed_bytes;
+    Error err = context->get_heif_file()->append_data_from_iloc(ID, compressed_bytes, unit.unit_offset, unit.unit_size);
+    if (err) {
+      return err;
+    }
+
+    // decompress only the unit
+    err = do_decompress_data(cmpC_box, compressed_bytes, data);
+    if (err) {
+      return err;
+    }
+  }
+  else if (icef_box) {
+    // get all data and decode all
+    std::vector<uint8_t> compressed_bytes;
+    Error err = context->get_heif_file()->append_data_from_iloc(ID, compressed_bytes); // image_id, src_data, tile_start_offset, total_tile_size);
+    if (err) {
+      return err;
+    }
+
+    for (Box_icef::CompressedUnitInfo unit_info : icef_box->get_units()) {
+      auto unit_start = compressed_bytes.begin() + unit_info.unit_offset;
+      auto unit_end = unit_start + unit_info.unit_size;
+      std::vector<uint8_t> compressed_unit_data = std::vector<uint8_t>(unit_start, unit_end);
+      std::vector<uint8_t> uncompressed_unit_data;
+      err = do_decompress_data(cmpC_box, compressed_unit_data, &uncompressed_unit_data);
+      if (err) {
+        return err;
+      }
+      data->insert(data->end(), uncompressed_unit_data.data(), uncompressed_unit_data.data() + uncompressed_unit_data.size());
+    }
+
+    // cut out the range that we actually need
+    memcpy(data->data(), data->data() + range_start_offset, range_size);
+    data->resize(range_size);
+  }
+  else {
+    // get all data and decode all
+    std::vector<uint8_t> compressed_bytes;
+    Error err = context->get_heif_file()->append_data_from_iloc(ID, compressed_bytes); // image_id, src_data, tile_start_offset, total_tile_size);
+    if (err) {
+      return err;
+    }
+
+    // Decode as a single blob
+    err = do_decompress_data(cmpC_box, compressed_bytes, data);
+    if (err) {
+      return err;
+    }
+
+    // cut out the range that we actually need
+    memcpy(data->data(), data->data() + range_start_offset, range_size);
+    data->resize(range_size);
+  }
+
+  return Error::Ok;
+}
+
+const Error AbstractDecoder::do_decompress_data(std::shared_ptr<const Box_cmpC>& cmpC_box,
+                                                std::vector<uint8_t> compressed_data,
+                                                std::vector<uint8_t>* data) const
+{
+  if (cmpC_box->get_compression_type() == fourcc("brot")) {
+#if HAVE_BROTLI
+    return decompress_brotli(compressed_data, data);
+#else
+    std::stringstream sstr;
+  sstr << "cannot decode unci item with brotli compression - not enabled" << std::endl;
+  return Error(heif_error_Unsupported_feature,
+               heif_suberror_Unsupported_generic_compression_method,
+               sstr.str());
+#endif
+  }
+  else if (cmpC_box->get_compression_type() == fourcc("zlib")) {
+#if HAVE_ZLIB
+    return decompress_zlib(compressed_data, data);
+#else
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with zlib compression - not enabled" << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+#endif
+  }
+  else if (cmpC_box->get_compression_type() == fourcc("defl")) {
+#if HAVE_ZLIB
+    return decompress_deflate(compressed_data, data);
+#else
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with deflate compression - not enabled" << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+#endif
+  }
+  else {
+    std::stringstream sstr;
+    sstr << "cannot decode unci item with unsupported compression type: " << cmpC_box->get_compression_type() << std::endl;
+    return Error(heif_error_Unsupported_feature,
+                 heif_suberror_Unsupported_generic_compression_method,
+                 sstr.str());
+  }
+}