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
29 static int FilesMatched;
30 static int FileSequence;
31
32 static const char * CurrentFile;
33
34 static const char * progname; // program name for error messages
35
36 //--------------------------------------------------------------------------
37 // Command line options flags
38 static int TrimExif = FALSE; // Cut off exif beyond interesting data.
39 static int RenameToDate = 0; // 1=rename, 2=rename all.
40 #ifdef _WIN32
41 static int RenameAssociatedFiles = FALSE;
42 #endif
43 static char * strftime_args = NULL; // Format for new file name.
44 static int Exif2FileTime = FALSE;
45 static int DoModify = FALSE;
46 static int DoReadAction = FALSE;
47 int ShowTags = FALSE; // Do not show raw by default.
48 static int Quiet = FALSE; // Be quiet on success (like unix programs)
49 int DumpExifMap = FALSE;
50 static int ShowConcise = FALSE;
51 static int CreateExifSection = FALSE;
52 static char * ApplyCommand = NULL; // Apply this command to all images.
53 static char * FilterModel = NULL;
54 static int ExifOnly = FALSE;
55 static int PortraitOnly = FALSE;
56 static time_t ExifTimeAdjust = 0; // Timezone adjust
57 static time_t ExifTimeSet = 0; // Set exif time to a value.
58 static char DateSet[11];
59 static unsigned DateSetChars = 0;
60 static unsigned FileTimeToExif = FALSE;
61
62 static int DeleteComments = FALSE;
63 static int DeleteExif = FALSE;
64 static int DeleteIptc = FALSE;
65 static int DeleteXmp = FALSE;
66 static int DeleteUnknown = FALSE;
67 static char * ThumbSaveName = NULL; // If not NULL, use this string to make up
68 // the filename to store the thumbnail to.
69
70 static char * ThumbInsertName = NULL; // If not NULL, use this string to make up
71 // the filename to retrieve the thumbnail from.
72
73 static int RegenThumbnail = FALSE;
74
75 static char * ExifXferScrFile = NULL;// Extract Exif header from this file, and
76 // put it into the Jpegs processed.
77
78 static int EditComment = FALSE; // Invoke an editor for editing the comment
79 static int SupressNonFatalErrors = FALSE; // Wether or not to pint warnings on recoverable errors
80
81 static char * CommentSavefileName = NULL; // Save comment to this file.
82 static char * CommentInsertfileName = NULL; // Insert comment from this file.
83 static char * CommentInsertLiteral = NULL; // Insert this comment (from command line)
84
85 static int AutoRotate = FALSE;
86 static int ZeroRotateTagOnly = FALSE;
87
88 static 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 //--------------------------------------------------------------------------
ErrFatal(char * msg)105 void ErrFatal(char * msg)
106 {
107 ALOGE("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 //--------------------------------------------------------------------------
ErrNonfatal(char * msg,int a1,int a2)116 void ErrNonfatal(char * msg, int a1, int a2)
117 {
118 ALOGV("Nonfatal Error : ");
119 ALOGV(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 //--------------------------------------------------------------------------
FileTimeAsString(char * TimeStr)131 void 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 //--------------------------------------------------------------------------
142 static 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 //--------------------------------------------------------------------------
200 static char KnownTags[][10] = {"date", "desc","scan_date","author",
201 "keyword","videograb",
202 "show_raw","panorama","titlepix",""};
203
204 static 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 //--------------------------------------------------------------------------
286 static 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 //--------------------------------------------------------------------------
315 static 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 //--------------------------------------------------------------------------
352 static 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 //--------------------------------------------------------------------------
421 static 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 //--------------------------------------------------------------------------
458 static 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 //--------------------------------------------------------------------------
480 void 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 //--------------------------------------------------------------------------
536 static 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 //--------------------------------------------------------------------------
698 static 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 //--------------------------------------------------------------------------
749 static 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 //--------------------------------------------------------------------------
772 void 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, 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
1091 skip_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;
1198 badtime:
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 //--------------------------------------------------------------------------
1206 static 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 //--------------------------------------------------------------------------
1362 time_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
1396 int 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