TinyExif.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
namespace NDEVR
{

    enum ErrorCode {
        PARSE_SUCCESS = 0,            
        PARSE_INVALID_JPEG = 1,       
        PARSE_UNKNOWN_BYTEALIGN = 2,  
        PARSE_ABSENT_DATA = 3,        
        PARSE_CORRUPT_DATA = 4,       
    };

    enum FieldCode {
        FIELD_NA = 0,                        
        FIELD_EXIF = (1 << 0),               
        FIELD_XMP = (1 << 1),                
        FIELD_ALL = FIELD_EXIF | FIELD_XMP   
    };
 
    class EntryParser;

    class NDEVR_DESIGN_API EXIFStream {
    public:
        virtual ~EXIFStream() {}

        virtual bool IsValid() const = 0;

        virtual const uint8_t* GetBuffer(unsigned desiredLength) = 0;

        virtual bool SkipBuffer(unsigned desiredLength) = 0;
    };

    class NDEVR_DESIGN_API EXIFInfo {
    public:
        EXIFInfo();

        EXIFInfo(EXIFStream& stream);

        EXIFInfo(std::istream& stream);

        EXIFInfo(const uint8_t* data, unsigned length);

        int parseFrom(EXIFStream& stream);

        int parseFrom(std::istream& stream);

        int parseFrom(const uint8_t* data, unsigned length);

        int parseFromEXIFSegment(const uint8_t* buf, unsigned len);
 
#ifndef TINYEXIF_NO_XMP_SUPPORT
        int parseFromXMPSegment(const uint8_t* buf, unsigned len);

        int parseFromXMPSegmentXML(const char* szXML, unsigned len);
#endif // TINYEXIF_NO_XMP_SUPPORT

        void clear();
 
    private:
        void parseIFDImage(EntryParser&, unsigned&, unsigned&);

        void parseIFDExif(EntryParser&);

        void parseIFDGPS(EntryParser&);

        void parseIFDMakerNote(EntryParser&);
 
    public:
        uint32_t Fields;                    
        uint32_t ImageWidth;                
        uint32_t ImageHeight;               
        uint32_t RelatedImageWidth;         
        uint32_t RelatedImageHeight;        
        String ImageDescription;            
        String Make;                        
        String Model;                       
        String SerialNumber;                
        uint16_t Orientation;               
        double XResolution;                 
        double YResolution;                 
        uint16_t ResolutionUnit;            
        uint16_t BitsPerSample;             
        String Software;                    
        String DateTime;                    
        String DateTimeOriginal;            
        String DateTimeDigitized;           
        String SubSecTimeOriginal;          
        String Copyright;                   
        double ExposureTime;                
        double FNumber;                     
        uint16_t ExposureProgram;           
        uint16_t ISOSpeedRatings;           
        double ShutterSpeedValue;           
        double ApertureValue;               
        double BrightnessValue;             
        double ExposureBiasValue;           
        double SubjectDistance;             
        double FocalLength;                 
        uint16_t Flash;                     
        uint16_t MeteringMode;              
        uint16_t LightSource;              
        uint16_t ProjectionType;            
        Buffer<uint16_t> SubjectArea;       

        struct NDEVR_DESIGN_API Calibration_t {
            double FocalLength;             
            double OpticalCenterX;          
            double OpticalCenterY;          
        } Calibration;                      

        struct NDEVR_DESIGN_API LensInfo_t {
            double FStopMin;                
            double FStopMax;                
            double FocalLengthMin;          
            double FocalLengthMax;          
            double DigitalZoomRatio;        
            double FocalLengthIn35mm;       
            double FocalPlaneXResolution;   
            double FocalPlaneYResolution;   
            uint16_t FocalPlaneResolutionUnit; 
            String Make;                    
            String Model;                   
        } LensInfo;                         

        struct NDEVR_DESIGN_API Geolocation_t {
            double Latitude;                
            double Longitude;               
            double Altitude;                
            int8_t AltitudeRef;             
            double RelativeAltitude;        
            double RollDegree;              
            double PitchDegree;             
            double YawDegree;               
            double SpeedX;                  
            double SpeedY;                  
            double SpeedZ;                  
            double AccuracyXY;              
            double AccuracyZ;               
            double GPSDOP;                  
            uint16_t GPSDifferential;       
            String GPSMapDatum;             
            String GPSTimeStamp;            
            String GPSDateStamp;            

            struct Coord_t {
                double degrees;             
                double minutes;             
                double seconds;             
                uint8_t direction;          
            } LatComponents,                
              LonComponents;                

            void parseCoords();

            bool hasLatLon() const;

            bool hasAltitude() const;

            bool hasRelativeAltitude()const;

            bool hasOrientation() const;

            bool hasSpeed() const;
        } GeoLocation;                      

        struct NDEVR_DESIGN_API GPano_t {
            double PosePitchDegrees;        
            double PoseRollDegrees;         

            bool hasPosePitchDegrees() const;

            bool hasPoseRollDegrees() const;
        } GPano;                            

        struct NDEVR_DESIGN_API MicroVideo_t {
            uint32_t HasMicroVideo;         
            uint32_t MicroVideoVersion;     
            uint32_t MicroVideoOffset;      
        } MicroVideo;                       
    };
 
} // namespace TinyEXIF