| //-------------------------------------------------------------------------- |
| // Program to pull the information out of various types of EXIF digital |
| // camera files and show it in a reasonably consistent way |
| // |
| // Version 2.86 |
| // |
| // Compiling under Windows: |
| // Make sure you have Microsoft's compiler on the path, then run make.bat |
| // |
| // Dec 1999 - Mar 2009 |
| // |
| // by Matthias Wandel www.sentex.net/~mwandel |
| //-------------------------------------------------------------------------- |
| #include "jhead.h" |
| |
| #include <sys/stat.h> |
| #include <utils/Log.h> |
| |
| #define JHEAD_VERSION "2.87" |
| |
| // This #define turns on features that are too very specific to |
| // how I organize my photos. Best to ignore everything inside #ifdef MATTHIAS |
| //#define MATTHIAS |
| |
| #ifdef _WIN32 |
| #include <io.h> |
| #endif |
| |
| static int FilesMatched; |
| static int FileSequence; |
| |
| static const char * CurrentFile; |
| |
| static const char * progname; // program name for error messages |
| |
| //-------------------------------------------------------------------------- |
| // Command line options flags |
| static int TrimExif = FALSE; // Cut off exif beyond interesting data. |
| static int RenameToDate = 0; // 1=rename, 2=rename all. |
| #ifdef _WIN32 |
| static int RenameAssociatedFiles = FALSE; |
| #endif |
| static char * strftime_args = NULL; // Format for new file name. |
| static int Exif2FileTime = FALSE; |
| static int DoModify = FALSE; |
| static int DoReadAction = FALSE; |
| int ShowTags = FALSE; // Do not show raw by default. |
| static int Quiet = FALSE; // Be quiet on success (like unix programs) |
| int DumpExifMap = FALSE; |
| static int ShowConcise = FALSE; |
| static int CreateExifSection = FALSE; |
| static char * ApplyCommand = NULL; // Apply this command to all images. |
| static char * FilterModel = NULL; |
| static int ExifOnly = FALSE; |
| static int PortraitOnly = FALSE; |
| static time_t ExifTimeAdjust = 0; // Timezone adjust |
| static time_t ExifTimeSet = 0; // Set exif time to a value. |
| static char DateSet[11]; |
| static unsigned DateSetChars = 0; |
| static unsigned FileTimeToExif = FALSE; |
| |
| static int DeleteComments = FALSE; |
| static int DeleteExif = FALSE; |
| static int DeleteIptc = FALSE; |
| static int DeleteXmp = FALSE; |
| static int DeleteUnknown = FALSE; |
| static char * ThumbSaveName = NULL; // If not NULL, use this string to make up |
| // the filename to store the thumbnail to. |
| |
| static char * ThumbInsertName = NULL; // If not NULL, use this string to make up |
| // the filename to retrieve the thumbnail from. |
| |
| static int RegenThumbnail = FALSE; |
| |
| static char * ExifXferScrFile = NULL;// Extract Exif header from this file, and |
| // put it into the Jpegs processed. |
| |
| static int EditComment = FALSE; // Invoke an editor for editing the comment |
| static int SupressNonFatalErrors = FALSE; // Wether or not to pint warnings on recoverable errors |
| |
| static char * CommentSavefileName = NULL; // Save comment to this file. |
| static char * CommentInsertfileName = NULL; // Insert comment from this file. |
| static char * CommentInsertLiteral = NULL; // Insert this comment (from command line) |
| |
| static int AutoRotate = FALSE; |
| static int ZeroRotateTagOnly = FALSE; |
| |
| static int ShowFileInfo = TRUE; // Indicates to show standard file info |
| // (file name, file size, file date) |
| |
| |
| #ifdef MATTHIAS |
| // This #ifdef to take out less than elegant stuff for editing |
| // the comments in a JPEG. The programs rdjpgcom and wrjpgcom |
| // included with Linux distributions do a better job. |
| |
| static char * AddComment = NULL; // Add this tag. |
| static char * RemComment = NULL; // Remove this tag |
| static int AutoResize = FALSE; |
| #endif // MATTHIAS |
| |
| //-------------------------------------------------------------------------- |
| // Error exit handler |
| //-------------------------------------------------------------------------- |
| void ErrFatal(char * msg) |
| { |
| LOGE("Error : %s\n", msg); |
| if (CurrentFile) fprintf(stderr,"in file '%s'\n",CurrentFile); |
| exit(EXIT_FAILURE); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Report non fatal errors. Now that microsoft.net modifies exif headers, |
| // there's corrupted ones, and there could be more in the future. |
| //-------------------------------------------------------------------------- |
| void ErrNonfatal(char * msg, int a1, int a2) |
| { |
| LOGE("Nonfatal Error : "); |
| LOGE(msg, a1, a2); |
| if (SupressNonFatalErrors) return; |
| |
| fprintf(stderr,"\nNonfatal Error : "); |
| if (CurrentFile) fprintf(stderr,"'%s' ",CurrentFile); |
| fprintf(stderr, msg, a1, a2); |
| fprintf(stderr, "\n"); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Set file time as exif time. |
| //-------------------------------------------------------------------------- |
| void FileTimeAsString(char * TimeStr) |
| { |
| struct tm ts; |
| ts = *localtime(&ImageInfo.FileDateTime); |
| strftime(TimeStr, 20, "%Y:%m:%d %H:%M:%S", &ts); |
| } |
| |
| #if 0 // not used -- possible security risk with use of system, sprintf, etc. |
| //-------------------------------------------------------------------------- |
| // Invoke an editor for editing a string. |
| //-------------------------------------------------------------------------- |
| static int FileEditComment(char * TempFileName, char * Comment, int CommentSize) |
| { |
| FILE * file; |
| int a; |
| char QuotedPath[PATH_MAX+10]; |
| |
| file = fopen(TempFileName, "w"); |
| if (file == NULL){ |
| fprintf(stderr, "Can't create file '%s'\n",TempFileName); |
| ErrFatal("could not create temporary file"); |
| } |
| fwrite(Comment, CommentSize, 1, file); |
| |
| fclose(file); |
| |
| fflush(stdout); // So logs are contiguous. |
| |
| { |
| char * Editor; |
| Editor = getenv("EDITOR"); |
| if (Editor == NULL){ |
| #ifdef _WIN32 |
| Editor = "notepad"; |
| #else |
| Editor = "vi"; |
| #endif |
| } |
| if (strlen(Editor) > PATH_MAX) ErrFatal("env too long"); |
| |
| sprintf(QuotedPath, "%s \"%s\"",Editor, TempFileName); |
| a = system(QuotedPath); |
| } |
| |
| if (a != 0){ |
| perror("Editor failed to launch"); |
| exit(-1); |
| } |
| |
| file = fopen(TempFileName, "r"); |
| if (file == NULL){ |
| ErrFatal("could not open temp file for read"); |
| } |
| |
| // Read the file back in. |
| CommentSize = fread(Comment, 1, 999, file); |
| |
| fclose(file); |
| |
| unlink(TempFileName); |
| |
| return CommentSize; |
| } |
| |
| #ifdef MATTHIAS |
| //-------------------------------------------------------------------------- |
| // Modify one of the lines in the comment field. |
| // This very specific to the photo album program stuff. |
| //-------------------------------------------------------------------------- |
| static char KnownTags[][10] = {"date", "desc","scan_date","author", |
| "keyword","videograb", |
| "show_raw","panorama","titlepix",""}; |
| |
| static int ModifyDescriptComment(char * OutComment, char * SrcComment) |
| { |
| char Line[500]; |
| int Len; |
| int a,i; |
| unsigned l; |
| int HasScandate = FALSE; |
| int TagExists = FALSE; |
| int Modified = FALSE; |
| Len = 0; |
| |
| OutComment[0] = 0; |
| |
| |
| for (i=0;;i++){ |
| if (SrcComment[i] == '\r' || SrcComment[i] == '\n' || SrcComment[i] == 0 || Len >= 199){ |
| // Process the line. |
| if (Len > 0){ |
| Line[Len] = 0; |
| //printf("Line: '%s'\n",Line); |
| for (a=0;;a++){ |
| l = strlen(KnownTags[a]); |
| if (!l){ |
| // Unknown tag. Discard it. |
| printf("Error: Unknown tag '%s'\n", Line); // Deletes the tag. |
| Modified = TRUE; |
| break; |
| } |
| if (memcmp(Line, KnownTags[a], l) == 0){ |
| if (Line[l] == ' ' || Line[l] == '=' || Line[l] == 0){ |
| // Its a good tag. |
| if (Line[l] == ' ') Line[l] = '='; // Use equal sign for clarity. |
| if (a == 2) break; // Delete 'orig_path' tag. |
| if (a == 3) HasScandate = TRUE; |
| if (RemComment){ |
| if (strlen(RemComment) == l){ |
| if (!memcmp(Line, RemComment, l)){ |
| Modified = TRUE; |
| break; |
| } |
| } |
| } |
| if (AddComment){ |
| // Overwrite old comment of same tag with new one. |
| if (!memcmp(Line, AddComment, l+1)){ |
| TagExists = TRUE; |
| strncpy(Line, AddComment, sizeof(Line)); |
| Modified = TRUE; |
| } |
| } |
| strncat(OutComment, Line, MAX_COMMENT_SIZE-5-strlen(OutComment)); |
| strcat(OutComment, "\n"); |
| break; |
| } |
| } |
| } |
| } |
| Line[Len = 0] = 0; |
| if (SrcComment[i] == 0) break; |
| }else{ |
| Line[Len++] = SrcComment[i]; |
| } |
| } |
| |
| if (AddComment && TagExists == FALSE){ |
| strncat(OutComment, AddComment, MAX_COMMENT_SIZE-5-strlen(OutComment)); |
| strcat(OutComment, "\n"); |
| Modified = TRUE; |
| } |
| |
| if (!HasScandate && !ImageInfo.DateTime[0]){ |
| // Scan date is not in the file yet, and it doesn't have one built in. Add it. |
| char Temp[30]; |
| sprintf(Temp, "scan_date=%s", ctime(&ImageInfo.FileDateTime)); |
| strncat(OutComment, Temp, MAX_COMMENT_SIZE-5-strlen(OutComment)); |
| Modified = TRUE; |
| } |
| return Modified; |
| } |
| //-------------------------------------------------------------------------- |
| // Automatic make smaller command stuff |
| //-------------------------------------------------------------------------- |
| static int AutoResizeCmdStuff(void) |
| { |
| static char CommandString[PATH_MAX+1]; |
| double scale; |
| |
| ApplyCommand = CommandString; |
| |
| if (ImageInfo.Height <= 1280 && ImageInfo.Width <= 1280){ |
| printf("not resizing %dx%x '%s'\n",ImageInfo.Height, ImageInfo.Width, ImageInfo.FileName); |
| return FALSE; |
| } |
| |
| scale = 1024.0 / ImageInfo.Height; |
| if (1024.0 / ImageInfo.Width < scale) scale = 1024.0 / ImageInfo.Width; |
| |
| if (scale < 0.5) scale = 0.5; // Don't scale down by more than a factor of two. |
| |
| sprintf(CommandString, "mogrify -geometry %dx%d -quality 85 &i",(int)(ImageInfo.Width*scale), (int)(ImageInfo.Height*scale)); |
| return TRUE; |
| } |
| |
| |
| #endif // MATTHIAS |
| |
| |
| //-------------------------------------------------------------------------- |
| // Escape an argument such that it is interpreted literally by the shell |
| // (returns the number of written characters) |
| //-------------------------------------------------------------------------- |
| static int shellescape(char* to, const char* from) |
| { |
| int i, j; |
| i = j = 0; |
| |
| // Enclosing characters in double quotes preserves the literal value of |
| // all characters within the quotes, with the exception of $, `, and \. |
| to[j++] = '"'; |
| while(from[i]) |
| { |
| #ifdef _WIN32 |
| // Under WIN32, there isn't really anything dangerous you can do with |
| // escape characters, plus windows users aren't as sercurity paranoid. |
| // Hence, no need to do fancy escaping. |
| to[j++] = from[i++]; |
| #else |
| switch(from[i]) { |
| case '"': |
| case '$': |
| case '`': |
| case '\\': |
| to[j++] = '\\'; |
| // Fallthru... |
| default: |
| to[j++] = from[i++]; |
| } |
| #endif |
| if (j >= PATH_MAX) ErrFatal("max path exceeded"); |
| } |
| to[j++] = '"'; |
| return j; |
| } |
| |
| |
| //-------------------------------------------------------------------------- |
| // Apply the specified command to the JPEG file. |
| //-------------------------------------------------------------------------- |
| static void DoCommand(const char * FileName, int ShowIt) |
| { |
| int a,e; |
| char ExecString[PATH_MAX*3]; |
| char TempName[PATH_MAX+10]; |
| int TempUsed = FALSE; |
| |
| e = 0; |
| |
| // Generate an unused temporary file name in the destination directory |
| // (a is the number of characters to copy from FileName) |
| a = strlen(FileName)-1; |
| while(a > 0 && FileName[a-1] != SLASH) a--; |
| memcpy(TempName, FileName, a); |
| strcpy(TempName+a, "XXXXXX"); |
| mktemp(TempName); |
| if(!TempName[0]) { |
| ErrFatal("Cannot find available temporary file name"); |
| } |
| |
| |
| |
| // Build the exec string. &i and &o in the exec string get replaced by input and output files. |
| for (a=0;;a++){ |
| if (ApplyCommand[a] == '&'){ |
| if (ApplyCommand[a+1] == 'i'){ |
| // Input file. |
| e += shellescape(ExecString+e, FileName); |
| a += 1; |
| continue; |
| } |
| if (ApplyCommand[a+1] == 'o'){ |
| // Needs an output file distinct from the input file. |
| e += shellescape(ExecString+e, TempName); |
| a += 1; |
| TempUsed = TRUE; |
| continue; |
| } |
| } |
| ExecString[e++] = ApplyCommand[a]; |
| if (ApplyCommand[a] == 0) break; |
| } |
| |
| if (ShowIt) printf("Cmd:%s\n",ExecString); |
| |
| errno = 0; |
| a = system(ExecString); |
| |
| if (a || errno){ |
| // A command can however fail without errno getting set or system returning an error. |
| if (errno) perror("system"); |
| ErrFatal("Problem executing specified command"); |
| } |
| |
| if (TempUsed){ |
| // Don't delete original file until we know a new one was created by the command. |
| struct stat dummy; |
| if (stat(TempName, &dummy) == 0){ |
| unlink(FileName); |
| rename(TempName, FileName); |
| }else{ |
| ErrFatal("specified command did not produce expected output file"); |
| } |
| } |
| } |
| |
| //-------------------------------------------------------------------------- |
| // check if this file should be skipped based on contents. |
| //-------------------------------------------------------------------------- |
| static int CheckFileSkip(void) |
| { |
| // I sometimes add code here to only process images based on certain |
| // criteria - for example, only to convert non progressive Jpegs to progressives, etc.. |
| |
| if (FilterModel){ |
| // Filtering processing by camera model. |
| // This feature is useful when pictures from multiple cameras are colated, |
| // the its found that one of the cameras has the time set incorrectly. |
| if (strstr(ImageInfo.CameraModel, FilterModel) == NULL){ |
| // Skip. |
| return TRUE; |
| } |
| } |
| |
| if (ExifOnly){ |
| // Filtering by EXIF only. Skip all files that have no Exif. |
| if (FindSection(M_EXIF) == NULL){ |
| return TRUE; |
| } |
| } |
| |
| if (PortraitOnly == 1){ |
| if (ImageInfo.Width > ImageInfo.Height) return TRUE; |
| } |
| |
| if (PortraitOnly == -1){ |
| if (ImageInfo.Width < ImageInfo.Height) return TRUE; |
| } |
| |
| return FALSE; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Subsititute original name for '&i' if present in specified name. |
| // This to allow specifying relative names when manipulating multiple files. |
| //-------------------------------------------------------------------------- |
| static void RelativeName(char * OutFileName, const char * NamePattern, const char * OrigName) |
| { |
| // If the filename contains substring "&i", then substitute the |
| // filename for that. This gives flexibility in terms of processing |
| // multiple files at a time. |
| char * Subst; |
| Subst = strstr(NamePattern, "&i"); |
| if (Subst){ |
| strncpy(OutFileName, NamePattern, Subst-NamePattern); |
| OutFileName[Subst-NamePattern] = 0; |
| strncat(OutFileName, OrigName, PATH_MAX); |
| strncat(OutFileName, Subst+2, PATH_MAX); |
| }else{ |
| strncpy(OutFileName, NamePattern, PATH_MAX); |
| } |
| } |
| |
| |
| #ifdef _WIN32 |
| //-------------------------------------------------------------------------- |
| // Rename associated files |
| //-------------------------------------------------------------------------- |
| void RenameAssociated(const char * FileName, char * NewBaseName) |
| { |
| int a; |
| int PathLen; |
| int ExtPos; |
| char FilePattern[_MAX_PATH+1]; |
| char NewName[_MAX_PATH+1]; |
| struct _finddata_t finddata; |
| long find_handle; |
| |
| for(ExtPos = strlen(FileName);FileName[ExtPos-1] != '.';){ |
| if (--ExtPos == 0) return; // No extension! |
| } |
| |
| memcpy(FilePattern, FileName, ExtPos); |
| FilePattern[ExtPos] = '*'; |
| FilePattern[ExtPos+1] = '\0'; |
| |
| for(PathLen = strlen(FileName);FileName[PathLen-1] != SLASH;){ |
| if (--PathLen == 0) break; |
| } |
| |
| find_handle = _findfirst(FilePattern, &finddata); |
| |
| for (;;){ |
| if (find_handle == -1) break; |
| |
| // Eliminate the obvious patterns. |
| if (!memcmp(finddata.name, ".",2)) goto next_file; |
| if (!memcmp(finddata.name, "..",3)) goto next_file; |
| if (finddata.attrib & _A_SUBDIR) goto next_file; |
| |
| strncpy(FilePattern+PathLen, finddata.name, PATH_MAX-PathLen); // full name with path |
| |
| strcpy(NewName, NewBaseName); |
| for(a = strlen(finddata.name);finddata.name[a] != '.';){ |
| if (--a == 0) goto next_file; |
| } |
| strncat(NewName, finddata.name+a, _MAX_PATH-strlen(NewName)); // add extension to new name |
| |
| if (rename(FilePattern, NewName) == 0){ |
| if (!Quiet){ |
| printf("%s --> %s\n",FilePattern, NewName); |
| } |
| } |
| |
| next_file: |
| if (_findnext(find_handle, &finddata) != 0) break; |
| } |
| _findclose(find_handle); |
| } |
| #endif |
| |
| //-------------------------------------------------------------------------- |
| // Handle renaming of files by date. |
| //-------------------------------------------------------------------------- |
| static void DoFileRenaming(const char * FileName) |
| { |
| int NumAlpha = 0; |
| int NumDigit = 0; |
| int PrefixPart = 0; // Where the actual filename starts. |
| int ExtensionPart; // Where the file extension starts. |
| int a; |
| struct tm tm; |
| char NewBaseName[PATH_MAX*2]; |
| int AddLetter = 0; |
| char NewName[PATH_MAX+2]; |
| |
| ExtensionPart = strlen(FileName); |
| for (a=0;FileName[a];a++){ |
| if (FileName[a] == SLASH){ |
| // Don't count path component. |
| NumAlpha = 0; |
| NumDigit = 0; |
| PrefixPart = a+1; |
| } |
| |
| if (FileName[a] == '.') ExtensionPart = a; // Remember where extension starts. |
| |
| if (isalpha(FileName[a])) NumAlpha += 1; // Tally up alpha vs. digits to judge wether to rename. |
| if (isdigit(FileName[a])) NumDigit += 1; |
| } |
| |
| if (RenameToDate <= 1){ |
| // If naming isn't forced, ensure name is mostly digits, or leave it alone. |
| if (NumAlpha > 8 || NumDigit < 4){ |
| return; |
| } |
| } |
| |
| if (!Exif2tm(&tm, ImageInfo.DateTime)){ |
| printf("File '%s' contains no exif date stamp. Using file date\n",FileName); |
| // Use file date/time instead. |
| tm = *localtime(&ImageInfo.FileDateTime); |
| } |
| |
| |
| strncpy(NewBaseName, FileName, PATH_MAX); // Get path component of name. |
| |
| if (strftime_args){ |
| // Complicated scheme for flexibility. Just pass the args to strftime. |
| time_t UnixTime; |
| |
| char *s; |
| char pattern[PATH_MAX+20]; |
| int n = ExtensionPart - PrefixPart; |
| |
| // Call mktime to get weekday and such filled in. |
| UnixTime = mktime(&tm); |
| if ((int)UnixTime == -1){ |
| printf("Could not convert %s to unix time",ImageInfo.DateTime); |
| return; |
| } |
| |
| // Substitute "%f" for the original name (minus path & extension) |
| pattern[PATH_MAX-1]=0; |
| strncpy(pattern, strftime_args, PATH_MAX-1); |
| while ((s = strstr(pattern, "%f")) && strlen(pattern) + n < PATH_MAX-1){ |
| memmove(s + n, s + 2, strlen(s+2) + 1); |
| memmove(s, FileName + PrefixPart, n); |
| } |
| |
| { |
| // Sequential number renaming part. |
| // '%i' type pattern becomes sequence number. |
| int ppos = -1; |
| for (a=0;pattern[a];a++){ |
| if (pattern[a] == '%'){ |
| ppos = a; |
| }else if (pattern[a] == 'i'){ |
| if (ppos >= 0 && a<ppos+4){ |
| // Replace this part with a number. |
| char pat[8], num[16]; |
| int l,nl; |
| memcpy(pat, pattern+ppos, 4); |
| pat[a-ppos] = 'd'; // Replace 'i' with 'd' for '%d' |
| pat[a-ppos+1] = '\0'; |
| sprintf(num, pat, FileSequence); // let printf do the number formatting. |
| nl = strlen(num); |
| l = strlen(pattern+a+1); |
| if (ppos+nl+l+1 >= PATH_MAX) ErrFatal("str overflow"); |
| memmove(pattern+ppos+nl, pattern+a+1, l+1); |
| memcpy(pattern+ppos, num, nl); |
| break; |
| } |
| }else if (!isdigit(pattern[a])){ |
| ppos = -1; |
| } |
| } |
| } |
| strftime(NewName, PATH_MAX, pattern, &tm); |
| }else{ |
| // My favourite scheme. |
| sprintf(NewName, "%02d%02d-%02d%02d%02d", |
| tm.tm_mon+1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec); |
| } |
| |
| NewBaseName[PrefixPart] = 0; |
| CatPath(NewBaseName, NewName); |
| |
| AddLetter = isdigit(NewBaseName[strlen(NewBaseName)-1]); |
| for (a=0;;a++){ |
| char NewName[PATH_MAX+10]; |
| char NameExtra[3]; |
| struct stat dummy; |
| |
| if (a){ |
| // Generate a suffix for the file name if previous choice of names is taken. |
| // depending on wether the name ends in a letter or digit, pick the opposite to separate |
| // it. This to avoid using a separator character - this because any good separator |
| // is before the '.' in ascii, and so sorting the names would put the later name before |
| // the name without suffix, causing the pictures to more likely be out of order. |
| if (AddLetter){ |
| NameExtra[0] = (char)('a'-1+a); // Try a,b,c,d... for suffix if it ends in a number. |
| }else{ |
| NameExtra[0] = (char)('0'-1+a); // Try 0,1,2,3... for suffix if it ends in a latter. |
| } |
| NameExtra[1] = 0; |
| }else{ |
| NameExtra[0] = 0; |
| } |
| |
| sprintf(NewName, "%s%s.jpg", NewBaseName, NameExtra); |
| |
| if (!strcmp(FileName, NewName)) break; // Skip if its already this name. |
| |
| if (!EnsurePathExists(NewBaseName)){ |
| break; |
| } |
| |
| |
| if (stat(NewName, &dummy)){ |
| // This name does not pre-exist. |
| if (rename(FileName, NewName) == 0){ |
| printf("%s --> %s\n",FileName, NewName); |
| #ifdef _WIN32 |
| if (RenameAssociatedFiles){ |
| sprintf(NewName, "%s%s", NewBaseName, NameExtra); |
| RenameAssociated(FileName, NewName); |
| } |
| #endif |
| }else{ |
| printf("Error: Couldn't rename '%s' to '%s'\n",FileName, NewName); |
| } |
| break; |
| |
| } |
| |
| if (a > 25 || (!AddLetter && a > 9)){ |
| printf("Possible new names for for '%s' already exist\n",FileName); |
| break; |
| } |
| } |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Rotate the image and its thumbnail |
| //-------------------------------------------------------------------------- |
| static int DoAutoRotate(const char * FileName) |
| { |
| if (ImageInfo.Orientation >= 2 && ImageInfo.Orientation <= 8){ |
| const char * Argument; |
| Argument = ClearOrientation(); |
| |
| if (!ZeroRotateTagOnly){ |
| char RotateCommand[PATH_MAX*2+50]; |
| if (Argument == NULL){ |
| ErrFatal("Orientation screwup"); |
| } |
| |
| sprintf(RotateCommand, "jpegtran -trim -%s -outfile &o &i", Argument); |
| ApplyCommand = RotateCommand; |
| DoCommand(FileName, FALSE); |
| ApplyCommand = NULL; |
| |
| // Now rotate the thumbnail, if there is one. |
| if (ImageInfo.ThumbnailOffset && |
| ImageInfo.ThumbnailSize && |
| ImageInfo.ThumbnailAtEnd){ |
| // Must have a thumbnail that exists and is modifieable. |
| |
| char ThumbTempName_in[PATH_MAX+5]; |
| char ThumbTempName_out[PATH_MAX+5]; |
| |
| strcpy(ThumbTempName_in, FileName); |
| strcat(ThumbTempName_in, ".thi"); |
| strcpy(ThumbTempName_out, FileName); |
| strcat(ThumbTempName_out, ".tho"); |
| SaveThumbnail(ThumbTempName_in); |
| sprintf(RotateCommand,"jpegtran -trim -%s -outfile \"%s\" \"%s\"", |
| Argument, ThumbTempName_out, ThumbTempName_in); |
| |
| if (system(RotateCommand) == 0){ |
| // Put the thumbnail back in the header |
| ReplaceThumbnail(ThumbTempName_out); |
| } |
| |
| unlink(ThumbTempName_in); |
| unlink(ThumbTempName_out); |
| } |
| } |
| return TRUE; |
| } |
| return FALSE; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Regenerate the thumbnail using mogrify |
| //-------------------------------------------------------------------------- |
| static int RegenerateThumbnail(const char * FileName) |
| { |
| char ThumbnailGenCommand[PATH_MAX*2+50]; |
| if (ImageInfo.ThumbnailOffset == 0 || ImageInfo.ThumbnailAtEnd == FALSE){ |
| // There is no thumbnail, or the thumbnail is not at the end. |
| return FALSE; |
| } |
| |
| sprintf(ThumbnailGenCommand, "mogrify -thumbnail %dx%d \"%s\"", |
| RegenThumbnail, RegenThumbnail, FileName); |
| |
| if (system(ThumbnailGenCommand) == 0){ |
| // Put the thumbnail back in the header |
| return ReplaceThumbnail(FileName); |
| }else{ |
| ErrFatal("Unable to run 'mogrify' command"); |
| return FALSE; |
| } |
| } |
| |
| //-------------------------------------------------------------------------- |
| // Do selected operations to one file at a time. |
| //-------------------------------------------------------------------------- |
| void ProcessFile(const char * FileName) |
| { |
| int Modified = FALSE; |
| ReadMode_t ReadMode; |
| |
| if (strlen(FileName) >= PATH_MAX-1){ |
| // Protect against buffer overruns in strcpy / strcat's on filename |
| ErrFatal("filename too long"); |
| } |
| |
| ReadMode = READ_METADATA; |
| CurrentFile = FileName; |
| FilesMatched = 1; |
| |
| ResetJpgfile(); |
| |
| // Start with an empty image information structure. |
| memset(&ImageInfo, 0, sizeof(ImageInfo)); |
| ImageInfo.FlashUsed = -1; |
| ImageInfo.MeteringMode = -1; |
| ImageInfo.Whitebalance = -1; |
| |
| // Store file date/time. |
| { |
| struct stat st; |
| if (stat(FileName, &st) >= 0){ |
| ImageInfo.FileDateTime = st.st_mtime; |
| ImageInfo.FileSize = st.st_size; |
| }else{ |
| ErrFatal("No such file"); |
| } |
| } |
| |
| if (DoModify || RenameToDate || Exif2FileTime){ |
| if (access(FileName, 2 /*W_OK*/)){ |
| printf("Skipping readonly file '%s'\n",FileName); |
| return; |
| } |
| } |
| |
| strncpy(ImageInfo.FileName, FileName, PATH_MAX); |
| |
| |
| if (ApplyCommand || AutoRotate){ |
| // Applying a command is special - the headers from the file have to be |
| // pre-read, then the command executed, and then the image part of the file read. |
| |
| if (!ReadJpegFile(FileName, READ_METADATA)) return; |
| |
| #ifdef MATTHIAS |
| if (AutoResize){ |
| // Automatic resize computation - to customize for each run... |
| if (AutoResizeCmdStuff() == 0){ |
| DiscardData(); |
| return; |
| } |
| } |
| #endif // MATTHIAS |
| |
| |
| if (CheckFileSkip()){ |
| DiscardData(); |
| return; |
| } |
| |
| DiscardAllButExif(); |
| |
| if (AutoRotate){ |
| if (DoAutoRotate(FileName)){ |
| Modified = TRUE; |
| } |
| }else{ |
| struct stat dummy; |
| DoCommand(FileName, Quiet ? FALSE : TRUE); |
| |
| if (stat(FileName, &dummy)){ |
| // The file is not there anymore. Perhaps the command |
| // was a delete or a move. So we are all done. |
| return; |
| } |
| Modified = TRUE; |
| } |
| ReadMode = READ_IMAGE; // Don't re-read exif section again on next read. |
| |
| }else if (ExifXferScrFile){ |
| char RelativeExifName[PATH_MAX+1]; |
| |
| // Make a relative name. |
| RelativeName(RelativeExifName, ExifXferScrFile, FileName); |
| |
| if(!ReadJpegFile(RelativeExifName, READ_METADATA)) return; |
| |
| DiscardAllButExif(); // Don't re-read exif section again on next read. |
| |
| Modified = TRUE; |
| ReadMode = READ_IMAGE; |
| } |
| |
| if (DoModify){ |
| ReadMode |= READ_IMAGE; |
| } |
| |
| if (!ReadJpegFile(FileName, ReadMode)) return; |
| |
| if (CheckFileSkip()){ |
| DiscardData(); |
| return; |
| } |
| |
| FileSequence += 1; // Count files processed. |
| |
| if (ShowConcise){ |
| ShowConciseImageInfo(); |
| }else{ |
| if (!(DoModify || DoReadAction) || ShowTags){ |
| ShowImageInfo(ShowFileInfo); |
| |
| { |
| // if IPTC section is present, show it also. |
| Section_t * IptcSection; |
| IptcSection = FindSection(M_IPTC); |
| |
| if (IptcSection){ |
| show_IPTC(IptcSection->Data, IptcSection->Size); |
| } |
| } |
| printf("\n"); |
| } |
| } |
| |
| if (ThumbSaveName){ |
| char OutFileName[PATH_MAX+1]; |
| // Make a relative name. |
| RelativeName(OutFileName, ThumbSaveName, FileName); |
| |
| if (SaveThumbnail(OutFileName)){ |
| printf("Created: '%s'\n", OutFileName); |
| } |
| } |
| |
| if (CreateExifSection){ |
| // Make a new minimal exif section |
| create_EXIF(NULL, 0, 0); |
| Modified = TRUE; |
| } |
| |
| if (RegenThumbnail){ |
| if (RegenerateThumbnail(FileName)){ |
| Modified = TRUE; |
| } |
| } |
| |
| if (ThumbInsertName){ |
| char ThumbFileName[PATH_MAX+1]; |
| // Make a relative name. |
| RelativeName(ThumbFileName, ThumbInsertName, FileName); |
| |
| if (ReplaceThumbnail(ThumbFileName)){ |
| Modified = TRUE; |
| } |
| }else if (TrimExif){ |
| // Deleting thumbnail is just replacing it with a null thumbnail. |
| if (ReplaceThumbnail(NULL)){ |
| Modified = TRUE; |
| } |
| } |
| |
| if ( |
| #ifdef MATTHIAS |
| AddComment || RemComment || |
| #endif |
| EditComment || CommentInsertfileName || CommentInsertLiteral){ |
| |
| Section_t * CommentSec; |
| char Comment[MAX_COMMENT_SIZE+1]; |
| int CommentSize; |
| |
| CommentSec = FindSection(M_COM); |
| |
| if (CommentSec == NULL){ |
| unsigned char * DummyData; |
| |
| DummyData = (uchar *) malloc(3); |
| DummyData[0] = 0; |
| DummyData[1] = 2; |
| DummyData[2] = 0; |
| CommentSec = CreateSection(M_COM, DummyData, 2); |
| } |
| |
| CommentSize = CommentSec->Size-2; |
| if (CommentSize > MAX_COMMENT_SIZE){ |
| fprintf(stderr, "Truncating comment at %d chars\n",MAX_COMMENT_SIZE); |
| CommentSize = MAX_COMMENT_SIZE; |
| } |
| |
| if (CommentInsertfileName){ |
| // Read a new comment section from file. |
| char CommentFileName[PATH_MAX+1]; |
| FILE * CommentFile; |
| |
| // Make a relative name. |
| RelativeName(CommentFileName, CommentInsertfileName, FileName); |
| |
| CommentFile = fopen(CommentFileName,"r"); |
| if (CommentFile == NULL){ |
| printf("Could not open '%s'\n",CommentFileName); |
| }else{ |
| // Read it in. |
| // Replace the section. |
| CommentSize = fread(Comment, 1, 999, CommentFile); |
| fclose(CommentFile); |
| if (CommentSize < 0) CommentSize = 0; |
| } |
| }else if (CommentInsertLiteral){ |
| strncpy(Comment, CommentInsertLiteral, MAX_COMMENT_SIZE); |
| CommentSize = strlen(Comment); |
| }else{ |
| #ifdef MATTHIAS |
| char CommentZt[MAX_COMMENT_SIZE+1]; |
| memcpy(CommentZt, (char *)CommentSec->Data+2, CommentSize); |
| CommentZt[CommentSize] = '\0'; |
| if (ModifyDescriptComment(Comment, CommentZt)){ |
| Modified = TRUE; |
| CommentSize = strlen(Comment); |
| } |
| if (EditComment) |
| #else |
| memcpy(Comment, (char *)CommentSec->Data+2, CommentSize); |
| #endif |
| { |
| char EditFileName[PATH_MAX+5]; |
| strcpy(EditFileName, FileName); |
| strcat(EditFileName, ".txt"); |
| |
| CommentSize = FileEditComment(EditFileName, Comment, CommentSize); |
| } |
| } |
| |
| if (strcmp(Comment, (char *)CommentSec->Data+2)){ |
| // Discard old comment section and put a new one in. |
| int size; |
| size = CommentSize+2; |
| free(CommentSec->Data); |
| CommentSec->Size = size; |
| CommentSec->Data = malloc(size); |
| CommentSec->Data[0] = (uchar)(size >> 8); |
| CommentSec->Data[1] = (uchar)(size); |
| memcpy((CommentSec->Data)+2, Comment, size-2); |
| Modified = TRUE; |
| } |
| if (!Modified){ |
| printf("Comment not modified\n"); |
| } |
| } |
| |
| |
| if (CommentSavefileName){ |
| Section_t * CommentSec; |
| CommentSec = FindSection(M_COM); |
| |
| if (CommentSec != NULL){ |
| char OutFileName[PATH_MAX+1]; |
| FILE * CommentFile; |
| |
| // Make a relative name. |
| RelativeName(OutFileName, CommentSavefileName, FileName); |
| |
| CommentFile = fopen(OutFileName,"w"); |
| |
| if (CommentFile){ |
| fwrite((char *)CommentSec->Data+2, CommentSec->Size-2 ,1, CommentFile); |
| fclose(CommentFile); |
| }else{ |
| ErrFatal("Could not write comment file"); |
| } |
| }else{ |
| printf("File '%s' contains no comment section\n",FileName); |
| } |
| } |
| |
| if (ExifTimeAdjust || ExifTimeSet || DateSetChars || FileTimeToExif){ |
| if (ImageInfo.numDateTimeTags){ |
| struct tm tm; |
| time_t UnixTime; |
| char TempBuf[50]; |
| int a; |
| Section_t * ExifSection; |
| if (ExifTimeSet){ |
| // A time to set was specified. |
| UnixTime = ExifTimeSet; |
| }else{ |
| if (FileTimeToExif){ |
| FileTimeAsString(ImageInfo.DateTime); |
| } |
| if (DateSetChars){ |
| memcpy(ImageInfo.DateTime, DateSet, DateSetChars); |
| a = 1970; |
| sscanf(DateSet, "%d", &a); |
| if (a < 1970){ |
| strcpy(TempBuf, ImageInfo.DateTime); |
| goto skip_unixtime; |
| } |
| } |
| // A time offset to adjust by was specified. |
| if (!Exif2tm(&tm, ImageInfo.DateTime)) goto badtime; |
| |
| // Convert to unix 32 bit time value, add offset, and convert back. |
| UnixTime = mktime(&tm); |
| if ((int)UnixTime == -1) goto badtime; |
| UnixTime += ExifTimeAdjust; |
| } |
| tm = *localtime(&UnixTime); |
| |
| // Print to temp buffer first to avoid putting null termination in destination. |
| // snprintf() would do the trick, hbut not available everywhere (like FreeBSD 4.4) |
| sprintf(TempBuf, "%04d:%02d:%02d %02d:%02d:%02d", |
| tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday, |
| tm.tm_hour, tm.tm_min, tm.tm_sec); |
| |
| skip_unixtime: |
| ExifSection = FindSection(M_EXIF); |
| |
| for (a = 0; a < ImageInfo.numDateTimeTags; a++) { |
| uchar * Pointer; |
| Pointer = ExifSection->Data+ImageInfo.DateTimeOffsets[a]+8; |
| memcpy(Pointer, TempBuf, 19); |
| } |
| memcpy(ImageInfo.DateTime, TempBuf, 19); |
| |
| Modified = TRUE; |
| }else{ |
| printf("File '%s' contains no Exif timestamp to change\n", FileName); |
| } |
| } |
| |
| if (DeleteComments){ |
| if (RemoveSectionType(M_COM)) Modified = TRUE; |
| } |
| if (DeleteExif){ |
| if (RemoveSectionType(M_EXIF)) Modified = TRUE; |
| } |
| if (DeleteIptc){ |
| if (RemoveSectionType(M_IPTC)) Modified = TRUE; |
| } |
| if (DeleteXmp){ |
| if (RemoveSectionType(M_XMP)) Modified = TRUE; |
| } |
| if (DeleteUnknown){ |
| if (RemoveUnknownSections()) Modified = TRUE; |
| } |
| |
| |
| if (Modified){ |
| char BackupName[PATH_MAX+5]; |
| struct stat buf; |
| |
| if (!Quiet) printf("Modified: %s\n",FileName); |
| |
| strcpy(BackupName, FileName); |
| strcat(BackupName, ".t"); |
| |
| // Remove any .old file name that may pre-exist |
| unlink(BackupName); |
| |
| // Rename the old file. |
| rename(FileName, BackupName); |
| |
| // Write the new file. |
| if (WriteJpegFile(FileName)) { |
| |
| // Copy the access rights from original file |
| if (stat(BackupName, &buf) == 0){ |
| // set Unix access rights and time to new file |
| struct utimbuf mtime; |
| chmod(FileName, buf.st_mode); |
| |
| mtime.actime = buf.st_mtime; |
| mtime.modtime = buf.st_mtime; |
| |
| utime(FileName, &mtime); |
| } |
| |
| // Now that we are done, remove original file. |
| unlink(BackupName); |
| } else { |
| // move back the backup file |
| rename(BackupName, FileName); |
| } |
| } |
| |
| |
| if (Exif2FileTime){ |
| // Set the file date to the date from the exif header. |
| if (ImageInfo.numDateTimeTags){ |
| // Converte the file date to Unix time. |
| struct tm tm; |
| time_t UnixTime; |
| struct utimbuf mtime; |
| if (!Exif2tm(&tm, ImageInfo.DateTime)) goto badtime; |
| |
| UnixTime = mktime(&tm); |
| if ((int)UnixTime == -1){ |
| goto badtime; |
| } |
| |
| mtime.actime = UnixTime; |
| mtime.modtime = UnixTime; |
| |
| if (utime(FileName, &mtime) != 0){ |
| printf("Error: Could not change time of file '%s'\n",FileName); |
| }else{ |
| if (!Quiet) printf("%s\n",FileName); |
| } |
| }else{ |
| printf("File '%s' contains no Exif timestamp\n", FileName); |
| } |
| } |
| |
| // Feature to rename image according to date and time from camera. |
| // I use this feature to put images from multiple digicams in sequence. |
| |
| if (RenameToDate){ |
| DoFileRenaming(FileName); |
| } |
| DiscardData(); |
| return; |
| badtime: |
| printf("Error: Time '%s': cannot convert to Unix time\n",ImageInfo.DateTime); |
| DiscardData(); |
| } |
| |
| //-------------------------------------------------------------------------- |
| // complain about bad state of the command line. |
| //-------------------------------------------------------------------------- |
| static void Usage (void) |
| { |
| printf("Jhead is a program for manipulating settings and thumnails in Exif jpeg headers\n" |
| "used by most Digital Cameras. v"JHEAD_VERSION" Matthias Wandel, Mar 02 2009.\n" |
| "http://www.sentex.net/~mwandel/jhead\n" |
| "\n"); |
| |
| printf("Usage: %s [options] files\n", progname); |
| printf("Where:\n" |
| " files path/filenames with or without wildcards\n" |
| |
| "[options] are:\n" |
| "\nGENERAL METADATA:\n" |
| " -te <name> Transfer exif header from another image file <name>\n" |
| " Uses same name mangling as '-st' option\n" |
| " -dc Delete comment field (as left by progs like Photoshop & Compupic)\n" |
| " -de Strip Exif section (smaller JPEG file, but lose digicam info)\n" |
| " -di Delete IPTC section (from Photoshop, or Picasa)\n" |
| " -dx Deletex XMP section\n" |
| " -du Delete non image sections except for Exif and comment sections\n" |
| " -purejpg Strip all unnecessary data from jpeg (combines -dc -de and -du)\n" |
| " -mkexif Create new minimal exif section (overwrites pre-existing exif)\n" |
| " -ce Edit comment field. Uses environment variable 'editor' to\n" |
| " determine which editor to use. If editor not set, uses VI\n" |
| " under Unix and notepad with windows\n" |
| " -cs <name> Save comment section to a file\n" |
| " -ci <name> Insert comment section from a file. -cs and -ci use same naming\n" |
| " scheme as used by the -st option\n" |
| " -cl string Insert literal comment string\n" |
| |
| "\nDATE / TIME MANIPULATION:\n" |
| " -ft Set file modification time to Exif time\n" |
| " -dsft Set Exif time to file modification time\n" |
| " -n[format-string]\n" |
| " Rename files according to date. Uses exif date if present, file\n" |
| " date otherwise. If the optional format-string is not supplied,\n" |
| " the format is mmdd-hhmmss. If a format-string is given, it is\n" |
| " is passed to the 'strftime' function for formatting\n" |
| " In addition to strftime format codes:\n" |
| " '%%f' as part of the string will include the original file name\n" |
| " '%%i' will include a sequence number, starting from 1. You can\n" |
| " You can specify '%%03i' for example to get leading zeros.\n" |
| " This feature is useful for ordering files from multiple digicams to\n" |
| " sequence of taking. Only renames files whose names are mostly\n" |
| " numerical (as assigned by digicam)\n" |
| " The '.jpg' is automatically added to the end of the name. If the\n" |
| " destination name already exists, a letter or digit is added to \n" |
| " the end of the name to make it unique.\n" |
| " The new name may include a path as part of the name. If this path\n" |
| " does not exist, it will be created\n" |
| " -nf[format-string]\n" |
| " Same as -n, but rename regardless of original name\n" |
| " -a (Windows only) Rename files with same name but different extension\n" |
| " Use together with -n to rename .AVI files from exif in .THM files\n" |
| " for example\n" |
| " -ta<+|->h[:mm[:ss]]\n" |
| " Adjust time by h:mm backwards or forwards. Useful when having\n" |
| " taken pictures with the wrong time set on the camera, such as when\n" |
| " traveling across time zones or DST changes. Dates can be adjusted\n" |
| " by offsetting by 24 hours or more. For large date adjustments,\n" |
| " use the -da option\n" |
| " -da<date>-<date>\n" |
| " Adjust date by large amounts. This is used to fix photos from\n" |
| " cameras where the date got set back to the default camera date\n" |
| " by accident or battery removal.\n" |
| " To deal with different months and years having different numbers of\n" |
| " days, a simple date-month-year offset would result in unexpected\n" |
| " results. Instead, the difference is specified as desired date\n" |
| " minus original date. Date is specified as yyyy:mm:dd or as date\n" |
| " and time in the format yyyy:mm:dd/hh:mm:ss\n" |
| " -ts<time> Set the Exif internal time to <time>. <time> is in the format\n" |
| " yyyy:mm:dd-hh:mm:ss\n" |
| " -ds<date> Set the Exif internal date. <date> is in the format YYYY:MM:DD\n" |
| " or YYYY:MM or YYYY\n" |
| |
| "\nTHUMBNAIL MANIPULATION:\n" |
| " -dt Remove exif integral thumbnails. Typically trims 10k\n" |
| " -st <name> Save Exif thumbnail, if there is one, in file <name>\n" |
| " If output file name contains the substring \"&i\" then the\n" |
| " image file name is substitute for the &i. Note that quotes around\n" |
| " the argument are required for the '&' to be passed to the program.\n" |
| #ifndef _WIN32 |
| " An output name of '-' causes thumbnail to be written to stdout\n" |
| #endif |
| " -rt <name> Replace Exif thumbnail. Can only be done with headers that\n" |
| " already contain a thumbnail.\n" |
| " -rgt[size] Regnerate exif thumbnail. Only works if image already\n" |
| " contains a thumbail. size specifies maximum height or width of\n" |
| " thumbnail. Relies on 'mogrify' programs to be on path\n" |
| |
| "\nROTATION TAG MANIPULATION:\n" |
| " -autorot Invoke jpegtran to rotate images according to Exif orientation tag\n" |
| " Note: Windows users must get jpegtran for this to work\n" |
| " -norot Zero out the rotation tag. This to avoid some browsers from\n" |
| " rotating the image again after you rotated it but neglected to\n" |
| " clear the rotation tag\n" |
| |
| "\nOUTPUT VERBOSITY CONTROL:\n" |
| " -h help (this text)\n" |
| " -v even more verbose output\n" |
| " -q Quiet (no messages on success, like Unix)\n" |
| " -V Show jhead version\n" |
| " -exifmap Dump header bytes, annotate. Pipe thru sort for better viewing\n" |
| " -se Supress error messages relating to corrupt exif header structure\n" |
| " -c concise output\n" |
| " -nofinfo Don't show file info (name/size/date)\n" |
| |
| "\nFILE MATCHING AND SELECTION:\n" |
| " -model model\n" |
| " Only process files from digicam containing model substring in\n" |
| " camera model description\n" |
| " -exonly Skip all files that don't have an exif header (skip all jpegs that\n" |
| " were not created by digicam)\n" |
| " -cmd command\n" |
| " Apply 'command' to every file, then re-insert exif and command\n" |
| " sections into the image. &i will be substituted for the input file\n" |
| " name, and &o (if &o is used). Use quotes around the command string\n" |
| " This is most useful in conjunction with the free ImageMagick tool. \n" |
| " For example, with my Canon S100, which suboptimally compresses\n" |
| " jpegs I can specify\n" |
| " jhead -cmd \"mogrify -quality 80 &i\" *.jpg\n" |
| " to re-compress a lot of images using ImageMagick to half the size,\n" |
| " and no visible loss of quality while keeping the exif header\n" |
| " Another invocation I like to use is jpegtran (hard to find for\n" |
| " windows). I type:\n" |
| " jhead -cmd \"jpegtran -progressive &i &o\" *.jpg\n" |
| " to convert jpegs to progressive jpegs (Unix jpegtran syntax\n" |
| " differs slightly)\n" |
| " -orp Only operate on 'portrait' aspect ratio images\n" |
| " -orl Only operate on 'landscape' aspect ratio images\n" |
| #ifdef _WIN32 |
| " -r No longer supported. Use the ** wildcard to recurse directories\n" |
| " with instead.\n" |
| " examples:\n" |
| " jhead **/*.jpg\n" |
| " jhead \"c:\\my photos\\**\\*.jpg\"\n" |
| #endif |
| |
| |
| #ifdef MATTHIAS |
| "\n" |
| " -cr Remove comment tag (my way)\n" |
| " -ca Add comment tag (my way)\n" |
| " -ar Auto resize to fit in 1024x1024, but never less than half\n" |
| #endif //MATTHIAS |
| |
| |
| ); |
| |
| exit(EXIT_FAILURE); |
| } |
| |
| |
| //-------------------------------------------------------------------------- |
| // Parse specified date or date+time from command line. |
| //-------------------------------------------------------------------------- |
| time_t ParseCmdDate(char * DateSpecified) |
| { |
| int a; |
| struct tm tm; |
| time_t UnixTime; |
| |
| tm.tm_wday = -1; |
| tm.tm_hour = tm.tm_min = tm.tm_sec = 0; |
| |
| a = sscanf(DateSpecified, "%d:%d:%d/%d:%d:%d", |
| &tm.tm_year, &tm.tm_mon, &tm.tm_mday, |
| &tm.tm_hour, &tm.tm_min, &tm.tm_sec); |
| |
| if (a != 3 && a < 5){ |
| // Date must be YYYY:MM:DD, YYYY:MM:DD+HH:MM |
| // or YYYY:MM:DD+HH:MM:SS |
| ErrFatal("Could not parse specified date"); |
| } |
| tm.tm_isdst = -1; |
| tm.tm_mon -= 1; // Adjust for unix zero-based months |
| tm.tm_year -= 1900; // Adjust for year starting at 1900 |
| |
| UnixTime = mktime(&tm); |
| if (UnixTime == -1){ |
| ErrFatal("Specified time is invalid or out of range"); |
| } |
| |
| return UnixTime; |
| } |
| |
| //-------------------------------------------------------------------------- |
| // The main program. |
| //-------------------------------------------------------------------------- |
| #if 0 |
| int main (int argc, char **argv) |
| { |
| int argn; |
| char * arg; |
| progname = argv[0]; |
| |
| for (argn=1;argn<argc;argn++){ |
| arg = argv[argn]; |
| if (arg[0] != '-') break; // Filenames from here on. |
| |
| // General metadata options: |
| if (!strcmp(arg,"-te")){ |
| ExifXferScrFile = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-dc")){ |
| DeleteComments = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-de")){ |
| DeleteExif = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-di")){ |
| DeleteIptc = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-dx")){ |
| DeleteXmp = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg, "-du")){ |
| DeleteUnknown = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg, "-purejpg")){ |
| DeleteExif = TRUE; |
| DeleteComments = TRUE; |
| DeleteIptc = TRUE; |
| DeleteUnknown = TRUE; |
| DeleteXmp = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-ce")){ |
| EditComment = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-cs")){ |
| CommentSavefileName = argv[++argn]; |
| }else if (!strcmp(arg,"-ci")){ |
| CommentInsertfileName = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-cl")){ |
| CommentInsertLiteral = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-mkexif")){ |
| CreateExifSection = TRUE; |
| DoModify = TRUE; |
| |
| // Output verbosity control |
| }else if (!strcmp(arg,"-h")){ |
| Usage(); |
| }else if (!strcmp(arg,"-v")){ |
| ShowTags = TRUE; |
| }else if (!strcmp(arg,"-q")){ |
| Quiet = TRUE; |
| }else if (!strcmp(arg,"-V")){ |
| printf("Jhead version: "JHEAD_VERSION" Compiled: "__DATE__"\n"); |
| exit(0); |
| }else if (!strcmp(arg,"-exifmap")){ |
| DumpExifMap = TRUE; |
| }else if (!strcmp(arg,"-se")){ |
| SupressNonFatalErrors = TRUE; |
| }else if (!strcmp(arg,"-c")){ |
| ShowConcise = TRUE; |
| }else if (!strcmp(arg,"-nofinfo")){ |
| ShowFileInfo = 0; |
| |
| // Thumbnail manipulation options |
| }else if (!strcmp(arg,"-dt")){ |
| TrimExif = TRUE; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-st")){ |
| ThumbSaveName = argv[++argn]; |
| DoReadAction = TRUE; |
| }else if (!strcmp(arg,"-rt")){ |
| ThumbInsertName = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!memcmp(arg,"-rgt", 4)){ |
| RegenThumbnail = 160; |
| sscanf(arg+4, "%d", &RegenThumbnail); |
| if (RegenThumbnail > 320){ |
| ErrFatal("Specified thumbnail geometry too big!"); |
| } |
| DoModify = TRUE; |
| |
| // Rotation tag manipulation |
| }else if (!strcmp(arg,"-autorot")){ |
| AutoRotate = 1; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-norot")){ |
| AutoRotate = 1; |
| ZeroRotateTagOnly = 1; |
| DoModify = TRUE; |
| |
| // Date/Time manipulation options |
| }else if (!memcmp(arg,"-n",2)){ |
| RenameToDate = 1; |
| DoReadAction = TRUE; // Rename doesn't modify file, so count as read action. |
| arg+=2; |
| if (*arg == 'f'){ |
| RenameToDate = 2; |
| arg++; |
| } |
| if (*arg){ |
| // A strftime format string is supplied. |
| strftime_args = arg; |
| #ifdef _WIN32 |
| SlashToNative(strftime_args); |
| #endif |
| //printf("strftime_args = %s\n",arg); |
| } |
| }else if (!strcmp(arg,"-a")){ |
| #ifndef _WIN32 |
| ErrFatal("Error: -a only supported in Windows version"); |
| #else |
| RenameAssociatedFiles = TRUE; |
| #endif |
| }else if (!strcmp(arg,"-ft")){ |
| Exif2FileTime = TRUE; |
| DoReadAction = TRUE; |
| }else if (!memcmp(arg,"-ta",3)){ |
| // Time adjust feature. |
| int hours, minutes, seconds, n; |
| minutes = seconds = 0; |
| if (arg[3] != '-' && arg[3] != '+'){ |
| ErrFatal("Error: -ta must be followed by +/- and a time"); |
| } |
| n = sscanf(arg+4, "%d:%d:%d", &hours, &minutes, &seconds); |
| |
| if (n < 1){ |
| ErrFatal("Error: -ta must be immediately followed by time"); |
| } |
| if (ExifTimeAdjust) ErrFatal("Can only use one of -da or -ta options at once"); |
| ExifTimeAdjust = hours*3600 + minutes*60 + seconds; |
| if (arg[3] == '-') ExifTimeAdjust = -ExifTimeAdjust; |
| DoModify = TRUE; |
| }else if (!memcmp(arg,"-da",3)){ |
| // Date adjust feature (large time adjustments) |
| time_t NewDate, OldDate = 0; |
| char * pOldDate; |
| NewDate = ParseCmdDate(arg+3); |
| pOldDate = strstr(arg+1, "-"); |
| if (pOldDate){ |
| OldDate = ParseCmdDate(pOldDate+1); |
| }else{ |
| ErrFatal("Must specifiy second date for -da option"); |
| } |
| if (ExifTimeAdjust) ErrFatal("Can only use one of -da or -ta options at once"); |
| ExifTimeAdjust = NewDate-OldDate; |
| DoModify = TRUE; |
| }else if (!memcmp(arg,"-dsft",5)){ |
| // Set file time to date/time in exif |
| FileTimeToExif = TRUE; |
| DoModify = TRUE; |
| }else if (!memcmp(arg,"-ds",3)){ |
| // Set date feature |
| int a; |
| // Check date validity and copy it. Could be incompletely specified. |
| strcpy(DateSet, "0000:01:01"); |
| for (a=0;arg[a+3];a++){ |
| if (isdigit(DateSet[a])){ |
| if (!isdigit(arg[a+3])){ |
| a = 0; |
| break; |
| } |
| }else{ |
| if (arg[a+3] != ':'){ |
| a=0; |
| break; |
| } |
| } |
| DateSet[a] = arg[a+3]; |
| } |
| if (a < 4 || a > 10){ |
| ErrFatal("Date must be in format YYYY, YYYY:MM, or YYYY:MM:DD"); |
| } |
| DateSetChars = a; |
| DoModify = TRUE; |
| }else if (!memcmp(arg,"-ts",3)){ |
| // Set the exif time. |
| // Time must be specified as "yyyy:mm:dd-hh:mm:ss" |
| char * c; |
| struct tm tm; |
| |
| c = strstr(arg+1, "-"); |
| if (c) *c = ' '; // Replace '-' with a space. |
| |
| if (!Exif2tm(&tm, arg+3)){ |
| ErrFatal("-ts option must be followed by time in format yyyy:mmm:dd-hh:mm:ss\n" |
| "Example: jhead -ts2001:01:01-12:00:00 foo.jpg"); |
| } |
| |
| ExifTimeSet = mktime(&tm); |
| |
| if ((int)ExifTimeSet == -1) ErrFatal("Time specified is out of range"); |
| DoModify = TRUE; |
| |
| // File matching and selection |
| }else if (!strcmp(arg,"-model")){ |
| if (argn+1 >= argc) Usage(); // No extra argument. |
| FilterModel = argv[++argn]; |
| }else if (!strcmp(arg,"-exonly")){ |
| ExifOnly = 1; |
| }else if (!strcmp(arg,"-orp")){ |
| PortraitOnly = 1; |
| }else if (!strcmp(arg,"-orl")){ |
| PortraitOnly = -1; |
| }else if (!strcmp(arg,"-cmd")){ |
| if (argn+1 >= argc) Usage(); // No extra argument. |
| ApplyCommand = argv[++argn]; |
| DoModify = TRUE; |
| |
| #ifdef MATTHIAS |
| }else if (!strcmp(arg,"-ca")){ |
| // Its a literal comment. Add. |
| AddComment = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-cr")){ |
| // Its a literal comment. Remove this keyword. |
| RemComment = argv[++argn]; |
| DoModify = TRUE; |
| }else if (!strcmp(arg,"-ar")){ |
| AutoResize = TRUE; |
| ShowConcise = TRUE; |
| ApplyCommand = (char *)1; // Must be non null so it does commands. |
| DoModify = TRUE; |
| #endif // MATTHIAS |
| }else{ |
| printf("Argument '%s' not understood\n",arg); |
| printf("Use jhead -h for list of arguments\n"); |
| exit(-1); |
| } |
| if (argn >= argc){ |
| // Used an extra argument - becuase the last argument |
| // used up an extr argument. |
| ErrFatal("Extra argument required"); |
| } |
| } |
| if (argn == argc){ |
| ErrFatal("No files to process. Use -h for help"); |
| } |
| |
| if (ThumbSaveName != NULL && strcmp(ThumbSaveName, "&i") == 0){ |
| printf("Error: By specifying \"&i\" for the thumbail name, your original file\n" |
| " will be overwitten. If this is what you really want,\n" |
| " specify -st \"./&i\" to override this check\n"); |
| exit(0); |
| } |
| |
| if (RegenThumbnail){ |
| if (ThumbSaveName || ThumbInsertName){ |
| printf("Error: Cannot regen and save or insert thumbnail in same run\n"); |
| exit(0); |
| } |
| } |
| |
| if (EditComment){ |
| if (CommentSavefileName != NULL || CommentInsertfileName != NULL){ |
| printf("Error: Cannot use -ce option in combination with -cs or -ci\n"); |
| exit(0); |
| } |
| } |
| |
| |
| if (ExifXferScrFile){ |
| if (FilterModel || ApplyCommand){ |
| ErrFatal("Error: Filter by model and/or applying command to files\n" |
| " invalid while transfering Exif headers"); |
| } |
| } |
| |
| FileSequence = 0; |
| for (;argn<argc;argn++){ |
| FilesMatched = FALSE; |
| |
| #ifdef _WIN32 |
| SlashToNative(argv[argn]); |
| // Use my globbing module to do fancier wildcard expansion with recursive |
| // subdirectories under Windows. |
| MyGlob(argv[argn], ProcessFile); |
| #else |
| // Under linux, don't do any extra fancy globbing - shell globbing is |
| // pretty fancy as it is - although not as good as myglob.c |
| ProcessFile(argv[argn]); |
| #endif |
| |
| if (!FilesMatched){ |
| fprintf(stderr, "Error: No files matched '%s'\n",argv[argn]); |
| } |
| } |
| |
| if (FileSequence == 0){ |
| return EXIT_FAILURE; |
| }else{ |
| return EXIT_SUCCESS; |
| } |
| } |
| #endif |
| |
| #endif // commented out -- security risk |
| |
