RubyGems - rjhead - Versions diffs - 2.88.1 → 2.88.2 - Mend

rjhead 2.88.1 → 2.88.2

Files changed (24) hide show

data/ext/jhead.h DELETED

@@ -1,251 +0,0 @@
-//--------------------------------------------------------------------------
-// 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 DELETED

@@ -1,149 +0,0 @@
-# -----------------------------------------------------
-# 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 DELETED

@@ -1,738 +0,0 @@
-//--------------------------------------------------------------------------
-// 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;
-}