Subject: [Boost-commit] svn:boost r61386 - sandbox/gil/boost/gil/extension/io2
From: dsaritz_at_[hidden]
Date: 2010-04-18 17:10:02
Author: psiha
Date: 2010-04-18 17:10:01 EDT (Sun, 18 Apr 2010)
New Revision: 61386
URL: http://svn.boost.org/trac/boost/changeset/61386
Log:
Added a faster/integer version/overload for a special default_color_converter code path.
Replaced the pixel_format_type<> logic/machinery/typedefs with simpler gil::image<> typedefs.
Moved more shared logic from the gp_image class to the formatted_image(_base) class (dimensions_mismatch(), get_raw_data() ...).
Simplified the formatted_image_base::check_type_match<> functor.
Added ROI/offset view support.
Replaced the multiple template parameter formatted_image design with a single template parameter and a traits class (formatted_image_traits<>).
Added proper and/or missing formatted_image<> copy_to() and copy_to_image() member function overloads.
Moved the core 'generic' and 'in-place' transform logic into the base formatted_image<> class.
Updated the GDI+ implementation with the above changes.
Fixed the GDI+ implementation to include CMYK support only for GDI+ 1.1 builds.
Minor other refactoring and stylistic changes.
Text files modified:
sandbox/gil/boost/gil/extension/io2/formatted_image.hpp | 579 +++++++++++++++++++++++++++++--------
sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp | 614 +++++++++++++--------------------------
sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp | 13
3 files changed, 653 insertions(+), 553 deletions(-)
Modified: sandbox/gil/boost/gil/extension/io2/formatted_image.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/formatted_image.hpp (original)
+++ sandbox/gil/boost/gil/extension/io2/formatted_image.hpp 2010-04-18 17:10:01 EDT (Sun, 18 Apr 2010)
@@ -26,8 +26,15 @@
#include <boost/gil/extension/dynamic_image/any_image.hpp>
+#ifdef _DEBUG
+#include <boost/detail/endian.hpp>
+#endif // _DEBUG
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/integral_c.hpp>
+#ifdef _DEBUG
+#include <boost/numeric/conversion/converter.hpp>
+#include <boost/numeric/conversion/converter_policies.hpp>
+#endif // _DEBUG
#include <boost/range/iterator_range.hpp>
#include <boost/static_assert.hpp>
//------------------------------------------------------------------------------
@@ -47,71 +54,92 @@
struct synchronize_formats {};
-namespace detail
+//...zzz...test unrolled 24bit-16bit conversion
+//template <typename ChannelValue, typename Layout, typename BitField, typename ChannelRefVec>
+//void color_convert
+//(
+// pixel <ChannelValue, Layout> const & src,
+// packed_pixel<BitField, ChannelRefVec, Layout> & dst
+//)
+//{
+// struct bfield_t
+// {
+// BitField r : 5;
+// BitField g : 6;
+// BitField b : 5;
+// };
+// //BitField & fast_dst( reinterpret_cast<BitField &>( dst ) );
+// bfield_t & fast_dst( reinterpret_cast<bfield_t &>( dst._bitfield ) );
+//
+// unsigned char const source_max ( detail::unsigned_integral_max_value<ChannelValue>::value );
+// //unsigned char const rb_max( (1<<5)-1 );
+// //unsigned char const g_max( (1<<6)-1 );
+// unsigned int const rtmp( ( static_cast<unsigned short>( src[ 0 ] ) << 5 ) - src[ 0 ] );
+// unsigned int const btmp( ( static_cast<unsigned short>( src[ 2 ] ) << 5 ) - src[ 2 ] );
+// unsigned int const gtmp( ( static_cast<unsigned short>( src[ 1 ] ) << 6 ) - src[ 1 ] );
+//
+// fast_dst.r = ( rtmp / source_max ) + ( ( rtmp % source_max ) > ( source_max / 2 ) );
+// fast_dst.b = ( btmp / source_max ) + ( ( btmp % source_max ) > ( source_max / 2 ) );
+// fast_dst.g = ( gtmp / source_max ) + ( ( gtmp % source_max ) > ( source_max / 2 ) );
+//}
+
+
+#if defined(BOOST_MSVC)
+# pragma warning( push )
+# pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif
+
+// An integer version of the unsigned channel downsampling/quantizing 'overload'...
+template <typename SrcChannelV, int DestPackedNumBits>
+struct channel_converter<SrcChannelV, packed_channel_value<DestPackedNumBits> >
+ : public std::unary_function<SrcChannelV, packed_channel_value<DestPackedNumBits> >
{
-//------------------------------------------------------------------------------
-
-
-typedef iterator_range<TCHAR const *> string_chunk_t;
-
-
-template <typename Pixel, bool planar>
-struct pixel_format_type : mpl::pair<Pixel, mpl::bool_<planar>> {};
-
-
-struct get_planar_pixel_iterator
-{
- template <typename PixelFormatType>
- struct apply
+ packed_channel_value<DestPackedNumBits> operator()( SrcChannelV const src ) const
{
- typedef planar_pixel_iterator
- <
- typename channel_type <typename PixelFormatType::first>::type,
- typename color_space_type<typename PixelFormatType::first>::type
- > type;
- };
-};
+ typedef packed_channel_value<DestPackedNumBits> DstChannelV;
-struct get_plain_pixel_iterator
-{
- template <typename PixelFormatType>
- struct apply
- {
- typedef typename PixelFormatType::first * type;
- };
-};
-
-
-template <typename PixelFormat>
-struct view_for_pixel_format
-{
- typedef typename type_from_x_iterator
- <
- typename mpl::if_
- <
- typename PixelFormat::second,
- get_planar_pixel_iterator,
- get_plain_pixel_iterator
+ typedef detail::channel_convert_to_unsigned <SrcChannelV> to_unsigned;
+ typedef detail::channel_convert_from_unsigned<DstChannelV> from_unsigned;
- >::type::apply<PixelFormat>::type
- >::view_t type;
+ if ( is_unsigned<SrcChannelV>::value )
+ {
+ SrcChannelV const source_max( detail::unsigned_integral_max_value<SrcChannelV>::value );
+ unsigned int const tmp ( ( static_cast<unsigned short>( src ) << DestPackedNumBits ) - src );
+ typename DstChannelV::integer_t const result
+ (
+ static_cast<typename DstChannelV::integer_t>( tmp / source_max ) + ( ( tmp % source_max ) > ( source_max / 2 ) )
+ );
+ #ifdef _DEBUG
+ unsigned char const destination_max( detail::unsigned_integral_max_value<DstChannelV>::value );
+ DstChannelV const debug_result
+ (
+ numeric::converter<unsigned, double, numeric::conversion_traits<unsigned, double>, numeric::def_overflow_handler, numeric::RoundEven<double> >::convert
+ (
+ src * double( destination_max ) / double( source_max )
+ )
+ );
+ BOOST_ASSERT( result == debug_result );
+ #endif // _DEBUG
+ return *gil_reinterpret_cast_c<DstChannelV const *>( &result );
+ }
+ else
+ {
+ typedef channel_converter_unsigned<typename to_unsigned::result_type, typename from_unsigned::argument_type> converter_unsigned;
+ return from_unsigned()(converter_unsigned()(to_unsigned()(src)));
+ }
+ }
};
-template <typename PixelFormats>
-struct views_for_pixel_formats
- : public mpl::transform<PixelFormats, view_for_pixel_format<mpl::_1> > {};
+#if defined(BOOST_MSVC)
+# pragma warning( pop )
+#endif
-template <typename PixelFormat>
-struct const_view_for_pixel_format
- :
- public view_for_pixel_format<pixel_format_type<typename PixelFormat::first const, PixelFormat::second::value> >
-{};
-
-template <typename PixelFormats>
-struct const_views_for_pixel_formats
- : public mpl::transform<PixelFormats, const_view_for_pixel_format<mpl::_1> > {};
+namespace detail
+{
+//------------------------------------------------------------------------------
+typedef iterator_range<TCHAR const *> string_chunk_t;
////////////////////////////////////////////////////////////////////////////////
@@ -126,36 +154,61 @@
typedef point2<std::ptrdiff_t> dimensions_t;
typedef unsigned int image_type_id;
- static image_type_id const unsupported_format = -1;
+ static image_type_id const unsupported_format = static_cast<image_type_id>( -1 );
protected:
- static bool dimensions_match( dimensions_t const & mine, dimensions_t const & other ) { return mine == other; }
+ static bool dimensions_mismatch( dimensions_t const & mine, dimensions_t const & other ) { return mine != other; }
+
template <class View>
- static bool dimensions_match( dimensions_t const & mine, View const & view ) { return dimensions_match( mine, view.dimensions(); ) }
+ static bool dimensions_mismatch( dimensions_t const & mine, View const & view )
+ {
+ return dimensions_mismatch( mine, view.dimensions() );
+ }
static void do_ensure_dimensions_match( dimensions_t const & mine, dimensions_t const & other )
{
- io_error_if( !dimensions_match( mine, other ), "input view size does not match source image size" );
+ io_error_if( dimensions_mismatch( mine, other ), "input view size does not match source image size" );
}
+
template <class View>
static void do_ensure_dimensions_match( dimensions_t const & mine, View const & view )
{
do_ensure_dimensions_match( mine, view.dimensions() );
}
- static void do_ensure_formats_match( bool const formats_match )
+ static void do_ensure_formats_match( bool const formats_mismatch )
{
- io_error_if( !formats_match, "input view format does not match source image format" );
+ io_error_if( formats_mismatch, "input view format does not match source image format" );
}
-protected:
template <typename Image>
- void do_synchronize_dimensions( Image & image, dimensions_t const & my_dimensions, unsigned int const alignment = 0 )
+ static void do_synchronize_dimensions( Image & image, dimensions_t const & my_dimensions, unsigned int const alignment = 0 )
{
image.recreate( my_dimensions, alignment );
}
+public: //...zzz...
+ template <typename View>
+ static unsigned char * get_raw_data( View const & view )
+ {
+ // A private implementation of interleaved_view_get_raw_data() that
+ // works with packed pixel views.
+ BOOST_STATIC_ASSERT(( !is_planar<View>::value /*&& view_is_basic<View>::value*/ ));
+ BOOST_STATIC_ASSERT(( is_pointer<typename View::x_iterator>::value ));
+
+ return gil_reinterpret_cast<unsigned char *>( &gil::at_c<0>( view( 0, 0 ) ) );
+ }
+
protected:
+ template <typename View>
+ struct is_plain_in_memory_view
+ :
+ mpl::bool_
+ <
+ is_pointer<typename View::x_iterator>::value ||
+ ( is_planar<View>::value && view_is_basic<View>::value )
+ > {};
+
struct assert_type_mismatch
{
typedef bool result_type;
@@ -166,7 +219,7 @@
struct throw_type_mismatch
{
typedef void result_type;
- result_type operator()() const { do_ensure_formats_match( false ); }
+ result_type operator()() const { do_ensure_formats_match( true ); }
};
template <typename Type, typename SupportedPixelFormats>
@@ -176,18 +229,20 @@
template <typename SupportedFormatIndex>
result_type operator()( SupportedFormatIndex const & ) const
{
- return worker<SupportedFormatIndex>( mpl::less<SupportedFormatIndex, mpl::size<SupportedPixelFormats> >() );
+ return is_same<Type, typename mpl::at<SupportedPixelFormats, SupportedFormatIndex>::type>::value;
}
+ };
+ template <typename ResultType>
+ struct assert_default_case_not_reached
+ {
+ typedef ResultType result_type;
template <typename Index>
- bool worker( mpl::true_ /*in-range*/ ) const
- {
- return is_same<Type, typename mpl::at<SupportedPixelFormats, Index>::type>::value;
- }
- template <typename Index>
- bool worker( mpl::false_ /*not-in-range*/ ) const
+ result_type operator()( Index const & ) const
{
- return false;
+ BOOST_ASSERT( !"Default case must not have been reached!" );
+ __assume( false );
+ return result_type();
}
};
@@ -213,20 +268,94 @@
////////////////////////////////////////////////////////////////////////////////
///
+/// \class offset_view_t
+/// \todo document properly...
+///
+////////////////////////////////////////////////////////////////////////////////
+
+template <class View, typename Offset>
+class offset_view_t
+{
+public:
+ offset_view_t( View const & view, Offset const & offset ) : view_( view ), offset_( offset ) {}
+
+ typename View::point_t dimensions() const
+ {
+ return offset_dimensions( offset_ );
+ }
+
+ View const & original_view() const { return view_ ; }
+ Offset const & offset () const { return offset_; }
+
+private:
+ typename View::point_t offset_dimensions( typename View::point_t::value_type const offset ) const
+ {
+ typename View::point_t view_dimensions( view_.dimensions() );
+ return view_dimensions += typename View::point_t( 0, offset );
+ }
+
+ typename View::point_t offset_dimensions( typename View::point_t const & offset ) const
+ {
+ typename View::point_t view_dimensions( view_.dimensions() );
+ return view_dimensions += offset;
+ }
+
+private:
+ View const & view_ ;
+ typename call_traits<Offset>::param_type offset_;
+};
+
+template <class View, typename Offset>
+View const & original_view( offset_view_t<View, Offset> const & offset_view ) { return offset_view.original_view(); }
+
+template <class View>
+View const & original_view( View const & view ) { return view; }
+
+template <typename Offset, class View>
+Offset const & get_offset( offset_view_t<View, Offset> const & offset_view ) { return offset_view.offset(); }
+
+template <typename Offset, class View>
+Offset get_offset( View const & ) { return Offset(); }
+
+
+template <class NewView, class View, typename Offset>
+offset_view_t<NewView, Offset> offset_new_view( NewView const & new_view, offset_view_t<View, Offset> const & offset_view )
+{
+ return offset_view_t<NewView, Offset>( new_view, offset_view.offset_ );
+}
+
+template <class NewView, class View>
+NewView const & offset_new_view( NewView const & new_view, View const & ) { return new_view; }
+
+
+////////////////////////////////////////////////////////////////////////////////
+/// \class formatted_image_traits
+/// ( forward declaration )
+////////////////////////////////////////////////////////////////////////////////
+
+template <class Impl>
+struct formatted_image_traits;
+
+
+////////////////////////////////////////////////////////////////////////////////
+///
/// \class formatted_image
///
////////////////////////////////////////////////////////////////////////////////
-template <class Impl, class SupportedPixelFormats, class ROI>
+template <class Impl>
class formatted_image : public formatted_image_base
{
public:
- //typedef typename any_image<typename Impl::supported_pixel_formats> any_image_t;
- typedef SupportedPixelFormats supported_pixel_formats;
- typedef ROI roi;
+ typedef typename formatted_image_traits<Impl>::format_t format_t;
- typedef any_image_view<typename const_views_for_pixel_formats<typename supported_pixel_formats>::type> const_view_t;
- typedef any_image_view<typename views_for_pixel_formats <typename supported_pixel_formats>::type> view_t;
+ typedef typename formatted_image_traits<Impl>::supported_pixel_formats_t supported_pixel_formats;
+ typedef typename formatted_image_traits<Impl>::roi_t roi;
+ typedef typename roi::offset_t offset_t;
+
+ typedef any_image<supported_pixel_formats> dynamic_image_t;
+ typedef typename dynamic_image_t::const_view_t const_view_t;
+ typedef typename dynamic_image_t:: view_t view_t;
BOOST_STATIC_CONSTANT( bool, has_full_roi = (is_same<roi::offset_t, roi::point_t>::value) );
@@ -249,16 +378,10 @@
{}
template <class Image>
- void apply()
- {
- impl_.copy_to( base::apply<Image>(), dimensions_policy(), formats_policy() );
- }
+ void apply() { impl_.copy_to( base::apply<Image>(), dimensions_policy(), formats_policy() ); }
template <typename SupportedFormatIndex>
- void operator()( SupportedFormatIndex const & )
- {
- apply<typename mpl::at<SupportedFormatIndex>::type>();
- }
+ void operator()( SupportedFormatIndex const & ) { apply<typename mpl::at<SupportedFormatIndex>::type>(); }
private:
Impl & impl_;
@@ -273,10 +396,7 @@
write_dynamic_view( Impl & impl ) : impl_( impl ) {}
template <class View>
- void apply( View const & view )
- {
- impl_.copy_from( view, dimensions_policy(), formats_policy() );
- }
+ void apply( View const & view ) { impl_.copy_from( view, dimensions_policy(), formats_policy() ); }
private:
Impl & impl_;
@@ -291,71 +411,156 @@
typedef mpl::range_c<std::size_t, 0, mpl::size<supported_pixel_formats>::value> valid_type_id_range_t;
private:
+ Impl & impl() { return static_cast<Impl &>( *this ); }
+ Impl const & impl() const { return static_cast<Impl const &>( *this ); }
+
+protected:
template <typename View>
- bool formats_match()
+ bool dimensions_mismatch( View const & view ) const
{
- Gdiplus::PixelFormat tzt = view_gp_format<View>::value;
- return switch_<valid_type_id_range_t>
+ return dimensions_mismatch( view.dimensions() );
+ }
+
+ bool dimensions_mismatch( dimensions_t const & other_dimensions ) const
+ {
+ return formatted_image_base::dimensions_mismatch( impl().dimensions(), other_dimensions );
+ }
+
+ template <class View>
+ void do_ensure_dimensions_match( View const & view ) const
+ {
+ formatted_image_base::do_ensure_dimensions_match( impl().dimensions(), view.dimensions() );
+ }
+
+ template <typename View>
+ bool formats_mismatch() const
+ {
+ return formats_mismatch( formatted_image_traits<Impl>::view_to_native_format::apply<View>::value );
+ }
+
+ bool formats_mismatch( typename formatted_image_traits<Impl>::format_t const other_format ) const
+ {
+ return other_format != impl().closest_gil_supported_format();
+ }
+
+ template <class View>
+ void do_ensure_formats_match() const { formatted_image_base::do_ensure_formats_match( formats_mismatch<View>() ); }
+
+ template <typename View>
+ bool can_do_inplace_transform() const
+ {
+ return can_do_inplace_transform<View>( format() );
+ }
+
+ template <typename View>
+ bool can_do_inplace_transform( typename formatted_image_traits<Impl>::format_t const my_format ) const
+ {
+ return ( Impl::format_size( my_format ) == sizeof( typename View::value_type ) );
+ }
+
+public: // Views...
+ template <typename View>
+ void copy_to( View & view, assert_dimensions_match, assert_formats_match ) const
+ {
+ BOOST_STATIC_ASSERT( formatted_image_traits<Impl>::is_supported<View>::value );
+ BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
+ BOOST_ASSERT( !impl().formats_mismatch<View>() );
+ impl().raw_convert_to_prepared_view
(
- impl().current_image_type_id(),
- check_type_match
- <
- pixel_format_type
- <
- typename View::value_type,
- is_planar<typename View>::value
- >,
- supported_pixel_formats
- >(),
- assert_type_mismatch()
+ formatted_image_traits<Impl>::view_data_t
+ (
+ original_view ( view ),
+ get_offset<offset_t>( view )
+ )
);
}
- Impl & impl() { return static_cast<Impl &>( *this ); }
-
-public:
- template <typename Image, typename DimensionsPolicy, typename FormatsPolicy>
- void copy_to_image( Image & image, DimensionsPolicy const dimensions_policy, FormatsPolicy const formats_policy )
+ template <typename View>
+ void copy_to( View & view, assert_dimensions_match, ensure_formats_match ) const
{
- impl().copy_to( view( image ), dimensions_policy, formats_policy );
+ impl().do_ensure_formats_match<View>();
+ impl().copy_to( view, assert_dimensions_match(), assert_formats_match() );
}
- template <typename Image, typename FormatsPolicy>
- void copy_to_image( Image & image, synchronize_dimensions, FormatsPolicy const formats_policy )
+ template <typename View>
+ void copy_to( View & view, ensure_dimensions_match, assert_formats_match ) const
{
- do_synchronize_dimensions( image, impl().dimensions(), Impl::desired_alignment );
- impl().copy_to( view( image ), assert_dimensions_match(), formats_policy );
+ impl().do_ensure_dimensions_match( view );
+ impl().copy_to( view, assert_dimensions_match(), assert_formats_match() );
}
template <typename View>
- void copy_to( View & view, assert_dimensions_match, assert_formats_match )
+ void copy_to( View & view, ensure_dimensions_match, ensure_formats_match ) const
{
- BOOST_ASSERT( dimensions_match( view.dimensions(), impl().dimensions() ) );
- BOOST_ASSERT( formats_match<View>() );
- impl().copy_to_prepared_view( view );
+ impl().do_ensure_formats_match<View>();
+ impl().do_ensure_dimensions_match( view );
+ impl().copy_to( view, assert_dimensions_match(), ensure_formats_match() );
}
template <typename View>
- void copy_to( View & view, assert_dimensions_match, ensure_formats_match )
+ void copy_to( View & view, ensure_dimensions_match, synchronize_formats ) const
{
- do_ensure_formats_match( formats_match<View>() );
- copy_to( view, assert_dimensions_match(), assert_formats_match() );
+ impl().do_ensure_dimensions_match( view );
+ impl().copy_to( view, assert_dimensions_match(), synchronize_formats() );
}
template <typename View>
- void copy_to( View & view, ensure_dimensions_match, assert_formats_match )
+ void copy_to( View & view, assert_dimensions_match, synchronize_formats ) const
+ {
+ BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
+ impl().raw_convert_to_prepared_view
+ (
+ formatted_image_traits<Impl>::view_data_t
+ (
+ original_view ( view ),
+ get_offset<offset_t>( view )
+ )
+ );
+ }
+
+ template <typename FormatConverter, typename View>
+ void copy_to( View & view, ensure_dimensions_match, FormatConverter const & format_converter ) const
+ {
+ impl().do_ensure_dimensions_match( view );
+ impl().copy_to( view, assert_dimensions_match(), format_converter );
+ }
+
+ template <typename FormatConverter, typename View>
+ void copy_to( View & view, assert_dimensions_match, FormatConverter const & format_converter ) const
+ {
+ BOOST_ASSERT( !impl().dimensions_mismatch( view ) );
+ impl().convert_to_prepared_view( view, format_converter );
+ }
+
+public: // Images...
+ template <typename Image, typename FormatsPolicy>
+ Image copy_to_image( FormatsPolicy const formats_policy ) const
+ {
+ Image image( impl().dimensions(), formatted_image_traits<Impl>::desired_alignment );
+ impl().copy_to( view( image ), assert_dimensions_match(), formats_policy );
+ return image;
+ }
+
+ template <typename Image, typename DimensionsPolicy, typename FormatsPolicy>
+ void copy_to_image( Image & image, DimensionsPolicy const dimensions_policy, FormatsPolicy const formats_policy ) const
+ {
+ impl().copy_to( view( image ), dimensions_policy, formats_policy );
+ }
+
+ template <typename Image, typename FormatsPolicy>
+ void copy_to_image( Image & image, synchronize_dimensions, FormatsPolicy const formats_policy ) const
{
- do_ensure_dimensions_match( formats_match<View>() );
- copy_to( view, assert_dimensions_match, assert_formats_match );
+ impl().do_synchronize_dimensions( image, impl().dimensions(), formatted_image_traits<Impl>::desired_alignment );
+ impl().copy_to( view( image ), assert_dimensions_match(), formats_policy );
}
template <typename Images, typename dimensions_policy, typename formats_policy>
- void copy_to( any_image<Images> & im )
+ void copy_to_image( any_image<Images> & im ) const
{
typedef mpl::range_c<std::size_t, 0, typename Impl::supported_pixel_formats> valid_range_t;
switch_<valid_range_t>
(
- Impl::current_image_type_id(),
+ impl().current_image_format_id(),
read_dynamic_image<Images, dimensions_policy, formats_policy>( im, *this ),
throw_type_mismatch()
);
@@ -373,16 +578,128 @@
);
}
- void save_to( std::string const & path )
+private:
+ template <class View, typename CC>
+ struct in_place_converter_t
+ {
+ typedef void result_type;
+
+ in_place_converter_t( CC const & cc, View const & view ) : cc_( cc ), view_( view ) {}
+
+ template <std::size_t index>
+ void operator()( mpl::integral_c<std::size_t, index> const & ) const
+ {
+ typedef typename mpl::at_c<supported_pixel_formats, index>::type::view_t view_t;
+ BOOST_STATIC_ASSERT( sizeof( view_t ) == sizeof( View ) );
+ for_each_pixel( *gil_reinterpret_cast_c<view_t const *>( &view_ ), *this );
+ }
+
+ template <typename SrcP>
+ typename enable_if<is_pixel<SrcP>>::type
+ operator()( SrcP & srcP )
+ {
+ BOOST_ASSERT( sizeof( SrcP ) == sizeof( typename View::value_type ) );
+ cc_( srcP, *gil_reinterpret_cast<typename View::value_type *>( &srcP ) );
+ }
+
+ void operator=( in_place_converter_t const & other )
+ {
+ BOOST_ASSERT( this->view_ == other.view_ );
+ this->cc_ = other.cc_;
+ }
+
+ CC cc_;
+ View const & view_;
+ };
+
+ template <class View, typename CC>
+ struct generic_converter_t
+ {
+ typedef void result_type;
+
+ generic_converter_t( Impl const & impl, CC const & cc, View const & view )
+ : impl_( impl ), cc_( cc ), view_( view ) {}
+
+ template <std::size_t index>
+ void operator()( mpl::integral_c<std::size_t, index> const & ) const
+ {
+ typedef typename mpl::at_c<supported_pixel_formats, index>::type::view_t my_view_t;
+ impl_.generic_convert_to_prepared_view<my_view_t>( view_, cc_ );
+ }
+
+ void operator=( generic_converter_t const & other )
+ {
+ BOOST_ASSERT( this->impl_ == other.impl_ );
+ BOOST_ASSERT( this->view_ == other.view_ );
+ this->cc_ = other.cc_;
+ }
+
+ Impl const & impl_;
+ CC cc_ ;
+ View const & view_;
+ };
+
+ template <class TargetView, class CC>
+ static void in_place_transform( unsigned int const source_view_type_id, TargetView const & view, CC const & cc )
+ {
+ return switch_<valid_type_id_range_t>
+ (
+ source_view_type_id,
+ in_place_converter_t<TargetView, CC>( cc, view ),
+ assert_default_case_not_reached<void>()
+ );
+ }
+
+ template <class TargetView, class CC>
+ void generic_transform( unsigned int const source_view_type_id, TargetView const & view, CC const & cc ) const
{
- impl().save_to( path.c_str() );
+ return switch_<valid_type_id_range_t>
+ (
+ source_view_type_id,
+ generic_converter_t<TargetView, CC>( impl(), cc, view ),
+ assert_default_case_not_reached<void>()
+ );
}
- void save_to( std::wstring const & path )
+ template <typename View, typename CC>
+ void convert_to_prepared_view( View const & view, CC const & converter ) const
{
- impl().save_to( path.c_str() );
+ BOOST_ASSERT( !dimensions_mismatch( view ) );
+ convert_to_prepared_view_worker
+ (
+ view,
+ converter,
+ mpl::bool_
+ <
+ is_plain_in_memory_view<View>::value &&
+ formatted_image_traits<Impl>::is_supported<View>::value
+ >()
+ );
+ }
+
+ template <typename View, typename CC>
+ void convert_to_prepared_view_worker( View const & view, CC const & converter, mpl::true_ /*can use raw*/ ) const
+ {
+ format_t const my_format ( impl().closest_gil_supported_format() );
+ unsigned int const current_image_format_id( impl().image_format_id( my_format ) );
+ if ( can_do_inplace_transform<View>( my_format ) )
+ {
+ Impl::view_data_t view_data( original_view( view ), get_offset<offset_t>( view ) );
+ view_data.set_format( my_format );
+ impl().copy_to_prepared_view( view_data );
+ in_place_transform( current_image_format_id, original_view( view ), converter );
+ }
+ else
+ {
+ generic_transform( current_image_format_id, view, converter );
+ }
}
+ template <typename View, typename CC>
+ void convert_to_prepared_view_worker( View const & view, CC const & converter, mpl::false_ /*must use generic*/ ) const
+ {
+ generic_transform( Impl::image_format_id( impl().closest_gil_supported_format() ), view, converter );
+ }
};
Modified: sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp (original)
+++ sandbox/gil/boost/gil/extension/io2/gp_private_base.hpp 2010-04-18 17:10:01 EDT (Sun, 18 Apr 2010)
@@ -44,6 +44,13 @@
{
//------------------------------------------------------------------------------
+#if (GDIPVER >= 0x0110)
+Gdiplus::PixelFormat const cmyk_format( PixelFormat32bppCMYK | PixelFormatGDI );
+#undef PixelFormat32bppCMYK
+#define PixelFormat32bppCMYK cmyk_format
+#else
+#undef PixelFormat32bppCMYK
+#endif // (GDIPVER >= 0x0110)
template <Gdiplus::PixelFormat gp_format> struct is_canonical : mpl::bool_ <(gp_format & PixelFormatCanonical) != 0> {};
template <Gdiplus::PixelFormat gp_format> struct is_extended : mpl::bool_ <(gp_format & PixelFormatExtended ) != 0> {};
@@ -54,70 +61,49 @@
template <Gdiplus::PixelFormat gp_format> struct pixel_size : mpl::size_t<( gp_format >> 8 ) & 0xff > {};
-template <typename Channel, typename ColorSpace>
-struct gil_to_gp_format : mpl::integral_c<Gdiplus::PixelFormat, PixelFormatUndefined> {};
-
-template <> struct gil_to_gp_format<bits8 ,rgb_t > : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat24bppRGB > {};
-template <> struct gil_to_gp_format<bits8 ,rgba_t> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat32bppARGB > {};
-template <> struct gil_to_gp_format<bits16,gray_t> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat16bppGrayScale> {};
-template <> struct gil_to_gp_format<bits16,rgb_t > : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat48bppRGB > {};
-template <> struct gil_to_gp_format<bits16,rgba_t> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat64bppARGB > {};
-
-/// @see GdiplusPixelFormats.h: ARGB -> little endian BGRA
+/// @see GdiplusPixelFormats.h: ARGB -> little endian BGRA
typedef bgra_layout_t gp_alpha_layout_t;
typedef bgr_layout_t gp_layout_t;
-typedef packed_pixel_type<uint16_t, mpl::vector3_c<unsigned,5,6,5>, gp_layout_t>::type gp_rgb565_pixel_t;
-struct unpacked_view_gp_format
-{
- template <class View>
- struct apply
- {
- typedef gil_to_gp_format
- <
- typename channel_type <View>::type,
- typename color_space_type<View>::type
- > type;
- };
-};
+typedef packed_pixel_type<uint16_t, mpl::vector3_c<unsigned,5,6,5>, gp_layout_t>::type gp_bgr565_pixel_t;
-struct packed_view_gp_format
-{
- template <class View>
- struct apply
- {
- typedef typename mpl::if_
- <
- is_same<typename View::value_type, gp_rgb565_pixel_t>,
- mpl::integral_c<Gdiplus::PixelFormat, PixelFormat16bppRGB565>,
- mpl::integral_c<Gdiplus::PixelFormat, PixelFormatUndefined>
- >::type type;
- };
-};
+template <typename Pixel, bool IsPlanar>
+struct gil_to_gp_format : mpl::integral_c<Gdiplus::PixelFormat, PixelFormatUndefined> {};
-typedef mpl::vector5
+template <> struct gil_to_gp_format<gp_bgr565_pixel_t, false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat16bppRGB565 > {};
+template <> struct gil_to_gp_format<bgr8_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat24bppRGB > {};
+template <> struct gil_to_gp_format<bgra8_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat32bppARGB > {};
+template <> struct gil_to_gp_format<gray16_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat16bppGrayScale> {};
+template <> struct gil_to_gp_format<bgr16_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat48bppRGB > {};
+template <> struct gil_to_gp_format<bgra16_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat64bppARGB > {};
+#if (GDIPVER >= 0x0110)
+template <> struct gil_to_gp_format<cmyk8_pixel_t , false> : mpl::integral_c<Gdiplus::PixelFormat, PixelFormat32bppCMYK > {};
+#endif // (GDIPVER >= 0x0110)
+
+
+typedef mpl::
+#if (GDIPVER >= 0x0110)
+ vector4
+#else
+ vector3
+#endif
<
- pixel_format_type<pixel<bits8 , gp_layout_t >, false>,
- pixel_format_type<pixel<bits8 , gp_alpha_layout_t>, false>,
- pixel_format_type<pixel<bits16, gray_layout_t >, false>,
- pixel_format_type<gp_rgb565_pixel_t , false>,
- pixel_format_type<cmyk_t , false>
+ image<bgr8_pixel_t , false>,
+ image<bgra8_pixel_t , false>,
+ image<gp_bgr565_pixel_t, false>
+ #if (GDIPVER >= 0x0110)
+ ,image<cmyk8_pixel_t , false>
+ #endif
> gp_supported_pixel_formats;
-template <class View>
struct view_gp_format
- :
- mpl::eval_if_c
- <
- // Err, an 'official' way to detect this?
- ( mpl::size<typename View::value_type::layout_t::channel_mapping_t>::value <= sizeof( typename View::value_type ) ),
- mpl::identity<unpacked_view_gp_format>,
- mpl::identity< packed_view_gp_format>
- >::type::apply<View>::type
-{};
+{
+ template <class View>
+ struct apply : gil_to_gp_format<typename View::value_type, is_planar<View>::value> {};
+};
typedef iterator_range<TCHAR const *> string_chunk_t;
@@ -230,6 +216,59 @@
: Gdiplus::Rect( Gdiplus::Point( top_left.x, top_left.y ), Gdiplus::Size( bottom_right.x - top_left.x, bottom_right.y - top_left.y ) ) {}
};
+class gp_image;
+
+template <>
+struct formatted_image_traits<gp_image>
+{
+ typedef Gdiplus::PixelFormat format_t;
+
+ typedef gp_supported_pixel_formats supported_pixel_formats_t;
+
+ typedef gp_roi roi_t;
+
+ typedef view_gp_format view_to_native_format;
+
+ template <class View>
+ struct is_supported : detail::is_supported<view_gp_format::apply<View>::value> {};
+
+ struct view_data_t : public Gdiplus::BitmapData
+ {
+ template <typename View>
+ view_data_t( View const & view ) : p_roi_( 0 ) { set_bitmapdata_for_view( view ); }
+
+ template <typename View>
+ view_data_t( View const & view, gp_roi::offset_t const & offset )
+ :
+ p_roi_( static_cast<gp_roi const *>( optional_roi_.address() ) )
+ {
+ set_bitmapdata_for_view( view );
+ new ( optional_roi_.address() ) gp_roi( offset, Width, Height );
+ }
+
+ Gdiplus::Rect const * const p_roi_;
+
+ private:
+ template <typename View>
+ void set_bitmapdata_for_view( View const & view )
+ {
+ Width = view.width();
+ Height = view.height();
+ Stride = view.pixels().row_size();
+ PixelFormat = view_gp_format::apply<View>::value;
+ Scan0 = formatted_image_base::get_raw_data( view );
+ Reserved = 0;
+ }
+
+ void operator=( view_data_t const & );
+
+ private:
+ aligned_storage<sizeof( gp_roi ), alignment_of<gp_roi>::value>::type optional_roi_;
+ };
+
+ BOOST_STATIC_CONSTANT( unsigned int, desired_alignment = sizeof( Gdiplus::ARGB ) );
+};
+
#if defined(BOOST_MSVC)
# pragma warning( push )
@@ -239,14 +278,14 @@
class gp_image
:
private gp_guard,
- public detail::formatted_image<gp_image, gp_supported_pixel_formats, gp_roi>
+ public detail::formatted_image<gp_image>
{
public:
- template <class View>
- struct is_supported : detail::is_supported<view_gp_format<View>::value> {};
+ static std::size_t format_size( format_t const format )
+ {
+ return Gdiplus::GetPixelFormatSize( format );
+ }
- BOOST_STATIC_CONSTANT( unsigned int, desired_alignment = sizeof( Gdiplus::ARGB ) );
-
private:
// - GP wants wide-char paths
// - we received a narrow-char path
@@ -314,7 +353,7 @@
view.width(),
view.height(),
view.pixels().row_size(),
- view_gp_format<View>::value,
+ view_gp_format::apply<View>::value,
get_raw_data( view ),
&pBitmap_
)
@@ -332,7 +371,7 @@
{
using namespace Gdiplus;
REAL width, height;
- verify_result( Gdiplus::DllExports::GdipGetImageDimension( const_cast<Gdiplus::GpBitmap *>( pBitmap_ ), &width, &height ) );
+ verify_result( DllExports::GdipGetImageDimension( const_cast<GpBitmap *>( pBitmap_ ), &width, &height ) );
return point2<std::ptrdiff_t>( static_cast<std::ptrdiff_t>( width ), static_cast<std::ptrdiff_t>( height ) );
}
@@ -345,138 +384,147 @@
private: // Private formatted_image_base interface.
friend base_t;
- Gdiplus::PixelFormat get_format() const
+ format_t format() const
{
- using namespace Gdiplus;
- PixelFormat format;
- verify_result( DllExports::GdipGetImagePixelFormat( pBitmap_, &format ) );
- return format;
+ format_t pixel_format;
+ verify_result( Gdiplus::DllExports::GdipGetImagePixelFormat( pBitmap_, &pixel_format ) );
+ return pixel_format;
}
- image_type_id current_image_type_id() const
+ format_t closest_gil_supported_format() const
{
- switch ( get_format() )
+ //http://www.tech-archive.net/Archive/Development/microsoft.public.win32.programmer.gdi/2008-01/msg00044.html
+ switch ( format() )
{
+ case PixelFormat16bppGrayScale:
case PixelFormat48bppRGB :
+ case PixelFormat32bppRGB :
case PixelFormat24bppRGB :
- return 0;
+ return
+ PixelFormat24bppRGB;
+ case PixelFormat64bppPARGB :
+ case PixelFormat32bppPARGB :
case PixelFormat64bppARGB :
case PixelFormat32bppARGB :
- return 1;
-
- case PixelFormat16bppGrayScale:
- return 2;
+ case PixelFormat16bppARGB1555 :
+ return
+ PixelFormat32bppARGB;
case PixelFormat16bppRGB565 :
- return 3;
+ case PixelFormat16bppRGB555 :
+ case PixelFormat8bppIndexed :
+ case PixelFormat4bppIndexed :
+ case PixelFormat1bppIndexed :
+ return
+ PixelFormat16bppRGB565;
+ #if (GDIPVER >= 0x0110)
case PixelFormat32bppCMYK :
- return 4;
+ return
+ PixelFormat32bppCMYK;
+ #endif // (GDIPVER >= 0x0110)
default:
BOOST_ASSERT( !"Should not get reached." ); __assume( false );
+ return PixelFormatUndefined;
+ }
- case PixelFormat16bppRGB555 :
-
- case PixelFormat64bppPARGB :
- case PixelFormat32bppPARGB :
+ }
- case PixelFormat16bppARGB1555 :
+ image_type_id current_image_format_id() const
+ {
+ return image_format_id( closest_gil_supported_format() );
+ }
- case PixelFormat32bppRGB :
+ static image_type_id image_format_id( format_t const closest_gil_supported_format )
+ {
+ switch ( closest_gil_supported_format )
+ {
+ case PixelFormat24bppRGB : return 0;
+ case PixelFormat32bppARGB : return 1;
+ case PixelFormat16bppGrayScale: return 2;
+ case PixelFormat16bppRGB565 : return 3;
+ #if (GDIPVER >= 0x0110)
+ case PixelFormat32bppCMYK : return 4;
+ #endif
- case PixelFormat1bppIndexed :
- case PixelFormat4bppIndexed :
- case PixelFormat8bppIndexed :
+ default:
+ BOOST_ASSERT( !"Should not get reached." ); __assume( false );
return unsupported_format;
}
}
public:
template <typename View>
- void convert_to_prepared_view( View const & view ) const
+ void generic_convert_to_prepared_view( View const & view ) const
{
- BOOST_STATIC_ASSERT( detail::is_supported<view_gp_format<View>::value>::value );
-
BOOST_ASSERT( !dimensions_mismatch( view ) );
+ //BOOST_ASSERT( !formats_mismatch ( view ) );
- using namespace Gdiplus;
-
- if ( detail::is_supported<view_gp_format<View>::value>::value )
- {
- PixelFormat const desired_format( view_gp_format<View>::value );
- pre_palettized_conversion<desired_format>( is_indexed<desired_format>::type() );
- copy_to_target( get_bitmap_data_for_view( view ) );
- }
- else
- {
- convert_to_prepared_view( view, default_color_converter() );
- }
+ BitmapData bitmapData;
+ Rect const rect( 0, 0, bitmapData.Width, bitmapData.Height );
+ ensure_result
+ (
+ DllExports::GdipBitmapLockBits
+ (
+ pBitmap_,
+ &rect,
+ ImageLockModeRead,
+ view_gp_format::apply<View>::value,
+ &bitmapData
+ )
+ );
+ copy_pixels // This must not throw!
+ (
+ interleaved_view
+ (
+ bitmapData.Width ,
+ bitmapData.Height,
+ gil_reinterpret_cast_c<typename View::value_type const *>( bitmapData.Scan0 ),
+ bitmapData.Stride
+ ),
+ view
+ );
+ verify_result( DllExports::GdipBitmapUnlockBits( pBitmap_, &bitmapData ) );
}
- template <typename View, typename CC>
- void convert_to_prepared_view( View const & view, CC const & converter ) const
+ void raw_convert_to_prepared_view( formatted_image_traits<gp_image>::view_data_t const & view_data ) const
{
- BOOST_ASSERT( !dimensions_mismatch( view ) );
+ BOOST_ASSERT( view_data.Scan0 );
using namespace Gdiplus;
- PixelFormat const my_format ( get_format() );
- BitmapData bitmapData( get_bitmap_data_for_view( view ) );
-
- if ( my_format == view_gp_format<View>::value )
- {
- copy_to_target( bitmapData );
- }
- else
- {
- bool const can_do_in_place( can_do_inplace_transform<typename View::value_type>( my_format ) );
- if ( can_do_in_place )
- {
- bitmapData.PixelFormat = my_format;
- copy_to_target( bitmapData );
- transform( my_format, view, view, converter );
- }
- else
- {
- BOOST_ASSERT( bitmapData.Scan0 );
- typedef typename View::value_type pixel_t;
- pixel_t * const p_raw_view( static_cast<pixel_t *>( bitmapData.Scan0 ) );
- bitmapData.Scan0 = 0;
-
- Rect const rect( 0, 0, bitmapData.Width, bitmapData.Height );
- ensure_result
- (
- DllExports::GdipBitmapLockBits
- (
- pBitmap_,
- &rect,
- ImageLockModeRead,
- bitmapData.PixelFormat,
- &bitmapData
- )
- );
- transform
- (
- bitmapData.PixelFormat,
- interleaved_view( bitmapData.Width, bitmapData.Height, p_raw_view, bitmapData.Stride ),
- view,
- converter
- );
- verify_result( DllExports::GdipBitmapUnlockBits( pBitmap_, &bitmapData ) );
- }
- }
+ BitmapData * const pMutableBitmapData( const_cast<BitmapData *>( static_cast<BitmapData const *>( &view_data ) ) );
+ GpStatus const load_result
+ (
+ DllExports::GdipBitmapLockBits
+ (
+ pBitmap_,
+ view_data.p_roi_,
+ ImageLockModeRead | ImageLockModeUserInputBuf,
+ view_data.PixelFormat,
+ pMutableBitmapData
+ )
+ );
+ GpStatus const unlock_result( DllExports::GdipBitmapUnlockBits( pBitmap_, pMutableBitmapData ) );
+ ensure_result( load_result );
+ verify_result( unlock_result );
}
- template <typename View>
- void copy_to_prepared_view( View const & view ) const
+
+ void copy_to_target( formatted_image_traits<gp_image>::view_data_t const & view_data ) const
{
- BOOST_ASSERT( !dimensions_mismatch( view ) );
- BOOST_ASSERT( !formats_mismatch<View>() );
- convert_to_prepared_view( view );
+ BOOST_ASSERT( view_data.Width == static_cast<UINT>( dimensions().x ) );
+ BOOST_ASSERT( view_data.Height == static_cast<UINT>( dimensions().y ) );
+ //...this need not hold as it can be used to perform GDI+ default
+ //internal colour conversion...maybe i'll provide another worker
+ //function...
+ //BOOST_ASSERT( view_data.PixelFormat == format () );
+ raw_convert_to_prepared_view( view_data );
}
+
private:
static CLSID const & png_codec()
{
@@ -504,70 +552,6 @@
return clsid;
}
- template <typename View>
- static BYTE * get_raw_data( View const & view )
- {
- // A private implementation of interleaved_view_get_raw_data() that
- // works with packed pixel views.
- BOOST_STATIC_ASSERT((!is_planar<View>::value /*&& view_is_basic<View>::value*/));
- BOOST_STATIC_ASSERT((boost::is_pointer<typename View::x_iterator>::value));
-
- BOOST_STATIC_ASSERT( detail::is_supported<view_gp_format<View>::value>::value );
-
- return static_cast<BYTE *>( &gil::at_c<0>( view( 0, 0 ) ) );
- }
-
- template <typename View>
- Gdiplus::BitmapData get_bitmap_data_for_view( View const & view ) const
- {
- using namespace Gdiplus;
-
- BitmapData const bitmapData =
- {
- view.width(),
- view.height(),
- view.pixels().row_size(),
- view_gp_format<View>::value,
- get_raw_data( view ),
- 0
- };
- return bitmapData;
- }
-
- void convert_to_target( Gdiplus::BitmapData const & bitmapData ) const
- {
- BOOST_ASSERT( bitmapData.Scan0 );
-
- using namespace Gdiplus;
-
- BitmapData * const pMutableBitmapData( const_cast<BitmapData *>( &bitmapData ) );
- GpStatus const load_result
- (
- DllExports::GdipBitmapLockBits
- (
- pBitmap_,
- 0,
- ImageLockModeRead | ImageLockModeUserInputBuf,
- bitmapData.PixelFormat,
- pMutableBitmapData
- )
- );
- GpStatus const unlock_result( DllExports::GdipBitmapUnlockBits( pBitmap_, pMutableBitmapData ) );
- ensure_result( load_result );
- verify_result( unlock_result );
- }
-
-
- void copy_to_target( Gdiplus::BitmapData const & bitmapData ) const
- {
- BOOST_ASSERT( bitmapData.Width == static_cast<UINT>( dimensions().x ) );
- BOOST_ASSERT( bitmapData.Height == static_cast<UINT>( dimensions().y ) );
- //...this need not hold as it can be used to perform GDI+ default
- //internal colour conversion...maybe i'll provide another worker
- //function...
- //BOOST_ASSERT( bitmapData.PixelFormat == get_format () );
- convert_to_target( bitmapData );
- }
template <Gdiplus::PixelFormat desired_format>
void pre_palettized_conversion( mpl::true_ /*is_indexed*/ )
@@ -576,7 +560,7 @@
// A GDI+ 1.1 (a non-distributable version, distributed with MS Office
// 2003 and MS Windows Vista and MS Windows 7) 'enhanced'/'tuned'
// version of the conversion routine for indexed/palettized image
- // formats. Unless/until proven usefull, pretty much still a GDI+ 1.1
+ // formats. Unless/until proven useful, pretty much still a GDI+ 1.1
// tester...
BOOST_ASSERT( !has_alpha<desired_format>::value && "Is this possible for indexed formats?" );
@@ -623,210 +607,12 @@
template <Gdiplus::PixelFormat desired_format>
void pre_palettized_conversion( mpl::false_ /*not is_indexed*/ ) const {}
-
- template <class SourceView, class DestinationView, class CC>
- static void transform( Gdiplus::PixelFormat const sourceFormat, SourceView const & src, DestinationView const & dst, CC const & converter )
- {
- // Reinterpret cast/type punning ugliness is required for dynamic
- // in-place detection/optimization...to be cleaned up...
- typedef typename DestinationView::value_type target_pixel_t;
- switch ( sourceFormat )
- {
- case PixelFormat48bppRGB :
- case PixelFormat24bppRGB :
- typedef pixel<bits8, gp_layout_t> gp_rgb24_pixel_t;
- typedef view_type_from_pixel<gp_rgb24_pixel_t, false>::type gp_rgb24_view_t ;
- transform_pixels
- (
- *gil_reinterpret_cast_c<gp_rgb24_view_t const *>( &src ),
- dst,
- color_convert_deref_fn
- <
- gp_rgb24_pixel_t const &,
- target_pixel_t,
- CC
- >( converter )
- );
- break;
-
- case PixelFormat64bppARGB :
- case PixelFormat32bppARGB :
- typedef pixel<bits8, gp_alpha_layout_t> gp_argb32_pixel_t;
- typedef view_type_from_pixel<gp_argb32_pixel_t, false>::type gp_argb32_view_t ;
- transform_pixels
- (
- *gil_reinterpret_cast_c<gp_argb32_view_t const *>( &src ),
- dst,
- color_convert_deref_fn
- <
- gp_argb32_pixel_t const &,
- target_pixel_t,
- CC
- >( converter )
- );
- break;
-
- case PixelFormat16bppGrayScale:
- typedef view_type_from_pixel<gray16_pixel_t, false>::type gp_gray16_view_t ;
- transform_pixels
- (
- *gil_reinterpret_cast_c<gp_gray16_view_t const *>( &src ),
- dst,
- color_convert_deref_fn
- <
- gray16_ref_t,
- target_pixel_t,
- CC
- >( converter )
- );
- break;
-
- case PixelFormat16bppRGB555 :
- BOOST_ASSERT( !"What about unused bits?" );
- typedef packed_pixel_type<uint16_t, mpl::vector3_c<unsigned,5,5,5>, gp_layout_t>::type gp555_pixel_t ;
- typedef view_type_from_pixel<gp555_pixel_t, false>::type gp_rgb16_555_view_t;
- //...this...does not compile...how to specify a layout with an
- //unused bit?
- //transform_pixels
- //(
- // *gil_reinterpret_cast_c<gp_rgb16_555_view_t const *>( &src ),
- // dst,
- // color_convert_deref_fn
- // <
- // gp555_pixel_t const &,
- // target_pixel_t,
- // CC
- // >( converter )
- //);
- break;
-
- case PixelFormat16bppRGB565 :
- BOOST_ASSERT( !"Why does this fail to compile?" );
- typedef packed_pixel_type<uint16_t, mpl::vector3_c<unsigned,5,6,5>, gp_layout_t>::type gp565_pixel_t ;
- typedef view_type_from_pixel<gp565_pixel_t, false>::type gp_rgb16_565_view_t;
- //transform_pixels
- //(
- // *gil_reinterpret_cast_c<gp_rgb16_565_view_t const *>( &src ),
- // dst,
- // color_convert_deref_fn
- // <
- // //gp565_pixel_t const &,
- // //gp_rgb16_565_view_t::reference,
- // gp565_pixel_t::const_reference,
- // target_pixel_t,
- // CC
- // >( converter )
- //);
- break;
-
- case PixelFormat32bppCMYK :
- BOOST_ASSERT( !"What about byte order/endianess here?" );
- typedef view_type_from_pixel<cmyk_t, false>::type gp_cmyk_view_t;
- //...this...does not compile...
- //transform_pixels
- //(
- // *gil_reinterpret_cast_c<gp_cmyk_view_t const *>( &src ),
- // dst,
- // color_convert_deref_fn
- // <
- // cmyk_t const &,
- // target_pixel_t,
- // CC
- // >( converter )
- //);
- break;
-
- case PixelFormat64bppPARGB :
- case PixelFormat32bppPARGB :
- BOOST_ASSERT( !"What about premultiplied alpha?" );
- break;
-
- case PixelFormat16bppARGB1555 :
- BOOST_ASSERT( !"What about 'high colour with 1 bit alpha?" );
- break;
-
- case PixelFormat32bppRGB :
- BOOST_ASSERT( !"What about 4 byte pixels without alpha?" );
- break;
-
- case PixelFormat1bppIndexed :
- case PixelFormat4bppIndexed :
- case PixelFormat8bppIndexed :
- BOOST_ASSERT( !"What about indexed colour?" );
- break;
-
- default: BOOST_ASSERT( !"Should not get reached." ); __assume( false );
- }
- }
-
-
void save_to( char const * const pFilename, CLSID const & encoderID ) const { save_to( wide_path( pFilename ), encoderID ); }
void save_to( wchar_t const * const pFilename, CLSID const & encoderID ) const
{
ensure_result( Gdiplus::DllExports::GdipSaveImageToFile( pBitmap_, pFilename, &encoderID, NULL ) );
}
-
- template <typename Pixel>
- bool can_do_inplace_transform() const
- {
- return can_do_inplace_transform<Pixel>( get_format() );
- }
-
- template <typename Pixel>
- bool can_do_inplace_transform( Gdiplus::PixelFormat const my_format ) const
- {
- return ( Gdiplus::GetPixelFormatSize( my_format ) == sizeof( Pixel ) );
- }
-
-
- template <typename View>
- bool dimensions_mismatch( View const & view ) const
- {
- return dimensions_mismatch( view.dimensions() );
- }
-
- bool dimensions_mismatch( point2<std::ptrdiff_t> const & other_dimensions ) const
- {
- return other_dimensions != dimensions();
- }
-
-
- template <typename View>
- bool formats_mismatch() const
- {
- return formats_mismatch( view_gp_format<View>::value );
- }
-
- bool formats_mismatch( Gdiplus::PixelFormat const other_format ) const
- {
- return other_format != get_format();
- }
-
-
- template <typename View>
- void ensure_dimensions_match( View const & view ) const
- {
- ensure_dimensions_match( view.dimensions() );
- }
-
- void ensure_dimensions_match( point2<std::ptrdiff_t> const & other_dimensions ) const
- {
- io_error_if( dimensions_mismatch( other_dimensions ), "input view size does not match source image size" );
- }
-
-
- template <typename View>
- void ensure_formats_match() const
- {
- ensure_formats_match( view_gp_format<View>::value );
- }
-
- void ensure_formats_match( Gdiplus::PixelFormat const other_format ) const
- {
- io_error_if( formats_mismatch( other_format ), "input view type is incompatible with the image type" );
- }
-
private:
friend class gp_view_base;
@@ -867,7 +653,7 @@
&bitmap_,
p_roi,
lock_mode,
- bitmap.get_format(),
+ bitmap.format(),
&bitmapData_
)
);
Modified: sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp
==============================================================================
--- sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp (original)
+++ sandbox/gil/boost/gil/extension/io2/gp_private_io.hpp 2010-04-18 17:10:01 EDT (Sun, 18 Apr 2010)
@@ -42,7 +42,7 @@
template <typename View>
inline void read_view( gp_image const & image, View const & view ) {
- image.copy_to_view( view );
+ image.copy_to( view, ensure_dimensions_match(), ensure_formats_match() );
}
template <typename View>
@@ -53,8 +53,7 @@
template <typename Image>
inline void read_image( gp_image const & gp_image, Image & gil_image ) {
- gil_image.recreate( gp_image.get_dimensions(), sizeof( Gdiplus::ARGB ) );
- gp_image.copy_to_prepared_view( view( gil_image ) );
+ gp_image.copy_to_image( gil_image, synchronize_dimensions(), ensure_formats_match() );
}
template <typename Image>
@@ -91,9 +90,8 @@
template <typename Image,typename CC>
-inline void read_and_convert_image( gp_image const & gp_image, Image & gil_image, CC cc ) {
- gil_image.recreate( gp_image.get_dimensions(), sizeof( Gdiplus::ARGB ) );
- gp_image.convert_to_prepared_view( view( gil_image ), cc );
+inline void read_and_convert_image( gp_image const & gp_image, Image & gil_image, CC const cc ) {
+ gp_image.copy_to_image( gil_image, synchronize_dimensions() , cc );
}
template <typename Image,typename CC>
@@ -109,8 +107,7 @@
template <typename Image>
inline void read_and_convert_image( gp_image const & gp_image, Image & gil_image ) {
- gil_image.recreate( gp_image.dimensions(), sizeof( Gdiplus::ARGB ) );
- gp_image.convert_to_prepared_view( view( gil_image ) );
+ gp_image.copy_to_image( gil_image, synchronize_dimensions() , synchronize_formats() );
}
template <typename Image>