//
|
// Copyright 2007-2012 Christian Henning, Lubomir Bourdev
|
//
|
// Distributed under the Boost Software License, Version 1.0
|
// See accompanying file LICENSE_1_0.txt or copy at
|
// http://www.boost.org/LICENSE_1_0.txt
|
//
|
#ifndef BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_SCANLINE_READ_HPP
|
#define BOOST_GIL_EXTENSION_IO_TIFF_DETAIL_SCANLINE_READ_HPP
|
|
#include <boost/gil/extension/io/tiff/detail/device.hpp>
|
#include <boost/gil/extension/io/tiff/detail/is_allowed.hpp>
|
#include <boost/gil/extension/io/tiff/detail/reader_backend.hpp>
|
|
#include <boost/gil/io/base.hpp>
|
#include <boost/gil/io/bit_operations.hpp>
|
#include <boost/gil/io/conversion_policies.hpp>
|
#include <boost/gil/io/device.hpp>
|
#include <boost/gil/io/reader_base.hpp>
|
#include <boost/gil/io/row_buffer_helper.hpp>
|
#include <boost/gil/io/scanline_read_iterator.hpp>
|
|
#include <algorithm>
|
#include <functional>
|
#include <string>
|
#include <type_traits>
|
#include <vector>
|
|
// taken from jpegxx - https://bitbucket.org/edd/jpegxx/src/ea2492a1a4a6/src/ijg_headers.hpp
|
#ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS
|
extern "C" {
|
#endif
|
|
#include <tiff.h>
|
#include <tiffio.h>
|
|
#ifndef BOOST_GIL_EXTENSION_IO_TIFF_C_LIB_COMPILED_AS_CPLUSPLUS
|
}
|
#endif
|
|
namespace boost { namespace gil {
|
|
///
|
/// TIFF scanline reader
|
///
|
template< typename Device >
|
class scanline_reader< Device
|
, tiff_tag
|
>
|
: public reader_backend< Device
|
, tiff_tag
|
>
|
{
|
public:
|
|
using tag_t = tiff_tag;
|
using backend_t = reader_backend<Device, tag_t>;
|
using this_t = scanline_reader<Device, tag_t>;
|
using iterator_t = scanline_read_iterator<this_t>;
|
|
scanline_reader( Device& device
|
, const image_read_settings< tiff_tag >& settings
|
)
|
: backend_t( device
|
, settings
|
)
|
{
|
initialize();
|
}
|
|
/// Read part of image defined by View and return the data.
|
void read( byte_t* dst, int pos )
|
{
|
_read_function( this, dst, pos );
|
}
|
|
/// Skip over a scanline.
|
void skip( byte_t* dst, int pos )
|
{
|
this->_read_function( this, dst, pos );
|
}
|
|
iterator_t begin() { return iterator_t( *this ); }
|
iterator_t end() { return iterator_t( *this, this->_info._height ); }
|
|
private:
|
|
void initialize()
|
{
|
io_error_if( this->_info._is_tiled
|
, "scanline_reader doesn't support tiled tiff images."
|
);
|
|
if( this->_info._photometric_interpretation == PHOTOMETRIC_PALETTE )
|
{
|
|
this->_scanline_length = this->_info._width
|
* num_channels< rgb16_view_t >::value
|
* sizeof( channel_type<rgb16_view_t>::type );
|
|
this->_io_dev.get_field_defaulted( this->_red
|
, this->_green
|
, this->_blue
|
);
|
|
_buffer = std::vector< byte_t >( this->_io_dev.get_scanline_size() );
|
|
switch( this->_info._bits_per_sample )
|
{
|
case 1:
|
{
|
using channel_t = channel_type<get_pixel_type<gray1_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_1_bit_index_image);
|
|
break;
|
}
|
|
case 2:
|
{
|
using channel_t = channel_type<get_pixel_type<gray2_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_2_bits_index_image);
|
|
break;
|
}
|
case 4:
|
{
|
using channel_t = channel_type<get_pixel_type<gray4_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_4_bits_index_image);
|
|
break;
|
}
|
|
case 8:
|
{
|
using channel_t = channel_type<get_pixel_type<gray8_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_8_bits_index_image);
|
|
break;
|
}
|
|
case 16:
|
{
|
using channel_t = channel_type<get_pixel_type<gray16_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_16_bits_index_image);
|
|
break;
|
}
|
|
case 24:
|
{
|
using channel_t = channel_type<get_pixel_type<gray24_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_24_bits_index_image);
|
|
break;
|
}
|
|
case 32:
|
{
|
using channel_t = channel_type<get_pixel_type<gray32_image_t::view_t>::type>::type;
|
|
int num_colors = channel_traits< channel_t >::max_value() + 1;
|
|
this->_palette = planar_rgb_view( num_colors
|
, 1
|
, this->_red
|
, this->_green
|
, this->_blue
|
, sizeof(uint16_t) * num_colors
|
);
|
|
_read_function = std::mem_fn(&this_t::read_32_bits_index_image);
|
|
break;
|
}
|
default: { io_error( "Not supported palette " ); }
|
}
|
}
|
else
|
{
|
this->_scanline_length = this->_io_dev.get_scanline_size();
|
|
if( this->_info._planar_configuration == PLANARCONFIG_SEPARATE )
|
{
|
io_error( "scanline_reader doesn't support planar tiff images." );
|
}
|
else if( this->_info._planar_configuration == PLANARCONFIG_CONTIG )
|
{
|
|
// the read_data function needs to know what gil type the source image is
|
// to have the default color converter function correctly
|
|
switch( this->_info._photometric_interpretation )
|
{
|
case PHOTOMETRIC_MINISWHITE:
|
case PHOTOMETRIC_MINISBLACK:
|
{
|
switch( this->_info._bits_per_sample )
|
{
|
case 1:
|
case 2:
|
case 4:
|
case 6:
|
case 8:
|
case 10:
|
case 12:
|
case 14:
|
case 16:
|
case 24:
|
case 32: { _read_function = std::mem_fn(&this_t::read_row); break; }
|
default: { io_error( "Image type is not supported." ); }
|
}
|
|
break;
|
}
|
|
case PHOTOMETRIC_RGB:
|
{
|
switch( this->_info._samples_per_pixel )
|
{
|
case 3:
|
{
|
switch( this->_info._bits_per_sample )
|
{
|
case 2:
|
case 4:
|
case 8:
|
case 10:
|
case 12:
|
case 14:
|
case 16:
|
case 24:
|
case 32: { _read_function = std::mem_fn(&this_t::read_row); break; }
|
default: { io_error( "Image type is not supported." ); }
|
}
|
|
break;
|
}
|
|
case 4:
|
{
|
switch( this->_info._bits_per_sample )
|
{
|
case 2:
|
case 4:
|
case 8:
|
case 10:
|
case 12:
|
case 14:
|
case 16:
|
case 24:
|
case 32: { _read_function = std::mem_fn(&this_t::read_row); break; }
|
default: { io_error( "Image type is not supported." ); }
|
}
|
|
break;
|
}
|
|
default: { io_error( "Image type is not supported." ); }
|
}
|
|
break;
|
}
|
case PHOTOMETRIC_SEPARATED: // CYMK
|
{
|
switch( this->_info._bits_per_sample )
|
{
|
case 2:
|
case 4:
|
case 8:
|
case 10:
|
case 12:
|
case 14:
|
case 16:
|
case 24:
|
case 32: { _read_function = std::mem_fn(&this_t::read_row); break; }
|
default: { io_error( "Image type is not supported." ); }
|
}
|
|
break;
|
}
|
|
default: { io_error( "Image type is not supported." ); }
|
}
|
}
|
else
|
{
|
io_error( "Wrong planar configuration setting." );
|
}
|
}
|
}
|
|
template< typename Src_View >
|
void read_n_bits_row( byte_t* dst, int pos )
|
{
|
using dst_view_t = rgb16_view_t;
|
|
this->_io_dev.read_scanline( _buffer
|
, pos
|
, 0
|
);
|
|
Src_View src_view = interleaved_view( this->_info._width
|
, 1
|
, (typename Src_View::x_iterator) &_buffer.front()
|
, this->_scanline_length
|
);
|
|
dst_view_t dst_view = interleaved_view( this->_info._width
|
, 1
|
, (typename dst_view_t::value_type*) dst
|
, num_channels< dst_view_t >::value * 2 * this->_info._width
|
);
|
|
|
typename Src_View::x_iterator src_it = src_view.row_begin( 0 );
|
typename dst_view_t::x_iterator dst_it = dst_view.row_begin( 0 );
|
|
for( dst_view_t::x_coord_t i = 0
|
; i < this->_info._width
|
; ++i, src_it++, dst_it++
|
)
|
{
|
auto const c = static_cast<std::uint16_t>(get_color(*src_it, gray_color_t()));
|
*dst_it = this->_palette[c];
|
}
|
}
|
|
void read_1_bit_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray1_image_t::view_t >( dst, pos );
|
}
|
|
void read_2_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray2_image_t::view_t >( dst, pos );
|
}
|
|
void read_4_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray4_image_t::view_t >( dst, pos );
|
}
|
|
void read_8_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray8_image_t::view_t >( dst, pos );
|
}
|
|
void read_16_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray16_image_t::view_t >( dst, pos );
|
}
|
|
void read_24_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray24_image_t::view_t >( dst, pos );
|
}
|
|
void read_32_bits_index_image( byte_t* dst, int pos )
|
{
|
read_n_bits_row< gray32_image_t::view_t >( dst, pos );
|
}
|
|
void read_row(byte_t* dst, int pos )
|
{
|
this->_io_dev.read_scanline( dst
|
, pos
|
, 0
|
);
|
}
|
|
private:
|
|
std::vector< byte_t> _buffer;
|
detail::mirror_bits<std::vector<byte_t>, std::true_type> _mirror_bites;
|
std::function<void(this_t*, byte_t*, int)> _read_function;
|
};
|
|
} // namespace gil
|
} // namespace boost
|
|
#endif
|
