FM / io

/usr/include/boost/gil/io

Name	Size	Mode	Actions
base.hpp	2799	0644	edit dl rm
bit_operations.hpp	3764	0644	edit dl rm
conversion_policies.hpp	2958	0644	edit dl rm
device.hpp	16689	0644	edit dl rm
dynamic_io_new.hpp	3079	0644	edit dl rm
error.hpp	579	0644	edit dl rm
get_reader.hpp	3932	0644	edit dl rm
get_read_device.hpp	1403	0644	edit dl rm
get_writer.hpp	2452	0644	edit dl rm
get_write_device.hpp	1335	0644	edit dl rm
io.hpp	3635	0644	edit dl rm
make_backend.hpp	3606	0644	edit dl rm
make_dynamic_image_reader.hpp	4436	0644	edit dl rm
make_dynamic_image_writer.hpp	5376	0644	edit dl rm
make_reader.hpp	5670	0644	edit dl rm
make_scanline_reader.hpp	3108	0644	edit dl rm
make_writer.hpp	4565	0644	edit dl rm
path_spec.hpp	3940	0644	edit dl rm
reader_base.hpp	3323	0644	edit dl rm
read_and_convert_image.hpp	10030	0644	edit dl rm
read_and_convert_view.hpp	10067	0644	edit dl rm
read_image.hpp	10090	0644	edit dl rm
read_image_info.hpp	3830	0644	edit dl rm
read_view.hpp	5993	0644	edit dl rm
row_buffer_helper.hpp	5172	0644	edit dl rm
scanline_read_iterator.hpp	2333	0644	edit dl rm
typedefs.hpp	2980	0644	edit dl rm
write_view.hpp	7095	0644	edit dl rm

Edit: /usr/include/boost/gil/io/row_buffer_helper.hpp (5172B)

// TODO: Shall we move toolbox to core?
#include <boost/gil/extension/toolbox/metafunctions/is_bit_aligned.hpp>
#include <boost/gil/extension/toolbox/metafunctions/is_homogeneous.hpp>
#include <boost/gil/extension/toolbox/metafunctions/pixel_bit_size.hpp>

#include <boost/gil/detail/mp11.hpp>
#include <boost/gil/io/typedefs.hpp>

#include <cstddef>
#include <type_traits>
#include <vector>

namespace boost { namespace gil { namespace detail {

template< typename Pixel
        , typename DummyT = void
        >
struct row_buffer_helper
{
    using element_t = Pixel;
    using buffer_t = std::vector<element_t>;
    using iterator_t = typename buffer_t::iterator;

row_buffer_helper( std::size_t width
                     , bool
                     )
    : _row_buffer( width )
    {}

element_t* data() { return &_row_buffer[0]; }

iterator_t begin() { return _row_buffer.begin(); }
    iterator_t end()   { return _row_buffer.end();   }

buffer_t& buffer() { return _row_buffer; }

private:

buffer_t _row_buffer;
};

template <typename Pixel>
struct row_buffer_helper
<
    Pixel,
    typename std::enable_if
    <
        is_bit_aligned<Pixel>::value
    >::type
>
{
    using element_t = byte_t;
    using buffer_t = std::vector<element_t>;
    using pixel_type = Pixel;
    using iterator_t = bit_aligned_pixel_iterator<pixel_type>;

row_buffer_helper(std::size_t width, bool in_bytes)
        : _c{( width * pixel_bit_size< pixel_type >::value) >> 3}
        , _r{width * pixel_bit_size< pixel_type >::value - (_c << 3)}
    {
        if (in_bytes)
        {
            _row_buffer.resize(width);
        }
        else
        {
            // add one byte if there are remaining bits
            _row_buffer.resize(_c + (_r != 0));
        }
    }

element_t* data() { return &_row_buffer[0]; }

iterator_t begin() { return iterator_t( &_row_buffer.front(),0 ); }
    iterator_t end()   { return _r == 0 ? iterator_t( &_row_buffer.back() + 1,  0 )
                                        : iterator_t( &_row_buffer.back()    , (int) _r );
                       }

buffer_t& buffer() { return _row_buffer; }

private:

// For instance 25 pixels of rgb2 type would be:
    // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits
    // c = 18 bytes
    // r = 6 bits

std::size_t _c; // number of full bytes
    std::size_t _r; // number of remaining bits

buffer_t _row_buffer;
};

template<typename Pixel>
struct row_buffer_helper
<
    Pixel,
    typename std::enable_if
    <
        mp11::mp_and
        <
            typename is_bit_aligned<Pixel>::type,
            typename is_homogeneous<Pixel>::type
        >::value
    >
>
{
    using element_t = byte_t;
    using buffer_t = std::vector<element_t>;
    using pixel_type = Pixel;
    using iterator_t = bit_aligned_pixel_iterator<pixel_type>;

row_buffer_helper( std::size_t width
                     , bool        in_bytes
                     )
    : _c( ( width
          * num_channels< pixel_type >::value
          * channel_type< pixel_type >::type::num_bits
          )
          >> 3
        )

, _r( width
        * num_channels< pixel_type >::value
        * channel_type< pixel_type >::type::num_bits
        - ( _c << 3 )
       )
    {
        if( in_bytes )
        {
            _row_buffer.resize( width );
        }
        else
        {
            // add one byte if there are remaining bits
            _row_buffer.resize( _c + ( _r!=0 ));
        }
    }

element_t* data() { return &_row_buffer[0]; }

buffer_t& buffer() { return _row_buffer; }

private:

// For instance 25 pixels of rgb2 type would be:
    // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits
    // c = 18 bytes
    // r = 6 bits

std::size_t _c; // number of full bytes
    std::size_t _r; // number of remaining bits

buffer_t _row_buffer;
};

template <typename View, typename D = void>
struct row_buffer_helper_view : row_buffer_helper<typename View::value_type>
{
    row_buffer_helper_view(std::size_t width, bool in_bytes)
        : row_buffer_helper<typename View::value_type>(width, in_bytes)
    {}
};

template <typename View>
struct row_buffer_helper_view
<
    View,
    typename std::enable_if
    <
        is_bit_aligned<typename View::value_type>::value
    >::type
> : row_buffer_helper<typename View::reference>
{
    row_buffer_helper_view(std::size_t width, bool in_bytes)
        : row_buffer_helper<typename View::reference>(width, in_bytes)
    {}
};

} // namespace detail
} // namespace gil
} // namespace boost

