1//--------------------------------------------------------------------------
2// Program to pull the information out of various types of EXIF digital
3// camera files and show it in a reasonably consistent way
4//
5// Version 2.86
6//
7// Compiling under Windows:
8//   Make sure you have Microsoft's compiler on the path, then run make.bat
9//
10// Dec 1999 - Mar 2009
11//
12// by Matthias Wandel   www.sentex.net/~mwandel
13//--------------------------------------------------------------------------
14#include "jhead.h"
15
16#include <sys/stat.h>
17#include <utils/Log.h>
18
19#define JHEAD_VERSION "2.87"
20
21// This #define turns on features that are too very specific to
22// how I organize my photos.  Best to ignore everything inside #ifdef MATTHIAS
23//#define MATTHIAS
24
25#ifdef _WIN32
26    #include <io.h>
27#endif
28
29static int FilesMatched;
30static int FileSequence;
31
32static const char * CurrentFile;
33
34static const char * progname;   // program name for error messages
35
36//--------------------------------------------------------------------------
37// Command line options flags
38static int TrimExif = FALSE;        // Cut off exif beyond interesting data.
39static int RenameToDate = 0;        // 1=rename, 2=rename all.
40#ifdef _WIN32
41static int RenameAssociatedFiles = FALSE;
42#endif
43static char * strftime_args = NULL; // Format for new file name.
44static int Exif2FileTime  = FALSE;
45static int DoModify     = FALSE;
46static int DoReadAction = FALSE;
47       int ShowTags     = FALSE;    // Do not show raw by default.
48static int Quiet        = FALSE;    // Be quiet on success (like unix programs)
49       int DumpExifMap  = FALSE;
50static int ShowConcise  = FALSE;
51static int CreateExifSection = FALSE;
52static char * ApplyCommand = NULL;  // Apply this command to all images.
53static char * FilterModel = NULL;
54static int    ExifOnly    = FALSE;
55static int    PortraitOnly = FALSE;
56static time_t ExifTimeAdjust = 0;   // Timezone adjust
57static time_t ExifTimeSet = 0;      // Set exif time to a value.
58static char DateSet[11];
59static unsigned DateSetChars = 0;
60static unsigned FileTimeToExif = FALSE;
61
62static int DeleteComments = FALSE;
63static int DeleteExif = FALSE;
64static int DeleteIptc = FALSE;
65static int DeleteXmp = FALSE;
66static int DeleteUnknown = FALSE;
67static char * ThumbSaveName = NULL; // If not NULL, use this string to make up
68                                    // the filename to store the thumbnail to.
69
70static char * ThumbInsertName = NULL; // If not NULL, use this string to make up
71                                    // the filename to retrieve the thumbnail from.
72
73static int RegenThumbnail = FALSE;
74
75static char * ExifXferScrFile = NULL;// Extract Exif header from this file, and
76                                    // put it into the Jpegs processed.
77
78static int EditComment = FALSE;     // Invoke an editor for editing the comment
79static int SupressNonFatalErrors = FALSE; // Wether or not to pint warnings on recoverable errors
80
81static char * CommentSavefileName = NULL; // Save comment to this file.
82static char * CommentInsertfileName = NULL; // Insert comment from this file.
83static char * CommentInsertLiteral = NULL;  // Insert this comment (from command line)
84
85static int AutoRotate = FALSE;
86static int ZeroRotateTagOnly = FALSE;
87
88static int ShowFileInfo = TRUE;     // Indicates to show standard file info
89                                    // (file name, file size, file date)
90
91
92#ifdef MATTHIAS
93    // This #ifdef to take out less than elegant stuff for editing
94    // the comments in a JPEG.  The programs rdjpgcom and wrjpgcom
95    // included with Linux distributions do a better job.
96
97    static char * AddComment = NULL; // Add this tag.
98    static char * RemComment = NULL; // Remove this tag
99    static int AutoResize = FALSE;
100#endif // MATTHIAS
101
102//--------------------------------------------------------------------------
103// Error exit handler
104//--------------------------------------------------------------------------
105void ErrFatal(char * msg)
106{
107    LOGE("Error : %s\n", msg);
108    if (CurrentFile) fprintf(stderr,"in file '%s'\n",CurrentFile);
109    exit(EXIT_FAILURE);
110}
111
112//--------------------------------------------------------------------------
113// Report non fatal errors.  Now that microsoft.net modifies exif headers,
114// there's corrupted ones, and there could be more in the future.
115//--------------------------------------------------------------------------
116void ErrNonfatal(char * msg, int a1, int a2)
117{
118    LOGV("Nonfatal Error : ");
119    LOGV(msg, a1, a2);
120    if (SupressNonFatalErrors) return;
121
122    fprintf(stderr,"\nNonfatal Error : ");
123    if (CurrentFile) fprintf(stderr,"'%s' ",CurrentFile);
124    fprintf(stderr, msg, a1, a2);
125    fprintf(stderr, "\n");
126}
127
128//--------------------------------------------------------------------------
129// Set file time as exif time.
130//--------------------------------------------------------------------------
131void FileTimeAsString(char * TimeStr)
132{
133    struct tm ts;
134    ts = *localtime(&ImageInfo.FileDateTime);
135    strftime(TimeStr, 20, "%Y:%m:%d %H:%M:%S", &ts);
136}
137
138#if 0       // not used -- possible security risk with use of system, sprintf, etc.
139//--------------------------------------------------------------------------
140// Invoke an editor for editing a string.
141//--------------------------------------------------------------------------
142static int FileEditComment(char * TempFileName, char * Comment, int CommentSize)
143{
144    FILE * file;
145    int a;
146    char QuotedPath[PATH_MAX+10];
147
148    file = fopen(TempFileName, "w");
149    if (file == NULL){
150        fprintf(stderr, "Can't create file '%s'\n",TempFileName);
151        ErrFatal("could not create temporary file");
152    }
153    fwrite(Comment, CommentSize, 1, file);
154
155    fclose(file);
156
157    fflush(stdout); // So logs are contiguous.
158
159    {
160        char * Editor;
161        Editor = getenv("EDITOR");
162        if (Editor == NULL){
163#ifdef _WIN32
164            Editor = "notepad";
165#else
166            Editor = "vi";
167#endif
168        }
169        if (strlen(Editor) > PATH_MAX) ErrFatal("env too long");
170
171        sprintf(QuotedPath, "%s \"%s\"",Editor, TempFileName);
172        a = system(QuotedPath);
173    }
174
175    if (a != 0){
176        perror("Editor failed to launch");
177        exit(-1);
178    }
179
180    file = fopen(TempFileName, "r");
181    if (file == NULL){
182        ErrFatal("could not open temp file for read");
183    }
184
185    // Read the file back in.
186    CommentSize = fread(Comment, 1, 999, file);
187
188    fclose(file);
189
190    unlink(TempFileName);
191
192    return CommentSize;
193}
194
195#ifdef MATTHIAS
196//--------------------------------------------------------------------------
197// Modify one of the lines in the comment field.
198// This very specific to the photo album program stuff.
199//--------------------------------------------------------------------------
200static char KnownTags[][10] = {"date", "desc","scan_date","author",
201                               "keyword","videograb",
202                               "show_raw","panorama","titlepix",""};
203
204static int ModifyDescriptComment(char * OutComment, char * SrcComment)
205{
206    char Line[500];
207    int Len;
208    int a,i;
209    unsigned l;
210    int HasScandate = FALSE;
211    int TagExists = FALSE;
212    int Modified = FALSE;
213    Len = 0;
214
215    OutComment[0] = 0;
216
217
218    for (i=0;;i++){
219        if (SrcComment[i] == '\r' || SrcComment[i] == '\n' || SrcComment[i] == 0 || Len >= 199){
220            // Process the line.
221            if (Len > 0){
222                Line[Len] = 0;
223                //printf("Line: '%s'\n",Line);
224                for (a=0;;a++){
225                    l = strlen(KnownTags[a]);
226                    if (!l){
227                        // Unknown tag.  Discard it.
228                        printf("Error: Unknown tag '%s'\n", Line); // Deletes the tag.
229                        Modified = TRUE;
230                        break;
231                    }
232                    if (memcmp(Line, KnownTags[a], l) == 0){
233                        if (Line[l] == ' ' || Line[l] == '=' || Line[l] == 0){
234                            // Its a good tag.
235                            if (Line[l] == ' ') Line[l] = '='; // Use equal sign for clarity.
236                            if (a == 2) break; // Delete 'orig_path' tag.
237                            if (a == 3) HasScandate = TRUE;
238                            if (RemComment){
239                                if (strlen(RemComment) == l){
240                                    if (!memcmp(Line, RemComment, l)){
241                                        Modified = TRUE;
242                                        break;
243                                    }
244                                }
245                            }
246                            if (AddComment){
247                                // Overwrite old comment of same tag with new one.
248                                if (!memcmp(Line, AddComment, l+1)){
249                                    TagExists = TRUE;
250                                    strncpy(Line, AddComment, sizeof(Line));
251                                    Modified = TRUE;
252                                }
253                            }
254                            strncat(OutComment, Line, MAX_COMMENT_SIZE-5-strlen(OutComment));
255                            strcat(OutComment, "\n");
256                            break;
257                        }
258                    }
259                }
260            }
261            Line[Len = 0] = 0;
262            if (SrcComment[i] == 0) break;
263        }else{
264            Line[Len++] = SrcComment[i];
265        }
266    }
267
268    if (AddComment && TagExists == FALSE){
269        strncat(OutComment, AddComment, MAX_COMMENT_SIZE-5-strlen(OutComment));
270        strcat(OutComment, "\n");
271        Modified = TRUE;
272    }
273
274    if (!HasScandate && !ImageInfo.DateTime[0]){
275        // Scan date is not in the file yet, and it doesn't have one built in.  Add it.
276        char Temp[30];
277        sprintf(Temp, "scan_date=%s", ctime(&ImageInfo.FileDateTime));
278        strncat(OutComment, Temp, MAX_COMMENT_SIZE-5-strlen(OutComment));
279        Modified = TRUE;
280    }
281    return Modified;
282}
283//--------------------------------------------------------------------------
284// Automatic make smaller command stuff
285//--------------------------------------------------------------------------
286static int AutoResizeCmdStuff(void)
287{
288    static char CommandString[PATH_MAX+1];
289    double scale;
290
291    ApplyCommand = CommandString;
292
293    if (ImageInfo.Height <= 1280 && ImageInfo.Width <= 1280){
294        printf("not resizing %dx%x '%s'\n",ImageInfo.Height, ImageInfo.Width, ImageInfo.FileName);
295        return FALSE;
296    }
297
298    scale = 1024.0 / ImageInfo.Height;
299    if (1024.0 / ImageInfo.Width < scale) scale = 1024.0 / ImageInfo.Width;
300
301    if (scale < 0.5) scale = 0.5; // Don't scale down by more than a factor of two.
302
303    sprintf(CommandString, "mogrify -geometry %dx%d -quality 85 &i",(int)(ImageInfo.Width*scale), (int)(ImageInfo.Height*scale));
304    return TRUE;
305}
306
307
308#endif // MATTHIAS
309
310
311//--------------------------------------------------------------------------
312// Escape an argument such that it is interpreted literally by the shell
313// (returns the number of written characters)
314//--------------------------------------------------------------------------
315static int shellescape(char* to, const char* from)
316{
317    int i, j;
318    i = j = 0;
319
320    // Enclosing characters in double quotes preserves the literal value of
321    // all characters within the quotes, with the exception of $, `, and \.
322    to[j++] = '"';
323    while(from[i])
324    {
325#ifdef _WIN32
326        // Under WIN32, there isn't really anything dangerous you can do with
327        // escape characters, plus windows users aren't as sercurity paranoid.
328        // Hence, no need to do fancy escaping.
329        to[j++] = from[i++];
330#else
331        switch(from[i]) {
332            case '"':
333            case '$':
334            case '`':
335            case '\\':
336                to[j++] = '\\';
337                // Fallthru...
338            default:
339                to[j++] = from[i++];
340        }
341#endif
342        if (j >= PATH_MAX) ErrFatal("max path exceeded");
343    }
344    to[j++] = '"';
345    return j;
346}
347
348
349//--------------------------------------------------------------------------
350// Apply the specified command to the JPEG file.
351//--------------------------------------------------------------------------
352static void DoCommand(const char * FileName, int ShowIt)
353{
354    int a,e;
355    char ExecString[PATH_MAX*3];
356    char TempName[PATH_MAX+10];
357    int TempUsed = FALSE;
358
359    e = 0;
360
361    // Generate an unused temporary file name in the destination directory
362    // (a is the number of characters to copy from FileName)
363    a = strlen(FileName)-1;
364    while(a > 0 && FileName[a-1] != SLASH) a--;
365    memcpy(TempName, FileName, a);
366    strcpy(TempName+a, "XXXXXX");
367    mktemp(TempName);
368    if(!TempName[0]) {
369        ErrFatal("Cannot find available temporary file name");
370    }
371
372
373
374    // Build the exec string.  &i and &o in the exec string get replaced by input and output files.
375    for (a=0;;a++){
376        if (ApplyCommand[a] == '&'){
377            if (ApplyCommand[a+1] == 'i'){
378                // Input file.
379                e += shellescape(ExecString+e, FileName);
380                a += 1;
381                continue;
382            }
383            if (ApplyCommand[a+1] == 'o'){
384                // Needs an output file distinct from the input file.
385                e += shellescape(ExecString+e, TempName);
386                a += 1;
387                TempUsed = TRUE;
388                continue;
389            }
390        }
391        ExecString[e++] = ApplyCommand[a];
392        if (ApplyCommand[a] == 0) break;
393    }
394
395    if (ShowIt) printf("Cmd:%s\n",ExecString);
396
397    errno = 0;
398    a = system(ExecString);
399
400    if (a || errno){
401        // A command can however fail without errno getting set or system returning an error.
402        if (errno) perror("system");
403        ErrFatal("Problem executing specified command");
404    }
405
406    if (TempUsed){
407        // Don't delete original file until we know a new one was created by the command.
408        struct stat dummy;
409        if (stat(TempName, &dummy) == 0){
410            unlink(FileName);
411            rename(TempName, FileName);
412        }else{
413            ErrFatal("specified command did not produce expected output file");
414        }
415    }
416}
417
418//--------------------------------------------------------------------------
419// check if this file should be skipped based on contents.
420//--------------------------------------------------------------------------
421static int CheckFileSkip(void)
422{
423    // I sometimes add code here to only process images based on certain
424    // criteria - for example, only to convert non progressive Jpegs to progressives, etc..
425
426    if (FilterModel){
427        // Filtering processing by camera model.
428        // This feature is useful when pictures from multiple cameras are colated,
429        // the its found that one of the cameras has the time set incorrectly.
430        if (strstr(ImageInfo.CameraModel, FilterModel) == NULL){
431            // Skip.
432            return TRUE;
433        }
434    }
435
436    if (ExifOnly){
437        // Filtering by EXIF only.  Skip all files that have no Exif.
438        if (FindSection(M_EXIF) == NULL){
439            return TRUE;
440        }
441    }
442
443    if (PortraitOnly == 1){
444        if (ImageInfo.Width > ImageInfo.Height) return TRUE;
445    }
446
447    if (PortraitOnly == -1){
448        if (ImageInfo.Width < ImageInfo.Height) return TRUE;
449    }
450
451    return FALSE;
452}
453
454//--------------------------------------------------------------------------
455// Subsititute original name for '&i' if present in specified name.
456// This to allow specifying relative names when manipulating multiple files.
457//--------------------------------------------------------------------------
458static void RelativeName(char * OutFileName, const char * NamePattern, const char * OrigName)
459{
460    // If the filename contains substring "&i", then substitute the
461    // filename for that.  This gives flexibility in terms of processing
462    // multiple files at a time.
463    char * Subst;
464    Subst = strstr(NamePattern, "&i");
465    if (Subst){
466        strncpy(OutFileName, NamePattern, Subst-NamePattern);
467        OutFileName[Subst-NamePattern] = 0;
468        strncat(OutFileName, OrigName, PATH_MAX);
469        strncat(OutFileName, Subst+2, PATH_MAX);
470    }else{
471        strncpy(OutFileName, NamePattern, PATH_MAX);
472    }
473}
474
475
476#ifdef _WIN32
477//--------------------------------------------------------------------------
478// Rename associated files
479//--------------------------------------------------------------------------
480void RenameAssociated(const char * FileName, char * NewBaseName)
481{
482    int a;
483    int PathLen;
484    int ExtPos;
485    char FilePattern[_MAX_PATH+1];
486    char NewName[_MAX_PATH+1];
487    struct _finddata_t finddata;
488    long find_handle;
489
490    for(ExtPos = strlen(FileName);FileName[ExtPos-1] != '.';){
491        if (--ExtPos == 0) return; // No extension!
492    }
493
494    memcpy(FilePattern, FileName, ExtPos);
495    FilePattern[ExtPos] = '*';
496    FilePattern[ExtPos+1] = '\0';
497
498    for(PathLen = strlen(FileName);FileName[PathLen-1] != SLASH;){
499        if (--PathLen == 0) break;
500    }
501
502    find_handle = _findfirst(FilePattern, &finddata);
503
504    for (;;){
505        if (find_handle == -1) break;
506
507        // Eliminate the obvious patterns.
508        if (!memcmp(finddata.name, ".",2)) goto next_file;
509        if (!memcmp(finddata.name, "..",3)) goto next_file;
510        if (finddata.attrib & _A_SUBDIR) goto next_file;
511
512        strncpy(FilePattern+PathLen, finddata.name, PATH_MAX-PathLen); // full name with path
513
514        strcpy(NewName, NewBaseName);
515        for(a = strlen(finddata.name);finddata.name[a] != '.';){
516            if (--a == 0) goto next_file;
517        }
518        strncat(NewName, finddata.name+a, _MAX_PATH-strlen(NewName)); // add extension to new name
519
520        if (rename(FilePattern, NewName) == 0){
521            if (!Quiet){
522                printf("%s --> %s\n",FilePattern, NewName);
523            }
524        }
525
526        next_file:
527        if (_findnext(find_handle, &finddata) != 0) break;
528    }
529    _findclose(find_handle);
530}
531#endif
532
533//--------------------------------------------------------------------------
534// Handle renaming of files by date.
535//--------------------------------------------------------------------------
536static void DoFileRenaming(const char * FileName)
537{
538    int NumAlpha = 0;
539    int NumDigit = 0;
540    int PrefixPart = 0; // Where the actual filename starts.
541    int ExtensionPart;  // Where the file extension starts.
542    int a;
543    struct tm tm;
544    char NewBaseName[PATH_MAX*2];
545    int AddLetter = 0;
546    char NewName[PATH_MAX+2];
547
548    ExtensionPart = strlen(FileName);
549    for (a=0;FileName[a];a++){
550        if (FileName[a] == SLASH){
551            // Don't count path component.
552            NumAlpha = 0;
553            NumDigit = 0;
554            PrefixPart = a+1;
555        }
556
557        if (FileName[a] == '.') ExtensionPart = a;  // Remember where extension starts.
558
559        if (isalpha(FileName[a])) NumAlpha += 1;    // Tally up alpha vs. digits to judge wether to rename.
560        if (isdigit(FileName[a])) NumDigit += 1;
561    }
562
563    if (RenameToDate <= 1){
564        // If naming isn't forced, ensure name is mostly digits, or leave it alone.
565        if (NumAlpha > 8 || NumDigit < 4){
566            return;
567        }
568    }
569
570    if (!Exif2tm(&tm, ImageInfo.DateTime)){
571        printf("File '%s' contains no exif date stamp.  Using file date\n",FileName);
572        // Use file date/time instead.
573        tm = *localtime(&ImageInfo.FileDateTime);
574    }
575
576
577    strncpy(NewBaseName, FileName, PATH_MAX); // Get path component of name.
578
579    if (strftime_args){
580        // Complicated scheme for flexibility.  Just pass the args to strftime.
581        time_t UnixTime;
582
583        char *s;
584        char pattern[PATH_MAX+20];
585        int n = ExtensionPart - PrefixPart;
586
587        // Call mktime to get weekday and such filled in.
588        UnixTime = mktime(&tm);
589        if ((int)UnixTime == -1){
590            printf("Could not convert %s to unix time",ImageInfo.DateTime);
591            return;
592        }
593
594        // Substitute "%f" for the original name (minus path & extension)
595        pattern[PATH_MAX-1]=0;
596        strncpy(pattern, strftime_args, PATH_MAX-1);
597        while ((s = strstr(pattern, "%f")) && strlen(pattern) + n < PATH_MAX-1){
598            memmove(s + n, s + 2, strlen(s+2) + 1);
599            memmove(s, FileName + PrefixPart, n);
600        }
601
602        {
603            // Sequential number renaming part.
604            // '%i' type pattern becomes sequence number.
605            int ppos = -1;
606            for (a=0;pattern[a];a++){
607                if (pattern[a] == '%'){
608                     ppos = a;
609                }else if (pattern[a] == 'i'){
610                    if (ppos >= 0 && a<ppos+4){
611                        // Replace this part with a number.
612                        char pat[8], num[16];
613                        int l,nl;
614                        memcpy(pat, pattern+ppos, 4);
615                        pat[a-ppos] = 'd'; // Replace 'i' with 'd' for '%d'
616                        pat[a-ppos+1] = '\0';
617                        sprintf(num, pat, FileSequence); // let printf do the number formatting.
618                        nl = strlen(num);
619                        l = strlen(pattern+a+1);
620                        if (ppos+nl+l+1 >= PATH_MAX) ErrFatal("str overflow");
621                        memmove(pattern+ppos+nl, pattern+a+1, l+1);
622                        memcpy(pattern+ppos, num, nl);
623                        break;
624                    }
625                }else if (!isdigit(pattern[a])){
626                    ppos = -1;
627                }
628            }
629        }
630        strftime(NewName, PATH_MAX, pattern, &tm);
631    }else{
632        // My favourite scheme.
633        sprintf(NewName, "%02d%02d-%02d%02d%02d",
634             tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
635    }
636
637    NewBaseName[PrefixPart] = 0;
638    CatPath(NewBaseName, NewName);
639
640    AddLetter = isdigit(NewBaseName[strlen(NewBaseName)-1]);
641    for (a=0;;a++){
642        char NewName[PATH_MAX+10];
643        char NameExtra[3];
644        struct stat dummy;
645
646        if (a){
647            // Generate a suffix for the file name if previous choice of names is taken.
648            // depending on wether the name ends in a letter or digit, pick the opposite to separate
649            // it.  This to avoid using a separator character - this because any good separator
650            // is before the '.' in ascii, and so sorting the names would put the later name before
651            // the name without suffix, causing the pictures to more likely be out of order.
652            if (AddLetter){
653                NameExtra[0] = (char)('a'-1+a); // Try a,b,c,d... for suffix if it ends in a number.
654            }else{
655                NameExtra[0] = (char)('0'-1+a); // Try 0,1,2,3... for suffix if it ends in a latter.
656            }
657            NameExtra[1] = 0;
658        }else{
659            NameExtra[0] = 0;
660        }
661
662        sprintf(NewName, "%s%s.jpg", NewBaseName, NameExtra);
663
664        if (!strcmp(FileName, NewName)) break; // Skip if its already this name.
665
666        if (!EnsurePathExists(NewBaseName)){
667            break;
668        }
669
670
671        if (stat(NewName, &dummy)){
672            // This name does not pre-exist.
673            if (rename(FileName, NewName) == 0){
674                printf("%s --> %s\n",FileName, NewName);
675#ifdef _WIN32
676                if (RenameAssociatedFiles){
677                    sprintf(NewName, "%s%s", NewBaseName, NameExtra);
678                    RenameAssociated(FileName, NewName);
679                }
680#endif
681            }else{
682                printf("Error: Couldn't rename '%s' to '%s'\n",FileName, NewName);
683            }
684            break;
685
686        }
687
688        if (a > 25 || (!AddLetter && a > 9)){
689            printf("Possible new names for for '%s' already exist\n",FileName);
690            break;
691        }
692    }
693}
694
695//--------------------------------------------------------------------------
696// Rotate the image and its thumbnail
697//--------------------------------------------------------------------------
698static int DoAutoRotate(const char * FileName)
699{
700    if (ImageInfo.Orientation >= 2 && ImageInfo.Orientation <= 8){
701        const char * Argument;
702        Argument = ClearOrientation();
703
704        if (!ZeroRotateTagOnly){
705            char RotateCommand[PATH_MAX*2+50];
706            if (Argument == NULL){
707                ErrFatal("Orientation screwup");
708            }
709
710            sprintf(RotateCommand, "jpegtran -trim -%s -outfile &o &i", Argument);
711            ApplyCommand = RotateCommand;
712            DoCommand(FileName, FALSE);
713            ApplyCommand = NULL;
714
715            // Now rotate the thumbnail, if there is one.
716            if (ImageInfo.ThumbnailOffset &&
717                ImageInfo.ThumbnailSize &&
718                ImageInfo.ThumbnailAtEnd){
719                // Must have a thumbnail that exists and is modifieable.
720
721                char ThumbTempName_in[PATH_MAX+5];
722                char ThumbTempName_out[PATH_MAX+5];
723
724                strcpy(ThumbTempName_in, FileName);
725                strcat(ThumbTempName_in, ".thi");
726                strcpy(ThumbTempName_out, FileName);
727                strcat(ThumbTempName_out, ".tho");
728                SaveThumbnail(ThumbTempName_in);
729                sprintf(RotateCommand,"jpegtran -trim -%s -outfile \"%s\" \"%s\"",
730                    Argument, ThumbTempName_out, ThumbTempName_in);
731
732                if (system(RotateCommand) == 0){
733                    // Put the thumbnail back in the header
734                    ReplaceThumbnail(ThumbTempName_out);
735                }
736
737                unlink(ThumbTempName_in);
738                unlink(ThumbTempName_out);
739            }
740        }
741        return TRUE;
742    }
743    return FALSE;
744}
745
746//--------------------------------------------------------------------------
747// Regenerate the thumbnail using mogrify
748//--------------------------------------------------------------------------
749static int RegenerateThumbnail(const char * FileName)
750{
751    char ThumbnailGenCommand[PATH_MAX*2+50];
752    if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailAtEnd == FALSE){
753        // There is no thumbnail, or the thumbnail is not at the end.
754        return FALSE;
755    }
756
757    sprintf(ThumbnailGenCommand, "mogrify -thumbnail %dx%d \"%s\"",
758        RegenThumbnail, RegenThumbnail, FileName);
759
760    if (system(ThumbnailGenCommand) == 0){
761        // Put the thumbnail back in the header
762        return ReplaceThumbnail(FileName);
763    }else{
764        ErrFatal("Unable to run 'mogrify' command");
765        return FALSE;
766    }
767}
768
769//--------------------------------------------------------------------------
770// Do selected operations to one file at a time.
771//--------------------------------------------------------------------------
772void ProcessFile(const char * FileName)
773{
774    int Modified = FALSE;
775    ReadMode_t ReadMode;
776
777    if (strlen(FileName) >= PATH_MAX-1){
778        // Protect against buffer overruns in strcpy / strcat's on filename
779        ErrFatal("filename too long");
780    }
781
782    ReadMode = READ_METADATA;
783    CurrentFile = FileName;
784    FilesMatched = 1;
785
786    ResetJpgfile();
787
788    // Start with an empty image information structure.
789    memset(&ImageInfo, 0, sizeof(ImageInfo));
790    ImageInfo.FlashUsed = -1;
791    ImageInfo.MeteringMode = -1;
792    ImageInfo.Whitebalance = -1;
793
794    // Store file date/time.
795    {
796        struct stat st;
797        if (stat(FileName, &st) >= 0){
798            ImageInfo.FileDateTime = st.st_mtime;
799            ImageInfo.FileSize = st.st_size;
800        }else{
801            ErrFatal("No such file");
802        }
803    }
804
805    if (DoModify || RenameToDate || Exif2FileTime){
806        if (access(FileName, 2 /*W_OK*/)){
807            printf("Skipping readonly file '%s'\n",FileName);
808            return;
809        }
810    }
811
812    strncpy(ImageInfo.FileName, FileName, PATH_MAX);
813
814
815    if (ApplyCommand || AutoRotate){
816        // Applying a command is special - the headers from the file have to be
817        // pre-read, then the command executed, and then the image part of the file read.
818
819        if (!ReadJpegFile(FileName, READ_METADATA)) return;
820
821        #ifdef MATTHIAS
822            if (AutoResize){
823                // Automatic resize computation - to customize for each run...
824                if (AutoResizeCmdStuff() == 0){
825                    DiscardData();
826                    return;
827                }
828            }
829        #endif // MATTHIAS
830
831
832        if (CheckFileSkip()){
833            DiscardData();
834            return;
835        }
836
837        DiscardAllButExif();
838
839        if (AutoRotate){
840            if (DoAutoRotate(FileName)){
841                Modified = TRUE;
842            }
843        }else{
844            struct stat dummy;
845            DoCommand(FileName, Quiet ? FALSE : TRUE);
846
847            if (stat(FileName, &dummy)){
848                // The file is not there anymore. Perhaps the command
849                // was a delete or a move.  So we are all done.
850                return;
851            }
852            Modified = TRUE;
853        }
854        ReadMode = READ_IMAGE;   // Don't re-read exif section again on next read.
855
856    }else if (ExifXferScrFile){
857        char RelativeExifName[PATH_MAX+1];
858
859        // Make a relative name.
860        RelativeName(RelativeExifName, ExifXferScrFile, FileName);
861
862        if(!ReadJpegFile(RelativeExifName, READ_METADATA)) return;
863
864        DiscardAllButExif();    // Don't re-read exif section again on next read.
865
866        Modified = TRUE;
867        ReadMode = READ_IMAGE;
868    }
869
870    if (DoModify){
871        ReadMode |= READ_IMAGE;
872    }
873
874    if (!ReadJpegFile(FileName, ReadMode)) return;
875
876    if (CheckFileSkip()){
877        DiscardData();
878        return;
879    }
880
881    FileSequence += 1; // Count files processed.
882
883    if (ShowConcise){
884        ShowConciseImageInfo();
885    }else{
886        if (!(DoModify || DoReadAction) || ShowTags){
887            ShowImageInfo(ShowFileInfo);
888
889            {
890                // if IPTC section is present, show it also.
891                Section_t * IptcSection;
892                IptcSection = FindSection(M_IPTC);
893
894                if (IptcSection){
895                    show_IPTC(IptcSection->Data, IptcSection->Size);
896                }
897            }
898            printf("\n");
899        }
900    }
901
902    if (ThumbSaveName){
903        char OutFileName[PATH_MAX+1];
904        // Make a relative name.
905        RelativeName(OutFileName, ThumbSaveName, FileName);
906
907        if (SaveThumbnail(OutFileName)){
908            printf("Created: '%s'\n", OutFileName);
909        }
910    }
911
912    if (CreateExifSection){
913        // Make a new minimal exif section
914        create_EXIF(NULL, 0, 0);
915        Modified = TRUE;
916    }
917
918    if (RegenThumbnail){
919        if (RegenerateThumbnail(FileName)){
920            Modified = TRUE;
921        }
922    }
923
924    if (ThumbInsertName){
925        char ThumbFileName[PATH_MAX+1];
926        // Make a relative name.
927        RelativeName(ThumbFileName, ThumbInsertName, FileName);
928
929        if (ReplaceThumbnail(ThumbFileName)){
930            Modified = TRUE;
931        }
932    }else if (TrimExif){
933        // Deleting thumbnail is just replacing it with a null thumbnail.
934        if (ReplaceThumbnail(NULL)){
935            Modified = TRUE;
936        }
937    }
938
939    if (
940#ifdef MATTHIAS
941        AddComment || RemComment ||
942#endif
943                   EditComment || CommentInsertfileName || CommentInsertLiteral){
944
945        Section_t * CommentSec;
946        char Comment[MAX_COMMENT_SIZE+1];
947        int CommentSize;
948
949        CommentSec = FindSection(M_COM);
950
951        if (CommentSec == NULL){
952            unsigned char * DummyData;
953
954            DummyData = (uchar *) malloc(3);
955            DummyData[0] = 0;
956            DummyData[1] = 2;
957            DummyData[2] = 0;
958            CommentSec = CreateSection(M_COM, DummyData, 2);
959        }
960
961        CommentSize = CommentSec->Size-2;
962        if (CommentSize > MAX_COMMENT_SIZE){
963            fprintf(stderr, "Truncating comment at %d chars\n",MAX_COMMENT_SIZE);
964            CommentSize = MAX_COMMENT_SIZE;
965        }
966
967        if (CommentInsertfileName){
968            // Read a new comment section from file.
969            char CommentFileName[PATH_MAX+1];
970            FILE * CommentFile;
971
972            // Make a relative name.
973            RelativeName(CommentFileName, CommentInsertfileName, FileName);
974
975            CommentFile = fopen(CommentFileName,"r");
976            if (CommentFile == NULL){
977                printf("Could not open '%s'\n",CommentFileName);
978            }else{
979                // Read it in.
980                // Replace the section.
981                CommentSize = fread(Comment, 1, 999, CommentFile);
982                fclose(CommentFile);
983                if (CommentSize < 0) CommentSize = 0;
984            }
985        }else if (CommentInsertLiteral){
986            strncpy(Comment, CommentInsertLiteral, MAX_COMMENT_SIZE);
987            CommentSize = strlen(Comment);
988        }else{
989#ifdef MATTHIAS
990            char CommentZt[MAX_COMMENT_SIZE+1];
991            memcpy(CommentZt, (char *)CommentSec->Data+2, CommentSize);
992            CommentZt[CommentSize] = '\0';
993            if (ModifyDescriptComment(Comment, CommentZt)){
994                Modified = TRUE;
995                CommentSize = strlen(Comment);
996            }
997            if (EditComment)
998#else
999            memcpy(Comment, (char *)CommentSec->Data+2, CommentSize);
1000#endif
1001            {
1002                char EditFileName[PATH_MAX+5];
1003                strcpy(EditFileName, FileName);
1004                strcat(EditFileName, ".txt");
1005
1006                CommentSize = FileEditComment(EditFileName, Comment, CommentSize);
1007            }
1008        }
1009
1010        if (strcmp(Comment, (char *)CommentSec->Data+2)){
1011            // Discard old comment section and put a new one in.
1012            int size;
1013            size = CommentSize+2;
1014            free(CommentSec->Data);
1015            CommentSec->Size = size;
1016            CommentSec->Data = malloc(size);
1017            CommentSec->Data[0] = (uchar)(size >> 8);
1018            CommentSec->Data[1] = (uchar)(size);
1019            memcpy((CommentSec->Data)+2, Comment, size-2);
1020            Modified = TRUE;
1021        }
1022        if (!Modified){
1023            printf("Comment not modified\n");
1024        }
1025    }
1026
1027
1028    if (CommentSavefileName){
1029        Section_t * CommentSec;
1030        CommentSec = FindSection(M_COM);
1031
1032        if (CommentSec != NULL){
1033            char OutFileName[PATH_MAX+1];
1034            FILE * CommentFile;
1035
1036            // Make a relative name.
1037            RelativeName(OutFileName, CommentSavefileName, FileName);
1038
1039            CommentFile = fopen(OutFileName,"w");
1040
1041            if (CommentFile){
1042                fwrite((char *)CommentSec->Data+2, CommentSec->Size-2 ,1, CommentFile);
1043                fclose(CommentFile);
1044            }else{
1045                ErrFatal("Could not write comment file");
1046            }
1047        }else{
1048            printf("File '%s' contains no comment section\n",FileName);
1049        }
1050    }
1051
1052    if (ExifTimeAdjust || ExifTimeSet || DateSetChars || FileTimeToExif){
1053       if (ImageInfo.numDateTimeTags){
1054            struct tm tm;
1055            time_t UnixTime;
1056            char TempBuf[50];
1057            int a;
1058            Section_t * ExifSection;
1059            if (ExifTimeSet){
1060                // A time to set was specified.
1061                UnixTime = ExifTimeSet;
1062            }else{
1063                if (FileTimeToExif){
1064                    FileTimeAsString(ImageInfo.DateTime);
1065                }
1066                if (DateSetChars){
1067                    memcpy(ImageInfo.DateTime, DateSet, DateSetChars);
1068                    a = 1970;
1069                    sscanf(DateSet, "%d", &a);
1070                    if (a < 1970){
1071                        strcpy(TempBuf, ImageInfo.DateTime);
1072                        goto skip_unixtime;
1073                    }
1074                }
1075                // A time offset to adjust by was specified.
1076                if (!Exif2tm(&tm, ImageInfo.DateTime)) goto badtime;
1077
1078                // Convert to unix 32 bit time value, add offset, and convert back.
1079                UnixTime = mktime(&tm);
1080                if ((int)UnixTime == -1) goto badtime;
1081                UnixTime += ExifTimeAdjust;
1082            }
1083            tm = *localtime(&UnixTime);
1084
1085            // Print to temp buffer first to avoid putting null termination in destination.
1086            // snprintf() would do the trick, hbut not available everywhere (like FreeBSD 4.4)
1087            sprintf(TempBuf, "%04d:%02d:%02d %02d:%02d:%02d",
1088                tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
1089                tm.tm_hour, tm.tm_min, tm.tm_sec);
1090
1091skip_unixtime:
1092            ExifSection = FindSection(M_EXIF);
1093
1094            for (a = 0; a < ImageInfo.numDateTimeTags; a++) {
1095                uchar * Pointer;
1096                Pointer = ExifSection->Data+ImageInfo.DateTimeOffsets[a]+8;
1097                memcpy(Pointer, TempBuf, 19);
1098            }
1099            memcpy(ImageInfo.DateTime, TempBuf, 19);
1100
1101            Modified = TRUE;
1102        }else{
1103            printf("File '%s' contains no Exif timestamp to change\n", FileName);
1104        }
1105    }
1106
1107    if (DeleteComments){
1108        if (RemoveSectionType(M_COM)) Modified = TRUE;
1109    }
1110    if (DeleteExif){
1111        if (RemoveSectionType(M_EXIF)) Modified = TRUE;
1112    }
1113    if (DeleteIptc){
1114        if (RemoveSectionType(M_IPTC)) Modified = TRUE;
1115    }
1116    if (DeleteXmp){
1117        if (RemoveSectionType(M_XMP)) Modified = TRUE;
1118    }
1119    if (DeleteUnknown){
1120        if (RemoveUnknownSections()) Modified = TRUE;
1121    }
1122
1123
1124    if (Modified){
1125        char BackupName[PATH_MAX+5];
1126        struct stat buf;
1127
1128        if (!Quiet) printf("Modified: %s\n",FileName);
1129
1130        strcpy(BackupName, FileName);
1131        strcat(BackupName, ".t");
1132
1133        // Remove any .old file name that may pre-exist
1134        unlink(BackupName);
1135
1136        // Rename the old file.
1137        rename(FileName, BackupName);
1138
1139        // Write the new file.
1140        if (WriteJpegFile(FileName)) {
1141
1142            // Copy the access rights from original file
1143            if (stat(BackupName, &buf) == 0){
1144                // set Unix access rights and time to new file
1145                struct utimbuf mtime;
1146                chmod(FileName, buf.st_mode);
1147
1148                mtime.actime = buf.st_mtime;
1149                mtime.modtime = buf.st_mtime;
1150
1151                utime(FileName, &mtime);
1152            }
1153
1154            // Now that we are done, remove original file.
1155            unlink(BackupName);
1156        } else {
1157            // move back the backup file
1158            rename(BackupName, FileName);
1159        }
1160    }
1161
1162
1163    if (Exif2FileTime){
1164        // Set the file date to the date from the exif header.
1165        if (ImageInfo.numDateTimeTags){
1166            // Converte the file date to Unix time.
1167            struct tm tm;
1168            time_t UnixTime;
1169            struct utimbuf mtime;
1170            if (!Exif2tm(&tm, ImageInfo.DateTime)) goto badtime;
1171
1172            UnixTime = mktime(&tm);
1173            if ((int)UnixTime == -1){
1174                goto badtime;
1175            }
1176
1177            mtime.actime = UnixTime;
1178            mtime.modtime = UnixTime;
1179
1180            if (utime(FileName, &mtime) != 0){
1181                printf("Error: Could not change time of file '%s'\n",FileName);
1182            }else{
1183                if (!Quiet) printf("%s\n",FileName);
1184            }
1185        }else{
1186            printf("File '%s' contains no Exif timestamp\n", FileName);
1187        }
1188    }
1189
1190    // Feature to rename image according to date and time from camera.
1191    // I use this feature to put images from multiple digicams in sequence.
1192
1193    if (RenameToDate){
1194        DoFileRenaming(FileName);
1195    }
1196    DiscardData();
1197    return;
1198badtime:
1199    printf("Error: Time '%s': cannot convert to Unix time\n",ImageInfo.DateTime);
1200    DiscardData();
1201}
1202
1203//--------------------------------------------------------------------------
1204// complain about bad state of the command line.
1205//--------------------------------------------------------------------------
1206static void Usage (void)
1207{
1208    printf("Jhead is a program for manipulating settings and thumnails in Exif jpeg headers\n"
1209           "used by most Digital Cameras.  v"JHEAD_VERSION" Matthias Wandel, Mar 02 2009.\n"
1210           "http://www.sentex.net/~mwandel/jhead\n"
1211           "\n");
1212
1213    printf("Usage: %s [options] files\n", progname);
1214    printf("Where:\n"
1215           " files       path/filenames with or without wildcards\n"
1216
1217           "[options] are:\n"
1218           "\nGENERAL METADATA:\n"
1219           "  -te <name> Transfer exif header from another image file <name>\n"
1220           "             Uses same name mangling as '-st' option\n"
1221           "  -dc        Delete comment field (as left by progs like Photoshop & Compupic)\n"
1222           "  -de        Strip Exif section (smaller JPEG file, but lose digicam info)\n"
1223           "  -di        Delete IPTC section (from Photoshop, or Picasa)\n"
1224           "  -dx        Deletex XMP section\n"
1225           "  -du        Delete non image sections except for Exif and comment sections\n"
1226           "  -purejpg   Strip all unnecessary data from jpeg (combines -dc -de and -du)\n"
1227           "  -mkexif    Create new minimal exif section (overwrites pre-existing exif)\n"
1228           "  -ce        Edit comment field.  Uses environment variable 'editor' to\n"
1229           "             determine which editor to use.  If editor not set, uses VI\n"
1230           "             under Unix and notepad with windows\n"
1231           "  -cs <name> Save comment section to a file\n"
1232           "  -ci <name> Insert comment section from a file.  -cs and -ci use same naming\n"
1233           "             scheme as used by the -st option\n"
1234           "  -cl string Insert literal comment string\n"
1235
1236           "\nDATE / TIME MANIPULATION:\n"
1237           "  -ft        Set file modification time to Exif time\n"
1238           "  -dsft      Set Exif time to file modification time\n"
1239           "  -n[format-string]\n"
1240           "             Rename files according to date.  Uses exif date if present, file\n"
1241           "             date otherwise.  If the optional format-string is not supplied,\n"
1242           "             the format is mmdd-hhmmss.  If a format-string is given, it is\n"
1243           "             is passed to the 'strftime' function for formatting\n"
1244           "             In addition to strftime format codes:\n"
1245           "             '%%f' as part of the string will include the original file name\n"
1246           "             '%%i' will include a sequence number, starting from 1. You can\n"
1247           "             You can specify '%%03i' for example to get leading zeros.\n"
1248           "             This feature is useful for ordering files from multiple digicams to\n"
1249           "             sequence of taking.  Only renames files whose names are mostly\n"
1250           "             numerical (as assigned by digicam)\n"
1251           "             The '.jpg' is automatically added to the end of the name.  If the\n"
1252           "             destination name already exists, a letter or digit is added to \n"
1253           "             the end of the name to make it unique.\n"
1254           "             The new name may include a path as part of the name.  If this path\n"
1255           "             does not exist, it will be created\n"
1256           "  -nf[format-string]\n"
1257           "             Same as -n, but rename regardless of original name\n"
1258           "  -a         (Windows only) Rename files with same name but different extension\n"
1259           "             Use together with -n to rename .AVI files from exif in .THM files\n"
1260           "             for example\n"
1261           "  -ta<+|->h[:mm[:ss]]\n"
1262           "             Adjust time by h:mm backwards or forwards.  Useful when having\n"
1263           "             taken pictures with the wrong time set on the camera, such as when\n"
1264           "             traveling across time zones or DST changes. Dates can be adjusted\n"
1265           "             by offsetting by 24 hours or more.  For large date adjustments,\n"
1266           "             use the -da option\n"
1267           "  -da<date>-<date>\n"
1268           "             Adjust date by large amounts.  This is used to fix photos from\n"
1269           "             cameras where the date got set back to the default camera date\n"
1270           "             by accident or battery removal.\n"
1271           "             To deal with different months and years having different numbers of\n"
1272           "             days, a simple date-month-year offset would result in unexpected\n"
1273           "             results.  Instead, the difference is specified as desired date\n"
1274           "             minus original date.  Date is specified as yyyy:mm:dd or as date\n"
1275           "             and time in the format yyyy:mm:dd/hh:mm:ss\n"
1276           "  -ts<time>  Set the Exif internal time to <time>.  <time> is in the format\n"
1277           "             yyyy:mm:dd-hh:mm:ss\n"
1278           "  -ds<date>  Set the Exif internal date.  <date> is in the format YYYY:MM:DD\n"
1279           "             or YYYY:MM or YYYY\n"
1280
1281           "\nTHUMBNAIL MANIPULATION:\n"
1282           "  -dt        Remove exif integral thumbnails.   Typically trims 10k\n"
1283           "  -st <name> Save Exif thumbnail, if there is one, in file <name>\n"
1284           "             If output file name contains the substring \"&i\" then the\n"
1285           "             image file name is substitute for the &i.  Note that quotes around\n"
1286           "             the argument are required for the '&' to be passed to the program.\n"
1287#ifndef _WIN32
1288           "             An output name of '-' causes thumbnail to be written to stdout\n"
1289#endif
1290           "  -rt <name> Replace Exif thumbnail.  Can only be done with headers that\n"
1291           "             already contain a thumbnail.\n"
1292           "  -rgt[size] Regnerate exif thumbnail.  Only works if image already\n"
1293           "             contains a thumbail.  size specifies maximum height or width of\n"
1294           "             thumbnail.  Relies on 'mogrify' programs to be on path\n"
1295
1296           "\nROTATION TAG MANIPULATION:\n"
1297           "  -autorot   Invoke jpegtran to rotate images according to Exif orientation tag\n"
1298           "             Note: Windows users must get jpegtran for this to work\n"
1299           "  -norot     Zero out the rotation tag.  This to avoid some browsers from\n"
1300           "             rotating the image again after you rotated it but neglected to\n"
1301           "             clear the rotation tag\n"
1302
1303           "\nOUTPUT VERBOSITY CONTROL:\n"
1304           "  -h         help (this text)\n"
1305           "  -v         even more verbose output\n"
1306           "  -q         Quiet (no messages on success, like Unix)\n"
1307           "  -V         Show jhead version\n"
1308           "  -exifmap   Dump header bytes, annotate.  Pipe thru sort for better viewing\n"
1309           "  -se        Supress error messages relating to corrupt exif header structure\n"
1310           "  -c         concise output\n"
1311           "  -nofinfo   Don't show file info (name/size/date)\n"
1312
1313           "\nFILE MATCHING AND SELECTION:\n"
1314           "  -model model\n"
1315           "             Only process files from digicam containing model substring in\n"
1316           "             camera model description\n"
1317           "  -exonly    Skip all files that don't have an exif header (skip all jpegs that\n"
1318           "             were not created by digicam)\n"
1319           "  -cmd command\n"
1320           "             Apply 'command' to every file, then re-insert exif and command\n"
1321           "             sections into the image. &i will be substituted for the input file\n"
1322           "             name, and &o (if &o is used). Use quotes around the command string\n"
1323           "             This is most useful in conjunction with the free ImageMagick tool. \n"
1324           "             For example, with my Canon S100, which suboptimally compresses\n"
1325           "             jpegs I can specify\n"
1326           "                jhead -cmd \"mogrify -quality 80 &i\" *.jpg\n"
1327           "             to re-compress a lot of images using ImageMagick to half the size,\n"
1328           "             and no visible loss of quality while keeping the exif header\n"
1329           "             Another invocation I like to use is jpegtran (hard to find for\n"
1330           "             windows).  I type:\n"
1331           "                jhead -cmd \"jpegtran -progressive &i &o\" *.jpg\n"
1332           "             to convert jpegs to progressive jpegs (Unix jpegtran syntax\n"
1333           "             differs slightly)\n"
1334           "  -orp       Only operate on 'portrait' aspect ratio images\n"
1335           "  -orl       Only operate on 'landscape' aspect ratio images\n"
1336#ifdef _WIN32
1337           "  -r         No longer supported.  Use the ** wildcard to recurse directories\n"
1338           "             with instead.\n"
1339           "             examples:\n"
1340           "                 jhead **/*.jpg\n"
1341           "                 jhead \"c:\\my photos\\**\\*.jpg\"\n"
1342#endif
1343
1344
1345#ifdef MATTHIAS
1346           "\n"
1347           "  -cr        Remove comment tag (my way)\n"
1348           "  -ca        Add comment tag (my way)\n"
1349           "  -ar        Auto resize to fit in 1024x1024, but never less than half\n"
1350#endif //MATTHIAS
1351
1352
1353           );
1354
1355    exit(EXIT_FAILURE);
1356}
1357
1358
1359//--------------------------------------------------------------------------
1360// Parse specified date or date+time from command line.
1361//--------------------------------------------------------------------------
1362time_t ParseCmdDate(char * DateSpecified)
1363{
1364    int a;
1365    struct tm tm;
1366    time_t UnixTime;
1367
1368    tm.tm_wday = -1;
1369    tm.tm_hour = tm.tm_min = tm.tm_sec = 0;
1370
1371    a = sscanf(DateSpecified, "%d:%d:%d/%d:%d:%d",
1372            &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
1373            &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
1374
1375    if (a != 3 && a < 5){
1376        // Date must be YYYY:MM:DD, YYYY:MM:DD+HH:MM
1377        // or YYYY:MM:DD+HH:MM:SS
1378        ErrFatal("Could not parse specified date");
1379    }
1380    tm.tm_isdst = -1;
1381    tm.tm_mon -= 1;      // Adjust for unix zero-based months
1382    tm.tm_year -= 1900;  // Adjust for year starting at 1900
1383
1384    UnixTime = mktime(&tm);
1385    if (UnixTime == -1){
1386        ErrFatal("Specified time is invalid or out of range");
1387    }
1388
1389    return UnixTime;
1390}
1391
1392//--------------------------------------------------------------------------
1393// The main program.
1394//--------------------------------------------------------------------------
1395#if 0
1396int main (int argc, char **argv)
1397{
1398    int argn;
1399    char * arg;
1400    progname = argv[0];
1401
1402    for (argn=1;argn<argc;argn++){
1403        arg = argv[argn];
1404        if (arg[0] != '-') break; // Filenames from here on.
1405
1406    // General metadata options:
1407        if (!strcmp(arg,"-te")){
1408            ExifXferScrFile = argv[++argn];
1409            DoModify = TRUE;
1410        }else if (!strcmp(arg,"-dc")){
1411            DeleteComments = TRUE;
1412            DoModify = TRUE;
1413        }else if (!strcmp(arg,"-de")){
1414            DeleteExif = TRUE;
1415            DoModify = TRUE;
1416        }else if (!strcmp(arg,"-di")){
1417            DeleteIptc = TRUE;
1418            DoModify = TRUE;
1419        }else if (!strcmp(arg,"-dx")){
1420            DeleteXmp = TRUE;
1421            DoModify = TRUE;
1422        }else if (!strcmp(arg, "-du")){
1423            DeleteUnknown = TRUE;
1424            DoModify = TRUE;
1425        }else if (!strcmp(arg, "-purejpg")){
1426            DeleteExif = TRUE;
1427            DeleteComments = TRUE;
1428            DeleteIptc = TRUE;
1429            DeleteUnknown = TRUE;
1430            DeleteXmp = TRUE;
1431            DoModify = TRUE;
1432        }else if (!strcmp(arg,"-ce")){
1433            EditComment = TRUE;
1434            DoModify = TRUE;
1435        }else if (!strcmp(arg,"-cs")){
1436            CommentSavefileName = argv[++argn];
1437        }else if (!strcmp(arg,"-ci")){
1438            CommentInsertfileName = argv[++argn];
1439            DoModify = TRUE;
1440        }else if (!strcmp(arg,"-cl")){
1441            CommentInsertLiteral = argv[++argn];
1442            DoModify = TRUE;
1443        }else if (!strcmp(arg,"-mkexif")){
1444            CreateExifSection = TRUE;
1445            DoModify = TRUE;
1446
1447    // Output verbosity control
1448        }else if (!strcmp(arg,"-h")){
1449            Usage();
1450        }else if (!strcmp(arg,"-v")){
1451            ShowTags = TRUE;
1452        }else if (!strcmp(arg,"-q")){
1453            Quiet = TRUE;
1454        }else if (!strcmp(arg,"-V")){
1455            printf("Jhead version: "JHEAD_VERSION"   Compiled: "__DATE__"\n");
1456            exit(0);
1457        }else if (!strcmp(arg,"-exifmap")){
1458            DumpExifMap = TRUE;
1459        }else if (!strcmp(arg,"-se")){
1460            SupressNonFatalErrors = TRUE;
1461        }else if (!strcmp(arg,"-c")){
1462            ShowConcise = TRUE;
1463        }else if (!strcmp(arg,"-nofinfo")){
1464            ShowFileInfo = 0;
1465
1466    // Thumbnail manipulation options
1467        }else if (!strcmp(arg,"-dt")){
1468            TrimExif = TRUE;
1469            DoModify = TRUE;
1470        }else if (!strcmp(arg,"-st")){
1471            ThumbSaveName = argv[++argn];
1472            DoReadAction = TRUE;
1473        }else if (!strcmp(arg,"-rt")){
1474            ThumbInsertName = argv[++argn];
1475            DoModify = TRUE;
1476        }else if (!memcmp(arg,"-rgt", 4)){
1477            RegenThumbnail = 160;
1478            sscanf(arg+4, "%d", &RegenThumbnail);
1479            if (RegenThumbnail > 320){
1480                ErrFatal("Specified thumbnail geometry too big!");
1481            }
1482            DoModify = TRUE;
1483
1484    // Rotation tag manipulation
1485        }else if (!strcmp(arg,"-autorot")){
1486            AutoRotate = 1;
1487            DoModify = TRUE;
1488        }else if (!strcmp(arg,"-norot")){
1489            AutoRotate = 1;
1490            ZeroRotateTagOnly = 1;
1491            DoModify = TRUE;
1492
1493    // Date/Time manipulation options
1494        }else if (!memcmp(arg,"-n",2)){
1495            RenameToDate = 1;
1496            DoReadAction = TRUE; // Rename doesn't modify file, so count as read action.
1497            arg+=2;
1498            if (*arg == 'f'){
1499                RenameToDate = 2;
1500                arg++;
1501            }
1502            if (*arg){
1503                // A strftime format string is supplied.
1504                strftime_args = arg;
1505                #ifdef _WIN32
1506                    SlashToNative(strftime_args);
1507                #endif
1508                //printf("strftime_args = %s\n",arg);
1509            }
1510        }else if (!strcmp(arg,"-a")){
1511            #ifndef _WIN32
1512                ErrFatal("Error: -a only supported in Windows version");
1513            #else
1514                RenameAssociatedFiles = TRUE;
1515            #endif
1516        }else if (!strcmp(arg,"-ft")){
1517            Exif2FileTime = TRUE;
1518            DoReadAction = TRUE;
1519        }else if (!memcmp(arg,"-ta",3)){
1520            // Time adjust feature.
1521            int hours, minutes, seconds, n;
1522            minutes = seconds = 0;
1523            if (arg[3] != '-' && arg[3] != '+'){
1524                ErrFatal("Error: -ta must be followed by +/- and a time");
1525            }
1526            n = sscanf(arg+4, "%d:%d:%d", &hours, &minutes, &seconds);
1527
1528            if (n < 1){
1529                ErrFatal("Error: -ta must be immediately followed by time");
1530            }
1531            if (ExifTimeAdjust) ErrFatal("Can only use one of -da or -ta options at once");
1532            ExifTimeAdjust = hours*3600 + minutes*60 + seconds;
1533            if (arg[3] == '-') ExifTimeAdjust = -ExifTimeAdjust;
1534            DoModify = TRUE;
1535        }else if (!memcmp(arg,"-da",3)){
1536            // Date adjust feature (large time adjustments)
1537            time_t NewDate, OldDate = 0;
1538            char * pOldDate;
1539            NewDate = ParseCmdDate(arg+3);
1540            pOldDate = strstr(arg+1, "-");
1541            if (pOldDate){
1542                OldDate = ParseCmdDate(pOldDate+1);
1543            }else{
1544                ErrFatal("Must specifiy second date for -da option");
1545            }
1546            if (ExifTimeAdjust) ErrFatal("Can only use one of -da or -ta options at once");
1547            ExifTimeAdjust = NewDate-OldDate;
1548            DoModify = TRUE;
1549        }else if (!memcmp(arg,"-dsft",5)){
1550            // Set file time to date/time in exif
1551            FileTimeToExif = TRUE;
1552            DoModify = TRUE;
1553        }else if (!memcmp(arg,"-ds",3)){
1554            // Set date feature
1555            int a;
1556            // Check date validity and copy it.  Could be incompletely specified.
1557            strcpy(DateSet, "0000:01:01");
1558            for (a=0;arg[a+3];a++){
1559                if (isdigit(DateSet[a])){
1560                    if (!isdigit(arg[a+3])){
1561                        a = 0;
1562                        break;
1563                    }
1564                }else{
1565                    if (arg[a+3] != ':'){
1566                        a=0;
1567                        break;
1568                    }
1569                }
1570                DateSet[a] = arg[a+3];
1571            }
1572            if (a < 4 || a > 10){
1573                ErrFatal("Date must be in format YYYY, YYYY:MM, or YYYY:MM:DD");
1574            }
1575            DateSetChars = a;
1576            DoModify = TRUE;
1577        }else if (!memcmp(arg,"-ts",3)){
1578            // Set the exif time.
1579            // Time must be specified as "yyyy:mm:dd-hh:mm:ss"
1580            char * c;
1581            struct tm tm;
1582
1583            c = strstr(arg+1, "-");
1584            if (c) *c = ' '; // Replace '-' with a space.
1585
1586            if (!Exif2tm(&tm, arg+3)){
1587                ErrFatal("-ts option must be followed by time in format yyyy:mmm:dd-hh:mm:ss\n"
1588                        "Example: jhead -ts2001:01:01-12:00:00 foo.jpg");
1589            }
1590
1591            ExifTimeSet  = mktime(&tm);
1592
1593            if ((int)ExifTimeSet == -1) ErrFatal("Time specified is out of range");
1594            DoModify = TRUE;
1595
1596    // File matching and selection
1597        }else if (!strcmp(arg,"-model")){
1598            if (argn+1 >= argc) Usage(); // No extra argument.
1599            FilterModel = argv[++argn];
1600        }else if (!strcmp(arg,"-exonly")){
1601            ExifOnly = 1;
1602        }else if (!strcmp(arg,"-orp")){
1603            PortraitOnly = 1;
1604        }else if (!strcmp(arg,"-orl")){
1605            PortraitOnly = -1;
1606        }else if (!strcmp(arg,"-cmd")){
1607            if (argn+1 >= argc) Usage(); // No extra argument.
1608            ApplyCommand = argv[++argn];
1609            DoModify = TRUE;
1610
1611#ifdef MATTHIAS
1612        }else if (!strcmp(arg,"-ca")){
1613            // Its a literal comment.  Add.
1614            AddComment = argv[++argn];
1615            DoModify = TRUE;
1616        }else if (!strcmp(arg,"-cr")){
1617            // Its a literal comment.  Remove this keyword.
1618            RemComment = argv[++argn];
1619            DoModify = TRUE;
1620        }else if (!strcmp(arg,"-ar")){
1621            AutoResize = TRUE;
1622            ShowConcise = TRUE;
1623            ApplyCommand = (char *)1; // Must be non null so it does commands.
1624            DoModify = TRUE;
1625#endif // MATTHIAS
1626        }else{
1627            printf("Argument '%s' not understood\n",arg);
1628            printf("Use jhead -h for list of arguments\n");
1629            exit(-1);
1630        }
1631        if (argn >= argc){
1632            // Used an extra argument - becuase the last argument
1633            // used up an extr argument.
1634            ErrFatal("Extra argument required");
1635        }
1636    }
1637    if (argn == argc){
1638        ErrFatal("No files to process.  Use -h for help");
1639    }
1640
1641    if (ThumbSaveName != NULL && strcmp(ThumbSaveName, "&i") == 0){
1642        printf("Error: By specifying \"&i\" for the thumbail name, your original file\n"
1643               "       will be overwitten.  If this is what you really want,\n"
1644               "       specify  -st \"./&i\"  to override this check\n");
1645        exit(0);
1646    }
1647
1648    if (RegenThumbnail){
1649        if (ThumbSaveName || ThumbInsertName){
1650            printf("Error: Cannot regen and save or insert thumbnail in same run\n");
1651            exit(0);
1652        }
1653    }
1654
1655    if (EditComment){
1656        if (CommentSavefileName != NULL || CommentInsertfileName != NULL){
1657            printf("Error: Cannot use -ce option in combination with -cs or -ci\n");
1658            exit(0);
1659        }
1660    }
1661
1662
1663    if (ExifXferScrFile){
1664        if (FilterModel || ApplyCommand){
1665            ErrFatal("Error: Filter by model and/or applying command to files\n"
1666            "   invalid while transfering Exif headers");
1667        }
1668    }
1669
1670    FileSequence = 0;
1671    for (;argn<argc;argn++){
1672        FilesMatched = FALSE;
1673
1674        #ifdef _WIN32
1675            SlashToNative(argv[argn]);
1676            // Use my globbing module to do fancier wildcard expansion with recursive
1677            // subdirectories under Windows.
1678            MyGlob(argv[argn], ProcessFile);
1679        #else
1680            // Under linux, don't do any extra fancy globbing - shell globbing is
1681            // pretty fancy as it is - although not as good as myglob.c
1682            ProcessFile(argv[argn]);
1683        #endif
1684
1685        if (!FilesMatched){
1686            fprintf(stderr, "Error: No files matched '%s'\n",argv[argn]);
1687        }
1688    }
1689
1690    if (FileSequence == 0){
1691        return EXIT_FAILURE;
1692    }else{
1693        return EXIT_SUCCESS;
1694    }
1695}
1696#endif
1697
1698#endif   // commented out -- security risk
1699
1700