rjhead 0.2.88

data/ext/jhead.h

@@ -0,0 +1,251 @@
+//--------------------------------------------------------------------------
+// Include file for jhead program.
+//
+// This include file only defines stuff that goes across modules.  
+// I like to keep the definitions for macros and structures as close to 
+// where they get used as possible, so include files only get stuff that 
+// gets used in more than one file.
+//--------------------------------------------------------------------------
+#define _CRT_SECURE_NO_DEPRECATE 1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <ctype.h>
+
+//--------------------------------------------------------------------------
+
+#ifdef _WIN32
+    #include <sys/utime.h>
+#else
+    #include <utime.h>
+    #include <sys/types.h>
+    #include <unistd.h>
+    #include <errno.h>
+    #include <limits.h>
+#endif
+
+
+typedef unsigned char uchar;
+
+#ifndef TRUE
+    #define TRUE 1
+    #define FALSE 0
+#endif
+
+#define MAX_COMMENT_SIZE 2000
+
+#ifdef _WIN32
+    #define PATH_MAX _MAX_PATH
+    #define SLASH '\\'
+#else
+    #define SLASH '/'
+#endif
+
+
+//--------------------------------------------------------------------------
+// This structure is used to store jpeg file sections in memory.
+typedef struct {
+    uchar *  Data;
+    int      Type;
+    unsigned Size;
+}Section_t;
+
+extern int ExifSectionIndex;
+
+extern int DumpExifMap;
+
+#define MAX_DATE_COPIES 10
+
+//--------------------------------------------------------------------------
+// This structure stores Exif header image elements in a simple manner
+// Used to store camera data as extracted from the various ways that it can be
+// stored in an exif header
+typedef struct {
+    char  FileName     [PATH_MAX+1];
+    time_t FileDateTime;
+
+    struct {
+        // Info in the jfif header.
+        // This info is not used much - jhead used to just replace it with default
+        // values, and over 10 years, only two people pointed this out.
+        char  Present;
+        char  ResolutionUnits;
+        short XDensity;
+        short YDensity;
+    }JfifHeader;
+
+    unsigned FileSize;
+    char  CameraMake   [32];
+    char  CameraModel  [40];
+    char  DateTime     [20];
+    int   Height, Width;
+    int   Orientation;
+    int   IsColor;
+    int   Process;
+    int   FlashUsed;
+    float FocalLength;
+    float ExposureTime;
+    float ApertureFNumber;
+    float Distance;
+    float CCDWidth;
+    float ExposureBias;
+    float DigitalZoomRatio;
+    int   FocalLength35mmEquiv; // Exif 2.2 tag - usually not present.
+    int   Whitebalance;
+    int   MeteringMode;
+    int   ExposureProgram;
+    int   ExposureMode;
+    int   ISOequivalent;
+    int   LightSource;
+    int   DistanceRange;
+
+    float xResolution;
+    float yResolution;
+    int   ResolutionUnit;
+
+    char  Comments[MAX_COMMENT_SIZE];
+    int   CommentWidthchars; // If nonzero, widechar comment, indicates number of chars.
+
+    unsigned ThumbnailOffset;          // Exif offset to thumbnail
+    unsigned ThumbnailSize;            // Size of thumbnail.
+    unsigned LargestExifOffset;        // Last exif data referenced (to check if thumbnail is at end)
+
+    char  ThumbnailAtEnd;              // Exif header ends with the thumbnail
+                                       // (we can only modify the thumbnail if its at the end)
+    int   ThumbnailSizeOffset;
+
+    int  DateTimeOffsets[MAX_DATE_COPIES];
+    int  numDateTimeTags;
+
+    int GpsInfoPresent;
+    char GpsLat[31];
+    char GpsLong[31];
+    char GpsAlt[20];
+}ImageInfo_t;
+
+
+
+#define EXIT_FAILURE  1
+#define EXIT_SUCCESS  0
+
+// jpgfile.c functions
+typedef enum {
+    READ_METADATA = 1,
+    READ_IMAGE = 2,
+    READ_ALL = 3
+}ReadMode_t;
+
+
+// prototypes for jhead.c functions
+void ErrFatal(char * msg);
+void ErrNonfatal(char * msg, int a1, int a2);
+void FileTimeAsString(char * TimeStr);
+
+// Prototypes for exif.c functions.
+int Exif2tm(struct tm * timeptr, char * ExifTime);
+void process_EXIF (unsigned char * CharBuf, unsigned int length);
+int RemoveThumbnail(unsigned char * ExifSection);
+void ShowImageInfo(int ShowFileInfo);
+void ShowConciseImageInfo(void);
+const char * ClearOrientation(void);
+void PrintFormatNumber(void * ValuePtr, int Format, int ByteCount);
+double ConvertAnyFormat(void * ValuePtr, int Format);
+int Get16u(void * Short);
+unsigned Get32u(void * Long);
+int Get32s(void * Long);
+void Put32u(void * Value, unsigned PutValue);
+void create_EXIF(void);
+
+//--------------------------------------------------------------------------
+// Exif format descriptor stuff
+extern const int BytesPerFormat[];
+#define NUM_FORMATS 12
+
+#define FMT_BYTE       1 
+#define FMT_STRING     2
+#define FMT_USHORT     3
+#define FMT_ULONG      4
+#define FMT_URATIONAL  5
+#define FMT_SBYTE      6
+#define FMT_UNDEFINED  7
+#define FMT_SSHORT     8
+#define FMT_SLONG      9
+#define FMT_SRATIONAL 10
+#define FMT_SINGLE    11
+#define FMT_DOUBLE    12
+
+
+// makernote.c prototypes
+extern void ProcessMakerNote(unsigned char * DirStart, int ByteCount,
+                 unsigned char * OffsetBase, unsigned ExifLength);
+
+// gpsinfo.c prototypes
+void ProcessGpsInfo(unsigned char * ValuePtr, int ByteCount, 
+                unsigned char * OffsetBase, unsigned ExifLength);
+
+// iptc.c prototpyes
+void show_IPTC (unsigned char * CharBuf, unsigned int length);
+void ShowXmp(Section_t XmpSection);
+
+// Prototypes for myglob.c module
+#ifdef _WIN32
+void MyGlob(const char * Pattern , void (*FileFuncParm)(const char * FileName));
+void SlashToNative(char * Path);
+#endif
+
+// Prototypes for paths.c module
+int EnsurePathExists(const char * FileName);
+void CatPath(char * BasePath, const char * FilePath);
+
+// Prototypes from jpgfile.c
+int ReadJpegSections (FILE * infile, ReadMode_t ReadMode);
+void DiscardData(void);
+void DiscardAllButExif(void);
+int ReadJpegFile(const char * FileName, ReadMode_t ReadMode);
+int ReplaceThumbnail(const char * ThumbFileName);
+int SaveThumbnail(char * ThumbFileName);
+int RemoveSectionType(int SectionType);
+int RemoveUnknownSections(void);
+void WriteJpegFile(const char * FileName);
+Section_t * FindSection(int SectionType);
+Section_t * CreateSection(int SectionType, unsigned char * Data, int size);
+void ResetJpgfile(void);
+
+
+// Variables from jhead.c used by exif.c
+extern ImageInfo_t ImageInfo;
+extern int ShowTags;
+
+//--------------------------------------------------------------------------
+// JPEG markers consist of one or more 0xFF bytes, followed by a marker
+// code byte (which is not an FF).  Here are the marker codes of interest
+// in this program.  (See jdmarker.c for a more complete list.)
+//--------------------------------------------------------------------------
+
+#define M_SOF0  0xC0          // Start Of Frame N
+#define M_SOF1  0xC1          // N indicates which compression process
+#define M_SOF2  0xC2          // Only SOF0-SOF2 are now in common use
+#define M_SOF3  0xC3
+#define M_SOF5  0xC5          // NB: codes C4 and CC are NOT SOF markers
+#define M_SOF6  0xC6
+#define M_SOF7  0xC7
+#define M_SOF9  0xC9
+#define M_SOF10 0xCA
+#define M_SOF11 0xCB
+#define M_SOF13 0xCD
+#define M_SOF14 0xCE
+#define M_SOF15 0xCF
+#define M_SOI   0xD8          // Start Of Image (beginning of datastream)
+#define M_EOI   0xD9          // End Of Image (end of datastream)
+#define M_SOS   0xDA          // Start Of Scan (begins compressed data)
+#define M_JFIF  0xE0          // Jfif marker
+#define M_EXIF  0xE1          // Exif marker.  Also used for XMP data!
+#define M_XMP   0x10E1        // Not a real tag (same value in file as Exif!)
+#define M_COM   0xFE          // COMment 
+#define M_DQT   0xDB
+#define M_DHT   0xC4
+#define M_DRI   0xDD
+#define M_IPTC  0xED          // IPTC marker

