[Boost-commit] svn:boost r61387 - sandbox/gil/boost/gil/extension/io2

Subject: [Boost-commit] svn:boost r61387 - sandbox/gil/boost/gil/extension/io2
From: dsaritz_at_[hidden]
Date: 2010-04-18 17:16:11

Author: psiha
Date: 2010-04-18 17:16:10 EDT (Sun, 18 Apr 2010)
New Revision: 61387
URL: http://svn.boost.org/trac/boost/changeset/61387

Log:
Added a first version of the LibJPEG formatted_image implementation.
Added:
   sandbox/gil/boost/gil/extension/io2/libjpeg_private_base.hpp   (contents, props changed)

Added: sandbox/gil/boost/gil/extension/io2/libjpeg_private_base.hpp
==============================================================================
--- (empty file)
+++ sandbox/gil/boost/gil/extension/io2/libjpeg_private_base.hpp	2010-04-18 17:16:10 EDT (Sun, 18 Apr 2010)
@@ -0,0 +1,604 @@
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \file libjpeg_private_base.hpp
+/// ------------------------------
+///
+/// Copyright (c) Domagoj Saric 2010.
+///
+///  Use, modification and distribution is subject to 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)
+///
+/// For more information, see http://www.boost.org
+///
+////////////////////////////////////////////////////////////////////////////////
+//------------------------------------------------------------------------------
+#pragma once
+#ifndef libjpeg_private_base_hpp__7C5F6951_A00F_4E0D_9783_488A49B1CA2B
+#define libjpeg_private_base_hpp__7C5F6951_A00F_4E0D_9783_488A49B1CA2B
+//------------------------------------------------------------------------------
+#include "../../gil_all.hpp"
+#include "formatted_image.hpp"
+#include "io_error.hpp"
+
+#include <boost/foreach.hpp>
+#include <boost/smart_ptr/scoped_ptr.hpp>
+
+#define JPEG_INTERNALS
+#include "jpeglib.h"
+#undef JPEG_INTERNALS
+
+#include <csetjmp>
+#include <cstdlib>
+//------------------------------------------------------------------------------
+namespace boost
+{
+//------------------------------------------------------------------------------
+namespace gil
+{
+//------------------------------------------------------------------------------
+namespace detail
+{
+//------------------------------------------------------------------------------
+
+BOOST_STATIC_ASSERT( BITS_IN_JSAMPLE == 8 );
+
+
+template <typename Pixel, bool isPlanar>
+struct gil_to_libjpeg_format : mpl::integral_c<J_COLOR_SPACE, JCS_UNKNOWN> {};
+
+template <> struct gil_to_libjpeg_format<rgb8_pixel_t , false> : mpl::integral_c<J_COLOR_SPACE, JCS_RGB      > {};
+template <> struct gil_to_libjpeg_format<gray8_pixel_t, false> : mpl::integral_c<J_COLOR_SPACE, JCS_GRAYSCALE> {};
+template <> struct gil_to_libjpeg_format<cmyk8_pixel_t, false> : mpl::integral_c<J_COLOR_SPACE, JCS_CMYK     > {};
+
+
+
+struct view_libjpeg_format
+{
+    template <class View>
+    struct apply : gil_to_libjpeg_format<typename View::value_type, is_planar<View>::value> {};
+};
+
+
+typedef mpl::vector3
+<
+    image<rgb8_pixel_t , false>,
+    image<gray8_pixel_t, false>,
+    image<cmyk8_pixel_t, false>
+> libjpeg_supported_pixel_formats;
+
+
+
+struct libjpeg_guard {};
+
+
+class libjpeg_roi
+{
+public:
+    typedef std::ptrdiff_t     value_type;
+    typedef point2<value_type> point_t   ;
+
+    typedef value_type         offset_t  ;
+
+public:
+    libjpeg_roi( value_type const start_row, value_type const end_row )
+        :
+        start_row_( start_row ),
+        end_row_  ( end_row   )
+    {}
+
+    value_type start_row() const { return start_row_; }
+    value_type end_row  () const { return end_row_  ; }
+
+private:
+    void operator=( libjpeg_roi const & );
+
+private:
+    value_type const start_row_;
+    value_type const   end_row_;
+};
+
+
+#if defined(BOOST_MSVC)
+#   pragma warning( push )
+#   pragma warning( disable : 4127 ) // "conditional expression is constant"
+#endif
+
+class libjpeg_base : private libjpeg_guard
+{
+protected:
+    struct for_decompressor {};
+    struct for_compressor   {};
+
+protected:
+    libjpeg_base( for_decompressor ) throw(...)
+    {
+        initialize_error_handler();
+        if ( setjmp( error_handler_target() ) )
+            throw_jpeg_error();
+        jpeg_create_decompress( &decompressor() );
+    }
+
+    libjpeg_base( for_compressor ) throw(...)
+    {
+        initialize_error_handler();
+        if ( setjmp( error_handler_target() ) )
+            throw_jpeg_error();
+        jpeg_create_compress( &compressor() );
+    }
+
+    ~libjpeg_base() { jpeg_destroy( &common() ); }
+
+    void abort() const { jpeg_abort( &mutable_this().common() ); }
+
+    jmp_buf & error_handler_target() const { return longjmp_target_; }
+
+    jpeg_common_struct           & common      ()       { return *gil_reinterpret_cast<j_common_ptr>( &libjpeg_object.compressor_ ); }
+    jpeg_common_struct     const & common      () const { return const_cast<libjpeg_base &>( *this ).common(); }
+    jpeg_compress_struct         & compressor  ()       { return libjpeg_object.compressor_  ; }
+    jpeg_compress_struct   const & compressor  () const { return const_cast<libjpeg_base &>( *this ).compressor(); }
+    jpeg_decompress_struct       & decompressor()       { return libjpeg_object.decompressor_; }
+    jpeg_decompress_struct const & decompressor() const { return const_cast<libjpeg_base &>( *this ).decompressor(); }
+
+    libjpeg_base & mutable_this() const { return const_cast<libjpeg_base &>( *this ); }
+
+    __declspec( noreturn )
+    static void throw_jpeg_error() throw(...)
+    {
+        io_error( "jpeg error" );
+    }
+
+private:
+    void initialize_error_handler()
+    {
+        common().err         = jpeg_std_error( &jerr_ );
+        common().client_data = this;
+        jerr_.error_exit = &libjpeg_base::libX_fatal_error_handler;
+    }
+
+    static inline void libX_fatal_error_handler( j_common_ptr const cinfo )
+    {
+        libjpeg_base * const p_me( gil_reinterpret_cast<libjpeg_base *>( cinfo->client_data ) );
+        BOOST_ASSERT( p_me );
+        longjmp( p_me->longjmp_target_, 1 );
+    }
+
+private:
+    union libjpeg_object_t
+    {
+        jpeg_compress_struct     compressor_;
+        jpeg_decompress_struct decompressor_;
+    } libjpeg_object;
+
+    jpeg_error_mgr         jerr_ ;
+
+    //#ifndef BOOST_MSVC
+    mutable jmp_buf longjmp_target_;
+    //#endif // BOOST_MSVC
+};
+
+class libjpeg_image;
+
+struct decompression_setup_data_t
+{
+    decompression_setup_data_t( J_COLOR_SPACE const format, JSAMPROW const buffer, libjpeg_roi::offset_t const offset )
+        : format_( format ), buffer_( buffer ), offset_( offset ) {}
+
+    J_COLOR_SPACE         /*const*/ format_;
+    JSAMPROW              /*const*/ buffer_;
+    libjpeg_roi::offset_t /*const*/ offset_;
+};
+
+struct view_data_t : decompression_setup_data_t
+{
+    template <class View>
+    explicit view_data_t( View const & view, libjpeg_roi::offset_t const offset )
+        :
+        decompression_setup_data_t
+        (
+            view_libjpeg_format::apply<View>::value,
+            formatted_image_base::get_raw_data( view ),
+            offset
+        ),
+        height_( view.height()            ),
+        width_ ( view.width ()            ),
+        stride_( view.pixels().row_size() )
+    {}
+
+    void set_format( J_COLOR_SPACE const format ) { format_ = format; }
+
+    unsigned int    /*const*/ height_;
+    unsigned int    /*const*/ width_ ;
+    unsigned int    /*const*/ stride_;
+};
+
+template <>
+struct formatted_image_traits<libjpeg_image>
+{
+    typedef J_COLOR_SPACE format_t;
+
+    typedef libjpeg_supported_pixel_formats supported_pixel_formats_t;
+
+    typedef libjpeg_roi roi_t;
+
+    typedef view_libjpeg_format view_to_native_format;
+
+    typedef view_data_t view_data_t;
+
+    template <class View>
+    struct is_supported : mpl::bool_<view_libjpeg_format::apply<View>::value != JCS_UNKNOWN> {};
+
+    BOOST_STATIC_CONSTANT( unsigned int, desired_alignment = sizeof( void * ) );
+};
+
+
+class libjpeg_image
+    :
+    public  libjpeg_base,
+    public  detail::formatted_image<libjpeg_image>
+{
+public:
+    format_t format() const { return decompressor().jpeg_color_space; }
+
+    format_t closest_gil_supported_format() const
+    {
+        switch ( format() )
+        {
+            case JCS_RGB  :
+            case JCS_YCbCr:
+                return JCS_RGB;
+            
+            case JCS_CMYK:
+            case JCS_YCCK:
+                return JCS_CMYK;
+
+            case JCS_GRAYSCALE:
+                return JCS_GRAYSCALE;
+
+            default:
+                BOOST_ASSERT( format() == JCS_UNKNOWN );
+                BOOST_ASSERT( !"Unknown format." );
+                return JCS_UNKNOWN;
+        }
+    }
+
+    image_type_id current_image_format_id() const
+    {
+        return image_format_id( closest_gil_supported_format() );
+    }
+
+    static image_type_id image_format_id( format_t const closest_gil_supported_format )
+    {
+        switch ( closest_gil_supported_format )
+        {
+            case JCS_RGB      : return 0;
+            case JCS_GRAYSCALE: return 1;
+            case JCS_CMYK     : return 2;
+            default:
+                BOOST_ASSERT( !"Should not get reached." ); __assume( false );
+                return unsupported_format;
+        }
+    }
+
+    static std::size_t format_size( format_t const format )
+    {
+        switch ( format )
+        {
+            default:
+                BOOST_ASSERT( !"Invalid or unknown format specified." ); __assume( false );
+                return 0;
+
+            case JCS_RGB:
+            case JCS_YCbCr:
+                return 3;
+            case JCS_CMYK:
+            case JCS_YCCK:
+                return 4;
+            case JCS_GRAYSCALE:
+                return 1;
+        }
+    }
+
+    //...zzz...
+    //std::size_t format_size( format_t const format ) const
+    //{
+    //    BOOST_ASSERT( format_size( format ) == decompressor().output_components );
+    //    BOOST_ASSERT( decompressor().out_color_components == decompressor().output_components );
+    //    ignore_unused_variable_warning( format );
+    //    return decompressor().output_components;
+    //}
+
+
+public: /// \ingroup Construction
+    explicit libjpeg_image( FILE * const p_file )
+        :
+        libjpeg_base( for_decompressor() )
+    {
+        BOOST_ASSERT( p_file );
+
+        if ( setjmp( error_handler_target() ) )
+            throw_jpeg_error();
+
+        jpeg_stdio_src( &decompressor(), p_file );
+
+        BOOST_VERIFY( jpeg_read_header( &decompressor(), true ) == JPEG_HEADER_OK );
+
+        io_error_if( decompressor().data_precision != 8, "Unsupported image file data precision." );
+    }
+
+
+public:
+    point2<std::ptrdiff_t> dimensions() const
+    {
+        return point2<std::ptrdiff_t>( decompressor().image_width, decompressor().image_height );
+    }
+
+
+private: // Private formatted_image_base interface.
+    friend base_t;
+    void raw_convert_to_prepared_view( view_data_t const & view_data ) const throw(...)
+    {
+        setup_decompression( view_data );
+
+        if ( setjmp( error_handler_target() ) )
+            throw_jpeg_error();
+
+        JSAMPROW scanlines[ 4 ] =
+        {
+            view_data.buffer_,
+            scanlines[ 0 ] + view_data.stride_,
+            scanlines[ 1 ] + view_data.stride_,
+            scanlines[ 2 ] + view_data.stride_
+        };
+
+        BOOST_ASSERT( _countof( scanlines ) >= decompressor().rec_outbuf_height );
+        unsigned int scanlines_to_read( view_data.height_ );
+        for ( ; ; )
+        {
+            BOOST_ASSERT( scanlines_to_read <= ( decompressor().output_height - decompressor().output_scanline ) );
+            unsigned int const lines_read
+            (
+                jpeg_read_scanlines
+                (
+                    &mutable_this().decompressor(),
+                    scanlines,
+                    (std::min)( _countof( scanlines ), scanlines_to_read )
+                )
+            );
+            scanlines_to_read -= lines_read;
+            if ( !scanlines_to_read )
+                return;
+
+            scanlines[ 0 ] = scanlines[ lines_read - 1 ] + view_data.stride_;
+            scanlines[ 1 ] = scanlines[ 0 ] + view_data.stride_;
+            scanlines[ 2 ] = scanlines[ 1 ] + view_data.stride_;
+            scanlines[ 3 ] = scanlines[ 2 ] + view_data.stride_;
+        }
+    }
+
+    template <class MyView, class TargetView, class Converter>
+    void generic_convert_to_prepared_view( TargetView const & view, Converter const & converter ) const
+    {
+        typedef typename MyView::value_type pixel_t;
+        std::size_t const scanline_length( decompressor().image_width * decompressor().num_components );
+        scoped_ptr<JSAMPLE> const p_scanline_buffer( new JSAMPLE[ scanline_length ] );
+        JSAMPROW       scanline   ( p_scanline_buffer.get()    );
+        JSAMPROW const scanlineEnd( scanline + scanline_length );
+        
+        BOOST_ASSERT( closest_gil_supported_format() == view_libjpeg_format::apply<MyView>::value );
+        setup_decompression
+        (
+            decompression_setup_data_t
+            (
+                view_libjpeg_format::apply<MyView>::value,
+                scanline,
+                detail::get_offset<offset_t>( view )
+            )
+        );
+
+        BOOST_ASSERT( decompressor().output_width      == decompressor().image_width    );
+        BOOST_ASSERT( decompressor().output_components == decompressor().num_components );
+        
+        if ( setjmp( error_handler_target() ) )
+            throw_jpeg_error();
+
+        unsigned int const scanlines_to_read( detail::original_view( view ).dimensions().y );
+        for ( unsigned int scanline_index( 0 ); scanline_index < scanlines_to_read; ++scanline_index )
+        {
+            BOOST_VERIFY
+            (
+                jpeg_read_scanlines
+                (
+                    &mutable_this().decompressor(),
+                    &scanline,
+                    1
+                ) == 1
+            );
+
+            pixel_t const *                 p_source_pixel( gil_reinterpret_cast_c<pixel_t const *>( scanline ) );
+            typename TargetView::x_iterator p_target_pixel( view.row_begin( scanline_index )                    );
+            while ( p_source_pixel < gil_reinterpret_cast_c<pixel_t const *>( scanlineEnd ) )
+            {
+                converter( *p_source_pixel, *p_target_pixel );
+                ++p_source_pixel;
+                ++p_target_pixel;
+            }
+        }
+    }
+
+    void copy_to_prepared_view( view_data_t const & view_data ) const
+    {
+        BOOST_ASSERT( view_data.width_  == static_cast<unsigned int>( dimensions().x ) );
+        BOOST_ASSERT( view_data.height_ == static_cast<unsigned int>( dimensions().y ) );
+        BOOST_ASSERT( view_data.format_ == closest_gil_supported_format()              );
+        raw_convert_to_prepared_view( view_data );
+    }
+
+private:
+    void setup_decompression( decompression_setup_data_t const & view_data ) const throw(...)
+    {
+        unsigned int const state       ( decompressor().global_state );
+        unsigned int       rows_to_skip( view_data.offset_           );
+        if
+        (
+            ( state                          != DSTATE_SCANNING   ) ||
+            ( decompressor().out_color_space != view_data.format_ ) ||
+            ( decompressor().output_scanline  > view_data.offset_ )
+        )
+        {
+            BOOST_ASSERT
+            (
+                ( state == DSTATE_READY    ) ||
+                ( state == DSTATE_SCANNING )
+            );
+
+            if ( setjmp( error_handler_target() ) )
+                throw_jpeg_error();
+
+            if ( state == DSTATE_SCANNING )
+                abort();
+
+            mutable_this().decompressor().out_color_space = view_data.format_;
+            BOOST_VERIFY( jpeg_start_decompress( &mutable_this().decompressor() ) );
+            BOOST_ASSERT( decompressor().output_scanline == 0 );
+        }
+        else
+            rows_to_skip -= decompressor().output_scanline;
+
+        if ( rows_to_skip )
+            skip_rows( rows_to_skip, view_data.buffer_ );
+        BOOST_ASSERT( decompressor().output_scanline == view_data.offset_ );
+    }
+
+    void skip_rows( unsigned int const number_of_rows_to_skip, JSAMPROW /*const*/ dummy_scanline_buffer ) const
+    {
+        BOOST_ASSERT( decompressor().raw_data_out == false           );
+        BOOST_ASSERT( decompressor().global_state == DSTATE_SCANNING );
+        mutable_this().decompressor().raw_data_out = true;
+        mutable_this().decompressor().global_state = DSTATE_RAW_OK;
+
+        std::size_t const max_number_of_components( 4 ); // CMYK
+        std::size_t const max_sampling_factor     ( 2 ); // Documentation
+        std::size_t const mcu_row_size            ( max_sampling_factor * DCTSIZE ); // Documentation
+        BOOST_ASSERT( decompressor().num_components    <= max_number_of_components );
+        BOOST_ASSERT( decompressor().max_v_samp_factor <= max_sampling_factor      );
+
+        JSAMPROW   dummy_component_2d_array[ mcu_row_size             ];
+        JSAMPARRAY dummy_scan_lines        [ max_number_of_components ];
+
+        std::fill( begin( dummy_component_2d_array ), end( dummy_component_2d_array ), dummy_scanline_buffer          );
+        std::fill( begin( dummy_scan_lines         ), end( dummy_scan_lines         ), &dummy_component_2d_array[ 0 ] );
+
+        unsigned int number_of_rows_to_skip_using_scanlines
+        (
+            number_of_rows_to_skip % mcu_row_size
+        );
+        unsigned int number_of_rows_to_skip_using_raw
+        (
+            number_of_rows_to_skip - number_of_rows_to_skip_using_scanlines
+        );
+
+        while ( number_of_rows_to_skip_using_raw )
+        {
+            unsigned int const lines_to_read( _countof( dummy_component_2d_array ) );
+            BOOST_VERIFY
+            (
+                jpeg_read_raw_data
+                (
+                    &mutable_this().decompressor(),
+                    dummy_scan_lines,
+                    lines_to_read
+                ) == lines_to_read
+            );
+            number_of_rows_to_skip_using_raw -= lines_to_read;
+        }
+
+        mutable_this().decompressor().raw_data_out = false;
+        mutable_this().decompressor().global_state = DSTATE_SCANNING;
+        while ( number_of_rows_to_skip_using_scanlines-- )
+        {
+            BOOST_VERIFY
+            (
+                jpeg_read_scanlines
+                (
+                    &mutable_this().decompressor(),
+                    &dummy_scanline_buffer,
+                    1
+                ) == 1
+            );
+        }
+    }
+
+    libjpeg_image & mutable_this() const { return static_cast<libjpeg_image &>( libjpeg_base::mutable_this() ); }
+
+private:
+    friend class libjpeg_view_base;
+
+};
+
+#if defined(BOOST_MSVC)
+#   pragma warning( pop )
+#endif
+
+
+//...zzz...incomplete...
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class libjpeg_view_base
+///
+////////////////////////////////////////////////////////////////////////////////
+
+class libjpeg_view_base : noncopyable
+{
+public:
+    ~libjpeg_view_base()
+    {
+    }
+
+protected:
+    libjpeg_view_base( libjpeg_image & bitmap, unsigned int const lock_mode, libjpeg_image::roi const * const p_roi = 0 )
+    {
+    }
+
+    template <typename Pixel>
+    typename type_from_x_iterator<Pixel *>::view_t
+    get_typed_view()
+    {
+        //todo assert correct type...
+        interleaved_view<Pixel *>( bitmapData_.Width, bitmapData_.Height, bitmapData_.Scan0, bitmapData_.Stride );
+    }
+
+private:
+};
+
+
+//...zzz...incomplete...
+////////////////////////////////////////////////////////////////////////////////
+///
+/// \class libjpeg_view
+///
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Pixel>
+class libjpeg_view
+    :
+    private libjpeg_view_base,
+    public  type_from_x_iterator<Pixel *>::view_t
+{
+public:
+    libjpeg_view( libjpeg_image & image, libjpeg_image::roi const * const p_roi = 0 )
+        :
+        libjpeg_view_base( image, ImageLockModeRead | ( is_const<Pixel>::value * ImageLockModeWrite ), p_roi ),
+        type_from_x_iterator<Pixel *>::view_t( get_typed_view<Pixel>() )
+    {}
+};
+
+
+//------------------------------------------------------------------------------
+} // namespace detail
+//------------------------------------------------------------------------------
+} // namespace gil
+//------------------------------------------------------------------------------
+} // namespace boost
+//------------------------------------------------------------------------------
+#endif // libjpeg_private_base_hpp