rjhead 0.2.88

data/ext/make.bat

@@ -0,0 +1 @@
+nmake -f makefile-win32

data/ext/makefile

@@ -0,0 +1,23 @@
+#--------------------------------
+# jhead makefile for Unix
+#--------------------------------
+OBJ=.
+SRC=.
+CFLAGS= -O3 -Wall
+
+all: jhead
+
+objs = $(OBJ)/jhead.o $(OBJ)/jpgfile.o $(OBJ)/paths.o \
+	$(OBJ)/exif.o $(OBJ)/iptc.o $(OBJ)/gpsinfo.o $(OBJ)/makernote.o 
+
+$(OBJ)/%.o:$(SRC)/%.c
+	${CC} $(CFLAGS) -c $< -o $@
+
+jhead: $(objs) jhead.h
+	${CC} -o jhead $(objs) -lm
+
+clean:
+	rm -f $(objs) jhead
+
+install:
+	mkdir -p ../bin; cp jhead ../bin/jhead

data/ext/makefile-win32

@@ -0,0 +1,27 @@
+#--------------------------------
+# jhead makefile for Win32
+#--------------------------------
+
+CC=cl /nologo
+CFLAGS=-c -G3 -Ox -W3 -Zp -Zd
+LINKER=link
+LINKCON = /nologo
+
+all:jhead.exe
+
+OBJ = .
+
+OBJECTS_JHEAD = $(OBJ)\jhead.obj  \
+                $(OBJ)\jpgfile.obj \
+                $(OBJ)\myglob.obj \
+                $(OBJ)\paths.obj \
+                $(OBJ)\exif.obj \
+                $(OBJ)\iptc.obj \
+                $(OBJ)\gpsinfo.obj \
+                $(OBJ)\makernote.obj
+
+$(OBJECTS_JHEAD): $(@B).c jhead.h
+    $(CC) /Fo$(OBJ)\ $(CFLAGS) $(@B).c
+
+jhead.exe: $(OBJECTS_JHEAD)
+    $(LINKER) $(LINKCON) -OUT:jhead.exe $(OBJECTS_JHEAD)

data/ext/makernote.c

