extract stream decoding to Decoder classes

CMakeLists.txt

@@ -243,7 +243,7 @@ endif()
 plugin_option(OpenJPEG_ENCODER "OpenJPEG J2K encoder" OFF ON)
 plugin_option(OpenJPEG_DECODER "OpenJPEG J2K decoder" OFF ON)
 if (WITH_OpenJPEG_ENCODER OR WITH_OpenJPEG_DECODER)
-    find_package(OpenJPEG 2)
+    find_package(OpenJPEG)
 endif()
 
 # ffmpeg

libheif/CMakeLists.txt

@@ -50,14 +50,20 @@ set(libheif_sources
         api/libheif/heif_items.cc
         api/libheif/heif_experimental.h
         api/libheif/heif_experimental.cc
+        codecs/decoder.h
+        codecs/decoder.cc
         codecs/hevc.cc
         codecs/hevc.h
+        codecs/hevc_dec.cc
+        codecs/hevc_dec.h
         codecs/avif.cc
         codecs/avif.h
         codecs/jpeg.h
         codecs/jpeg.cc
         codecs/jpeg2000.h
         codecs/jpeg2000.cc
+        codecs/jpeg2000_dec.h
+        codecs/jpeg2000_dec.cc
         codecs/vvc.h
         codecs/vvc.cc
         codecs/avc.h

libheif/api/libheif/heif.h

@@ -1141,16 +1141,18 @@ LIBHEIF_API
 int heif_image_handle_is_premultiplied_alpha(const struct heif_image_handle*);
 
 // Returns -1 on error, e.g. if this information is not present in the image.
+// Only defined for images coded in the YCbCr colorspace.
 LIBHEIF_API
 int heif_image_handle_get_luma_bits_per_pixel(const struct heif_image_handle*);
 
 // Returns -1 on error, e.g. if this information is not present in the image.
+// Only defined for images coded in the YCbCr colorspace.
 LIBHEIF_API
 int heif_image_handle_get_chroma_bits_per_pixel(const struct heif_image_handle*);
 
 // Return the colorspace that libheif proposes to use for decoding.
 // Usually, these will be either YCbCr or Monochrome, but it may also propose RGB for images
-// encoded with matrix_coefficients=0.
+// encoded with matrix_coefficients=0 or for images coded natively in RGB.
 // It may also return *_undefined if the file misses relevant information to determine this without decoding.
 LIBHEIF_API
 struct heif_error heif_image_handle_get_preferred_decoding_colorspace(const struct heif_image_handle* image_handle,

libheif/codecs/decoder.cc

@@ -0,0 +1,183 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 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 "codecs/decoder.h"
+#include "error.h"
+#include "context.h"
+#include "plugin_registry.h"
+#include "libheif/api_structs.h"
+
+#include "codecs/hevc_dec.h"
+#include "codecs/jpeg2000_dec.h"
+
+#include <limits>
+
+
+void DataExtent::set_from_image_item(class HeifFile* file, heif_item_id item)
+{
+  m_iloc = file->get_property<Box_iloc>(item);
+  m_item_id = item;
+}
+
+
+Result<std::vector<uint8_t>*> DataExtent::read_data() const
+{
+  if (!m_raw.empty()) {
+    return &m_raw;
+  }
+  else if (m_iloc) {
+    // image
+    m_iloc->read_data(m_item_id, m_file->get_reader(), nullptr, &m_raw, 0, std::numeric_limits<uint64_t>::max());
+  }
+  else {
+    // sequence
+    assert(false); // TODO
+  }
+
+  return &m_raw;
+}
+
+
+Result<std::vector<uint8_t>> DataExtent::read_data(uint64_t offset, uint64_t size) const
+{
+  std::vector<uint8_t> data;
+
+  if (!m_raw.empty()) {
+    data.insert(data.begin(), m_raw.begin() + offset, m_raw.begin() + offset + size);
+    return data;
+  }
+  else if (m_iloc) {
+    // TODO: cache data
+
+    // image
+    Error err = m_iloc->read_data(m_item_id, m_file->get_reader(), nullptr, &m_raw, 0, size);
+    if (err) {
+      return err;
+    }
+    return data;
+  }
+  else {
+    // sequence
+    assert(false); // TODO
+    return Error::Ok;
+  }
+}
+
+
+std::shared_ptr<Decoder> Decoder::alloc_for_compression_format(const HeifContext* ctx, heif_item_id id, uint32_t format_4cc)
+{
+  switch (format_4cc) {
+    case fourcc("hvc1"): {
+      auto hvcC = ctx->get_heif_file()->get_property<Box_hvcC>(id);
+      return std::make_shared<Decoder_HEVC>(hvcC);
+    }
+    case fourcc("j2k1"): {
+      auto j2kH = ctx->get_heif_file()->get_property<Box_j2kH>(id);
+      return std::make_shared<Decoder_JPEG2000>(j2kH);
+    }
+#if WITH_UNCOMPRESSED_CODEC
+#endif
+    default:
+      assert(false);
+      return nullptr;
+  }
+}
+
+
+Result<std::vector<uint8_t>> Decoder::get_compressed_data() const
+{
+  // --- get the compressed image data
+
+  // data from configuration blocks
+
+  Result<std::vector<uint8_t>> confData = read_bitstream_configuration_data();
+  if (confData.error) {
+    return confData.error;
+  }
+
+  std::vector<uint8_t> data = confData.value;
+
+  // image data, usually from 'mdat'
+
+  Result dataResult = m_data_extent.read_data();
+  if (dataResult.error) {
+    return dataResult.error;
+  }
+
+  data.insert(data.begin(), dataResult.value->begin(), dataResult.value->end());
+
+  return data;
+}
+
+
+Result<std::shared_ptr<HeifPixelImage>>
+Decoder::decode_single_frame_from_compressed_data(heif_compression_format compression_format,
+                                                  const struct heif_decoding_options& options,
+                                                  const std::vector<uint8_t>& data)
+{
+  const struct heif_decoder_plugin* decoder_plugin = get_decoder(compression_format, options.decoder_id);
+  if (!decoder_plugin) {
+    return Error(heif_error_Plugin_loading_error, heif_suberror_No_matching_decoder_installed);
+  }
+
+
+  // --- decode image with the plugin
+
+  void* decoder;
+  struct heif_error err = decoder_plugin->new_decoder(&decoder);
+  if (err.code != heif_error_Ok) {
+    return Error(err.code, err.subcode, err.message);
+  }
+
+  if (decoder_plugin->plugin_api_version >= 2) {
+    if (decoder_plugin->set_strict_decoding) {
+      decoder_plugin->set_strict_decoding(decoder, options.strict_decoding);
+    }
+  }
+
+  err = decoder_plugin->push_data(decoder, data.data(), data.size());
+  if (err.code != heif_error_Ok) {
+    decoder_plugin->free_decoder(decoder);
+    return Error(err.code, err.subcode, err.message);
+  }
+
+  heif_image* decoded_img = nullptr;
+
+  err = decoder_plugin->decode_image(decoder, &decoded_img);
+  if (err.code != heif_error_Ok) {
+    decoder_plugin->free_decoder(decoder);
+    return Error(err.code, err.subcode, err.message);
+  }
+
+  if (!decoded_img) {
+    // TODO(farindk): The plugin should return an error in this case.
+    decoder_plugin->free_decoder(decoder);
+    return Error(heif_error_Decoder_plugin_error, heif_suberror_Unspecified);
+  }
+
+  // -- cleanup
+
+  std::shared_ptr<HeifPixelImage> img = std::move(decoded_img->image);
+  heif_image_release(decoded_img);
+
+  decoder_plugin->free_decoder(decoder);
+
+  return img;
+}

libheif/codecs/decoder.h

@@ -0,0 +1,90 @@
+/*
+ * HEIF codec.
+ * Copyright (c) 2024 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/>.
+ */
+
+#ifndef HEIF_DECODER_H
+#define HEIF_DECODER_H
+
+#include "libheif/heif.h"
+#include "box.h"
+#include "error.h"
+#include "file.h"
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include <codecs/hevc.h>
+
+
+// Specifies the input data for decoding.
+// For images, this points to the iloc extents.
+// For sequences, this points to the track data.
+struct DataExtent
+{
+  std::shared_ptr<HeifFile> m_file;
+
+  // --- raw data
+  mutable std::vector<uint8_t> m_raw; // also for cached data
+
+  // --- image
+  std::shared_ptr<Box_iloc> m_iloc;
+  heif_item_id m_item_id = 0;
+
+  // --- sequence
+  // TODO
+
+  void set_from_image_item(class HeifFile* file, heif_item_id item);
+
+  Result<std::vector<uint8_t>*> read_data() const;
+
+  Result<std::vector<uint8_t>> read_data(uint64_t offset, uint64_t size) const;
+};
+
+
+class Decoder
+{
+public:
+  virtual ~Decoder() = default;
+
+  static std::shared_ptr<Decoder> alloc_for_compression_format(const HeifContext* ctx, heif_item_id, uint32_t format_4cc);
+
+  void set_data_extent(DataExtent extent) { m_data_extent = std::move(extent); }
+
+  [[nodiscard]] virtual int get_luma_bits_per_pixel() const = 0;
+
+  [[nodiscard]] virtual int get_chroma_bits_per_pixel() const = 0;
+
+  [[nodiscard]] virtual Error get_coded_image_colorspace(heif_colorspace*, heif_chroma*) const = 0;
+
+  [[nodiscard]] virtual Result<std::vector<uint8_t>> read_bitstream_configuration_data() const = 0;
+
+  Result<std::vector<uint8_t>> get_compressed_data() const;
+
+  static Result<std::shared_ptr<HeifPixelImage>>
+  decode_single_frame_from_compressed_data(heif_compression_format compression_format,
+                                           const struct heif_decoding_options& options,
+                                           const std::vector<uint8_t>& data);
+
+private:
+  DataExtent m_data_extent;
+};
+
+
+#endif