jpgimage.hpp

// ***************************************************************** -*- C++ -*-
/*
 * Copyright (C) 2004-2021 Exiv2 authors
 * This program is part of the Exiv2 distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
 */
 
#ifndef JPGIMAGE_HPP_
#define JPGIMAGE_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
// included header files
#include "image.hpp"
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
 
// *****************************************************************************
// class definitions
 
    // Supported JPEG image formats
    namespace ImageType {
        const int jpeg = 1;         
        const int exv  = 2;         
    }

    struct EXIV2API Photoshop {
        // Todo: Public for now
        static const char     ps3Id_[]; 
        static const char*    irbId_[]; 
        static const char     bimId_[]; 
        static const uint16_t iptc_;    
        static const uint16_t preview_; 

        static bool isIrb(const byte* pPsData,
                          long        sizePsData);
        static bool valid(const byte* pPsData,
                          long        sizePsData);
        static int locateIrb(const byte *pPsData,
                             long sizePsData,
                             uint16_t psTag,
                             const byte **record,
                             uint32_t *const sizeHdr,
                             uint32_t *const sizeData);
        static int locateIptcIrb(const byte *pPsData,
                                 long sizePsData,
                                 const byte **record,
                                 uint32_t *const sizeHdr,
                                 uint32_t *const sizeData);
        static int locatePreviewIrb(const byte *pPsData,
                                    long sizePsData,
                                    const byte **record,
                                    uint32_t *const sizeHdr,
                                    uint32_t *const sizeData);
        static DataBuf setIptcIrb(const byte*     pPsData,
                                  long            sizePsData,
                                  const IptcData& iptcData);
 
    }; // class Photoshop

    class EXIV2API JpegBase : public Image {
    public:

        void readMetadata();
        void writeMetadata();

        void printStructure(std::ostream& out, PrintStructureOption option,int depth);
 
    protected:


        JpegBase(int              type,
                 BasicIo::AutoPtr io,
                 bool             create,
                 const byte       initData[],
                 long             dataSize);



        virtual bool isThisType(BasicIo& iIo, bool advance) const =0;



        virtual int writeHeader(BasicIo& oIo) const =0;
 
        // Constant Data
        static const byte dht_;                 
        static const byte dqt_;                 
        static const byte dri_;                 
        static const byte sos_;                 
        static const byte eoi_;                 
        static const byte app0_;                
        static const byte app1_;                
        static const byte app2_;                
        static const byte app13_;               
        static const byte com_;                 
        static const byte sof0_;                
        static const byte sof1_;                
        static const byte sof2_;                
        static const byte sof3_;                
        static const byte sof5_;                
        static const byte sof6_;                
        static const byte sof7_;                
        static const byte sof9_;                
        static const byte sof10_;               
        static const byte sof11_;               
        static const byte sof13_;               
        static const byte sof14_;               
        static const byte sof15_;               
        static const char exifId_[];            
        static const char jfifId_[];            
        static const char xmpId_[];             
        static const char iccId_[];             
 
    private:


        JpegBase();
        JpegBase(const JpegBase& rhs);
        JpegBase& operator=(const JpegBase& rhs);



        int initImage(const byte initData[], long dataSize);
        void doWriteMetadata(BasicIo& oIo);



        int advanceToMarker() const;
 
    }; // class JpegBase

    class EXIV2API JpegImage : public JpegBase {
        friend EXIV2API bool isJpegType(BasicIo& iIo, bool advance);
    public:


        JpegImage(BasicIo::AutoPtr io, bool create);

        std::string mimeType() const;
 
    protected:

        bool isThisType(BasicIo& iIo, bool advance) const;


        int writeHeader(BasicIo& oIo) const;
 
    private:
        // Constant data
        static const byte soi_;          // SOI marker
        static const byte blank_[];      // Minimal Jpeg image
 
        // NOT Implemented
        JpegImage();
        JpegImage(const JpegImage& rhs);
        JpegImage& operator=(const JpegImage& rhs);
 
    }; // class JpegImage

    class EXIV2API ExvImage : public JpegBase {
        friend EXIV2API bool isExvType(BasicIo& iIo, bool advance);
    public:


        ExvImage(BasicIo::AutoPtr io, bool create);

        std::string mimeType() const;
 
    protected:

        bool isThisType(BasicIo& iIo, bool advance) const;

        int writeHeader(BasicIo& oIo) const;
 
    private:
        // Constant data
        static const char exiv2Id_[];    // EXV identifier
        static const byte blank_[];      // Minimal exiv2 file
 
        // NOT Implemented
        ExvImage();
        ExvImage(const ExvImage& rhs);
        ExvImage& operator=(const ExvImage& rhs);
 
    }; // class ExvImage
 
// *****************************************************************************
// template, inline and free functions
 
    // These could be static private functions on Image subclasses but then
    // ImageFactory needs to be made a friend.
    EXIV2API Image::AutoPtr newJpegInstance(BasicIo::AutoPtr io, bool create);
    EXIV2API bool isJpegType(BasicIo& iIo, bool advance);
    EXIV2API Image::AutoPtr newExvInstance(BasicIo::AutoPtr io, bool create);
    EXIV2API bool isExvType(BasicIo& iIo, bool advance);
 
}                                       // namespace Exiv2
 
#endif                                  // #ifndef JPGIMAGE_HPP_