@@ -0,0 +1,184 @@
+//--------------------------------------------------------------------------
+// Parse some maker specific onformation.
+// (Very limited right now - add maker specific stuff to this module)
+//--------------------------------------------------------------------------
+#include "jhead.h"
+
+//--------------------------------------------------------------------------
+// Process exif format directory, as used by Cannon maker note
+//--------------------------------------------------------------------------
+void ProcessCanonMakerNoteDir(unsigned char * DirStart, unsigned char * OffsetBase, 
+        unsigned ExifLength)
+{
+    int de;
+    int a;
+    int NumDirEntries;
+
+    NumDirEntries = Get16u(DirStart);
+    #define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
+
+    {
+        unsigned char * DirEnd;
+        DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
+        if (DirEnd > (OffsetBase+ExifLength)){
+            ErrNonfatal("Illegally sized Exif makernote subdir (%d entries)",NumDirEntries,0);
+            return;
+        }
+
+        if (DumpExifMap){
+            printf("Map: %05d-%05d: Directory (makernote)\n",(int)(DirStart-OffsetBase), (int)(DirEnd-OffsetBase));
+        }
+    }
+
+    if (ShowTags){
+        printf("(dir has %d entries)\n",NumDirEntries);
+    }
+
+    for (de=0;de<NumDirEntries;de++){
+        int Tag, Format, Components;
+        unsigned char * ValuePtr;
+        int ByteCount;
+        unsigned char * DirEntry;
+        DirEntry = DIR_ENTRY_ADDR(DirStart, de);
+
+        Tag = Get16u(DirEntry);
+        Format = Get16u(DirEntry+2);
+        Components = Get32u(DirEntry+4);
+
+        if ((Format-1) >= NUM_FORMATS) {
+            // (-1) catches illegal zero case as unsigned underflows to positive large.
+            ErrNonfatal("Illegal Exif number format %d for maker tag %04x", Format, Tag);
+            continue;
+        }
+
+        if ((unsigned)Components > 0x10000){
+            ErrNonfatal("Too many components (%d) for Exif maker tag %04x", Components, Tag);
+            continue;
+        }
+
+        ByteCount = Components * BytesPerFormat[Format];
+
+        if (ByteCount > 4){
+            unsigned OffsetVal;
+            OffsetVal = Get32u(DirEntry+8);
+            // If its bigger than 4 bytes, the dir entry contains an offset.
+            if (OffsetVal+ByteCount > ExifLength){
+                // Bogus pointer offset and / or bytecount value
+                ErrNonfatal("Illegal value pointer for Exif maker tag %04x", Tag,0);
+                continue;
+            }
+            ValuePtr = OffsetBase+OffsetVal;
+
+            if (DumpExifMap){
+                printf("Map: %05d-%05d:   Data for makernote tag %04x\n",OffsetVal, OffsetVal+ByteCount, Tag);
+            }
+        }else{
+            // 4 bytes or less and value is in the dir entry itself
+            ValuePtr = DirEntry+8;
+        }
+
+        if (ShowTags){
+            // Show tag name
+            printf("            Canon maker tag %04x Value = ", Tag);
+        }
+
+        // Show tag value.
+        switch(Format){
+
+            case FMT_UNDEFINED:
+                // Undefined is typically an ascii string.
+
+            case FMT_STRING:
+                // String arrays printed without function call (different from int arrays)
+                if (ShowTags){
+                    printf("\"");
+                    for (a=0;a<ByteCount;a++){
+                        int ZeroSkipped = 0;
+                        if (ValuePtr[a] >= 32){
+                            if (ZeroSkipped){
+                                printf("?");
+                                ZeroSkipped = 0;
+                            }
+                            putchar(ValuePtr[a]);
+                        }else{
+                            if (ValuePtr[a] == 0){
+                                ZeroSkipped = 1;
+                            }
+                        }
+                    }
+                    printf("\"\n");
+                }
+                break;
+
+            default:
+                if (ShowTags){
+                    PrintFormatNumber(ValuePtr, Format, ByteCount);
+                    printf("\n");
+                }
+        }
+        if (Tag == 1 && Components > 16){
+            int IsoCode = Get16u(ValuePtr + 16*sizeof(unsigned short));
+            if (IsoCode >= 16 && IsoCode <= 24){
+                ImageInfo.ISOequivalent = 50 << (IsoCode-16);
+            } 
+        }
+
+        if (Tag == 4 && Format == FMT_USHORT){
+            if (Components > 7){
+                int WhiteBalance = Get16u(ValuePtr + 7*sizeof(unsigned short));
+                switch(WhiteBalance){
+                    // 0=Auto, 6=Custom
+                    case 1: ImageInfo.LightSource = 1; break; // Sunny
+                    case 2: ImageInfo.LightSource = 1; break; // Cloudy
+                    case 3: ImageInfo.LightSource = 3; break; // Thungsten
+                    case 4: ImageInfo.LightSource = 2; break; // Fourescent
+                    case 5: ImageInfo.LightSource = 4; break; // Flash
+                }
+            }
+            if (Components > 19 && ImageInfo.Distance <= 0) {
+                // Indicates the distance the autofocus camera is focused to.
+                // Tends to be less accurate as distance increases.
+                int temp_dist = Get16u(ValuePtr + 19*sizeof(unsigned short));
+                if (temp_dist != 65535){
+                    ImageInfo.Distance = (float)temp_dist/100;
+                }else{
+                    ImageInfo.Distance = -1 /* infinity */;
+                }
+            }
+        }
+    }
+}
+
+//--------------------------------------------------------------------------
+// Show generic maker note - just hex bytes.
+//--------------------------------------------------------------------------
+void ShowMakerNoteGeneric(unsigned char * ValuePtr, int ByteCount)
+{
+    int a;
+    for (a=0;a<ByteCount;a++){
+        if (a > 10){
+            printf("...");
+            break;
+        }
+        printf(" %02x",ValuePtr[a]);
+    }
+    printf(" (%d bytes)", ByteCount);
+    printf("\n");
+
+}
+
+//--------------------------------------------------------------------------
+// Process maker note - to the limited extent that its supported.
+//--------------------------------------------------------------------------
+void ProcessMakerNote(unsigned char * ValuePtr, int ByteCount, 
+        unsigned char * OffsetBase, unsigned ExifLength)
+{
+    if (strstr(ImageInfo.CameraMake, "Canon")){
+        ProcessCanonMakerNoteDir(ValuePtr, OffsetBase, ExifLength);
+    }else{
+        if (ShowTags){
+            ShowMakerNoteGeneric(ValuePtr, ByteCount);
+        }
+    }
+}
+

data/ext/myglob.c

