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

| vigra/codec.hxx |
--- | --- | ---

    00001 /************************************************************************/
    00002 /*                                                                      */
    00003 /*               Copyright 2001-2002 by Gunnar Kedenburg                */
    00004 /*       Cognitive Systems Group, University of Hamburg, Germany        */
    00005 /*                                                                      */
    00006 /*    This file is part of the VIGRA computer vision library.           */
    00007 /*    ( Version 1.4.0, Dec 21 2005 )                                    */
    00008 /*    The VIGRA Website is                                              */
    00009 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
    00010 /*    Please direct questions, bug reports, and contributions to        */
    00011 /*        koethe@informatik.uni-hamburg.de          or                  */
    00012 /*        vigra@kogs1.informatik.uni-hamburg.de                         */
    00013 /*                                                                      */
    00014 /*    Permission is hereby granted, free of charge, to any person       */
    00015 /*    obtaining a copy of this software and associated documentation    */
    00016 /*    files (the "Software"), to deal in the Software without           */
    00017 /*    restriction, including without limitation the rights to use,      */
    00018 /*    copy, modify, merge, publish, distribute, sublicense, and/or      */
    00019 /*    sell copies of the Software, and to permit persons to whom the    */
    00020 /*    Software is furnished to do so, subject to the following          */
    00021 /*    conditions:                                                       */
    00022 /*                                                                      */
    00023 /*    The above copyright notice and this permission notice shall be    */
    00024 /*    included in all copies or substantial portions of the             */
    00025 /*    Software.                                                         */
    00026 /*                                                                      */
    00027 /*    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND    */
    00028 /*    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   */
    00029 /*    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          */
    00030 /*    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT       */
    00031 /*    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,      */
    00032 /*    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING      */
    00033 /*    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR     */
    00034 /*    OTHER DEALINGS IN THE SOFTWARE.                                   */
    00035 /*                                                                      */
    00036 /************************************************************************/
    00037
    00038 #ifndef VIGRA_CODEC_HXX
    00039 #define VIGRA_CODEC_HXX
    00040
    00041 #include <memory>
    00042 #include <string>
    00043 #include <vector>
    00044
    00045 // possible pixel types:
    00046 // "undefined", "UINT8", "INT16", "INT32", "FLOAT", "DOUBLE"
    00047
    00048 // possible compression types:
    00049 // "undefined", "RLE", "LZW", "LOSSLESS", "JPEG"
    00050
    00051 // possible file types:
    00052 // "undefined", "TIFF", "VIFF", "JPEG", "PNG", "PNM", "BMP", "SUN", "XPM"
    00053
    00054 // possible name extensions:
    00055 // "undefined", "tif", "tiff", "jpg", "jpeg", "png", "pnm", "bmp", "sun",
    00056 // "xpm" (also capital forms)
    00057
    00058 namespace vigra
    00059 {
    00060     template <class T>
    00061     struct TypeAsString
    00062     {
    00063         static std::string result() { return "undefined"; }
    00064     };
    00065
    00066     template <>
    00067     struct TypeAsString<unsigned char>
    00068     {
    00069         static std::string result() { return "UINT8"; }
    00070     };
    00071
    00072     template <>
    00073     struct TypeAsString<short>
    00074     {
    00075         static std::string result() { return "INT16"; }
    00076     };
    00077
    00078     template <>
    00079     struct TypeAsString<int>
    00080     {
    00081         static std::string result() { return "INT32"; }
    00082     };
    00083
    00084     template <>
    00085     struct TypeAsString<long>
    00086     {
    00087         static std::string result() { return "INT32"; }
    00088     };
    00089
    00090     template <>
    00091     struct TypeAsString<float>
    00092     {
    00093         static std::string result() { return "FLOAT"; }
    00094     };
    00095
    00096     template <>
    00097     struct TypeAsString<double>
    00098     {
    00099         static std::string result() { return "DOUBLE"; }
    00100     };
    00101
    00102
    00103     // codec description
    00104     struct CodecDesc
    00105     {
    00106         std::string fileType;
    00107         std::vector<std::string> pixelTypes;
    00108         std::vector<std::string> compressionTypes;
    00109         std::vector<std::vector<char> > magicStrings;
    00110         std::vector<std::string> fileExtensions;
    00111         std::vector<int> bandNumbers;
    00112     };
    00113
    00114     // Decoder and Encoder are pure virtual types that define a common
    00115     // interface for all image file formats impex supports.
    00116
    00117     struct Decoder
    00118     {
    00119         virtual ~Decoder() {};
    00120         virtual void init( const std::string & ) = 0;
    00121         virtual void close() = 0;
    00122         virtual void abort() = 0;
    00123
    00124         virtual std::string getFileType() const = 0;
    00125         virtual std::string getPixelType() const = 0;
    00126
    00127         virtual unsigned int getWidth() const = 0;
    00128         virtual unsigned int getHeight() const = 0;
    00129         virtual unsigned int getNumBands() const = 0;
    00130         virtual unsigned int getOffset() const = 0;
    00131
    00132         virtual const void * currentScanlineOfBand( unsigned int ) const = 0;
    00133         virtual void nextScanline() = 0;
    00134     };
    00135
    00136     struct Encoder
    00137     {
    00138         virtual ~Encoder() {};
    00139         virtual void init( const std::string & ) = 0;
    00140         virtual void close() = 0;
    00141         virtual void abort() = 0;
    00142
    00143         virtual std::string getFileType() const = 0;
    00144         virtual unsigned int getOffset() const = 0;
    00145
    00146         virtual void setWidth( unsigned int ) = 0;
    00147         virtual void setHeight( unsigned int ) = 0;
    00148         virtual void setNumBands( unsigned int ) = 0;
    00149         virtual void setCompressionType( const std::string &, int = -1 ) = 0;
    00150         virtual void setPixelType( const std::string & ) = 0;
    00151         virtual void finalizeSettings() = 0;
    00152
    00153         virtual void * currentScanlineOfBand( unsigned int ) = 0;
    00154         virtual void nextScanline() = 0;
    00155
    00156         struct TIFFNoLZWException {};
    00157     };
    00158
    00159     // codec factory for registration at the codec manager
    00160
    00161     struct CodecFactory
    00162     {
    00163         virtual CodecDesc getCodecDesc() const = 0;
    00164         virtual std::auto_ptr<Decoder> getDecoder() const = 0;
    00165         virtual std::auto_ptr<Encoder> getEncoder() const = 0;
    00166     };
    00167
    00168     // factory functions to encapsulate the codec managers
    00169     //
    00170     // codecs are selected according to the following order:
    00171     // - (if provided) the FileType
    00172     // - (in case of decoders) the file's magic string
    00173     // - the filename extension
    00174
    00175     std::auto_ptr<Decoder>
    00176     getDecoder( const std::string &, const std::string & = "undefined" );
    00177
    00178     std::auto_ptr<Encoder>
    00179     getEncoder( const std::string &, const std::string & = "undefined" );
    00180
    00181     // functions to query the capabilities of certain codecs
    00182
    00183     std::vector<std::string> queryCodecPixelTypes( const std::string & );
    00184
    00185     bool negotiatePixelType( std::string const & codecname,
    00186                  std::string const & srcPixeltype, std::string & destPixeltype);
    00187
    00188     bool isPixelTypeSupported( const std::string &, const std::string & );
    00189
    00190     bool isBandNumberSupported( const std::string &, int bands );
    00191 }
    00192
    00193 #endif // VIGRA_CODEC_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de) Cognitive Systems Group, University of Hamburg, Germany | html generated using doxygen and Python VIGRA 1.4.0 (21 Dec 2005)