[ 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.3.2, Jan 27 2005 )                                    */
    00008 /*    You may use, modify, and distribute this software according       */
    00009 /*    to the terms stated in the LICENSE file included in               */
    00010 /*    the VIGRA distribution.                                           */
    00011 /*                                                                      */
    00012 /*    The VIGRA Website is                                              */
    00013 /*        http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/      */
    00014 /*    Please direct questions, bug reports, and contributions to        */
    00015 /*        koethe@informatik.uni-hamburg.de                              */
    00016 /*                                                                      */
    00017 /*  THIS SOFTWARE IS PROVIDED AS IS AND WITHOUT ANY EXPRESS OR          */
    00018 /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED      */
    00019 /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. */
    00020 /*                                                                      */
    00021 /************************************************************************/
    00022
    00023 #ifndef VIGRA_CODEC_HXX
    00024 #define VIGRA_CODEC_HXX
    00025
    00026 #include <memory>
    00027 #include <string>
    00028 #include <vector>
    00029
    00030 // possible pixel types:
    00031 // "undefined", "UINT8", "INT16", "INT32", "FLOAT", "DOUBLE"
    00032
    00033 // possible compression types:
    00034 // "undefined", "RLE", "LZW", "LOSSLESS", "JPEG"
    00035
    00036 // possible file types:
    00037 // "undefined", "TIFF", "VIFF", "JPEG", "PNG", "PNM", "BMP", "SUN", "XPM"
    00038
    00039 // possible name extensions:
    00040 // "undefined", "tif", "tiff", "jpg", "jpeg", "png", "pnm", "bmp", "sun",
    00041 // "xpm" (also capital forms)
    00042
    00043 namespace vigra
    00044 {
    00045     template <class T>
    00046     struct TypeAsString
    00047     {
    00048         static std::string result() { return "undefined"; }
    00049     };
    00050
    00051     template <>
    00052     struct TypeAsString<unsigned char>
    00053     {
    00054         static std::string result() { return "UINT8"; }
    00055     };
    00056
    00057     template <>
    00058     struct TypeAsString<short>
    00059     {
    00060         static std::string result() { return "INT16"; }
    00061     };
    00062
    00063     template <>
    00064     struct TypeAsString<int>
    00065     {
    00066         static std::string result() { return "INT32"; }
    00067     };
    00068
    00069     template <>
    00070     struct TypeAsString<long>
    00071     {
    00072         static std::string result() { return "INT32"; }
    00073     };
    00074
    00075     template <>
    00076     struct TypeAsString<float>
    00077     {
    00078         static std::string result() { return "FLOAT"; }
    00079     };
    00080
    00081     template <>
    00082     struct TypeAsString<double>
    00083     {
    00084         static std::string result() { return "DOUBLE"; }
    00085     };
    00086
    00087
    00088     // codec description
    00089     struct CodecDesc
    00090     {
    00091         std::string fileType;
    00092         std::vector<std::string> pixelTypes;
    00093         std::vector<std::string> compressionTypes;
    00094         std::vector<std::vector<char> > magicStrings;
    00095         std::vector<std::string> fileExtensions;
    00096         std::vector<int> bandNumbers;
    00097     };
    00098
    00099     // Decoder and Encoder are pure virtual types that define a common
    00100     // interface for all image file formats impex supports.
    00101
    00102     struct Decoder
    00103     {
    00104         virtual ~Decoder() {};
    00105         virtual void init( const std::string & ) = 0;
    00106         virtual void close() = 0;
    00107         virtual void abort() = 0;
    00108
    00109         virtual std::string getFileType() const = 0;
    00110         virtual std::string getPixelType() const = 0;
    00111
    00112         virtual unsigned int getWidth() const = 0;
    00113         virtual unsigned int getHeight() const = 0;
    00114         virtual unsigned int getNumBands() const = 0;
    00115         virtual unsigned int getOffset() const = 0;
    00116
    00117         virtual const void * currentScanlineOfBand( unsigned int ) const = 0;
    00118         virtual void nextScanline() = 0;
    00119     };
    00120
    00121     struct Encoder
    00122     {
    00123         virtual ~Encoder() {};
    00124         virtual void init( const std::string & ) = 0;
    00125         virtual void close() = 0;
    00126         virtual void abort() = 0;
    00127
    00128         virtual std::string getFileType() const = 0;
    00129         virtual unsigned int getOffset() const = 0;
    00130
    00131         virtual void setWidth( unsigned int ) = 0;
    00132         virtual void setHeight( unsigned int ) = 0;
    00133         virtual void setNumBands( unsigned int ) = 0;
    00134         virtual void setCompressionType( const std::string &, int = -1 ) = 0;
    00135         virtual void setPixelType( const std::string & ) = 0;
    00136         virtual void finalizeSettings() = 0;
    00137
    00138         virtual void * currentScanlineOfBand( unsigned int ) = 0;
    00139         virtual void nextScanline() = 0;
    00140
    00141         struct TIFFNoLZWException {};
    00142     };
    00143
    00144     // codec factory for registration at the codec manager
    00145
    00146     struct CodecFactory
    00147     {
    00148         virtual CodecDesc getCodecDesc() const = 0;
    00149         virtual std::auto_ptr<Decoder> getDecoder() const = 0;
    00150         virtual std::auto_ptr<Encoder> getEncoder() const = 0;
    00151     };
    00152
    00153     // factory functions to encapsulate the codec managers
    00154     //
    00155     // codecs are selected according to the following order:
    00156     // - (if provided) the FileType
    00157     // - (in case of decoders) the file's magic string
    00158     // - the filename extension
    00159
    00160     std::auto_ptr<Decoder>
    00161     getDecoder( const std::string &, const std::string & = "undefined" );
    00162
    00163     std::auto_ptr<Encoder>
    00164     getEncoder( const std::string &, const std::string & = "undefined" );
    00165
    00166     // functions to query the capabilities of certain codecs
    00167
    00168     std::vector<std::string> queryCodecPixelTypes( const std::string & );
    00169
    00170     bool negotiatePixelType( std::string const & codecname,
    00171                  std::string const & srcPixeltype, std::string & destPixeltype);
    00172
    00173     bool isPixelTypeSupported( const std::string &, const std::string & );
    00174
    00175     bool isBandNumberSupported( const std::string &, int bands );
    00176 }
    00177
    00178 #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.3.2 (27 Jan 2005)