[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

vigra/codec.hxx |

    00001 /************************************************************************/
    00002 /*                                                                      */
    00003 /*               Copyright 2001-2002 by Gunnar Kedenburg                */
    00004 /*                                                                      */
    00005 /*    This file is part of the VIGRA computer vision library.           */
    00006 /*    The VIGRA Website is                                              */
    00007 /*        http://hci.iwr.uni-heidelberg.de/vigra/                       */
    00008 /*    Please direct questions, bug reports, and contributions to        */
    00009 /*        ullrich.koethe@iwr.uni-heidelberg.de    or                    */
    00010 /*        vigra@informatik.uni-hamburg.de                               */
    00011 /*                                                                      */
    00012 /*    Permission is hereby granted, free of charge, to any person       */
    00013 /*    obtaining a copy of this software and associated documentation    */
    00014 /*    files (the "Software"), to deal in the Software without           */
    00015 /*    restriction, including without limitation the rights to use,      */
    00016 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
    00017 /*    sell copies of the Software, and to permit persons to whom the    */
    00018 /*    Software is furnished to do so, subject to the following          */
    00019 /*    conditions:                                                       */
    00020 /*                                                                      */
    00021 /*    The above copyright notice and this permission notice shall be    */
    00022 /*    included in all copies or substantial portions of the             */
    00023 /*    Software.                                                         */
    00024 /*                                                                      */
    00025 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
    00026 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
    00027 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
    00028 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
    00029 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
    00030 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
    00031 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
    00032 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */
    00033 /*                                                                      */
    00034 /************************************************************************/
    00035
    00036 /* Modifications by Pablo d'Angelo
    00037  * updated to vigra 1.4 by Douglas Wilkins
    00038  * as of 18 February 2006:
    00039  *  - Added UINT16 and UINT32 pixel types.
    00040  *  - Added support for obtaining extra bands beyond RGB.
    00041  *  - Added support for a position field that indicates the start of this
    00042  *    image relative to some global origin.
    00043  *  - Added support for x and y resolution fields.
    00044  *  - Added support for ICC Profiles
    00045  */
    00046
    00047 #ifndef VIGRA_CODEC_HXX
    00048 #define VIGRA_CODEC_HXX
    00049
    00050 #include <memory>
    00051 #include <string>
    00052 #include <vector>
    00053
    00054 #include "array_vector.hxx"
    00055 #include "config.hxx"
    00056 #include "diff2d.hxx"
    00057 #include "sized_int.hxx"
    00058
    00059 // possible pixel types:
    00060 // "undefined", "UINT8", "UINT16", "INT16", "UINT32", "INT32", "FLOAT", "DOUBLE"
    00061
    00062 // possible compression types:
    00063 // "undefined", "RLE", "LZW", "LOSSLESS", "JPEG", "DEFLATE"
    00064
    00065 // possible file types:
    00066 // "undefined", "TIFF", "VIFF", "JPEG", "PNG", "PNM", "BMP", "SUN", "XPM", "EXR"
    00067
    00068 // possible name extensions:
    00069 // "undefined", "tif", "tiff", "jpg", "jpeg", "png", "pnm", "bmp", "sun",
    00070 // "xpm", "exr" (also capital forms)
    00071
    00072 namespace vigra
    00073 {
    00074     template <class T>
    00075     struct TypeAsString
    00076     {
    00077         static std::string result() { return "undefined"; }
    00078     };
    00079
    00080     template <>
    00081     struct TypeAsString<Int8>
    00082     {
    00083         static std::string result() { return "INT8"; }
    00084     };
    00085
    00086     template <>
    00087     struct TypeAsString<UInt8>
    00088     {
    00089         static std::string result() { return "UINT8"; }
    00090     };
    00091
    00092     template <>
    00093     struct TypeAsString<Int16>
    00094     {
    00095         static std::string result() { return "INT16"; }
    00096     };
    00097
    00098     template <>
    00099     struct TypeAsString<UInt16>
    00100     {
    00101         static std::string result() { return "UINT16"; }
    00102     };
    00103
    00104     template <>
    00105     struct TypeAsString<Int32>
    00106     {
    00107         static std::string result() { return "INT32"; }
    00108     };
    00109
    00110     template <>
    00111     struct TypeAsString<UInt32>
    00112     {
    00113         static std::string result() { return "UINT32"; }
    00114     };
    00115
    00116     template <>
    00117     struct TypeAsString<float>
    00118     {
    00119         static std::string result() { return "FLOAT"; }
    00120     };
    00121
    00122     template <>
    00123     struct TypeAsString<double>
    00124     {
    00125         static std::string result() { return "DOUBLE"; }
    00126     };
    00127
    00128
    00129     // codec description
    00130     struct CodecDesc
    00131     {
    00132         std::string fileType;
    00133         std::vector<std::string> pixelTypes;
    00134         std::vector<std::string> compressionTypes;
    00135         std::vector<std::vector<char> > magicStrings;
    00136         std::vector<std::string> fileExtensions;
    00137         std::vector<int> bandNumbers;
    00138     };
    00139
    00140     // Decoder and Encoder are virtual types that define a common
    00141     // interface for all image file formats impex supports.
    00142
    00143     struct Decoder
    00144     {
    00145         virtual ~Decoder() {};
    00146         virtual void init( const std::string & ) = 0;
    00147
    00148         // initialize with an image index. For codecs that do not support this feature, the standard init is called.
    00149         virtual void init( const std::string & fileName, unsigned int)
    00150         {
    00151           init(fileName);
    00152         }
    00153
    00154         virtual void close() = 0;
    00155         virtual void abort() = 0;
    00156
    00157         virtual std::string getFileType() const = 0;
    00158         virtual std::string getPixelType() const = 0;
    00159
    00160         virtual unsigned int getNumImages() const
    00161         {
    00162           return 1;
    00163         }
    00164
    00165         virtual void setImageIndex(unsigned int)
    00166         {
    00167         }
    00168
    00169         virtual unsigned int getImageIndex() const
    00170         {
    00171           return 0;
    00172         }
    00173
    00174         virtual unsigned int getWidth() const = 0;
    00175         virtual unsigned int getHeight() const = 0;
    00176         virtual unsigned int getNumBands() const = 0;
    00177         virtual unsigned int getNumExtraBands() const
    00178         {
    00179             return 0;
    00180         }
    00181
    00182         virtual vigra::Diff2D getPosition() const
    00183         {
    00184             return vigra::Diff2D();
    00185         }
    00186
    00187         virtual float getXResolution() const
    00188         {
    00189             return 0.0f;
    00190         }
    00191         virtual float getYResolution() const
    00192         {
    00193             return 0.0f;
    00194         }
    00195
    00196         virtual vigra::Size2D getCanvasSize() const
    00197         {
    00198             return vigra::Size2D(this->getWidth(), this->getHeight());
    00199         }
    00200
    00201         virtual unsigned int getOffset() const = 0;
    00202
    00203         virtual const void * currentScanlineOfBand( unsigned int ) const = 0;
    00204         virtual void nextScanline() = 0;
    00205
    00206         typedef ArrayVector<unsigned char> ICCProfile;
    00207
    00208         const ICCProfile & getICCProfile() const
    00209         {
    00210             return iccProfile_;
    00211         }
    00212
    00213         ICCProfile iccProfile_;
    00214     };
    00215
    00216     struct Encoder
    00217     {
    00218         virtual ~Encoder() {};
    00219         virtual void init( const std::string & ) = 0;
    00220
    00221         // initialize with file access mode. For codecs that do not support this feature, the standard init is called.
    00222         virtual void init( const std::string & fileName, const std::string & )
    00223         {
    00224           init(fileName);
    00225         }
    00226
    00227         virtual void close() = 0;
    00228         virtual void abort() = 0;
    00229
    00230         virtual std::string getFileType() const = 0;
    00231         virtual unsigned int getOffset() const = 0;
    00232
    00233         virtual void setWidth( unsigned int ) = 0;
    00234         virtual void setHeight( unsigned int ) = 0;
    00235         virtual void setNumBands( unsigned int ) = 0;
    00236         virtual void setCompressionType( const std::string &, int = -1 ) = 0;
    00237         virtual void setPixelType( const std::string & ) = 0;
    00238         virtual void finalizeSettings() = 0;
    00239
    00240         virtual void setPosition( const vigra::Diff2D & /*pos*/ )
    00241         {
    00242         }
    00243         virtual void setCanvasSize( const vigra::Size2D & /*size*/)
    00244         {
    00245         }
    00246         virtual void setXResolution( float /*xres*/ )
    00247         {
    00248         }
    00249         virtual void setYResolution( float /*yres*/ )
    00250         {
    00251         }
    00252
    00253         typedef ArrayVector<unsigned char> ICCProfile;
    00254
    00255         virtual void setICCProfile(const ICCProfile & /* data */)
    00256         {
    00257         }
    00258
    00259         virtual void * currentScanlineOfBand( unsigned int ) = 0;
    00260         virtual void nextScanline() = 0;
    00261
    00262         struct TIFFCompressionException {};
    00263     };
    00264
    00265     // codec factory for registration at the codec manager
    00266
    00267     struct CodecFactory
    00268     {
    00269         virtual CodecDesc getCodecDesc() const = 0;
    00270         virtual VIGRA_UNIQUE_PTR<Decoder> getDecoder() const = 0;
    00271         virtual VIGRA_UNIQUE_PTR<Encoder> getEncoder() const = 0;
    00272         virtual ~CodecFactory() {};
    00273     };
    00274
    00275     // factory functions to encapsulate the codec managers
    00276     //
    00277     // codecs are selected according to the following order:
    00278     // - (if provided) the FileType
    00279     // - (in case of decoders) the file's magic string
    00280     // - the filename extension
    00281
    00282     VIGRA_EXPORT VIGRA_UNIQUE_PTR<Decoder>
    00283     getDecoder( const std::string &, const std::string & = "undefined", unsigned int = 0 );
    00284
    00285     VIGRA_EXPORT VIGRA_UNIQUE_PTR<Encoder>
    00286     getEncoder( const std::string &, const std::string & = "undefined", const std::string & = "w" );
    00287
    00288     VIGRA_EXPORT std::string
    00289     getEncoderType( const std::string &, const std::string & = "undefined" );
    00290
    00291     // functions to query the capabilities of certain codecs
    00292
    00293     VIGRA_EXPORT std::vector<std::string> queryCodecPixelTypes( const std::string & );
    00294
    00295     VIGRA_EXPORT bool negotiatePixelType( std::string const & codecname,
    00296                  std::string const & srcPixeltype, std::string & destPixeltype);
    00297
    00298     VIGRA_EXPORT bool isPixelTypeSupported( const std::string &, const std::string & );
    00299
    00300     VIGRA_EXPORT bool isBandNumberSupported( const std::string &, int bands );
    00301 }
    00302
    00303 #endif // VIGRA_CODEC_HXX

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python vigra 1.9.0 (Tue Nov 6 2012)