@@ -0,0 +1,305 @@
+//--------------------------------------------------------------------------------
+// Module to do recursive directory file matching under windows.
+//
+// Tries to do pattern matching to produce similar results as Unix, but using
+// the Windows _findfirst to do all the pattern matching.
+//
+// Also hadles recursive directories - "**" path component expands into
+// any levels of subdirectores (ie c:\**\*.c matches ALL .c files on drive c:)
+// 
+// Matthias Wandel Nov 5 2000
+//--------------------------------------------------------------------------------
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <io.h>
+#include "jhead.h"
+
+#define TRUE 1
+#define FALSE 0
+
+//#define DEBUGGING
+
+typedef struct {
+    char * Name;
+    int attrib;
+}FileEntry;
+
+
+#ifdef DEBUGGING
+//--------------------------------------------------------------------------------
+// Dummy function to show operation.
+//--------------------------------------------------------------------------------
+void ShowName(const char * FileName)
+{
+    printf("     %s\n",FileName);
+}
+#endif
+
+//--------------------------------------------------------------------------------
+// Simple path splicing (assumes no '\' in either part)
+//--------------------------------------------------------------------------------
+static void SplicePath(char * dest, const char * p1, const char * p2)
+{
+    int l;
+    l = strlen(p1);
+    if (!l){
+        strcpy(dest, p2);
+    }else{
+        if (l+strlen(p2) > _MAX_PATH-2){
+            fprintf(stderr,"Path too long\n");
+            exit(-1);
+        }
+        memcpy(dest, p1, l+1);
+        if (dest[l-1] != '\\' && dest[l-1] != ':'){
+            dest[l++] = '\\';
+        }
+        strcpy(dest+l, p2);
+    }
+}
+
+//--------------------------------------------------------------------------------
+// Qsort compare function
+//--------------------------------------------------------------------------------
+int CompareFunc(const void * f1, const void * f2)
+{
+    return strcmp(((FileEntry *)f1)->Name,((FileEntry *)f2)->Name);
+}
+
+//--------------------------------------------------------------------------------
+// Decide how a particular pattern should be handled, and call function for each.
+//--------------------------------------------------------------------------------
+void MyGlob(const char * Pattern , void (*FileFuncParm)(const char * FileName))
+{
+    char BasePattern[_MAX_PATH];
+    char MatchPattern[_MAX_PATH];
+    char PatCopy[_MAX_PATH*2+1];
+
+    int a;
+
+    int MatchFiles, MatchDirs;
+    int BaseEnd, PatternEnd;
+    int SawPat;
+    int RecurseAt;
+
+    strcpy(PatCopy, Pattern);
+
+    #ifdef DEBUGGING
+        printf("Called with '%s'\n",Pattern);
+    #endif
+
+DoRecursion:
+    MatchFiles = FALSE;
+    MatchDirs = TRUE;
+    BaseEnd = 0;
+    PatternEnd = 0;
+
+    SawPat = FALSE;
+    RecurseAt = -1;
+
+    // Split the path into base path and pattern to match against using findfirst.
+    for (a=0;;a++){
+        if (PatCopy[a] == '*' || PatCopy[a] == '?'){
+            SawPat = TRUE;
+        }
+
+        if (PatCopy[a] == '*' && PatCopy[a+1] == '*'){
+            if (a == 0 || PatCopy[a-1] == '\\' || PatCopy[a-1] == ':'){
+                if (PatCopy[a+2] == '\\' || PatCopy[a+2] == '\0'){
+                    // x\**\y  ---> x\y  x\*\**\y
+                    RecurseAt = a;
+                    if (PatCopy[a+2]){
+                        memcpy(PatCopy+a, PatCopy+a+3, strlen(PatCopy)-a-1);
+                    }else{
+                        PatCopy[a+1] = '\0';
+                    }
+                }
+            }
+        }
+
+        if (PatCopy[a] == '\\' || (PatCopy[a] == ':' && PatCopy[a+1] != '\\')){
+            PatternEnd = a;
+            if (SawPat) break; // Findfirst can only match one level of wildcard at a time.
+            BaseEnd = a+1;
+        }
+        if (PatCopy[a] == '\0'){
+            PatternEnd = a;
+            MatchFiles = TRUE;
+            MatchDirs = FALSE;
+            break;
+        }
+    }
+
+    if (!SawPat){
+        // No pattern.  This should refer to a file.
+        FileFuncParm(PatCopy);
+        return;
+    }
+
+    strncpy(BasePattern, PatCopy, BaseEnd);
+    BasePattern[BaseEnd] = 0;
+
+    strncpy(MatchPattern, PatCopy, PatternEnd);
+    MatchPattern[PatternEnd] = 0;
+
+    #ifdef DEBUGGING
+        printf("Base:%s  Pattern:%s Files:%d dirs:%d\n",BasePattern, MatchPattern, MatchFiles, MatchDirs);
+    #endif
+
+    {
+        FileEntry * FileList = NULL;
+        int NumAllocated = 0;
+        int NumHave = 0;
+        
+        struct _finddata_t finddata;
+        long find_handle;
+
+        find_handle = _findfirst(MatchPattern, &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){
+                if (!MatchDirs) goto next_file;
+            }else{
+                if (!MatchFiles) goto next_file;
+            }
+
+            // Add it to the list.
+            if (NumAllocated <= NumHave){
+                NumAllocated = NumAllocated+10+NumAllocated/2;
+                FileList = realloc(FileList, NumAllocated * sizeof(FileEntry));
+                if (FileList == NULL) goto nomem;
+            }
+            a = strlen(finddata.name);
+            FileList[NumHave].Name = malloc(a+1);
+            if (FileList[NumHave].Name == NULL){
+                nomem:
+                printf("malloc failure\n");
+                exit(-1);
+            }
+            memcpy(FileList[NumHave].Name, finddata.name, a+1);
+            FileList[NumHave].attrib = finddata.attrib;
+            NumHave++;
+
+            next_file:
+            if (_findnext(find_handle, &finddata) != 0) break;
+        }
+        _findclose(find_handle);
+
+        // Sort the list...
+        qsort(FileList, NumHave, sizeof(FileEntry), CompareFunc);
+
+
+        // Use the list.
+        for (a=0;a<NumHave;a++){
+            char CombinedName[_MAX_PATH*2+1];
+            if (FileList[a].attrib & _A_SUBDIR){
+                if (MatchDirs){
+                    // Need more directories.
+                    SplicePath(CombinedName, BasePattern, FileList[a].Name);
+                    strncat(CombinedName, PatCopy+PatternEnd, _MAX_PATH*2-strlen(CombinedName));
+                    MyGlob(CombinedName,FileFuncParm);
+                }
+            }else{
+                if (MatchFiles){
+                    // We need files at this level.
+                    SplicePath(CombinedName, BasePattern, FileList[a].Name);
+                    FileFuncParm(CombinedName);
+                }
+            }
+            free(FileList[a].Name);
+        }
+        free(FileList);
+    }
+
+    if(RecurseAt >= 0){
+        strcpy(MatchPattern, PatCopy+RecurseAt);
+        PatCopy[RecurseAt] = 0;
+        strncpy(PatCopy+RecurseAt, "*\\**\\", _MAX_PATH*2-RecurseAt);
+        strncat(PatCopy, MatchPattern, _MAX_PATH*2-strlen(PatCopy));
+       
+        #ifdef DEBUGGING
+            printf("Recurse with '%s'\n",PatCopy);
+        #endif
+
+        // As this function context is no longer needed, we can just goto back
+        // to the top of it to avoid adding another context on the stack.
+        goto DoRecursion;
+    }
+}
+
+//--------------------------------------------------------------------------------
+// Flip slashes to native OS representation (for Windows)
+//--------------------------------------------------------------------------------
+void SlashToNative(char * Path)
+{
+    int a;
+    for (a=0;Path[a];a++){
+        if (Path[a] == '/') Path[a] = SLASH;
+    }
+}
+
+
+#ifdef DEBUGGING
+//--------------------------------------------------------------------------------
+// The main program.
+//--------------------------------------------------------------------------------
+int main (int argc, char **argv)
+ {
+    int argn;
+    char * arg;
+    int Subdirs = 0;
+
+    for (argn=1;argn<argc;argn++){
+        arg = argv[argn];
+        if (arg[0] != '-') break; // Filenames from here on.
+        if (!strcmp(arg,"-r")){
+            printf("do recursive\n");
+            Subdirs = 1;
+        }else{
+            fprintf(stderr, "Argument '%s' not understood\n",arg);
+        }
+    }
+    if (argn == argc){
+        fprintf(stderr,"Error: Must supply a file name\n");
+    }
+
+    for (;argn<argc;argn++){
+        MyGlob(argv[argn], ShowName);
+    }
+    return EXIT_SUCCESS;
+}
+#endif
+
+/*
+
+non-recursive test cases:
+
+    e:\make*\*
+    \make*\*
+    e:*\*.c
+    \*\*.c
+    \*
+    c:*.c
+    c:\*
+    ..\*.c
+
+
+recursive test cases:
+    **
+    **\*.c
+    c:\**\*.c
+    c:**\*.c
+    .\**
+    ..\**
+
+*/
+
+