/usr/include/boost/gil/extension/io/jpeg_dynamic_io.hpp is in libboost1.55-dev 1.55.0+dfsg-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | /*
Copyright 2005-2007 Adobe Systems Incorporated
Use, modification and distribution are 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).
See http://opensource.adobe.com/gil for most recent version including documentation.
*/
/*************************************************************************************************/
#ifndef GIL_JPEG_DYNAMIC_IO_H
#define GIL_JPEG_DYNAMIC_IO_H
/// \file
/// \brief Support for reading and writing JPEG files
/// Requires libjpeg
///
/// \author Hailin Jin and Lubomir Bourdev \n
/// Adobe Systems Incorporated
/// \date 2005-2007 \n Last updated June 10, 2006
#include <stdio.h>
#include <string>
#include <boost/mpl/bool.hpp>
#include <boost/shared_ptr.hpp>
#include "../dynamic_image/dynamic_image_all.hpp"
#include "io_error.hpp"
#include "jpeg_io.hpp"
#include "jpeg_io_private.hpp"
#include "dynamic_io.hpp"
namespace boost { namespace gil {
namespace detail {
struct jpeg_write_is_supported {
template<typename View> struct apply
: public mpl::bool_<jpeg_write_support<View>::is_supported> {};
};
class jpeg_writer_dynamic : public jpeg_writer {
int _quality;
public:
jpeg_writer_dynamic(FILE* file, int quality=100) : jpeg_writer(file) , _quality(quality) {}
jpeg_writer_dynamic(const char* filename, int quality=100) : jpeg_writer(filename), _quality(quality) {}
template <typename Views>
void write_view(const any_image_view<Views>& runtime_view) {
dynamic_io_fnobj<jpeg_write_is_supported, jpeg_writer> op(this);
apply_operation(runtime_view,op);
}
};
class jpeg_type_format_checker {
J_COLOR_SPACE _color_type;
public:
jpeg_type_format_checker(J_COLOR_SPACE color_type_in) :
_color_type(color_type_in) {}
template <typename Image>
bool apply() {
return jpeg_read_support<typename Image::view_t>::color_type==_color_type;
}
};
struct jpeg_read_is_supported {
template<typename View> struct apply
: public mpl::bool_<jpeg_read_support<View>::is_supported> {};
};
class jpeg_reader_dynamic : public jpeg_reader {
public:
jpeg_reader_dynamic(FILE* file) : jpeg_reader(file) {}
jpeg_reader_dynamic(const char* filename) : jpeg_reader(filename){}
template <typename Images>
void read_image(any_image<Images>& im) {
if (!construct_matched(im,detail::jpeg_type_format_checker(_cinfo.out_color_space))) {
io_error("jpeg_reader_dynamic::read_image(): no matching image type between those of the given any_image and that of the file");
} else {
im.recreate(get_dimensions());
dynamic_io_fnobj<jpeg_read_is_supported, jpeg_reader> op(this);
apply_operation(view(im),op);
}
}
};
} // namespace detail
/// \ingroup JPEG_IO
/// \brief reads a JPEG image into a run-time instantiated image
/// Opens the given JPEG file name, selects the first type in Images whose color space and channel are compatible to those of the image file
/// and creates a new image of that type with the dimensions specified by the image file.
/// Throws std::ios_base::failure if none of the types in Images are compatible with the type on disk.
template <typename Images>
inline void jpeg_read_image(const char* filename,any_image<Images>& im) {
detail::jpeg_reader_dynamic m(filename);
m.read_image(im);
}
/// \ingroup JPEG_IO
/// \brief reads a JPEG image into a run-time instantiated image
template <typename Images>
inline void jpeg_read_image(const std::string& filename,any_image<Images>& im) {
jpeg_read_image(filename.c_str(),im);
}
/// \ingroup JPEG_IO
/// \brief Saves the currently instantiated view to a jpeg file specified by the given jpeg image file name.
/// Throws std::ios_base::failure if the currently instantiated view type is not supported for writing by the I/O extension
/// or if it fails to create the file.
template <typename Views>
inline void jpeg_write_view(const char* filename,const any_image_view<Views>& runtime_view) {
detail::jpeg_writer_dynamic m(filename);
m.write_view(runtime_view);
}
/// \ingroup JPEG_IO
/// \brief Saves the currently instantiated view to a jpeg file specified by the given jpeg image file name.
template <typename Views>
inline void jpeg_write_view(const std::string& filename,const any_image_view<Views>& runtime_view) {
jpeg_write_view(filename.c_str(),runtime_view);
}
} } // namespace boost::gil
#endif
|