data/ext/jhead.spec

@@ -0,0 +1,149 @@
+# -----------------------------------------------------
+# Define static values
+# ----------------------------------------------------- 
+
+# -----------------------------------------------------
+# Define requirements for configure, BuildRequire,
+# Require and so on (depending on macros)
+# -----------------------------------------------------
+
+# -----------------------------------------------------
+# RPM-Information
+# -----------------------------------------------------
+Name:			jhead
+Summary:		Tool for handling EXIF metadata in JPEG image files
+
+Version:		2.88
+Release:		0
+
+Group:			Libraries
+License:		Public Domain
+URL:			http://www.sentex.net/~mwandel/jhead/
+
+Source:			http://www.sentex.net/~mwandel/jhead/%{name}-%{version}.tar.gz
+
+BuildRoot:		%{_tmppath}/%{name}-%{version}-root
+BuildRequires:		glibc-devel
+
+# -----------------------------------------------------
+# Package-Information (for main package)
+# -----------------------------------------------------
+%description
+This package provides a tool for displaying and manipulating non-image
+portions of EXIF format JPEG image files, as produced by most digital cameras.
+
+# -----------------------------------------------------
+# Prepare-Section
+# -----------------------------------------------------
+%prep
+%setup -q 
+
+# -----------------------------------------------------
+# Build-Section
+# -----------------------------------------------------
+%build
+make %{?_smp_mflags}
+
+# -----------------------------------------------------
+# Install-Section
+# -----------------------------------------------------
+%install
+mkdir -p %{buildroot}%{_bindir}
+cp jhead %{buildroot}%{_bindir}
+mkdir -p %{buildroot}%{_mandir}/man1/
+cp jhead.1.gz %{buildroot}%{_mandir}/man1/
+
+# -----------------------------------------------------
+# Clean-Section
+# -----------------------------------------------------
+%clean
+rm -rf %{buildroot}
+
+# -----------------------------------------------------
+# Files-Section (for main package)
+# -----------------------------------------------------
+%files
+%defattr(0644,root,root,0755)
+%attr(0755,root,root) %{_bindir}/*
+%doc readme.txt usage.html
+%{_mandir}/man1/jhead.1.gz
+
+# -----------------------------------------------------
+# Changelog-Section
+# -----------------------------------------------------
+%changelog
+
+* Fri Nov 6 2009 - 2.88
+- Added ability to move files around with the -n command
+- Various minor bugfixes and maintenance changes
+
+* Thu Mar 3 2009 - 2.87
+- Added the ability to move files with the -n option
+- Fix a bunch of breakages from security fixes asked
+  for by debian people
+
+* Sat Feb 14 2009 - 2.86
+- Added ability to move files around with the -n command
+- Various minor bugfixes and maintenance changes
+
+* Mon Oct 4 2008 - 2.84
+- decode more exif tags in -v mode
+- Fix gpsinfo altitude bug
+- Fix several potential stirng overflows
+
+* Thu Apr 03 2008 - 2.82
+- No longer delete XMP section on some operations
+- Improve IPTC display
+- Minor tweaks and cleanups
+
+* Tue Nov 13 2007 - 2.8
+- Limited IPTC handling
+- Added -q option
+- Fix handling of corrupted GPS directory.
+- Extract focus distance from canon makernote.
+- Extract subject range (pentax and fuji cameras)
+
+* Thu Jan 11 2007 - 2.7
+- Release version 2.7
+
+* Sat  Apr 29 2006 - 2.6
+- Release version 2.6
+
+* Sun Jan 08 2006 - 2.5
+- Release version 2.5
+
+* Thu Jun 10 2005 - 2.4-2
+- Minor fixups.
+
+* Sun May 29 2005 - 2.4
+- Display gps info
+- Added -da optino for large date adjust
+- Fix time reference bug for -ta option
+- Fix crashes with some corrupt jpeg files
+
+* Mon Jan 03 2005 - 2.4
+- Handle readonly files better
+- Handle more strange jpegs
+- added 'purejpg' option
+- Display digital zoom ratio
+
+* Sun Jun 20 2004 - 2.2-0
+- Various bug and spelling fixes.
+- added ability to do sequential renaming
+
+* Tue Jan 08 2004 Matthias Wandel <mwandel[at]sentex.net> - 2.1-0
+- Bumped version number to 2.1 for new jhead release.
+- Added -cl feature
+- added -noroot feature
+
+* Tue Jun 03 2003 Oliver Pitzeier <oliver@linux-kernel.at> - 2.0-3
+- Specfile cleanup/beautifying
+- Use _smp_mflags within make
+- Add versions to the changelog entries
+
+* Mon Apr 14 2003 Matthias Wandel <mwandel[at]sentex.net> - 2.0-2
+- First jhead 2.0 RPM built by me.
+- Finally wrote a nice man page for jhead
+- Using jhead 1.9 RPM from connectiva linux as starting point (left in the portugese tags)
+
+

data/ext/jpgfile.c

@@ -0,0 +1,738 @@
+//--------------------------------------------------------------------------
+// Program to pull the information out of various types of EXIF digital 
+// camera files and show it in a reasonably consistent way
+//
+// This module handles basic Jpeg file handling
+//
+// Matthias Wandel
+//--------------------------------------------------------------------------
+#include "jhead.h"
+
+// Storage for simplified info extracted from file.
+ImageInfo_t ImageInfo;
+
+
+static Section_t * Sections = NULL;
+static int SectionsAllocated;
+static int SectionsRead;
+static int HaveAll;
+
+
+
+#define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
+//--------------------------------------------------------------------------
+// Get 16 bits motorola order (always) for jpeg header stuff.
+//--------------------------------------------------------------------------
+static int Get16m(const void * Short)
+{
+    return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
+}
+
+
+//--------------------------------------------------------------------------
+// Process a COM marker.
+// We want to print out the marker contents as legible text;
+// we must guard against random junk and varying newline representations.
+//--------------------------------------------------------------------------
+static void process_COM (const uchar * Data, int length)
+{
+    int ch;
+    char Comment[MAX_COMMENT_SIZE+1];
+    int nch;
+    int a;
+
+    nch = 0;
+
+    if (length > MAX_COMMENT_SIZE) length = MAX_COMMENT_SIZE; // Truncate if it won't fit in our structure.
+
+    for (a=2;a<length;a++){
+        ch = Data[a];
+
+        if (ch == '\r' && Data[a+1] == '\n') continue; // Remove cr followed by lf.
+
+        if (ch >= 32 || ch == '\n' || ch == '\t'){
+            Comment[nch++] = (char)ch;
+        }else{
+            Comment[nch++] = '?';
+        }
+    }
+
+    Comment[nch] = '\0'; // Null terminate
+
+    if (ShowTags){
+        printf("COM marker comment: %s\n",Comment);
+    }
+
+    strcpy(ImageInfo.Comments,Comment);
+    ImageInfo.CommentWidthchars = 0;
+}
+
+ 
+//--------------------------------------------------------------------------
+// Process a SOFn marker.  This is useful for the image dimensions
+//--------------------------------------------------------------------------
+static void process_SOFn (const uchar * Data, int marker)
+{
+    int data_precision, num_components;
+
+    data_precision = Data[2];
+    ImageInfo.Height = Get16m(Data+3);
+    ImageInfo.Width = Get16m(Data+5);
+    num_components = Data[7];
+
+    if (num_components == 3){
+        ImageInfo.IsColor = 1;
+    }else{
+        ImageInfo.IsColor = 0;
+    }
+
+    ImageInfo.Process = marker;
+
+    if (ShowTags){
+        printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
+                   ImageInfo.Width, ImageInfo.Height, num_components, data_precision);
+    }
+}
+
+
+//--------------------------------------------------------------------------
+// Check sections array to see if it needs to be increased in size.
+//--------------------------------------------------------------------------
+void CheckSectionsAllocated(void)
+{
+    if (SectionsRead > SectionsAllocated){
+        ErrFatal("allocation screwup");
+    }
+    if (SectionsRead >= SectionsAllocated){
+        SectionsAllocated += SectionsAllocated/2;
+        Sections = (Section_t *)realloc(Sections, sizeof(Section_t)*SectionsAllocated);
+        if (Sections == NULL){
+            ErrFatal("could not allocate data for entire image");
+        }
+    }
+}
+
+
+//--------------------------------------------------------------------------
+// Parse the marker stream until SOS or EOI is seen;
+//--------------------------------------------------------------------------
+int ReadJpegSections (FILE * infile, ReadMode_t ReadMode)
+{
+    int a;
+    int HaveCom = FALSE;
+
+    a = fgetc(infile);
+
+    if (a != 0xff || fgetc(infile) != M_SOI){
+        return FALSE;
+    }
+
+    ImageInfo.JfifHeader.XDensity = ImageInfo.JfifHeader.YDensity = 300;
+    ImageInfo.JfifHeader.ResolutionUnits = 1;
+
+    for(;;){
+        int itemlen;
+        int prev;
+        int marker = 0;
+        int ll,lh, got;
+        uchar * Data;
+
+        CheckSectionsAllocated();
+
+        prev = 0;
+        for (a=0;;a++){
+            marker = fgetc(infile);
+            if (marker != 0xff && prev == 0xff) break;
+            prev = marker;
+        }
+
+        if (a > 10){
+            ErrNonfatal("Extraneous %d padding bytes before section %02X",a-1,marker);
+        }
+
+        Sections[SectionsRead].Type = marker;
+  
+        // Read the length of the section.
+        lh = fgetc(infile);
+        ll = fgetc(infile);
+
+        itemlen = (lh << 8) | ll;
+
+        if (itemlen < 2){
+            ErrFatal("invalid marker");
+        }
+
+        Sections[SectionsRead].Size = itemlen;
+
+        Data = (uchar *)malloc(itemlen);
+        if (Data == NULL){
+            ErrFatal("Could not allocate memory");
+        }
+        Sections[SectionsRead].Data = Data;
+
+        // Store first two pre-read bytes.
+        Data[0] = (uchar)lh;
+        Data[1] = (uchar)ll;
+
+        got = fread(Data+2, 1, itemlen-2, infile); // Read the whole section.
+        if (got != itemlen-2){
+            ErrFatal("Premature end of file?");
+        }
+        SectionsRead += 1;
+
+        switch(marker){
+
+            case M_SOS:   // stop before hitting compressed data 
+                // If reading entire image is requested, read the rest of the data.
+                if (ReadMode & READ_IMAGE){
+                    int cp, ep, size;
+                    // Determine how much file is left.
+                    cp = ftell(infile);
+                    fseek(infile, 0, SEEK_END);
+                    ep = ftell(infile);
+                    fseek(infile, cp, SEEK_SET);
+
+                    size = ep-cp;
+                    Data = (uchar *)malloc(size);
+                    if (Data == NULL){
+                        ErrFatal("could not allocate data for entire image");
+                    }
+
+                    got = fread(Data, 1, size, infile);
+                    if (got != size){
+                        ErrFatal("could not read the rest of the image");
+                    }
+
+                    CheckSectionsAllocated();
+                    Sections[SectionsRead].Data = Data;
+                    Sections[SectionsRead].Size = size;
+                    Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
+                    SectionsRead ++;
+                    HaveAll = 1;
+                }
+                return TRUE;
+
+            case M_EOI:   // in case it's a tables-only JPEG stream
+                fprintf(stderr,"No image in jpeg!\n");
+                return FALSE;
+
+            case M_COM: // Comment section
+                if (HaveCom || ((ReadMode & READ_METADATA) == 0)){
+                    // Discard this section.
+                    free(Sections[--SectionsRead].Data);
+                }else{
+                    process_COM(Data, itemlen);
+                    HaveCom = TRUE;
+                }
+                break;
+
+            case M_JFIF:
+                // Regular jpegs always have this tag, exif images have the exif
+                // marker instead, althogh ACDsee will write images with both markers.
+                // this program will re-create this marker on absence of exif marker.
+                // hence no need to keep the copy from the file.
+                if (memcmp(Data+2, "JFIF\0",5)){
+                    fprintf(stderr,"Header missing JFIF marker\n");
+                }
+                if (itemlen < 16){
+                    fprintf(stderr,"Jfif header too short\n");
+                    goto ignore;
+                }
+
+                ImageInfo.JfifHeader.Present = TRUE;
+                ImageInfo.JfifHeader.ResolutionUnits = Data[9];
+                ImageInfo.JfifHeader.XDensity = (Data[10]<<8) | Data[11];
+                ImageInfo.JfifHeader.YDensity = (Data[12]<<8) | Data[13];
+                if (ShowTags){
+                    printf("JFIF SOI marker: Units: %d ",ImageInfo.JfifHeader.ResolutionUnits);
+                    switch(ImageInfo.JfifHeader.ResolutionUnits){
+                        case 0: printf("(aspect ratio)"); break;
+                        case 1: printf("(dots per inch)"); break;
+                        case 2: printf("(dots per cm)"); break;
+                        default: printf("(unknown)"); break;
+                    }
+                    printf("  X-density=%d Y-density=%d\n",ImageInfo.JfifHeader.XDensity, ImageInfo.JfifHeader.YDensity);
+
+                    if (Data[14] || Data[15]){
+                        fprintf(stderr,"Ignoring jfif header thumbnail\n");
+                    }
+                }
+
+                ignore:
+
+                free(Sections[--SectionsRead].Data);
+                break;
+
+            case M_EXIF:
+                // There can be different section using the same marker.
+                if (ReadMode & READ_METADATA){
+                    if (memcmp(Data+2, "Exif", 4) == 0){
+                        process_EXIF(Data, itemlen);
+                        break;
+                    }else if (memcmp(Data+2, "http:", 5) == 0){
+                        Sections[SectionsRead-1].Type = M_XMP; // Change tag for internal purposes.
+                        if (ShowTags){
+                            printf("Image cotains XMP section, %d bytes long\n", itemlen);
+                            if (ShowTags){
+                                ShowXmp(Sections[SectionsRead-1]);
+                            }
+                        }
+                        break;
+                    }
+                }
+                // Oterwise, discard this section.
+                free(Sections[--SectionsRead].Data);
+                break;
+
+            case M_IPTC:
+                if (ReadMode & READ_METADATA){
+                    if (ShowTags){
+                        printf("Image cotains IPTC section, %d bytes long\n", itemlen);
+                    }
+                    // Note: We just store the IPTC section.  Its relatively straightforward
+                    // and we don't act on any part of it, so just display it at parse time.
+                }else{
+                    free(Sections[--SectionsRead].Data);
+                }
+                break;
+           
+            case M_SOF0: 
+            case M_SOF1: 
+            case M_SOF2: 
+            case M_SOF3: 
+            case M_SOF5: 
+            case M_SOF6: 
+            case M_SOF7: 
+            case M_SOF9: 
+            case M_SOF10:
+            case M_SOF11:
+            case M_SOF13:
+            case M_SOF14:
+            case M_SOF15:
+                process_SOFn(Data, marker);
+                break;
+            default:
+                // Skip any other sections.
+                if (ShowTags){
+                    printf("Jpeg section marker 0x%02x size %d\n",marker, itemlen);
+                }
+                break;
+        }
+    }
+    return TRUE;
+}
+
+//--------------------------------------------------------------------------
+// Discard read data.
+//--------------------------------------------------------------------------
+void DiscardData(void)
+{
+    int a;
+
+    for (a=0;a<SectionsRead;a++){
+        free(Sections[a].Data);
+    }
+
+    memset(&ImageInfo, 0, sizeof(ImageInfo));
+    SectionsRead = 0;
+    HaveAll = 0;
+}
+
+//--------------------------------------------------------------------------
+// Read image data.
+//--------------------------------------------------------------------------
+int ReadJpegFile(const char * FileName, ReadMode_t ReadMode)
+{
+    FILE * infile;
+    int ret;
+
+    infile = fopen(FileName, "rb"); // Unix ignores 'b', windows needs it.
+
+    if (infile == NULL) {
+        fprintf(stderr, "can't open '%s'\n", FileName);
+        return FALSE;
+    }
+
+
+    // Scan the JPEG headers.
+    ret = ReadJpegSections(infile, ReadMode);
+    if (!ret){
+        fprintf(stderr,"Not JPEG: %s\n",FileName);
+    }
+
+    fclose(infile);
+
+    if (ret == FALSE){
+        DiscardData();
+    }
+    return ret;
+}
+
+
+//--------------------------------------------------------------------------
+// Replace or remove exif thumbnail
+//--------------------------------------------------------------------------
+int SaveThumbnail(char * ThumbFileName)
+{
+    FILE * ThumbnailFile;
+
+    if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailSize == 0){
+        fprintf(stderr,"Image contains no thumbnail\n");
+        return FALSE;
+    }
+
+    if (strcmp(ThumbFileName, "-") == 0){
+        // A filename of '-' indicates thumbnail goes to stdout.
+        // This doesn't make much sense under Windows, so this feature is unix only.
+        ThumbnailFile = stdout;
+    }else{
+        ThumbnailFile = fopen(ThumbFileName,"wb");
+    }
+
+    if (ThumbnailFile){
+        uchar * ThumbnailPointer;
+        Section_t * ExifSection;
+        ExifSection = FindSection(M_EXIF);
+        ThumbnailPointer = ExifSection->Data+ImageInfo.ThumbnailOffset+8;
+
+        fwrite(ThumbnailPointer, ImageInfo.ThumbnailSize ,1, ThumbnailFile);
+        fclose(ThumbnailFile);
+        return TRUE;
+    }else{
+        ErrFatal("Could not write thumbnail file");
+        return FALSE;
+    }
+}
+
+//--------------------------------------------------------------------------
+// Replace or remove exif thumbnail
+//--------------------------------------------------------------------------
+int ReplaceThumbnail(const char * ThumbFileName)
+{
+    FILE * ThumbnailFile;
+    int ThumbLen, NewExifSize;
+    Section_t * ExifSection;
+    uchar * ThumbnailPointer;
+
+    if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailAtEnd == FALSE){
+        if (ThumbFileName == NULL){
+            // Delete of nonexistent thumbnail (not even pointers present)
+            // No action, no error.
+            return FALSE;
+        }
+
+        // Adding or removing of thumbnail is not possible - that would require rearranging
+        // of the exif header, which is risky, and jhad doesn't know how to do.
+        fprintf(stderr,"Image contains no thumbnail to replace - add is not possible\n");
+        return FALSE;
+    }
+
+    if (ThumbFileName){
+        ThumbnailFile = fopen(ThumbFileName,"rb");
+
+        if (ThumbnailFile == NULL){
+            ErrFatal("Could not read thumbnail file");
+            return FALSE;
+        }
+
+        // get length
+        fseek(ThumbnailFile, 0, SEEK_END);
+
+        ThumbLen = ftell(ThumbnailFile);
+        fseek(ThumbnailFile, 0, SEEK_SET);
+
+        if (ThumbLen + ImageInfo.ThumbnailOffset > 0x10000-20){
+            ErrFatal("Thumbnail is too large to insert into exif header");
+        }
+    }else{
+        if (ImageInfo.ThumbnailSize == 0){
+             return FALSE;
+        }
+
+        ThumbLen = 0;
+        ThumbnailFile = NULL;
+    }
+
+    ExifSection = FindSection(M_EXIF);
+
+    NewExifSize = ImageInfo.ThumbnailOffset+8+ThumbLen;
+    ExifSection->Data = (uchar *)realloc(ExifSection->Data, NewExifSize);
+
+    ThumbnailPointer = ExifSection->Data+ImageInfo.ThumbnailOffset+8;
+
+    if (ThumbnailFile){
+        fread(ThumbnailPointer, ThumbLen, 1, ThumbnailFile);
+        fclose(ThumbnailFile);
+    }
+
+    ImageInfo.ThumbnailSize = ThumbLen;
+
+    Put32u(ExifSection->Data+ImageInfo.ThumbnailSizeOffset+8, ThumbLen);
+
+    ExifSection->Data[0] = (uchar)(NewExifSize >> 8);
+    ExifSection->Data[1] = (uchar)NewExifSize;
+    ExifSection->Size = NewExifSize;
+
+    return TRUE;
+}
+
+
+//--------------------------------------------------------------------------
+// Discard everything but the exif and comment sections.
+//--------------------------------------------------------------------------
+void DiscardAllButExif(void)
+{
+    Section_t ExifKeeper;
+    Section_t CommentKeeper;
+    Section_t IptcKeeper;
+    Section_t XmpKeeper;
+    int a;
+
+    memset(&ExifKeeper, 0, sizeof(ExifKeeper));
+    memset(&CommentKeeper, 0, sizeof(CommentKeeper));
+    memset(&IptcKeeper, 0, sizeof(IptcKeeper));
+    memset(&XmpKeeper, 0, sizeof(IptcKeeper));
+
+    for (a=0;a<SectionsRead;a++){
+        if (Sections[a].Type == M_EXIF && ExifKeeper.Type == 0){
+           ExifKeeper = Sections[a];
+        }else if (Sections[a].Type == M_XMP && XmpKeeper.Type == 0){
+           XmpKeeper = Sections[a];
+        }else if (Sections[a].Type == M_COM && CommentKeeper.Type == 0){
+            CommentKeeper = Sections[a];
+        }else if (Sections[a].Type == M_IPTC && IptcKeeper.Type == 0){
+            IptcKeeper = Sections[a];
+        }else{
+            free(Sections[a].Data);
+        }
+    }
+    SectionsRead = 0;
+    if (ExifKeeper.Type){
+        CheckSectionsAllocated();
+        Sections[SectionsRead++] = ExifKeeper;
+    }
+    if (CommentKeeper.Type){
+        CheckSectionsAllocated();
+        Sections[SectionsRead++] = CommentKeeper;
+    }
+    if (IptcKeeper.Type){
+        CheckSectionsAllocated();
+        Sections[SectionsRead++] = IptcKeeper;
+    }
+
+    if (XmpKeeper.Type){
+        CheckSectionsAllocated();
+        Sections[SectionsRead++] = XmpKeeper;
+    }
+}    
+
+//--------------------------------------------------------------------------
+// Write image data back to disk.
+//--------------------------------------------------------------------------
+void WriteJpegFile(const char * FileName)
+{
+    FILE * outfile;
+    int a;
+
+    if (!HaveAll){
+        ErrFatal("Can't write back - didn't read all");
+    }
+
+    outfile = fopen(FileName,"wb");
+    if (outfile == NULL){
+        ErrFatal("Could not open file for write");
+    }
+
+    // Initial static jpeg marker.
+    fputc(0xff,outfile);
+    fputc(0xd8,outfile);
+    
+    if (Sections[0].Type != M_EXIF && Sections[0].Type != M_JFIF){
+        // The image must start with an exif or jfif marker.  If we threw those away, create one.
+        static uchar JfifHead[18] = {
+            0xff, M_JFIF,
+            0x00, 0x10, 'J' , 'F' , 'I' , 'F' , 0x00, 0x01, 
+            0x01, 0x01, 0x01, 0x2C, 0x01, 0x2C, 0x00, 0x00 
+        };
+
+        if (ImageInfo.ResolutionUnit == 2 || ImageInfo.ResolutionUnit == 3){
+            // Use the exif resolution info to fill out the jfif header.
+            // Usually, for exif images, there's no jfif header, so if wediscard
+            // the exif header, use info from the exif header for the jfif header.
+            
+            ImageInfo.JfifHeader.ResolutionUnits = (char)(ImageInfo.ResolutionUnit-1);
+            // Jfif is 1 and 2, Exif is 2 and 3 for In and cm respecively
+            ImageInfo.JfifHeader.XDensity = (int)ImageInfo.xResolution;
+            ImageInfo.JfifHeader.YDensity = (int)ImageInfo.yResolution;
+        }
+
+        JfifHead[11] = ImageInfo.JfifHeader.ResolutionUnits;
+        JfifHead[12] = (uchar)(ImageInfo.JfifHeader.XDensity >> 8);
+        JfifHead[13] = (uchar)ImageInfo.JfifHeader.XDensity;
+        JfifHead[14] = (uchar)(ImageInfo.JfifHeader.YDensity >> 8);
+        JfifHead[15] = (uchar)ImageInfo.JfifHeader.YDensity;
+        
+
+        fwrite(JfifHead, 18, 1, outfile);
+
+        // use the values from the exif data for the jfif header, if we have found values
+        if (ImageInfo.ResolutionUnit != 0) { 
+            // JFIF.ResolutionUnit is {1,2}, EXIF.ResolutionUnit is {2,3}
+            JfifHead[11] = (uchar)ImageInfo.ResolutionUnit - 1; 
+        }
+        if (ImageInfo.xResolution > 0.0 && ImageInfo.yResolution > 0.0) { 
+            JfifHead[12] = (uchar)((int)ImageInfo.xResolution>>8);
+            JfifHead[13] = (uchar)((int)ImageInfo.xResolution);
+
+            JfifHead[14] = (uchar)((int)ImageInfo.yResolution>>8);
+            JfifHead[15] = (uchar)((int)ImageInfo.yResolution);
+        }
+    }
+
+
+    // Write all the misc sections
+    for (a=0;a<SectionsRead-1;a++){
+        fputc(0xff,outfile);
+        fputc((unsigned char)Sections[a].Type, outfile);
+        fwrite(Sections[a].Data, Sections[a].Size, 1, outfile);
+    }
+
+    // Write the remaining image data.
+    fwrite(Sections[a].Data, Sections[a].Size, 1, outfile);
+       
+    fclose(outfile);
+}
+
+
+//--------------------------------------------------------------------------
+// Check if image has exif header.
+//--------------------------------------------------------------------------
+Section_t * FindSection(int SectionType)
+{
+    int a;
+
+    for (a=0;a<SectionsRead;a++){
+        if (Sections[a].Type == SectionType){
+            return &Sections[a];
+        }
+    }
+    // Could not be found.
+    return NULL;
+}
+
+//--------------------------------------------------------------------------
+// Remove a certain type of section.
+//--------------------------------------------------------------------------
+int RemoveSectionType(int SectionType)
+{
+    int a;
+    for (a=0;a<SectionsRead-1;a++){
+        if (Sections[a].Type == SectionType){
+            // Free up this section
+            free (Sections[a].Data);
+            // Move succeding sections back by one to close space in array.
+            memmove(Sections+a, Sections+a+1, sizeof(Section_t) * (SectionsRead-a));
+            SectionsRead -= 1;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+//--------------------------------------------------------------------------
+// Remove sectons not part of image and not exif or comment sections.
+//--------------------------------------------------------------------------
+int RemoveUnknownSections(void)
+{
+    int a;
+    int Modified = FALSE;
+    for (a=0;a<SectionsRead-1;){
+        switch(Sections[a].Type){
+            case  M_SOF0:
+            case  M_SOF1:
+            case  M_SOF2:
+            case  M_SOF3:
+            case  M_SOF5:
+            case  M_SOF6:
+            case  M_SOF7:
+            case  M_SOF9:
+            case  M_SOF10:
+            case  M_SOF11:
+            case  M_SOF13:
+            case  M_SOF14:
+            case  M_SOF15:
+            case  M_SOI:
+            case  M_EOI:
+            case  M_SOS:
+            case  M_JFIF:
+            case  M_EXIF:
+            case  M_XMP:
+            case  M_COM:
+            case  M_DQT:
+            case  M_DHT:
+            case  M_DRI:
+            case  M_IPTC:
+                // keep.
+                a++;
+                break;
+            default:
+                // Unknown.  Delete.
+                free (Sections[a].Data);
+                // Move succeding sections back by one to close space in array.
+                memmove(Sections+a, Sections+a+1, sizeof(Section_t) * (SectionsRead-a));
+                SectionsRead -= 1;
+                Modified = TRUE;
+        }
+    }
+    return Modified;
+}
+
+//--------------------------------------------------------------------------
+// Add a section (assume it doesn't already exist) - used for 
+// adding comment sections and exif sections
+//--------------------------------------------------------------------------
+Section_t * CreateSection(int SectionType, unsigned char * Data, int Size)
+{
+    Section_t * NewSection;
+    int a;
+    int NewIndex;
+    NewIndex = 2;
+
+    if (SectionType == M_EXIF) NewIndex = 0; // Exif alwas goes first!
+
+    // Insert it in third position - seems like a safe place to put 
+    // things like comments.
+
+    if (SectionsRead < NewIndex){
+        ErrFatal("Too few sections!");
+    }
+
+    CheckSectionsAllocated();
+    for (a=SectionsRead;a>NewIndex;a--){
+        Sections[a] = Sections[a-1];          
+    }
+    SectionsRead += 1;
+
+    NewSection = Sections+NewIndex;
+
+    NewSection->Type = SectionType;
+    NewSection->Size = Size;
+    NewSection->Data = Data;
+
+    return NewSection;
+}
+
+
+//--------------------------------------------------------------------------
+// Initialisation.
+//--------------------------------------------------------------------------
+void ResetJpgfile(void)
+{
+    if (Sections == NULL){
+        Sections = (Section_t *)malloc(sizeof(Section_t)*5);
+        SectionsAllocated = 5;
+    }
+
+    SectionsRead = 0;
+    HaveAll = 0;
+}