Home | History | Annotate | Download | only in jhead
      1 //--------------------------------------------------------------------------
      2 // Include file for jhead program.
      3 //
      4 // This include file only defines stuff that goes across modules.
      5 // I like to keep the definitions for macros and structures as close to
      6 // where they get used as possible, so include files only get stuff that
      7 // gets used in more than one file.
      8 //--------------------------------------------------------------------------
      9 #define _CRT_SECURE_NO_DEPRECATE 1
     10 
     11 #include <stdio.h>
     12 #include <stdlib.h>
     13 #include <string.h>
     14 #include <time.h>
     15 #include <errno.h>
     16 #include <ctype.h>
     17 #include <stdint.h>
     18 
     19 //--------------------------------------------------------------------------
     20 
     21 #ifdef _WIN32
     22     #include <sys/utime.h>
     23 #else
     24     #include <utime.h>
     25     #include <sys/types.h>
     26     #include <unistd.h>
     27     #include <errno.h>
     28     #include <limits.h>
     29 #endif
     30 
     31 
     32 typedef unsigned char uchar;
     33 
     34 #ifndef TRUE
     35     #define TRUE 1
     36     #define FALSE 0
     37 #endif
     38 
     39 #define MAX_COMMENT_SIZE 2000
     40 #define GPS_PROCESSING_METHOD_LEN 100
     41 
     42 #ifdef _WIN32
     43     #define PATH_MAX _MAX_PATH
     44     #define SLASH '\\'
     45 #else
     46     #define SLASH '/'
     47 #endif
     48 
     49 
     50 //--------------------------------------------------------------------------
     51 // This structure is used to store jpeg file sections in memory.
     52 typedef struct {
     53     uchar *  Data;
     54     int      Type;
     55     unsigned Size;
     56 }Section_t;
     57 
     58 extern int ExifSectionIndex;
     59 
     60 extern int DumpExifMap;
     61 
     62 #define MAX_DATE_COPIES 10
     63 
     64 typedef struct {
     65     uint32_t num;
     66     uint32_t denom;
     67 } rat_t;
     68 
     69 //--------------------------------------------------------------------------
     70 // This structure stores Exif header image elements in a simple manner
     71 // Used to store camera data as extracted from the various ways that it can be
     72 // stored in an exif header
     73 typedef struct {
     74     char  FileName     [PATH_MAX+1];
     75     time_t FileDateTime;
     76     unsigned FileSize;
     77     char  CameraMake   [32];
     78     char  CameraModel  [40];
     79     char  DateTime     [20];
     80     int   Height, Width;
     81     int   Orientation;
     82     int   IsColor;
     83     int   Process;
     84     int   FlashUsed;
     85     rat_t FocalLength;
     86     float ExposureTime;
     87     float ApertureFNumber;
     88     float Distance;
     89     float CCDWidth;
     90     float ExposureBias;
     91     float DigitalZoomRatio;
     92     int   FocalLength35mmEquiv; // Exif 2.2 tag - usually not present.
     93     int   Whitebalance;
     94     int   MeteringMode;
     95     int   ExposureProgram;
     96     int   ExposureMode;
     97     int   ISOequivalent;
     98     int   LightSource;
     99     int   DistanceRange;
    100 
    101     char  Comments[MAX_COMMENT_SIZE];
    102     int   CommentWidchars; // If nonzer, widechar comment, indicates number of chars.
    103 
    104     unsigned ThumbnailOffset;          // Exif offset to thumbnail
    105     unsigned ThumbnailSize;            // Size of thumbnail.
    106     unsigned LargestExifOffset;        // Last exif data referenced (to check if thumbnail is at end)
    107 
    108     char  ThumbnailAtEnd;              // Exif header ends with the thumbnail
    109                                        // (we can only modify the thumbnail if its at the end)
    110     int   ThumbnailSizeOffset;
    111 
    112     int  DateTimeOffsets[MAX_DATE_COPIES];
    113     int  numDateTimeTags;
    114 
    115     int GpsInfoPresent;
    116     char GpsLat[31];
    117     char GpsLatRaw[31];
    118     char GpsLatRef[2];
    119     char GpsLong[31];
    120     char GpsLongRaw[31];
    121     char GpsLongRef[2];
    122     char GpsAlt[20];
    123     rat_t GpsAltRaw;
    124     char GpsAltRef;
    125     // gps-datestamp is 11 bytes ascii in EXIF 2.2
    126     char GpsDateStamp[11];
    127     char GpsTimeStamp[11];
    128     char GpsProcessingMethod[GPS_PROCESSING_METHOD_LEN + 1];
    129 }ImageInfo_t;
    130 
    131 
    132 
    133 #define EXIT_FAILURE  1
    134 #define EXIT_SUCCESS  0
    135 
    136 // jpgfile.c functions
    137 typedef enum {
    138     READ_METADATA = 1,
    139     READ_IMAGE = 2,
    140     READ_ALL = 3
    141 }ReadMode_t;
    142 
    143 
    144 typedef struct {
    145     unsigned short Tag;     // tag value, i.e. TAG_MODEL
    146     int Format;             // format of data
    147     char* Value;            // value of data in string format
    148     int DataLength;         // length of string when format says Value is a string
    149     int GpsTag;             // bool - the tag is related to GPS info
    150 } ExifElement_t;
    151 
    152 
    153 typedef struct {
    154     unsigned short Tag;
    155     char * Desc;
    156     int Format;
    157     int DataLength;         // Number of elements in Format. -1 means any length.
    158 } TagTable_t;
    159 
    160 
    161 // prototypes for jhead.c functions
    162 void ErrFatal(char * msg);
    163 void ErrNonfatal(char * msg, int a1, int a2);
    164 void FileTimeAsString(char * TimeStr);
    165 
    166 // Prototypes for exif.c functions.
    167 int Exif2tm(struct tm * timeptr, char * ExifTime);
    168 void process_EXIF (unsigned char * CharBuf, unsigned int length);
    169 int RemoveThumbnail(unsigned char * ExifSection);
    170 void ShowImageInfo(int ShowFileInfo);
    171 void ShowConciseImageInfo(void);
    172 const char * ClearOrientation(void);
    173 void PrintFormatNumber(void * ValuePtr, int Format, int ByteCount);
    174 double ConvertAnyFormat(void * ValuePtr, int Format);
    175 int Get16u(void * Short);
    176 unsigned Get32u(void * Long);
    177 int Get32s(void * Long);
    178 void Put32u(void * Value, unsigned PutValue);
    179 void create_EXIF(ExifElement_t* elements, int exifTagCount, int gpsTagCount, int hasDateTimeTag);
    180 int TagNameToValue(const char* tagName);
    181 int IsDateTimeTag(unsigned short tag);
    182 
    183 //--------------------------------------------------------------------------
    184 // Exif format descriptor stuff
    185 extern const int BytesPerFormat[];
    186 #define NUM_FORMATS 12
    187 
    188 #define FMT_BYTE       1
    189 #define FMT_STRING     2
    190 #define FMT_USHORT     3
    191 #define FMT_ULONG      4
    192 #define FMT_URATIONAL  5
    193 #define FMT_SBYTE      6
    194 #define FMT_UNDEFINED  7
    195 #define FMT_SSHORT     8
    196 #define FMT_SLONG      9
    197 #define FMT_SRATIONAL 10
    198 #define FMT_SINGLE    11
    199 #define FMT_DOUBLE    12
    200 
    201 
    202 // makernote.c prototypes
    203 extern void ProcessMakerNote(unsigned char * DirStart, int ByteCount,
    204                  unsigned char * OffsetBase, unsigned ExifLength);
    205 
    206 // gpsinfo.c prototypes
    207 void ProcessGpsInfo(unsigned char * ValuePtr, int ByteCount,
    208                 unsigned char * OffsetBase, unsigned ExifLength);
    209 int IsGpsTag(const char* tag);
    210 int GpsTagToFormatType(unsigned short tag);
    211 int GpsTagNameToValue(const char* tagName);
    212 TagTable_t* GpsTagToTagTableEntry(unsigned short tag);
    213 static const char ExifAsciiPrefix[] = { 0x41, 0x53, 0x43, 0x49, 0x49, 0x0, 0x0, 0x0 };
    214 
    215 // iptc.c prototpyes
    216 void show_IPTC (unsigned char * CharBuf, unsigned int length);
    217 void ShowXmp(Section_t XmpSection);
    218 
    219 // Prototypes for myglob.c module
    220 #ifdef _WIN32
    221 void MyGlob(const char * Pattern , void (*FileFuncParm)(const char * FileName));
    222 void SlashToNative(char * Path);
    223 #endif
    224 
    225 // Prototypes for paths.c module
    226 int EnsurePathExists(const char * FileName);
    227 void CatPath(char * BasePath, const char * FilePath);
    228 
    229 // Prototypes from jpgfile.c
    230 int ReadJpegSections (FILE * infile, ReadMode_t ReadMode);
    231 void DiscardData(void);
    232 void DiscardAllButExif(void);
    233 int ReadJpegFile(const char * FileName, ReadMode_t ReadMode);
    234 int ReplaceThumbnail(const char * ThumbFileName);
    235 int ReplaceThumbnailFromBuffer(const char* Thumb, int ThumbLen);
    236 int SaveThumbnail(char * ThumbFileName);
    237 int RemoveSectionType(int SectionType);
    238 int RemoveUnknownSections(void);
    239 int WriteJpegFile(const char * FileName);
    240 Section_t * FindSection(int SectionType);
    241 Section_t * CreateSection(int SectionType, unsigned char * Data, int size);
    242 void ResetJpgfile(void);
    243 int ReadJpegSectionsFromBuffer (unsigned char* buffer, unsigned int buffer_size, ReadMode_t ReadMode);
    244 int WriteJpegToBuffer(unsigned char* buffer, unsigned int buffer_size);
    245 
    246 // Variables from jhead.c used by exif.c
    247 extern ImageInfo_t ImageInfo;
    248 extern int ShowTags;
    249 extern char* formatStr(int format);
    250 
    251 //--------------------------------------------------------------------------
    252 // JPEG markers consist of one or more 0xFF bytes, followed by a marker
    253 // code byte (which is not an FF).  Here are the marker codes of interest
    254 // in this program.  (See jdmarker.c for a more complete list.)
    255 //--------------------------------------------------------------------------
    256 
    257 #define M_SOF0  0xC0          // Start Of Frame N
    258 #define M_SOF1  0xC1          // N indicates which compression process
    259 #define M_SOF2  0xC2          // Only SOF0-SOF2 are now in common use
    260 #define M_SOF3  0xC3
    261 #define M_SOF5  0xC5          // NB: codes C4 and CC are NOT SOF markers
    262 #define M_SOF6  0xC6
    263 #define M_SOF7  0xC7
    264 #define M_SOF9  0xC9
    265 #define M_SOF10 0xCA
    266 #define M_SOF11 0xCB
    267 #define M_SOF13 0xCD
    268 #define M_SOF14 0xCE
    269 #define M_SOF15 0xCF
    270 #define M_SOI   0xD8          // Start Of Image (beginning of datastream)
    271 #define M_EOI   0xD9          // End Of Image (end of datastream)
    272 #define M_SOS   0xDA          // Start Of Scan (begins compressed data)
    273 #define M_JFIF  0xE0          // Jfif marker
    274 #define M_EXIF  0xE1          // Exif marker.  Also used for XMP data!
    275 #define M_XMP   0x10E1        // Not a real tag (same value in file as Exif!)
    276 #define M_COM   0xFE          // COMment
    277 #define M_DQT   0xDB
    278 #define M_DHT   0xC4
    279 #define M_DRI   0xDD
    280 #define M_IPTC  0xED          // IPTC marker
    281