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/bit_operations.hpp (3764B)

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

#include <array>
#include <cstddef>
#include <type_traits>

namespace boost { namespace gil { namespace detail {

// 1110 1100 -> 0011 0111
template <typename Buffer, typename IsBitAligned>
struct mirror_bits
{
    mirror_bits(bool) {};

void operator()(Buffer&) {}
    void operator()(byte_t*, std::size_t){}
};

// The functor will generate a lookup table since the
// mirror operation is quite costly.
template <typename Buffer>
struct mirror_bits<Buffer, std::true_type>
{
    mirror_bits(bool apply_operation = true)
        : apply_operation_(apply_operation)
    {
        if(apply_operation_)
        {
            byte_t i = 0;
            do
            {
                lookup_[i] = mirror(i);
            }
            while (i++ != 255);
        }
   }

void operator()(Buffer& buffer)
    {
        if (apply_operation_)
            for_each(buffer.begin(), buffer.end(), [this](byte_t& c) { lookup(c); });
    }

void operator()(byte_t *dst, std::size_t size)
    {
        for (std::size_t i = 0; i < size; ++i)
        {
            lookup(*dst);
            ++dst;
        }
    }

private:

void lookup(byte_t& c)
    {
        c = lookup_[c];
    }

static byte_t mirror(byte_t c)
    {
        byte_t result = 0;
        for (int i = 0; i < 8; ++i)
        {
            result = result << 1;
            result |= (c & 1);
            c = c >> 1;
        }

return result;
    }

std::array<byte_t, 256> lookup_;
    bool apply_operation_;

};

// 0011 1111 -> 1100 0000
template <typename Buffer, typename IsBitAligned>
struct negate_bits
{
    void operator()(Buffer&) {};
};

template <typename Buffer>
struct negate_bits<Buffer, std::true_type>
{
    void operator()(Buffer& buffer)
    {
        for_each(buffer.begin(), buffer.end(),
            negate_bits<Buffer, std::true_type>::negate);
    }

void operator()(byte_t* dst, std::size_t size)
    {
        for (std::size_t i = 0; i < size; ++i)
        {
            negate(*dst);
            ++dst;
        }
    }

private:

static void negate(byte_t& b)
    {
        b = ~b;
    }
};

// 11101100 -> 11001110
template <typename Buffer, typename IsBitAligned>
struct swap_half_bytes
{
    void operator()(Buffer&) {};
};

template <typename Buffer>
struct swap_half_bytes<Buffer, std::true_type>
{
    void operator()(Buffer& buffer)
    {
        for_each(buffer.begin(), buffer.end(),
            swap_half_bytes<Buffer, std::true_type>::swap);
    }

void operator()(byte_t* dst, std::size_t size)
    {
        for (std::size_t i = 0; i < size; ++i)
        {
            swap(*dst);
            ++dst;
        }
    }

private:

static void swap(byte_t& c)
    {
        c = ((c << 4) & 0xF0) | ((c >> 4) & 0x0F);
    }
};

template <typename Buffer>
struct do_nothing
{
   do_nothing() = default;

void operator()(Buffer&) {}
};

/// Count consecutive zeros on the right
template <typename T>
inline unsigned int trailing_zeros(T x) noexcept
{
    unsigned int n = 0;

x = ~x & (x - 1);
    while (x)
    {
        n = n + 1;
        x = x >> 1;
    }

return n;
}

/// Counts ones in a bit-set
template <typename T>
inline
unsigned int count_ones(T x) noexcept
{
    unsigned int n = 0;

while (x)
    {
        // clear the least significant bit set
        x &= x - 1;
        ++n;
    }

return n;
}

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

#endif

// // Copyright 2007-2008 Christian Henning, Andreas Pokorny, 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_IO_BIT_OPERATIONS_HPP #define BOOST_GIL_IO_BIT_OPERATIONS_HPP #include #include #include #include namespace boost { namespace gil { namespace detail { // 1110 1100 -> 0011 0111 template struct mirror_bits { mirror_bits(bool) {}; void operator()(Buffer&) {} void operator()(byte_t*, std::size_t){} }; // The functor will generate a lookup table since the // mirror operation is quite costly. template struct mirror_bits { mirror_bits(bool apply_operation = true) : apply_operation_(apply_operation) { if(apply_operation_) { byte_t i = 0; do { lookup_[i] = mirror(i); } while (i++ != 255); } } void operator()(Buffer& buffer) { if (apply_operation_) for_each(buffer.begin(), buffer.end(), [this](byte_t& c) { lookup(c); }); } void operator()(byte_t *dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { lookup(*dst); ++dst; } } private: void lookup(byte_t& c) { c = lookup_[c]; } static byte_t mirror(byte_t c) { byte_t result = 0; for (int i = 0; i < 8; ++i) { result = result << 1; result |= (c & 1); c = c >> 1; } return result; } std::array lookup_; bool apply_operation_; }; // 0011 1111 -> 1100 0000 template struct negate_bits { void operator()(Buffer&) {}; }; template struct negate_bits { void operator()(Buffer& buffer) { for_each(buffer.begin(), buffer.end(), negate_bits::negate); } void operator()(byte_t* dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { negate(*dst); ++dst; } } private: static void negate(byte_t& b) { b = ~b; } }; // 11101100 -> 11001110 template struct swap_half_bytes { void operator()(Buffer&) {}; }; template struct swap_half_bytes { void operator()(Buffer& buffer) { for_each(buffer.begin(), buffer.end(), swap_half_bytes::swap); } void operator()(byte_t* dst, std::size_t size) { for (std::size_t i = 0; i < size; ++i) { swap(*dst); ++dst; } } private: static void swap(byte_t& c) { c = ((c << 4) & 0xF0) | ((c >> 4) & 0x0F); } }; template struct do_nothing { do_nothing() = default; void operator()(Buffer&) {} }; /// Count consecutive zeros on the right template inline unsigned int trailing_zeros(T x) noexcept { unsigned int n = 0; x = ~x & (x - 1); while (x) { n = n + 1; x = x >> 1; } return n; } /// Counts ones in a bit-set template inline unsigned int count_ones(T x) noexcept { unsigned int n = 0; while (x) { // clear the least significant bit set x &= x - 1; ++n; } return n; } }}} // namespace boost::gil::detail #endif