#endif

// // Copyright 2007-2008 Christian Henning // // 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_IO_ROW_BUFFER_HELPER_HPP #define BOOST_GIL_IO_ROW_BUFFER_HELPER_HPP // TODO: Shall we move toolbox to core? #include #include #include #include #include #include #include #include namespace boost { namespace gil { namespace detail { template< typename Pixel , typename DummyT = void > struct row_buffer_helper { using element_t = Pixel; using buffer_t = std::vector; using iterator_t = typename buffer_t::iterator; row_buffer_helper( std::size_t width , bool ) : _row_buffer( width ) {} element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return _row_buffer.begin(); } iterator_t end() { return _row_buffer.end(); } buffer_t& buffer() { return _row_buffer; } private: buffer_t _row_buffer; }; template struct row_buffer_helper < Pixel, typename std::enable_if < is_bit_aligned::value >::type > { using element_t = byte_t; using buffer_t = std::vector; using pixel_type = Pixel; using iterator_t = bit_aligned_pixel_iterator; row_buffer_helper(std::size_t width, bool in_bytes) : _c{( width * pixel_bit_size< pixel_type >::value) >> 3} , _r{width * pixel_bit_size< pixel_type >::value - (_c << 3)} { if (in_bytes) { _row_buffer.resize(width); } else { // add one byte if there are remaining bits _row_buffer.resize(_c + (_r != 0)); } } element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return iterator_t( &_row_buffer.front(),0 ); } iterator_t end() { return _r == 0 ? iterator_t( &_row_buffer.back() + 1, 0 ) : iterator_t( &_row_buffer.back() , (int) _r ); } buffer_t& buffer() { return _row_buffer; } private: // For instance 25 pixels of rgb2 type would be: // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits // c = 18 bytes // r = 6 bits std::size_t _c; // number of full bytes std::size_t _r; // number of remaining bits buffer_t _row_buffer; }; template struct row_buffer_helper < Pixel, typename std::enable_if < mp11::mp_and < typename is_bit_aligned::type, typename is_homogeneous::type >::value > > { using element_t = byte_t; using buffer_t = std::vector; using pixel_type = Pixel; using iterator_t = bit_aligned_pixel_iterator; row_buffer_helper( std::size_t width , bool in_bytes ) : _c( ( width * num_channels< pixel_type >::value * channel_type< pixel_type >::type::num_bits ) >> 3 ) , _r( width * num_channels< pixel_type >::value * channel_type< pixel_type >::type::num_bits - ( _c << 3 ) ) { if( in_bytes ) { _row_buffer.resize( width ); } else { // add one byte if there are remaining bits _row_buffer.resize( _c + ( _r!=0 )); } } element_t* data() { return &_row_buffer[0]; } iterator_t begin() { return iterator_t( &_row_buffer.front(),0 ); } iterator_t end() { return _r == 0 ? iterator_t( &_row_buffer.back() + 1, 0 ) : iterator_t( &_row_buffer.back() , (int) _r ); } buffer_t& buffer() { return _row_buffer; } private: // For instance 25 pixels of rgb2 type would be: // overall 25 pixels * 3 channels * 2 bits/channel = 150 bits // c = 18 bytes // r = 6 bits std::size_t _c; // number of full bytes std::size_t _r; // number of remaining bits buffer_t _row_buffer; }; template struct row_buffer_helper_view : row_buffer_helper { row_buffer_helper_view(std::size_t width, bool in_bytes) : row_buffer_helper(width, in_bytes) {} }; template struct row_buffer_helper_view < View, typename std::enable_if < is_bit_aligned::value >::type > : row_buffer_helper { row_buffer_helper_view(std::size_t width, bool in_bytes) : row_buffer_helper(width, in_bytes) {} }; } // namespace detail } // namespace gil } // namespace boost #endif