Commit 48a57e81 for libheif
commit 48a57e819b35f91396eb0502f4c64b8b5e09c359
Author: Dirk Farin <dirk.farin@gmail.com>
Date: Fri May 15 00:37:51 2026 +0200
rename get_channel() to get_channel_memory()
diff --git a/libheif/api/libheif/heif_image.cc b/libheif/api/libheif/heif_image.cc
index 7fdf0044..04bc0772 100644
--- a/libheif/api/libheif/heif_image.cc
+++ b/libheif/api/libheif/heif_image.cc
@@ -155,7 +155,7 @@ const uint8_t* heif_image_get_plane_readonly(const heif_image* image,
}
size_t stride;
- const auto* p = image->image->get_channel(channel, &stride);
+ const auto* p = image->image->get_channel_memory(channel, &stride);
// TODO: use C++20 std::cmp_greater()
if (stride > static_cast<uint32_t>(std::numeric_limits<int>::max())) {
@@ -181,7 +181,7 @@ uint8_t* heif_image_get_plane(heif_image* image,
}
size_t stride;
- uint8_t* p = image->image->get_channel(channel, &stride);
+ uint8_t* p = image->image->get_channel_memory(channel, &stride);
// TODO: use C++20 std::cmp_greater()
if (stride > static_cast<uint32_t>(std::numeric_limits<int>::max())) {
@@ -206,7 +206,7 @@ const uint8_t* heif_image_get_plane_readonly2(const heif_image* image,
return nullptr;
}
- return image->image->get_channel(channel, out_stride);
+ return image->image->get_channel_memory(channel, out_stride);
}
@@ -223,7 +223,7 @@ uint8_t* heif_image_get_plane2(heif_image* image,
return nullptr;
}
- return image->image->get_channel(channel, out_stride);
+ return image->image->get_channel_memory(channel, out_stride);
}
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc
index 8a5354ae..96e51e82 100644
--- a/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc
+++ b/libheif/codecs/uncompressed/unc_decoder_block_component_interleave.cc
@@ -104,7 +104,7 @@ Error unc_decoder_block_component_interleave::decode_tile(const std::vector<uint
heif_channel channel;
comp[i].use = map_uncompressed_component_to_channel(m_cmpd, c, &channel);
if (comp[i].use) {
- comp[i].dst_plane = img->get_channel(channel, &comp[i].dst_plane_stride);
+ comp[i].dst_plane = img->get_channel_memory(channel, &comp[i].dst_plane_stride);
}
else {
comp[i].dst_plane = nullptr;
diff --git a/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
index 462a3cc2..075c6a58 100644
--- a/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
+++ b/libheif/codecs/uncompressed/unc_decoder_block_pixel_interleave.cc
@@ -93,7 +93,7 @@ Error unc_decoder_block_pixel_interleave::decode_tile(const std::vector<uint8_t>
heif_channel channel;
comp[i].use = map_uncompressed_component_to_channel(m_cmpd, c, &channel);
if (comp[i].use) {
- comp[i].dst_plane = img->get_channel(channel, &comp[i].dst_plane_stride);
+ comp[i].dst_plane = img->get_channel_memory(channel, &comp[i].dst_plane_stride);
}
else {
comp[i].dst_plane = nullptr;
diff --git a/libheif/codecs/uncompressed/unc_decoder_legacybase.cc b/libheif/codecs/uncompressed/unc_decoder_legacybase.cc
index 10707222..8458becc 100644
--- a/libheif/codecs/uncompressed/unc_decoder_legacybase.cc
+++ b/libheif/codecs/uncompressed/unc_decoder_legacybase.cc
@@ -156,10 +156,10 @@ unc_decoder_legacybase::ChannelListEntry unc_decoder_legacybase::buildChannelLis
entry.tile_height /= 2;
}
if (entry.channel == heif_channel_Cb) {
- entry.other_chroma_dst_plane = img->get_channel(heif_channel_Cr, &(entry.other_chroma_dst_plane_stride));
+ entry.other_chroma_dst_plane = img->get_channel_memory(heif_channel_Cr, &(entry.other_chroma_dst_plane_stride));
}
else if (entry.channel == heif_channel_Cr) {
- entry.other_chroma_dst_plane = img->get_channel(heif_channel_Cb, &(entry.other_chroma_dst_plane_stride));
+ entry.other_chroma_dst_plane = img->get_channel_memory(heif_channel_Cb, &(entry.other_chroma_dst_plane_stride));
}
}
entry.bits_per_component_sample = component.component_bit_depth;
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
index 56092ff4..2b8e0d86 100644
--- a/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_block_pixel_interleave.cc
@@ -93,7 +93,7 @@ std::vector<uint8_t> unc_encoder_rgb_block_pixel_interleave::encode_tile(const s
uint16_t bpp = src_image->get_bits_per_pixel(heif_channel_interleaved);
size_t src_stride;
- const auto* src_data = reinterpret_cast<const uint16_t*>(src_image->get_channel(heif_channel_interleaved, &src_stride));
+ const auto* src_data = reinterpret_cast<const uint16_t*>(src_image->get_channel_memory(heif_channel_interleaved, &src_stride));
src_stride /= 2;
uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
index 50d16fc6..c359d610 100644
--- a/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_bytealign_pixel_interleave.cc
@@ -118,7 +118,7 @@ std::vector<uint8_t> unc_encoder_rgb_bytealign_pixel_interleave::encode_tile(con
std::vector<uint8_t> data;
size_t src_stride;
- const uint8_t* src_data = src_image->get_channel(heif_channel_interleaved, &src_stride);
+ const uint8_t* src_data = src_image->get_channel_memory(heif_channel_interleaved, &src_stride);
uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
data.resize(out_size);
diff --git a/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
index 51188d7c..36a0e3c0 100644
--- a/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
+++ b/libheif/codecs/uncompressed/unc_encoder_rgb_pixel_interleave.cc
@@ -100,7 +100,7 @@ std::vector<uint8_t> unc_encoder_rgb_pixel_interleave::encode_tile(const std::sh
std::vector<uint8_t> data;
size_t src_stride;
- const uint8_t* src_data = src_image->get_channel(heif_channel_interleaved, &src_stride);
+ const uint8_t* src_data = src_image->get_channel_memory(heif_channel_interleaved, &src_stride);
uint64_t out_size = static_cast<uint64_t>(src_image->get_height()) * src_image->get_width() * m_bytes_per_pixel;
data.resize(out_size);
diff --git a/libheif/color-conversion/alpha.cc b/libheif/color-conversion/alpha.cc
index 6aaa4412..bfcd929e 100644
--- a/libheif/color-conversion/alpha.cc
+++ b/libheif/color-conversion/alpha.cc
@@ -186,17 +186,17 @@ Op_flatten_alpha_plane<Pixel>::convert_colorspace(const std::shared_ptr<const He
const Pixel* p_alpha;
size_t stride_alpha;
- p_alpha = (const Pixel*)input->get_channel(heif_channel_Alpha, &stride_alpha);
+ p_alpha = (const Pixel*)input->get_channel_memory(heif_channel_Alpha, &stride_alpha);
int bpp_alpha = input->get_bits_per_pixel(heif_channel_Alpha);
Pixel alpha_max = (Pixel)((1 << bpp_alpha) - 1);
const Pixel* p_in;
size_t stride_in;
- p_in = (const Pixel*)input->get_channel(channel, &stride_in);
+ p_in = (const Pixel*)input->get_channel_memory(channel, &stride_in);
Pixel* p_out;
size_t stride_out;
- p_out = (Pixel*)outimg->get_channel(channel, &stride_out);
+ p_out = (Pixel*)outimg->get_channel_memory(channel, &stride_out);
if (sizeof(Pixel) == 2) {
stride_alpha /= 2;
@@ -362,11 +362,11 @@ Op_adjust_alpha_bit_depth::convert_colorspace(const std::shared_ptr<const HeifPi
// Upscale: 8-bit alpha -> HDR using pattern replication
const uint8_t* p_in;
size_t stride_in;
- p_in = input->get_channel(heif_channel_Alpha, &stride_in);
+ p_in = input->get_channel_memory(heif_channel_Alpha, &stride_in);
uint16_t* p_out;
size_t stride_out;
- p_out = (uint16_t*) outimg->get_channel(heif_channel_Alpha, &stride_out);
+ p_out = (uint16_t*) outimg->get_channel_memory(heif_channel_Alpha, &stride_out);
stride_out /= 2;
int shift1 = target_bpp - input_alpha_bpp;
@@ -382,12 +382,12 @@ Op_adjust_alpha_bit_depth::convert_colorspace(const std::shared_ptr<const HeifPi
// Downscale: HDR alpha -> 8-bit
const uint16_t* p_in;
size_t stride_in;
- p_in = (const uint16_t*) input->get_channel(heif_channel_Alpha, &stride_in);
+ p_in = (const uint16_t*) input->get_channel_memory(heif_channel_Alpha, &stride_in);
stride_in /= 2;
uint8_t* p_out;
size_t stride_out;
- p_out = outimg->get_channel(heif_channel_Alpha, &stride_out);
+ p_out = outimg->get_channel_memory(heif_channel_Alpha, &stride_out);
int shift = input_alpha_bpp - 8;
@@ -400,12 +400,12 @@ Op_adjust_alpha_bit_depth::convert_colorspace(const std::shared_ptr<const HeifPi
// HDR alpha -> different HDR: rescale within uint16_t
const uint16_t* p_in;
size_t stride_in;
- p_in = (const uint16_t*) input->get_channel(heif_channel_Alpha, &stride_in);
+ p_in = (const uint16_t*) input->get_channel_memory(heif_channel_Alpha, &stride_in);
stride_in /= 2;
uint16_t* p_out;
size_t stride_out;
- p_out = (uint16_t*) outimg->get_channel(heif_channel_Alpha, &stride_out);
+ p_out = (uint16_t*) outimg->get_channel_memory(heif_channel_Alpha, &stride_out);
stride_out /= 2;
if (target_bpp > input_alpha_bpp) {
@@ -429,11 +429,11 @@ Op_adjust_alpha_bit_depth::convert_colorspace(const std::shared_ptr<const HeifPi
// SDR alpha -> different SDR (both <= 8)
const uint8_t* p_in;
size_t stride_in;
- p_in = input->get_channel(heif_channel_Alpha, &stride_in);
+ p_in = input->get_channel_memory(heif_channel_Alpha, &stride_in);
uint8_t* p_out;
size_t stride_out;
- p_out = outimg->get_channel(heif_channel_Alpha, &stride_out);
+ p_out = outimg->get_channel_memory(heif_channel_Alpha, &stride_out);
if (target_bpp > input_alpha_bpp) {
int shift1 = target_bpp - input_alpha_bpp;
diff --git a/libheif/color-conversion/bayer_bilinear.cc b/libheif/color-conversion/bayer_bilinear.cc
index 3e3dd90d..db4f79c0 100644
--- a/libheif/color-conversion/bayer_bilinear.cc
+++ b/libheif/color-conversion/bayer_bilinear.cc
@@ -114,10 +114,10 @@ Op_bayer_bilinear_to_RGB24_32::convert_colorspace(const std::shared_ptr<const He
}
size_t in_stride = 0;
- const uint8_t* in_p = input->get_channel(heif_channel_filter_array, &in_stride);
+ const uint8_t* in_p = input->get_channel_memory(heif_channel_filter_array, &in_stride);
size_t out_stride = 0;
- uint8_t* out_p = outimg->get_channel(heif_channel_interleaved, &out_stride);
+ uint8_t* out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_stride);
// Build a lookup table: for each pattern position, which RGB channel (0=R,1=G,2=B) does it provide?
std::vector<int> pattern_channel(pw * ph);
diff --git a/libheif/color-conversion/chroma_sampling.cc b/libheif/color-conversion/chroma_sampling.cc
index e52ba7f2..5b63f733 100644
--- a/libheif/color-conversion/chroma_sampling.cc
+++ b/libheif/color-conversion/chroma_sampling.cc
@@ -149,12 +149,12 @@ Op_YCbCr444_to_YCbCr420_average<Pixel>::convert_colorspace(const std::shared_ptr
Pixel* out_y, * out_cb, * out_cr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_y = (const Pixel*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (const Pixel*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (const Pixel*) input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_y = (Pixel*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (Pixel*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (Pixel*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_y = (const Pixel*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (const Pixel*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (const Pixel*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_y = (Pixel*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (Pixel*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (Pixel*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
if (hdr) {
in_y_stride /= 2;
@@ -171,8 +171,8 @@ Op_YCbCr444_to_YCbCr420_average<Pixel>::convert_colorspace(const std::shared_ptr
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
@@ -373,19 +373,19 @@ Op_YCbCr444_to_YCbCr422_average<Pixel>::convert_colorspace(const std::shared_ptr
Pixel* out_y, * out_cb, * out_cr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_y = (const Pixel*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (const Pixel*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (const Pixel*) input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_y = (Pixel*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (Pixel*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (Pixel*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_y = (const Pixel*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (const Pixel*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (const Pixel*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_y = (Pixel*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (Pixel*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (Pixel*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
const uint8_t* in_a;
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
@@ -568,19 +568,19 @@ Op_YCbCr420_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_pt
Pixel* out_y, * out_cb, * out_cr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_y = (const Pixel*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (const Pixel*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (const Pixel*) input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_y = (Pixel*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (Pixel*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (Pixel*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_y = (const Pixel*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (const Pixel*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (const Pixel*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_y = (Pixel*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (Pixel*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (Pixel*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
const uint8_t* in_a;
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
@@ -849,19 +849,19 @@ Op_YCbCr422_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_pt
Pixel* out_y, * out_cb, * out_cr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_y = (const Pixel*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (const Pixel*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (const Pixel*) input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_y = (Pixel*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (Pixel*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (Pixel*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_y = (const Pixel*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (const Pixel*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (const Pixel*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_y = (Pixel*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (Pixel*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (Pixel*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
const uint8_t* in_a;
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
diff --git a/libheif/color-conversion/hdr_sdr.cc b/libheif/color-conversion/hdr_sdr.cc
index 77b41397..8a6fda5a 100644
--- a/libheif/color-conversion/hdr_sdr.cc
+++ b/libheif/color-conversion/hdr_sdr.cc
@@ -89,11 +89,11 @@ Op_to_hdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>
const uint8_t* p_in;
size_t stride_in;
- p_in = input->get_channel(channel, &stride_in);
+ p_in = input->get_channel_memory(channel, &stride_in);
uint16_t* p_out;
size_t stride_out;
- p_out = (uint16_t*) outimg->get_channel(channel, &stride_out);
+ p_out = (uint16_t*) outimg->get_channel_memory(channel, &stride_out);
stride_out /= 2;
for (uint32_t y = 0; y < height; y++)
@@ -180,12 +180,12 @@ Op_to_sdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>
const uint16_t* p_in;
size_t stride_in;
- p_in = (uint16_t*) input->get_channel(channel, &stride_in);
+ p_in = (uint16_t*) input->get_channel_memory(channel, &stride_in);
stride_in /= 2;
uint8_t* p_out;
size_t stride_out;
- p_out = outimg->get_channel(channel, &stride_out);
+ p_out = outimg->get_channel_memory(channel, &stride_out);
for (uint32_t y = 0; y < height; y++)
for (uint32_t x = 0; x < width; x++) {
@@ -224,10 +224,10 @@ Op_to_sdr_planes::convert_colorspace(const std::shared_ptr<const HeifPixelImage>
}
size_t stride_in;
- const uint8_t* p_in = input->get_channel(channel, &stride_in);
+ const uint8_t* p_in = input->get_channel_memory(channel, &stride_in);
size_t stride_out;
- uint8_t* p_out = outimg->get_channel(channel, &stride_out);
+ uint8_t* p_out = outimg->get_channel_memory(channel, &stride_out);
for (uint32_t y = 0; y < height; y++)
for (uint32_t x = 0; x < width; x++) {
diff --git a/libheif/color-conversion/monochrome.cc b/libheif/color-conversion/monochrome.cc
index 1747a50c..4ec5b708 100644
--- a/libheif/color-conversion/monochrome.cc
+++ b/libheif/color-conversion/monochrome.cc
@@ -94,11 +94,11 @@ Op_mono_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelIma
const uint8_t* in_y;
size_t in_y_stride = 0;
- in_y = input->get_channel(heif_channel_Y, &in_y_stride);
+ in_y = input->get_channel_memory(heif_channel_Y, &in_y_stride);
- out_y = outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ out_y = outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
auto chroma_value = static_cast<uint8_t>(1 << (input_bpp - 1));
@@ -118,11 +118,11 @@ Op_mono_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelIma
const uint16_t* in_y;
size_t in_y_stride = 0;
- in_y = (const uint16_t*) input->get_channel(heif_channel_Y, &in_y_stride);
+ in_y = (const uint16_t*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
- out_y = (uint16_t*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (uint16_t*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (uint16_t*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ out_y = (uint16_t*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (uint16_t*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (uint16_t*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
in_y_stride /= 2;
out_y_stride /= 2;
@@ -148,8 +148,8 @@ Op_mono_to_YCbCr420::convert_colorspace(const std::shared_ptr<const HeifPixelIma
size_t in_a_stride = 0;
size_t out_a_stride = 0;
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
uint32_t memory_width = (alpha_bpp > 8 ? width * 2 : width);
@@ -245,12 +245,12 @@ Op_mono_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelIma
uint8_t* out_p;
size_t out_p_stride = 0;
- in_y = input->get_channel(heif_channel_Y, &in_y_stride);
+ in_y = input->get_channel_memory(heif_channel_Y, &in_y_stride);
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
uint32_t x, y;
for (y = 0; y < height; y++) {
diff --git a/libheif/color-conversion/rgb2rgb.cc b/libheif/color-conversion/rgb2rgb.cc
index ac5983d2..d23f19ee 100644
--- a/libheif/color-conversion/rgb2rgb.cc
+++ b/libheif/color-conversion/rgb2rgb.cc
@@ -107,13 +107,13 @@ Op_RGB_to_RGB24_32::convert_colorspace(const std::shared_ptr<const HeifPixelImag
uint8_t* out_p;
size_t out_p_stride = 0;
- in_r = input->get_channel(heif_channel_R, &in_r_stride);
- in_g = input->get_channel(heif_channel_G, &in_g_stride);
- in_b = input->get_channel(heif_channel_B, &in_b_stride);
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ in_r = input->get_channel_memory(heif_channel_R, &in_r_stride);
+ in_g = input->get_channel_memory(heif_channel_G, &in_g_stride);
+ in_b = input->get_channel_memory(heif_channel_B, &in_b_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
uint32_t x, y;
@@ -245,13 +245,13 @@ Op_RGB_HDR_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPi
uint8_t* out_p;
size_t out_p_stride = 0;
- in_r = (uint16_t*) input->get_channel(heif_channel_R, &in_r_stride);
- in_g = (uint16_t*) input->get_channel(heif_channel_G, &in_g_stride);
- in_b = (uint16_t*) input->get_channel(heif_channel_B, &in_b_stride);
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ in_r = (uint16_t*) input->get_channel_memory(heif_channel_R, &in_r_stride);
+ in_g = (uint16_t*) input->get_channel_memory(heif_channel_G, &in_g_stride);
+ in_b = (uint16_t*) input->get_channel_memory(heif_channel_B, &in_b_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
if (input_has_alpha) {
- in_a = (uint16_t*) input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = (uint16_t*) input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
assert(in_a != nullptr);
// should never happen, but makes clang-tidy happy
@@ -380,13 +380,13 @@ Op_RGB_to_RRGGBBaa_BE::convert_colorspace(const std::shared_ptr<const HeifPixelI
uint8_t* out_p;
size_t out_p_stride = 0;
- in_r = input->get_channel(heif_channel_R, &in_r_stride);
- in_g = input->get_channel(heif_channel_G, &in_g_stride);
- in_b = input->get_channel(heif_channel_B, &in_b_stride);
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ in_r = input->get_channel_memory(heif_channel_R, &in_r_stride);
+ in_g = input->get_channel_memory(heif_channel_G, &in_g_stride);
+ in_b = input->get_channel_memory(heif_channel_B, &in_b_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
if (input_has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
const int pixelsize = (output_has_alpha ? 8 : 6);
@@ -499,14 +499,14 @@ Op_RRGGBBaa_BE_to_RGB_HDR::convert_colorspace(const std::shared_ptr<const HeifPi
uint16_t* out_r, * out_g, * out_b, * out_a = nullptr;
size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_p_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_p_stride);
- out_r = (uint16_t*) outimg->get_channel(heif_channel_R, &out_r_stride);
- out_g = (uint16_t*) outimg->get_channel(heif_channel_G, &out_g_stride);
- out_b = (uint16_t*) outimg->get_channel(heif_channel_B, &out_b_stride);
+ out_r = (uint16_t*) outimg->get_channel_memory(heif_channel_R, &out_r_stride);
+ out_g = (uint16_t*) outimg->get_channel_memory(heif_channel_G, &out_g_stride);
+ out_b = (uint16_t*) outimg->get_channel_memory(heif_channel_B, &out_b_stride);
if (want_alpha) {
- out_a = (uint16_t*) outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ out_a = (uint16_t*) outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
out_r_stride /= 2;
@@ -614,14 +614,14 @@ Op_RGB24_32_to_RGB::convert_colorspace(const std::shared_ptr<const HeifPixelImag
uint8_t* out_r, * out_g, * out_b, * out_a = nullptr;
size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_p_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_p_stride);
- out_r = outimg->get_channel(heif_channel_R, &out_r_stride);
- out_g = outimg->get_channel(heif_channel_G, &out_g_stride);
- out_b = outimg->get_channel(heif_channel_B, &out_b_stride);
+ out_r = outimg->get_channel_memory(heif_channel_R, &out_r_stride);
+ out_g = outimg->get_channel_memory(heif_channel_G, &out_g_stride);
+ out_b = outimg->get_channel_memory(heif_channel_B, &out_b_stride);
if (want_alpha) {
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
uint32_t x, y;
@@ -747,8 +747,8 @@ Op_RRGGBBaa_swap_endianness::convert_colorspace(const std::shared_ptr<const Heif
uint8_t* out_p;
size_t out_p_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_p_stride);
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_p_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
size_t n_bytes = std::min(in_p_stride, out_p_stride);
diff --git a/libheif/color-conversion/rgb2yuv.cc b/libheif/color-conversion/rgb2yuv.cc
index ae854bd0..da952900 100644
--- a/libheif/color-conversion/rgb2yuv.cc
+++ b/libheif/color-conversion/rgb2yuv.cc
@@ -148,19 +148,19 @@ Op_RGB_to_YCbCr<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixel
Pixel* out_y, * out_cb, * out_cr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_r = (const Pixel*) input->get_channel(heif_channel_R, &in_r_stride);
- in_g = (const Pixel*) input->get_channel(heif_channel_G, &in_g_stride);
- in_b = (const Pixel*) input->get_channel(heif_channel_B, &in_b_stride);
- out_y = (Pixel*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (Pixel*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (Pixel*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_r = (const Pixel*) input->get_channel_memory(heif_channel_R, &in_r_stride);
+ in_g = (const Pixel*) input->get_channel_memory(heif_channel_G, &in_g_stride);
+ in_b = (const Pixel*) input->get_channel_memory(heif_channel_B, &in_b_stride);
+ out_y = (Pixel*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (Pixel*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (Pixel*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
const uint8_t* in_a;
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
@@ -403,13 +403,13 @@ Op_RRGGBBxx_HDR_to_YCbCr420::convert_colorspace(const std::shared_ptr<const Heif
uint16_t* out_y, * out_cb, * out_cr, * out_a = nullptr;
size_t out_y_stride = 0, out_cb_stride = 0, out_cr_stride = 0, out_a_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_p_stride);
- out_y = (uint16_t*) outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = (uint16_t*) outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = (uint16_t*) outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_p_stride);
+ out_y = (uint16_t*) outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = (uint16_t*) outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = (uint16_t*) outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
if (has_alpha) {
- out_a = (uint16_t*) outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ out_a = (uint16_t*) outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
@@ -612,14 +612,14 @@ Op_RGB24_32_to_YCbCr::convert_colorspace(const std::shared_ptr<const HeifPixelIm
const uint8_t* in_p;
size_t in_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_stride);
- out_y = outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ out_y = outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
if (want_alpha) {
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
out_a = nullptr;
@@ -880,14 +880,14 @@ Op_RGB24_32_to_YCbCr444_GBR::convert_colorspace(const std::shared_ptr<const Heif
const uint8_t* in_p;
size_t in_stride = 0;
- in_p = input->get_channel(heif_channel_interleaved, &in_stride);
+ in_p = input->get_channel_memory(heif_channel_interleaved, &in_stride);
- out_y = outimg->get_channel(heif_channel_Y, &out_y_stride);
- out_cb = outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- out_cr = outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ out_y = outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ out_cb = outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ out_cr = outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
if (want_alpha) {
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
diff --git a/libheif/color-conversion/rgb2yuv_sharp.cc b/libheif/color-conversion/rgb2yuv_sharp.cc
index aad638af..f262fdb8 100644
--- a/libheif/color-conversion/rgb2yuv_sharp.cc
+++ b/libheif/color-conversion/rgb2yuv_sharp.cc
@@ -184,9 +184,9 @@ Op_Any_RGB_to_YCbCr_420_Sharp::convert_colorspace(
int input_bits = 0;
if (planar_input) {
size_t in_r_stride = 0, in_g_stride = 0, in_b_stride = 0;
- in_r = input->get_channel(heif_channel_R, &in_r_stride);
- in_g = input->get_channel(heif_channel_G, &in_g_stride);
- in_b = input->get_channel(heif_channel_B, &in_b_stride);
+ in_r = input->get_channel_memory(heif_channel_R, &in_r_stride);
+ in_g = input->get_channel_memory(heif_channel_G, &in_g_stride);
+ in_b = input->get_channel_memory(heif_channel_B, &in_b_stride);
// The stride must be the same for all channels.
if (in_r_stride != in_g_stride || in_r_stride != in_b_stride) {
return Error::InternalError;
@@ -199,11 +199,11 @@ Op_Any_RGB_to_YCbCr_420_Sharp::convert_colorspace(
return Error::InternalError;
}
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
}
else {
- const uint8_t* in_p = input->get_channel(heif_channel_interleaved, &in_stride);
+ const uint8_t* in_p = input->get_channel_memory(heif_channel_interleaved, &in_stride);
input_bits = input->get_bits_per_pixel(heif_channel_interleaved);
in_r = &in_p[input_bytes_per_sample * 0];
in_g = &in_p[input_bytes_per_sample * 1];
@@ -215,9 +215,9 @@ Op_Any_RGB_to_YCbCr_420_Sharp::convert_colorspace(
}
size_t out_cb_stride = 0, out_cr_stride = 0, out_y_stride = 0;
- uint8_t* out_y = outimg->get_channel(heif_channel_Y, &out_y_stride);
- uint8_t* out_cb = outimg->get_channel(heif_channel_Cb, &out_cb_stride);
- uint8_t* out_cr = outimg->get_channel(heif_channel_Cr, &out_cr_stride);
+ uint8_t* out_y = outimg->get_channel_memory(heif_channel_Y, &out_y_stride);
+ uint8_t* out_cb = outimg->get_channel_memory(heif_channel_Cb, &out_cb_stride);
+ uint8_t* out_cr = outimg->get_channel_memory(heif_channel_Cr, &out_cr_stride);
bool full_range_flag = true;
Kr_Kb kr_kb = Kr_Kb::defaults();
@@ -253,7 +253,7 @@ Op_Any_RGB_to_YCbCr_420_Sharp::convert_colorspace(
: 0;
size_t out_a_stride;
- uint8_t* out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ uint8_t* out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
uint16_t alpha_max = static_cast<uint16_t>((1 << input_bits) - 1);
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
diff --git a/libheif/color-conversion/yuv2rgb.cc b/libheif/color-conversion/yuv2rgb.cc
index de589b07..134afa19 100644
--- a/libheif/color-conversion/yuv2rgb.cc
+++ b/libheif/color-conversion/yuv2rgb.cc
@@ -159,12 +159,12 @@ Op_YCbCr_to_RGB<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixel
Pixel* out_r, * out_g, * out_b;
size_t out_r_stride = 0, out_g_stride = 0, out_b_stride = 0, out_a_stride = 0;
- in_y = (const Pixel*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (const Pixel*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (const Pixel*) input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_r = (Pixel*) outimg->get_channel(heif_channel_R, &out_r_stride);
- out_g = (Pixel*) outimg->get_channel(heif_channel_G, &out_g_stride);
- out_b = (Pixel*) outimg->get_channel(heif_channel_B, &out_b_stride);
+ in_y = (const Pixel*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (const Pixel*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (const Pixel*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_r = (Pixel*) outimg->get_channel_memory(heif_channel_R, &out_r_stride);
+ out_g = (Pixel*) outimg->get_channel_memory(heif_channel_G, &out_g_stride);
+ out_b = (Pixel*) outimg->get_channel_memory(heif_channel_B, &out_b_stride);
// We only copy the alpha, do not access it as 16 bit
@@ -172,8 +172,8 @@ Op_YCbCr_to_RGB<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixel
uint8_t* out_a;
if (has_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
- out_a = outimg->get_channel(heif_channel_Alpha, &out_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
+ out_a = outimg->get_channel_memory(heif_channel_Alpha, &out_a_stride);
}
else {
in_a = nullptr;
@@ -383,10 +383,10 @@ Op_YCbCr420_to_RGB24::convert_colorspace(const std::shared_ptr<const HeifPixelIm
uint8_t* out_p;
size_t out_p_stride = 0;
- in_y = input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = input->get_channel(heif_channel_Cr, &in_cr_stride);
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ in_y = input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
uint32_t x, y;
for (y = 0; y < height; y++) {
@@ -525,14 +525,14 @@ Op_YCbCr420_to_RGB32::convert_colorspace(const std::shared_ptr<const HeifPixelIm
uint8_t* out_p;
size_t out_p_stride = 0;
- in_y = input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = input->get_channel(heif_channel_Cr, &in_cr_stride);
+ in_y = input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
if (with_alpha) {
- in_a = input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
uint32_t x, y;
for (y = 0; y < height; y++) {
@@ -672,13 +672,13 @@ Op_YCbCr420_to_RRGGBBaa::convert_colorspace(const std::shared_ptr<const HeifPixe
const uint16_t* in_y, * in_cb, * in_cr, * in_a = nullptr;
size_t in_y_stride = 0, in_cb_stride = 0, in_cr_stride = 0, in_a_stride = 0;
- out_p = outimg->get_channel(heif_channel_interleaved, &out_p_stride);
- in_y = (uint16_t*) input->get_channel(heif_channel_Y, &in_y_stride);
- in_cb = (uint16_t*) input->get_channel(heif_channel_Cb, &in_cb_stride);
- in_cr = (uint16_t*) input->get_channel(heif_channel_Cr, &in_cr_stride);
+ out_p = outimg->get_channel_memory(heif_channel_interleaved, &out_p_stride);
+ in_y = (uint16_t*) input->get_channel_memory(heif_channel_Y, &in_y_stride);
+ in_cb = (uint16_t*) input->get_channel_memory(heif_channel_Cb, &in_cb_stride);
+ in_cr = (uint16_t*) input->get_channel_memory(heif_channel_Cr, &in_cr_stride);
if (has_alpha) {
- in_a = (uint16_t*) input->get_channel(heif_channel_Alpha, &in_a_stride);
+ in_a = (uint16_t*) input->get_channel_memory(heif_channel_Alpha, &in_a_stride);
}
int maxval = (1 << bpp) - 1;
diff --git a/libheif/image-items/mask_image.cc b/libheif/image-items/mask_image.cc
index 146c6a6b..a3cb1d35 100644
--- a/libheif/image-items/mask_image.cc
+++ b/libheif/image-items/mask_image.cc
@@ -109,7 +109,7 @@ Error MaskImageCodec::decode_mask_image(const HeifContext* context,
}
size_t stride;
- uint8_t* dst = img->get_channel(heif_channel_Y, &stride);
+ uint8_t* dst = img->get_channel_memory(heif_channel_Y, &stride);
if (stride == static_cast<size_t>(width) * bytes_per_pixel) {
memcpy(dst, data.data(), static_cast<size_t>(width) * bytes_per_pixel * height);
}
@@ -176,7 +176,7 @@ Result<Encoder::CodedImageData> ImageItem_mask::encode(const std::shared_ptr<Hei
// TODO: we could add an option to lossless-compress this data
std::vector<uint8_t> data;
size_t src_stride;
- uint8_t* src_data = image->get_channel(heif_channel_Y, &src_stride);
+ uint8_t* src_data = image->get_channel_memory(heif_channel_Y, &src_stride);
uint32_t w = image->get_width();
uint32_t h = image->get_height();
diff --git a/libheif/image/pixelimage.cc b/libheif/image/pixelimage.cc
index ae5fa650..cee1e757 100644
--- a/libheif/image/pixelimage.cc
+++ b/libheif/image/pixelimage.cc
@@ -855,8 +855,8 @@ Error HeifPixelImage::copy_new_channel_from(const std::shared_ptr<const HeifPixe
const uint8_t* src;
size_t src_stride = 0;
- src = src_image->get_channel(src_channel, &src_stride);
- dst = get_channel(dst_channel, &dst_stride);
+ src = src_image->get_channel_memory(src_channel, &src_stride);
+ dst = get_channel_memory(dst_channel, &dst_stride);
uint32_t bpl = width * (src_image->get_storage_bits_per_pixel(src_channel) / 8);
@@ -884,8 +884,8 @@ Error HeifPixelImage::extract_alpha_from_RGBA(const std::shared_ptr<const HeifPi
const uint8_t* src;
size_t src_stride = 0;
- src = src_image->get_channel(heif_channel_interleaved, &src_stride);
- dst = get_channel(heif_channel_Y, &dst_stride);
+ src = src_image->get_channel_memory(heif_channel_interleaved, &src_stride);
+ dst = get_channel_memory(heif_channel_Y, &dst_stride);
//int bpl = width * (src_image->get_storage_bits_per_pixel(src_channel) / 8);
@@ -923,7 +923,7 @@ void HeifPixelImage::fill_channel(heif_channel dst_channel, uint16_t value)
if (bpp <= 8) {
uint8_t* dst;
size_t dst_stride = 0;
- dst = get_channel(dst_channel, &dst_stride);
+ dst = get_channel_memory(dst_channel, &dst_stride);
uint32_t width_bytes = width * num_interleaved;
for (uint32_t y = 0; y < height; y++) {
@@ -933,7 +933,7 @@ void HeifPixelImage::fill_channel(heif_channel dst_channel, uint16_t value)
else {
uint16_t* dst;
size_t dst_stride = 0;
- dst = get_channel<uint16_t>(dst_channel, &dst_stride);
+ dst = get_channel_memory<uint16_t>(dst_channel, &dst_stride);
dst_stride /= sizeof(uint16_t);
for (uint32_t y = 0; y < height; y++) {
@@ -1039,10 +1039,10 @@ Error HeifPixelImage::copy_image_to(const std::shared_ptr<const HeifPixelImage>&
for (heif_channel channel : channels) {
size_t tile_stride;
- const uint8_t* tile_data = source->get_channel(channel, &tile_stride);
+ const uint8_t* tile_data = source->get_channel_memory(channel, &tile_stride);
size_t out_stride;
- uint8_t* out_data = get_channel(channel, &out_stride);
+ uint8_t* out_data = get_channel_memory(channel, &out_stride);
if (w <= x0 || h <= y0) {
return {heif_error_Invalid_input,
@@ -1104,7 +1104,7 @@ void HeifPixelImage::zero_region(uint32_t x0, uint32_t y0, uint32_t w, uint32_t
ch = std::min(ch, plane_h - cy0);
size_t stride = 0;
- uint8_t* data = get_channel(channel, &stride);
+ uint8_t* data = get_channel_memory(channel, &stride);
uint32_t bytes_per_pixel = get_storage_bits_per_pixel(channel) / 8;
uint32_t width_bytes = cw * bytes_per_pixel;
@@ -1570,7 +1570,7 @@ Error HeifPixelImage::overlay(std::shared_ptr<HeifPixelImage>& overlay, int32_t
size_t alpha_stride = 0;
uint8_t* alpha_p;
- alpha_p = overlay->get_channel(heif_channel_Alpha, &alpha_stride);
+ alpha_p = overlay->get_channel_memory(heif_channel_Alpha, &alpha_stride);
for (heif_channel channel : channels) {
if (!has_channel(channel)) {
@@ -1583,8 +1583,8 @@ Error HeifPixelImage::overlay(std::shared_ptr<HeifPixelImage>& overlay, int32_t
size_t out_stride = 0;
uint8_t* out_p;
- in_p = overlay->get_channel(channel, &in_stride);
- out_p = get_channel(channel, &out_stride);
+ in_p = overlay->get_channel_memory(channel, &in_stride);
+ out_p = get_channel_memory(channel, &out_stride);
uint32_t in_w = overlay->get_width(channel);
uint32_t in_h = overlay->get_height(channel);
@@ -1779,7 +1779,7 @@ Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& ou
const auto* in_data = static_cast<const uint8_t*>(plane.mem);
size_t out_stride = 0;
- auto* out_data = out_img->get_channel(heif_channel_interleaved, &out_stride);
+ auto* out_data = out_img->get_channel_memory(heif_channel_interleaved, &out_stride);
for (uint32_t y = 0; y < out_h; y++) {
uint32_t iy = y * m_height / height;
@@ -1801,7 +1801,7 @@ Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& ou
const uint16_t* in_data = static_cast<const uint16_t*>(plane.mem);
size_t out_stride = 0;
- uint16_t* out_data = out_img->get_channel<uint16_t>(heif_channel_interleaved, &out_stride);
+ uint16_t* out_data = out_img->get_channel_memory<uint16_t>(heif_channel_interleaved, &out_stride);
in_stride /= 2;
out_stride /= 2;
@@ -1839,7 +1839,7 @@ Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& ou
const auto* in_data = static_cast<const uint8_t*>(plane.mem);
size_t out_stride = 0;
- auto* out_data = out_img->get_channel(channel, &out_stride);
+ auto* out_data = out_img->get_channel_memory(channel, &out_stride);
for (uint32_t y = 0; y < out_h; y++) {
uint32_t iy = y * m_height / height;
@@ -1858,7 +1858,7 @@ Error HeifPixelImage::scale_nearest_neighbor(std::shared_ptr<HeifPixelImage>& ou
const uint16_t* in_data = static_cast<const uint16_t*>(plane.mem);
size_t out_stride = 0;
- uint16_t* out_data = out_img->get_channel<uint16_t>(channel, &out_stride);
+ uint16_t* out_data = out_img->get_channel_memory<uint16_t>(channel, &out_stride);
in_stride /= 2;
out_stride /= 2;
@@ -1885,7 +1885,7 @@ void HeifPixelImage::debug_dump() const
auto channels = get_channel_set();
for (auto c : channels) {
size_t stride = 0;
- const uint8_t* p = get_channel(c, &stride);
+ const uint8_t* p = get_channel_memory(c, &stride);
for (int y = 0; y < 8; y++) {
for (int x = 0; x < 8; x++) {
@@ -1950,10 +1950,10 @@ HeifPixelImage::extract_image_area(uint32_t x0, uint32_t y0, uint32_t w, uint32_
for (heif_channel channel : channels) {
size_t src_stride;
- const uint8_t* src_data = get_channel(channel, &src_stride);
+ const uint8_t* src_data = get_channel_memory(channel, &src_stride);
size_t out_stride;
- uint8_t* out_data = areaImg->get_channel(channel, &out_stride);
+ uint8_t* out_data = areaImg->get_channel_memory(channel, &out_stride);
if (areaImg->get_bits_per_pixel(channel) != get_bits_per_pixel(channel)) {
return Error{
diff --git a/libheif/image/pixelimage.h b/libheif/image/pixelimage.h
index ca59de85..f4053eb2 100644
--- a/libheif/image/pixelimage.h
+++ b/libheif/image/pixelimage.h
@@ -102,9 +102,9 @@ public:
// Which plane is "primary" depends on the colorspace:
// YCbCr / monochrome -> the Y plane (Cb/Cr may be legitimately subsampled)
// RGB planar -> R, G and B planes must all be present and all equal
- // RGB interleaved -> the interleaved plane
- // filter_array -> the filter_array plane
- // undefined / custom -> not checked here; returns true
+ // RGB interleaved -> the interleaved plane
+ // filter_array -> the filter_array plane
+ // undefined / custom -> not checked here; returns true
bool primary_planes_have_size(uint32_t width, uint32_t height) const;
heif_chroma get_chroma_format() const { return m_chroma; }
@@ -127,12 +127,12 @@ public:
// Note: we are using size_t as stride type since the stride is usually involved in a multiplication with the line number.
// For very large images (e.g. >2 GB), this can result in an integer overflow and corresponding illegal memory access.
// (see https://github.com/strukturag/libheif/issues/1419)
- uint8_t* get_channel(heif_channel channel, size_t* out_stride) { return get_channel<uint8_t>(channel, out_stride); }
+ uint8_t* get_channel_memory(heif_channel channel, size_t* out_stride) { return get_channel_memory<uint8_t>(channel, out_stride); }
- const uint8_t* get_channel(heif_channel channel, size_t* out_stride) const { return get_channel<uint8_t>(channel, out_stride); }
+ const uint8_t* get_channel_memory(heif_channel channel, size_t* out_stride) const { return get_channel_memory<uint8_t>(channel, out_stride); }
template <typename T>
- T* get_channel(heif_channel channel, size_t* out_stride)
+ T* get_channel_memory(heif_channel channel, size_t* out_stride)
{
auto* comp = find_storage_for_channel(channel);
if (!comp) {
@@ -150,9 +150,9 @@ public:
}
template <typename T>
- const T* get_channel(heif_channel channel, size_t* out_stride) const
+ const T* get_channel_memory(heif_channel channel, size_t* out_stride) const
{
- return const_cast<HeifPixelImage*>(this)->get_channel<T>(channel, out_stride);
+ return const_cast<HeifPixelImage*>(this)->get_channel_memory<T>(channel, out_stride);
}
diff --git a/tests/conversion.cc b/tests/conversion.cc
index 434cfcbb..6c1e5b4c 100644
--- a/tests/conversion.cc
+++ b/tests/conversion.cc
@@ -76,7 +76,7 @@ std::string PrintChannel(const HeifPixelImage& image, heif_channel channel) {
uint32_t width = std::min(image.get_width(channel), max_cols);
uint32_t height = std::min(image.get_height(channel), max_rows);
size_t stride;
- const T* p = (T*)image.get_channel(channel, &stride);
+ const T* p = (T*)image.get_channel_memory(channel, &stride);
stride /= (int)sizeof(T);
int bpp = image.get_bits_per_pixel(channel);
int digits = (int)std::ceil(std::log10(1 << bpp)) + 1;
@@ -129,8 +129,8 @@ double GetPsnr(const HeifPixelImage& original, const HeifPixelImage& compressed,
size_t orig_stride;
size_t compressed_stride;
- const T* orig_p = (T*)original.get_channel(channel, &orig_stride);
- const T* compressed_p = (T*)compressed.get_channel(channel, &compressed_stride);
+ const T* orig_p = (T*)original.get_channel_memory(channel, &orig_stride);
+ const T* compressed_p = (T*)compressed.get_channel_memory(channel, &compressed_stride);
orig_stride /= (int)sizeof(T);
compressed_stride /= (int)sizeof(T);
double mse = 0.0;
@@ -324,7 +324,7 @@ void TestConversion(const std::string& test_name, ColorState input_state,
for (const Plane& plane : GetPlanes(target_state, width, height)) {
INFO("Channel: " << plane.channel);
size_t stride;
- CHECK(out_image->get_channel(plane.channel, &stride) != nullptr);
+ CHECK(out_image->get_channel_memory(plane.channel, &stride) != nullptr);
CHECK(out_image->get_bits_per_pixel(plane.channel) ==
target_state.bits_per_pixel);
// If an alpha plane was created from nothing, check that it's filled
@@ -653,7 +653,7 @@ static void fill_plane(std::shared_ptr<HeifPixelImage>& img, heif_channel channe
REQUIRE(!error);
size_t stride;
- uint8_t* p = img->get_channel(channel, &stride);
+ uint8_t* p = img->get_channel_memory(channel, &stride);
for (int y = 0; y < h; y++) {
for (int x = 0; x < w; x++) {
@@ -670,7 +670,7 @@ static void assert_plane(std::shared_ptr<HeifPixelImage>& img, heif_channel chan
uint32_t h = img->get_height(channel);
size_t stride;
- uint8_t* p = img->get_channel(channel, &stride);
+ uint8_t* p = img->get_channel_memory(channel, &stride);
for (uint32_t y = 0; y < h; y++) {
INFO("row: " << y);
@@ -746,7 +746,7 @@ TEST_CASE("RGB 5-6-5 to RGB")
uint8_t v = 1;
for (heif_channel plane: {heif_channel_R, heif_channel_G, heif_channel_B}) {
size_t dst_stride = 0;
- uint8_t *dst = img->get_channel(plane, &dst_stride);
+ uint8_t *dst = img->get_channel_memory(plane, &dst_stride);
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
dst[y * dst_stride + x] = v;
@@ -848,7 +848,7 @@ TEST_CASE("Mismatched alpha bit depth - conversion correctness") {
// Verify the output has correct interleaved pixel values
size_t stride;
- const uint8_t* p = out->get_channel(heif_channel_interleaved, &stride);
+ const uint8_t* p = out->get_channel_memory(heif_channel_interleaved, &stride);
REQUIRE(p != nullptr);
// Check first pixel: R=512>>2=128, G=256>>2=64, B=768>>2=192, A=200
@@ -885,7 +885,7 @@ TEST_CASE("Mismatched alpha bit depth - conversion correctness") {
CHECK(out->get_chroma_format() == heif_chroma_interleaved_RGBA);
size_t stride;
- const uint8_t* p = out->get_channel(heif_channel_interleaved, &stride);
+ const uint8_t* p = out->get_channel_memory(heif_channel_interleaved, &stride);
REQUIRE(p != nullptr);
CHECK(p[0] == 128); // R (unchanged)
diff --git a/tests/pixel_data_types.cc b/tests/pixel_data_types.cc
index 1f4b1945..1e86a621 100644
--- a/tests/pixel_data_types.cc
+++ b/tests/pixel_data_types.cc
@@ -36,7 +36,7 @@ TEST_CASE( "uint32_t" )
image.add_channel(heif_channel_Y, 3,2, 32, limits, heif_component_datatype_unsigned_integer);
size_t stride;
- uint32_t* data = image.get_channel<uint32_t>(heif_channel_Y, &stride);
+ uint32_t* data = image.get_channel_memory<uint32_t>(heif_channel_Y, &stride);
stride /= sizeof(uint32_t);
REQUIRE(stride >= 3);
@@ -63,7 +63,7 @@ TEST_CASE( "uint32_t" )
REQUIRE(rotationResult.error().error_code == heif_error_Ok);
rot = *rotationResult;
- data = rot->get_channel<uint32_t>(heif_channel_Y, &stride);
+ data = rot->get_channel_memory<uint32_t>(heif_channel_Y, &stride);
stride /= sizeof(uint32_t);
REQUIRE(data[0*stride + 0] == 1000);
@@ -103,7 +103,7 @@ TEST_CASE( "uint32_t" )
REQUIRE(crop->get_width(heif_channel_Y) == 2);
REQUIRE(crop->get_height(heif_channel_Y) == 1);
- data = crop->get_channel<uint32_t>(heif_channel_Y, &stride);
+ data = crop->get_channel_memory<uint32_t>(heif_channel_Y, &stride);
stride /= sizeof(uint32_t);
REQUIRE(data[0*stride + 0] == 0);
@@ -116,7 +116,7 @@ TEST_CASE( "uint32_t" )
REQUIRE(crop->get_width(heif_channel_Y) == 2);
REQUIRE(crop->get_height(heif_channel_Y) == 2);
- data = crop->get_channel<uint32_t>(heif_channel_Y, &stride);
+ data = crop->get_channel_memory<uint32_t>(heif_channel_Y, &stride);
stride /= sizeof(uint32_t);
REQUIRE(data[0*stride + 0] == 0);
@@ -135,7 +135,7 @@ TEST_CASE( "complex64_t" )
image.add_channel(heif_channel_Y, 3,2, 128, limits, heif_component_datatype_complex_number);
size_t stride;
- heif_complex64* data = image.get_channel<heif_complex64>(heif_channel_Y, &stride);
+ heif_complex64* data = image.get_channel_memory<heif_complex64>(heif_channel_Y, &stride);
stride /= sizeof(heif_complex64);
REQUIRE(stride >= 3);