File better-exif.patch of Package kdegraphics3

Overview Repositories Revisions Requests Users Attributes Meta

File better-exif.patch of Package kdegraphics3 (Revision c70c51f3c7af53b14a9e7ddea6bf2ac8)

Currently displaying revision c70c51f3c7af53b14a9e7ddea6bf2ac8 , Show latest

--- kfile-plugins/jpeg/kfile_jpeg.h.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/kfile_jpeg.h	2006-10-23 16:30:57.000000000 +0200
@@ -37,6 +37,7 @@ public:
                                          QObject* parent, const char* name) const;
     
 private:
+    void insertValue( KFileMetaInfoGroup& exifGroup, int index, const QString& value );
     QDateTime parseDateTime( const QString& string ); 
 };
 
--- kfile-plugins/jpeg/Makefile.am.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/Makefile.am	2006-10-23 16:30:57.000000000 +0200
@@ -6,12 +6,12 @@ KDE_CXXFLAGS = $(USE_EXCEPTIONS)
 INCLUDES         = $(all_includes)
 
 # these are the headers for your project
-noinst_HEADERS   = kfile_jpeg.h exif.h
+noinst_HEADERS   = kfile_jpeg.h
 
 kde_module_LTLIBRARIES = kfile_jpeg.la
 
-kfile_jpeg_la_SOURCES = kfile_jpeg.cpp exif.cpp kfile_setcomment.cpp
-kfile_jpeg_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN)
+kfile_jpeg_la_SOURCES = kfile_jpeg.cpp
+kfile_jpeg_la_LDFLAGS = $(all_libraries) -module $(KDE_PLUGIN) -lexif
 kfile_jpeg_la_LIBADD = $(LIB_KIO)
 
 # let automoc handle all of the meta source files (moc)
--- kfile-plugins/jpeg/exif.h.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/exif.h	1970-01-01 01:00:00.000000000 +0100
@@ -1,126 +0,0 @@
-#ifndef __EXIF_H__
-#define __EXIF_H__
-
-/**
-	exif.h
-*/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <math.h>
-#include <time.h>
-
-#include "qstring.h"
-#include "qfile.h"
-#include "qimage.h"
-#include <kdebug.h>
-
-typedef enum {
-    READ_EXIF = 1,
-    READ_IMAGE = 2,
-    READ_ALL = 3
-}ReadMode_t;
-
-//--------------------------------------------------------------------------
-// This structure is used to store jpeg file sections in memory.
-typedef struct {
-    uchar *  Data;
-    int      Type;
-    unsigned Size;
-}Section_t;
-
-typedef unsigned char uchar;
-
-typedef struct {
-    unsigned short Tag;
-    const char*const Desc;
-}TagTable_t;
-
-#define MAX_SECTIONS 20
-#define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
-
-class ExifData {
-    Section_t Sections[MAX_SECTIONS];
-
-    QString CameraMake;
-    QString CameraModel;
-    QString DateTime;
-    int   Orientation;
-    int   Height, Width;
-    int   ExifImageLength, ExifImageWidth;
-    int   IsColor;
-    int   Process;
-    int   FlashUsed;
-    float FocalLength;
-    float ExposureTime;
-    float ApertureFNumber;
-    float Distance;
-    int    Whitebalance;
-    int    MeteringMode;
-    float CCDWidth;
-    float ExposureBias;
-    int   ExposureProgram;
-    int   ISOequivalent;
-    int   CompressionLevel;
-    QString UserComment;
-    QString Comment;
-    QImage Thumbnail;
-
-    int ReadJpegSections (QFile & infile, ReadMode_t ReadMode);
-    void DiscardData(void);
-    int Get16u(void * Short);
-    int Get32s(void * Long);
-    unsigned Get32u(void * Long);
-    double ConvertAnyFormat(void * ValuePtr, int Format);
-    void ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength);
-    void process_COM (const uchar * Data, int length);
-    void process_SOFn (const uchar * Data, int marker);
-    int Get16m(const void * Short);
-    void process_EXIF(unsigned char * CharBuf, unsigned int length);
-    int Exif2tm(struct tm * timeptr, char * ExifTime);
-
-public:
-    ExifData();
-    bool scan(const QString &);
-    QString getCameraMake() { return CameraMake; }
-    QString getCameraModel() { return CameraModel; }
-    QString getDateTime() { return DateTime; }
-    int getOrientation() { return Orientation; }
-    int getHeight() { return Height; }
-    int getWidth() { return Width; }
-    int getIsColor() { return IsColor; }
-    int getProcess() { return Process; }
-    int getFlashUsed() { return FlashUsed; }
-    float getFocalLength() { return FocalLength; }
-    float getExposureTime() { return ExposureTime; }
-    float getApertureFNumber() { return ApertureFNumber; }
-    float getDistance() { return Distance; }
-    int getWhitebalance() { return Whitebalance; }
-    int getMeteringMode() { return MeteringMode; }
-    float getCCDWidth() { return CCDWidth; }
-    float getExposureBias() { return ExposureBias; }
-    int getExposureProgram() { return ExposureProgram; }
-    int getISOequivalent() { return ISOequivalent; }
-    int getCompressionLevel() { return CompressionLevel; }
-    QString getUserComment() { return UserComment; }
-    QString getComment() { return Comment; }
-    QImage getThumbnail();
-    bool isThumbnailSane();
-    bool isNullThumbnail() { return !isThumbnailSane(); }
-};
-
-class FatalError {
-    const char* ex;
-public:
-    FatalError(const char* s) { ex = s; }
-    void debug_print() const { kdDebug(7034) << "exception: " << ex << endl; }
-};
-
-extern TagTable_t ProcessTable[];
-
-//--------------------------------------------------------------------------
-// Define comment writing code, impelemented in setcomment.c
-extern int safe_copy_and_modify( const char * original_filename, const char * comment );
-
-#endif
-
--- kfile-plugins/jpeg/exif.cpp.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/exif.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,954 +0,0 @@
-//--------------------------------------------------------------------------
-// Program to pull the information out of various types of EFIF digital
-// camera files and show it in a reasonably consistent way
-//
-// This module parses the very complicated exif structures.
-//
-// Matthias Wandel,  Dec 1999 - August 2000
-//--------------------------------------------------------------------------
-
-
-#include "exif.h"
-#include <qwmatrix.h>
-#include <kglobal.h>
-
-
-static unsigned char * LastExifRefd;
-static int ExifSettingsLength;
-static double FocalplaneXRes;
-static double FocalplaneUnits;
-static int MotorolaOrder = 0;
-static int SectionsRead;
-//static int HaveAll;
-
-//--------------------------------------------------------------------------
-// Table of Jpeg encoding process names
-
-#define M_SOF0  0xC0            // Start Of Frame N
-#define M_SOF1  0xC1            // N indicates which compression process
-#define M_SOF2  0xC2            // Only SOF0-SOF2 are now in common use
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5            // NB: codes C4 and CC are NOT SOF markers
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8            // Start Of Image (beginning of datastream)
-#define M_EOI   0xD9            // End Of Image (end of datastream)
-#define M_SOS   0xDA            // Start Of Scan (begins compressed data)
-#define M_JFIF  0xE0            // Jfif marker
-#define M_EXIF  0xE1            // Exif marker
-#define M_COM   0xFE            // COMment
-
-
-TagTable_t ProcessTable[] = {
-    { M_SOF0,   "Baseline"},
-    { M_SOF1,   "Extended sequential"},
-    { M_SOF2,   "Progressive"},
-    { M_SOF3,   "Lossless"},
-    { M_SOF5,   "Differential sequential"},
-    { M_SOF6,   "Differential progressive"},
-    { M_SOF7,   "Differential lossless"},
-    { M_SOF9,   "Extended sequential, arithmetic coding"},
-    { M_SOF10,  "Progressive, arithmetic coding"},
-    { M_SOF11,  "Lossless, arithmetic coding"},
-    { M_SOF13,  "Differential sequential, arithmetic coding"},
-    { M_SOF14,  "Differential progressive, arithmetic coding"},
-    { M_SOF15,  "Differential lossless, arithmetic coding"},
-    { 0,        "Unknown"}
-};
-
-
-
-//--------------------------------------------------------------------------
-// Describes format descriptor
-static int BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
-#define NUM_FORMATS 12
-
-#define FMT_BYTE       1
-#define FMT_STRING     2
-#define FMT_USHORT     3
-#define FMT_ULONG      4
-#define FMT_URATIONAL  5
-#define FMT_SBYTE      6
-#define FMT_UNDEFINED  7
-#define FMT_SSHORT     8
-#define FMT_SLONG      9
-#define FMT_SRATIONAL 10
-#define FMT_SINGLE    11
-#define FMT_DOUBLE    12
-
-//--------------------------------------------------------------------------
-// Describes tag values
-
-#define TAG_EXIF_OFFSET       0x8769
-#define TAG_INTEROP_OFFSET    0xa005
-
-#define TAG_MAKE              0x010F
-#define TAG_MODEL             0x0110
-#define TAG_ORIENTATION       0x0112
-
-#define TAG_EXPOSURETIME      0x829A
-#define TAG_FNUMBER           0x829D
-
-#define TAG_SHUTTERSPEED      0x9201
-#define TAG_APERTURE          0x9202
-#define TAG_MAXAPERTURE       0x9205
-#define TAG_FOCALLENGTH       0x920A
-
-#define TAG_DATETIME_ORIGINAL 0x9003
-#define TAG_USERCOMMENT       0x9286
-
-#define TAG_SUBJECT_DISTANCE  0x9206
-#define TAG_FLASH             0x9209
-
-#define TAG_FOCALPLANEXRES    0xa20E
-#define TAG_FOCALPLANEUNITS   0xa210
-#define TAG_EXIF_IMAGEWIDTH   0xA002
-#define TAG_EXIF_IMAGELENGTH  0xA003
-
-// the following is added 05-jan-2001 vcs
-#define TAG_EXPOSURE_BIAS     0x9204
-#define TAG_WHITEBALANCE      0x9208
-#define TAG_METERING_MODE     0x9207
-#define TAG_EXPOSURE_PROGRAM  0x8822
-#define TAG_ISO_EQUIVALENT    0x8827
-#define TAG_COMPRESSION_LEVEL 0x9102
-
-#define TAG_THUMBNAIL_OFFSET  0x0201
-#define TAG_THUMBNAIL_LENGTH  0x0202
-
-
-/*static TagTable_t TagTable[] = {
-  {   0x100,   "ImageWidth"},
-  {   0x101,   "ImageLength"},
-  {   0x102,   "BitsPerSample"},
-  {   0x103,   "Compression"},
-  {   0x106,   "PhotometricInterpretation"},
-  {   0x10A,   "FillOrder"},
-  {   0x10D,   "DocumentName"},
-  {   0x10E,   "ImageDescription"},
-  {   0x10F,   "Make"},
-  {   0x110,   "Model"},
-  {   0x111,   "StripOffsets"},
-  {   0x112,   "Orientation"},
-  {   0x115,   "SamplesPerPixel"},
-  {   0x116,   "RowsPerStrip"},
-  {   0x117,   "StripByteCounts"},
-  {   0x11A,   "XResolution"},
-  {   0x11B,   "YResolution"},
-  {   0x11C,   "PlanarConfiguration"},
-  {   0x128,   "ResolutionUnit"},
-  {   0x12D,   "TransferFunction"},
-  {   0x131,   "Software"},
-  {   0x132,   "DateTime"},
-  {   0x13B,   "Artist"},
-  {   0x13E,   "WhitePoint"},
-  {   0x13F,   "PrimaryChromaticities"},
-  {   0x156,   "TransferRange"},
-  {   0x200,   "JPEGProc"},
-  {   0x201,   "ThumbnailOffset"},
-  {   0x202,   "ThumbnailLength"},
-  {   0x211,   "YCbCrCoefficients"},
-  {   0x212,   "YCbCrSubSampling"},
-  {   0x213,   "YCbCrPositioning"},
-  {   0x214,   "ReferenceBlackWhite"},
-  {   0x828D,  "CFARepeatPatternDim"},
-  {   0x828E,  "CFAPattern"},
-  {   0x828F,  "BatteryLevel"},
-  {   0x8298,  "Copyright"},
-  {   0x829A,  "ExposureTime"},
-  {   0x829D,  "FNumber"},
-  {   0x83BB,  "IPTC/NAA"},
-  {   0x8769,  "ExifOffset"},
-  {   0x8773,  "InterColorProfile"},
-  {   0x8822,  "ExposureProgram"},
-  {   0x8824,  "SpectralSensitivity"},
-  {   0x8825,  "GPSInfo"},
-  {   0x8827,  "ISOSpeedRatings"},
-  {   0x8828,  "OECF"},
-  {   0x9000,  "ExifVersion"},
-  {   0x9003,  "DateTimeOriginal"},
-  {   0x9004,  "DateTimeDigitized"},
-  {   0x9101,  "ComponentsConfiguration"},
-  {   0x9102,  "CompressedBitsPerPixel"},
-  {   0x9201,  "ShutterSpeedValue"},
-  {   0x9202,  "ApertureValue"},
-  {   0x9203,  "BrightnessValue"},
-  {   0x9204,  "ExposureBiasValue"},
-  {   0x9205,  "MaxApertureValue"},
-  {   0x9206,  "SubjectDistance"},
-  {   0x9207,  "MeteringMode"},
-  {   0x9208,  "LightSource"},
-  {   0x9209,  "Flash"},
-  {   0x920A,  "FocalLength"},
-  {   0x927C,  "MakerNote"},
-  {   0x9286,  "UserComment"},
-  {   0x9290,  "SubSecTime"},
-  {   0x9291,  "SubSecTimeOriginal"},
-  {   0x9292,  "SubSecTimeDigitized"},
-  {   0xA000,  "FlashPixVersion"},
-  {   0xA001,  "ColorSpace"},
-  {   0xA002,  "ExifImageWidth"},
-  {   0xA003,  "ExifImageLength"},
-  {   0xA005,  "InteroperabilityOffset"},
-  {   0xA20B,  "FlashEnergy"},                 // 0x920B in TIFF/EP
-  {   0xA20C,  "SpatialFrequencyResponse"},  // 0x920C    -  -
-  {   0xA20E,  "FocalPlaneXResolution"},     // 0x920E    -  -
-  {   0xA20F,  "FocalPlaneYResolution"},      // 0x920F    -  -
-  {   0xA210,  "FocalPlaneResolutionUnit"},  // 0x9210    -  -
-  {   0xA214,  "SubjectLocation"},             // 0x9214    -  -
-  {   0xA215,  "ExposureIndex"},            // 0x9215    -  -
-  {   0xA217,  "SensingMethod"},            // 0x9217    -  -
-  {   0xA300,  "FileSource"},
-  {   0xA301,  "SceneType"},
-  {      0, NULL}
-} ;
-*/
-
-
-//--------------------------------------------------------------------------
-// Parse the marker stream until SOS or EOI is seen;
-//--------------------------------------------------------------------------
-int ExifData::ReadJpegSections (QFile & infile, ReadMode_t ReadMode)
-{
-    int a;
-
-    a = infile.getch();
-
-    if (a != 0xff || infile.getch() != M_SOI) {
-        SectionsRead = 0;
-        return false;
-    }
-    for(SectionsRead = 0; SectionsRead < MAX_SECTIONS-1; ){
-        int marker = 0;
-        int got;
-        unsigned int ll,lh;
-        unsigned int itemlen;
-        uchar * Data;
-
-        for (a=0;a<7;a++){
-            marker = infile.getch();
-            if (marker != 0xff) break;
-
-            if (a >= 6){
-
-                kdDebug(7034) << "too many padding bytes\n";
-                return false;
-
-            }
-        }
-
-        if (marker == 0xff){
-            // 0xff is legal padding, but if we get that many, something's wrong.
-            throw FatalError("too many padding bytes!");
-        }
-
-        Sections[SectionsRead].Type = marker;
-
-        // Read the length of the section.
-        lh = (uchar) infile.getch();
-        ll = (uchar) infile.getch();
-
-        itemlen = (lh << 8) | ll;
-
-        if (itemlen < 2) {
-            throw FatalError("invalid marker");
-        }
-
-        Sections[SectionsRead].Size = itemlen;
-
-        Data = (uchar *)malloc(itemlen+1); // Add 1 to allow sticking a 0 at the end.
-        Sections[SectionsRead].Data = Data;
-
-        // Store first two pre-read bytes.
-        Data[0] = (uchar)lh;
-        Data[1] = (uchar)ll;
-
-        got = infile.readBlock((char*)Data+2, itemlen-2); // Read the whole section.
-        if (( unsigned ) got != itemlen-2){
-            throw FatalError("reading from file");
-        }
-        SectionsRead++;
-
-        switch(marker){
-
-            case M_SOS:   // stop before hitting compressed data
-                // If reading entire image is requested, read the rest of the data.
-                if (ReadMode & READ_IMAGE){
-                    unsigned long size;
-
-                    size = kMax( 0ul, infile.size()-infile.at() );
-                    Data = (uchar *)malloc(size);
-                    if (Data == NULL){
-                        throw FatalError("could not allocate data for entire image");
-                    }
-
-                    got = infile.readBlock((char*)Data,  size);
-                    if (( unsigned ) got != size){
-                        throw FatalError("could not read the rest of the image");
-                    }
-
-                    Sections[SectionsRead].Data = Data;
-                    Sections[SectionsRead].Size = size;
-                    Sections[SectionsRead].Type = PSEUDO_IMAGE_MARKER;
-                    SectionsRead ++;
-                    //HaveAll = 1;
-                }
-                return true;
-
-            case M_EOI:   // in case it's a tables-only JPEG stream
-                kdDebug(7034) << "No image in jpeg!\n";
-                return false;
-
-            case M_COM: // Comment section
-		// pieczy 2002-02-12
-		// now the User comment goes to UserComment
-		// so we can store a Comment section also in READ_EXIF mode
-		process_COM(Data, itemlen);
-                break;
-
-            case M_JFIF:
-                // Regular jpegs always have this tag, exif images have the exif
-                // marker instead, althogh ACDsee will write images with both markers.
-                // this program will re-create this marker on absence of exif marker.
-                // hence no need to keep the copy from the file.
-                free(Sections[--SectionsRead].Data);
-                break;
-
-            case M_EXIF:
-                // Seen files from some 'U-lead' software with Vivitar scanner
-                // that uses marker 31 for non exif stuff.  Thus make sure
-                // it says 'Exif' in the section before treating it as exif.
-                if ((ReadMode & READ_EXIF) && memcmp(Data+2, "Exif", 4) == 0){
-                    process_EXIF((uchar *)Data, itemlen); // FIXME: This call
-			// requires Data to be array of at least 8 bytes. Code
-			// above only checks for itemlen < 2.
-                }else{
-                    // Discard this section.
-                    free(Sections[--SectionsRead].Data);
-                }
-                break;
-
-            case M_SOF0:
-            case M_SOF1:
-            case M_SOF2:
-            case M_SOF3:
-            case M_SOF5:
-            case M_SOF6:
-            case M_SOF7:
-            case M_SOF9:
-            case M_SOF10:
-            case M_SOF11:
-            case M_SOF13:
-            case M_SOF14:
-            case M_SOF15:
-                process_SOFn(Data, marker); //FIXME: This call requires Data to
-		// be array of at least 8 bytes. Code above only checks for 
-		// itemlen < 2.
-                break;
-            default:
-                break;
-        }
-    }
-    return true;
-}
-
-
-//--------------------------------------------------------------------------
-// Discard read data.
-//--------------------------------------------------------------------------
-void ExifData::DiscardData(void)
-{
-    for (int a=0; a < SectionsRead; a++)
-        free(Sections[a].Data);
-    SectionsRead = 0;
-}
-
-//--------------------------------------------------------------------------
-// Convert a 16 bit unsigned value from file's native byte order
-//--------------------------------------------------------------------------
-int ExifData::Get16u(void * Short)
-{
-    if (MotorolaOrder){
-        return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
-    }else{
-        return (((uchar *)Short)[1] << 8) | ((uchar *)Short)[0];
-    }
-}
-
-//--------------------------------------------------------------------------
-// Convert a 32 bit signed value from file's native byte order
-//--------------------------------------------------------------------------
-int ExifData::Get32s(void * Long)
-{
-    if (MotorolaOrder){
-        return  ((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16)
-              | (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 );
-    }else{
-        return  ((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16)
-              | (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 );
-    }
-}
-
-//--------------------------------------------------------------------------
-// Convert a 32 bit unsigned value from file's native byte order
-//--------------------------------------------------------------------------
-unsigned ExifData::Get32u(void * Long)
-{
-    return (unsigned)Get32s(Long) & 0xffffffff;
-}
-
-//--------------------------------------------------------------------------
-// Evaluate number, be it int, rational, or float from directory.
-//--------------------------------------------------------------------------
-double ExifData::ConvertAnyFormat(void * ValuePtr, int Format)
-{
-    double Value;
-    Value = 0;
-
-    switch(Format){
-        case FMT_SBYTE:     Value = *(signed char *)ValuePtr;  break;
-        case FMT_BYTE:      Value = *(uchar *)ValuePtr;        break;
-
-        case FMT_USHORT:    Value = Get16u(ValuePtr);          break;
-
-        case FMT_ULONG:     Value = Get32u(ValuePtr);          break;
-
-        case FMT_URATIONAL:
-        case FMT_SRATIONAL:
-            {
-                int Num,Den;
-                Num = Get32s(ValuePtr);
-                Den = Get32s(4+(char *)ValuePtr);
-                if (Den == 0){
-                    Value = 0;
-                }else{
-                    Value = (double)Num/Den;
-                }
-                break;
-            }
-
-        case FMT_SSHORT:    Value = (signed short)Get16u(ValuePtr);  break;
-        case FMT_SLONG:     Value = Get32s(ValuePtr);                break;
-
-        // Not sure if this is correct (never seen float used in Exif format)
-        case FMT_SINGLE:    Value = (double)*(float *)ValuePtr;      break;
-        case FMT_DOUBLE:    Value = *(double *)ValuePtr;             break;
-    }
-    return Value;
-}
-
-//--------------------------------------------------------------------------
-// Process one of the nested EXIF directories.
-//--------------------------------------------------------------------------
-void ExifData::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBase, unsigned ExifLength)
-{
-    int de;
-    int a;
-    int NumDirEntries;
-    unsigned ThumbnailOffset = 0;
-    unsigned ThumbnailSize = 0;
-
-    NumDirEntries = Get16u(DirStart);
-    #define DIR_ENTRY_ADDR(Start, Entry) (Start+2+12*(Entry))
-
-    {
-        unsigned char * DirEnd;
-        DirEnd = DIR_ENTRY_ADDR(DirStart, NumDirEntries);
-        if (DirEnd+4 > (OffsetBase+ExifLength)){
-            if (DirEnd+2 == OffsetBase+ExifLength || DirEnd == OffsetBase+ExifLength){
-                // Version 1.3 of jhead would truncate a bit too much.
-                // This also caught later on as well.
-            }else{
-                // Note: Files that had thumbnails trimmed with jhead 1.3 or earlier
-                // might trigger this.
-                throw FatalError("Illegally sized directory");
-            }
-        }
-        if (DirEnd < LastExifRefd) LastExifRefd = DirEnd;
-    }
-
-    for (de=0;de<NumDirEntries;de++){
-        int Tag, Format, Components;
-        unsigned char * ValuePtr;
-        int ByteCount;
-        char * DirEntry;
-        DirEntry = (char *)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.
-            throw FatalError("Illegal format code in EXIF dir");
-        }
-
-        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
-                //printf("Offset %d bytes %d ExifLen %d\n",OffsetVal, ByteCount, ExifLength);
-
-                throw FatalError("Illegal pointer offset value in EXIF");
-            }
-            ValuePtr = OffsetBase+OffsetVal;
-        }else{
-            // 4 bytes or less and value is in the dir entry itself
-            ValuePtr = (unsigned char *)DirEntry+8;
-        }
-
-        if (LastExifRefd < ValuePtr+ByteCount){
-            // Keep track of last byte in the exif header that was actually referenced.
-            // That way, we know where the discardable thumbnail data begins.
-            LastExifRefd = ValuePtr+ByteCount;
-        }
-
-        // Extract useful components of tag
-        switch(Tag){
-
-            case TAG_MAKE:
-                ExifData::CameraMake = QString((char*)ValuePtr);
-                break;
-
-            case TAG_MODEL:
-                ExifData::CameraModel = QString((char*)ValuePtr);
-		break;
-
-            case TAG_ORIENTATION:
-                Orientation = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_DATETIME_ORIGINAL:
-		DateTime = QString((char*)ValuePtr);
-                break;
-
-            case TAG_USERCOMMENT:
-                // Olympus has this padded with trailing spaces.  Remove these first.
-                for (a=ByteCount;;){
-                    a--;
-                    if ((ValuePtr)[a] == ' '){
-                        (ValuePtr)[a] = '\0';
-                    }else{
-                        break;
-                    }
-                    if (a == 0) break;
-                }
-
-                // Copy the comment
-                if (memcmp(ValuePtr, "ASCII",5) == 0){
-                    for (a=5;a<10;a++){
-                        int c;
-                        c = (ValuePtr)[a];
-                        if (c != '\0' && c != ' '){
-                            //strncpy(ImageInfo.Comments, (const char*)(a+ValuePtr), 199);
-                            UserComment.sprintf("%s", (const char*)(a+ValuePtr));
-                            break;
-                        }
-                    }
-                }else{
-                    //strncpy(ImageInfo.Comments, (const char*)ValuePtr, 199);
-                    UserComment.sprintf("%s", (const char*)ValuePtr);
-                }
-                break;
-
-            case TAG_FNUMBER:
-                // Simplest way of expressing aperture, so I trust it the most.
-                // (overwrite previously computd value if there is one)
-		ExifData::ApertureFNumber = (float)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_APERTURE:
-            case TAG_MAXAPERTURE:
-                // More relevant info always comes earlier, so only use this field if we don't
-                // have appropriate aperture information yet.
-                if (ExifData::ApertureFNumber == 0){
-                    ExifData::ApertureFNumber
-                        = (float)exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)*0.5);
-                }
-                break;
-
-            case TAG_FOCALLENGTH:
-                // Nice digital cameras actually save the focal length as a function
-                // of how far they are zoomed in.
-                ExifData::FocalLength = (float)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_SUBJECT_DISTANCE:
-                // Inidcates the distacne the autofocus camera is focused to.
-                // Tends to be less accurate as distance increases.
-                ExifData::Distance = (float)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_EXPOSURETIME:
-                // Simplest way of expressing exposure time, so I trust it most.
-                // (overwrite previously computd value if there is one)
-                ExifData::ExposureTime = (float)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_SHUTTERSPEED:
-                // More complicated way of expressing exposure time, so only use
-                // this value if we don't already have it from somewhere else.
-                if (ExifData::ExposureTime == 0){
-                    ExifData::ExposureTime
-                        = (float)(1/exp(ConvertAnyFormat(ValuePtr, Format)*log(2.0)));
-                }
-                break;
-
-            case TAG_FLASH:
-		ExifData::FlashUsed = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_EXIF_IMAGELENGTH:
-                ExifImageLength = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_EXIF_IMAGEWIDTH:
-                ExifImageWidth = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_FOCALPLANEXRES:
-                FocalplaneXRes = ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_FOCALPLANEUNITS:
-                switch((int)ConvertAnyFormat(ValuePtr, Format)){
-                    case 1: FocalplaneUnits = 25.4; break; // inch
-                    case 2:
-                        // According to the information I was using, 2 means meters.
-                        // But looking at the Cannon powershot's files, inches is the only
-                        // sensible value.
-                        FocalplaneUnits = 25.4;
-                        break;
-
-                    case 3: FocalplaneUnits = 10;   break;  // centimeter
-                    case 4: FocalplaneUnits = 1;    break;  // milimeter
-                    case 5: FocalplaneUnits = .001; break;  // micrometer
-                }
-                break;
-
-                // Remaining cases contributed by: Volker C. Schoech (schoech@gmx.de)
-
-            case TAG_EXPOSURE_BIAS:
-	    	ExifData::ExposureBias = (float)ConvertAnyFormat(ValuePtr, Format);
-		break;
-
-            case TAG_WHITEBALANCE:
-                 ExifData::Whitebalance = (int)ConvertAnyFormat(ValuePtr, Format);
-		 break;
-
-            case TAG_METERING_MODE:
-                ExifData::MeteringMode = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_EXPOSURE_PROGRAM:
-                ExifData::ExposureProgram = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_ISO_EQUIVALENT:
-                ExifData::ISOequivalent = (int)ConvertAnyFormat(ValuePtr, Format);
-                if ( ExifData::ISOequivalent < 50 ) ExifData::ISOequivalent *= 200;
-                break;
-
-            case TAG_COMPRESSION_LEVEL:
-                ExifData::CompressionLevel = (int)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_THUMBNAIL_OFFSET:
-                ThumbnailOffset = (unsigned)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-            case TAG_THUMBNAIL_LENGTH:
-                ThumbnailSize = (unsigned)ConvertAnyFormat(ValuePtr, Format);
-                break;
-
-        }
-
-        if (Tag == TAG_EXIF_OFFSET || Tag == TAG_INTEROP_OFFSET){
-            unsigned char * SubdirStart;
-            SubdirStart = OffsetBase + Get32u(ValuePtr);
-            if (SubdirStart < OffsetBase || SubdirStart > OffsetBase+ExifLength){
-                throw FatalError("Illegal subdirectory link");
-            }
-            ProcessExifDir(SubdirStart, OffsetBase, ExifLength);
-            continue;
-        }
-    }
-
-    {
-        // In addition to linking to subdirectories via exif tags,
-        // there's also a potential link to another directory at the end of each
-        // directory.  this has got to be the result of a comitee!
-        unsigned char * SubdirStart;
-        unsigned Offset;
-
-        if (DIR_ENTRY_ADDR(DirStart, NumDirEntries) + 4 <= OffsetBase+ExifLength){
-            Offset = Get32u(DIR_ENTRY_ADDR(DirStart, NumDirEntries));
-	    // There is at least one jpeg from an HP camera having an Offset of almost MAXUINT.
-	    // Adding OffsetBase to it produces an overflow, so compare with ExifLength here.
-	    // See http://bugs.kde.org/show_bug.cgi?id=54542
-	    if (Offset && Offset < ExifLength){
-                SubdirStart = OffsetBase + Offset;
-                if (SubdirStart > OffsetBase+ExifLength){
-                    if (SubdirStart < OffsetBase+ExifLength+20){
-                        // Jhead 1.3 or earlier would crop the whole directory!
-                        // As Jhead produces this form of format incorrectness,
-                        // I'll just let it pass silently
-                        kdDebug(7034) << "Thumbnail removed with Jhead 1.3 or earlier\n";
-                    }else{
-                        throw FatalError("Illegal subdirectory link 2");
-                    }
-                }else{
-                    if (SubdirStart <= OffsetBase+ExifLength){
-                        ProcessExifDir(SubdirStart, OffsetBase, ExifLength);
-                    }
-                }
-            }
-        }else{
-            // The exif header ends before the last next directory pointer.
-        }
-    }
-
-    if (ThumbnailSize && ThumbnailOffset){
-        if (ThumbnailSize + ThumbnailOffset <= ExifLength){
-            // The thumbnail pointer appears to be valid.  Store it.
-	    Thumbnail.loadFromData(OffsetBase + ThumbnailOffset, ThumbnailSize, "JPEG");
-        }
-    }
-}
-
-//--------------------------------------------------------------------------
-// Process a COM marker.  We want to leave the bytes unchanged.  The
-// progam that displays this text may decide to remove blanks, convert
-// newlines, or otherwise modify the text.  In particular we want to be
-// safe for passing utf-8 text.
-//--------------------------------------------------------------------------
-void ExifData::process_COM (const uchar * Data, int length)
-{
-    Comment = QString::fromUtf8((char *)Data+2, (length-2));
-}
-
-
-//--------------------------------------------------------------------------
-// Process a SOFn marker.  This is useful for the image dimensions
-//--------------------------------------------------------------------------
-void ExifData::process_SOFn (const uchar * Data, int marker)
-{
-    int data_precision, num_components;
-
-    data_precision = Data[2];
-    ExifData::Height = Get16m(Data+3);
-    ExifData::Width = Get16m(Data+5);
-    num_components = Data[7];
-
-    if (num_components == 3){
-        ExifData::IsColor = 1;
-    }else{
-        ExifData::IsColor = 0;
-    }
-
-    ExifData::Process = marker;
-
-}
-
-//--------------------------------------------------------------------------
-// Get 16 bits motorola order (always) for jpeg header stuff.
-//--------------------------------------------------------------------------
-int ExifData::Get16m(const void * Short)
-{
-    return (((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
-}
-
-
-//--------------------------------------------------------------------------
-// Process a EXIF marker
-// Describes all the drivel that most digital cameras include...
-//--------------------------------------------------------------------------
-void ExifData::process_EXIF(unsigned char * CharBuf, unsigned int length)
-{
-    ExifData::FlashUsed = 0; // If it s from a digicam, and it used flash, it says so.
-
-    FocalplaneXRes = 0;
-    FocalplaneUnits = 0;
-    ExifImageWidth = 0;
-    ExifImageLength = 0;
-
-    {   // Check the EXIF header component
-        static const uchar ExifHeader[] = "Exif\0\0";
-        if (memcmp(CharBuf+2, ExifHeader,6)){
-            throw FatalError("Incorrect Exif header");
-        }
-    }
-
-    if (memcmp(CharBuf+8,"II",2) == 0){
-        // printf("Exif section in Intel order\n");
-        MotorolaOrder = 0;
-    }else{
-        if (memcmp(CharBuf+8,"MM",2) == 0){
-            // printf("Exif section in Motorola order\n");
-            MotorolaOrder = 1;
-        }else{
-            throw FatalError("Invalid Exif alignment marker.");
-        }
-    }
-
-    // Check the next two values for correctness.
-    if (Get16u(CharBuf+10) != 0x2a
-      || Get32u(CharBuf+12) != 0x08){
-        throw FatalError("Invalid Exif start (1)");
-    }
-
-    LastExifRefd = CharBuf;
-
-    // First directory starts 16 bytes in.  Offsets start at 8 bytes in.
-    ProcessExifDir(CharBuf+16, CharBuf+8, length-6);
-
-    // This is how far the interesting (non thumbnail) part of the exif went.
-    ExifSettingsLength = LastExifRefd - CharBuf;
-
-    // Compute the CCD width, in milimeters.
-    if (FocalplaneXRes != 0){
-	kdDebug(7034) << "ExifImageWidth " << ExifImageWidth << " FocalplaneUnits " << FocalplaneUnits << " FocalplaneXRes " << FocalplaneXRes << endl;
-        ExifData::CCDWidth = (float)(ExifImageWidth * FocalplaneUnits / FocalplaneXRes);
-    }
-}
-
-//--------------------------------------------------------------------------
-// Convert exif time to Unix time structure
-//--------------------------------------------------------------------------
-int ExifData::Exif2tm(struct tm * timeptr, char * ExifTime)
-{
-    int a;
-
-    timeptr->tm_wday = -1;
-
-    // Check for format: YYYY:MM:DD HH:MM:SS format.
-    a = sscanf(ExifTime, "%d:%d:%d %d:%d:%d",
-            &timeptr->tm_year, &timeptr->tm_mon, &timeptr->tm_mday,
-            &timeptr->tm_hour, &timeptr->tm_min, &timeptr->tm_sec);
-
-    if (a == 6){
-        timeptr->tm_isdst = -1;
-        timeptr->tm_mon -= 1;      // Adjust for unix zero-based months
-        timeptr->tm_year -= 1900;  // Adjust for year starting at 1900
-        return true; // worked.
-    }
-
-    return false; // Wasn't in Exif date format.
-}
-
-//--------------------------------------------------------------------------
-// Contructor for initialising
-//--------------------------------------------------------------------------
-ExifData::ExifData()
-{
-    ExifData::Whitebalance = -1;
-    ExifData::MeteringMode = -1;
-    ExifData::FlashUsed = 0;
-    Orientation = 0;
-    Height = 0;
-    Width = 0;
-    IsColor = 0;
-    Process = 0;
-    FocalLength = 0;
-    ExposureTime = 0;
-    ApertureFNumber = 0;
-    Distance = 0;
-    CCDWidth = 0;
-    ExposureBias = 0;
-    ExposureProgram = 0;
-    ISOequivalent = 0;
-    CompressionLevel = 0;
-}
-
-//--------------------------------------------------------------------------
-// process a EXIF jpeg file
-//--------------------------------------------------------------------------
-bool ExifData::scan(const QString & path)
-{
-    int ret;
-
-    QFile f(path);
-    if ( !f.open(IO_ReadOnly) )
-        return false;
-
-    try {
-        // Scan the JPEG headers.
-        ret = ReadJpegSections(f, READ_EXIF);
-    }
-    catch (FatalError& e) {
-        e.debug_print();
-        f.close();
-        return false;
-    }
-
-    if (ret == false){
-        kdDebug(7034) << "Not JPEG file!\n";
-        DiscardData();
-        f.close();
-        return false;
-    }
-    f.close();
-    DiscardData();
-
-    //now make the strings clean,
-    // for exmaple my Casio is a "QV-4000   "
-    CameraMake = CameraMake.stripWhiteSpace();
-    CameraModel = CameraModel.stripWhiteSpace();
-    UserComment = UserComment.stripWhiteSpace();
-    Comment = Comment.stripWhiteSpace();
-    return true;
-}
-
-//--------------------------------------------------------------------------
-// Does the embedded thumbnail match the jpeg image?
-//--------------------------------------------------------------------------
-#ifndef JPEG_TOL
-#define JPEG_TOL 0.02
-#endif
-bool ExifData::isThumbnailSane() {
-  if (Thumbnail.isNull()) return false;
-
-  // check whether thumbnail dimensions match the image
-  // not foolproof, but catches some altered images (jpegtran -rotate)
-  if (ExifImageLength != 0 && ExifImageLength != Height) return false;
-  if (ExifImageWidth != 0 && ExifImageWidth != Width) return false;
-  if (Thumbnail.width() == 0 || Thumbnail.height() == 0) return false;
-  if (Height == 0 || Width == 0) return false;
-  double d = (double)Height/Width*Thumbnail.width()/Thumbnail.height();
-  return (1-JPEG_TOL < d) && (d < 1+JPEG_TOL);
-}
-
-
-//--------------------------------------------------------------------------
-// return a thumbnail that respects the orientation flag
-// only if it seems sane
-//--------------------------------------------------------------------------
-QImage ExifData::getThumbnail() {
-  if (!isThumbnailSane()) return NULL;
-  if (!Orientation || Orientation == 1) return Thumbnail;
-
-  // now fix orientation
-  QWMatrix M;
-  QWMatrix flip= QWMatrix(-1,0,0,1,0,0);
-  switch (Orientation) {  // notice intentional fallthroughs
-    case 2: M = flip; break;
-    case 4: M = flip;
-    case 3: M.rotate(180); break;
-    case 5: M = flip;
-    case 6: M.rotate(90); break;
-    case 7: M = flip;
-    case 8: M.rotate(270); break;
-    default: break; // should never happen
-  }
-  return Thumbnail.xForm(M);
-}
--- kfile-plugins/jpeg/kfile_setcomment.cpp.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/kfile_setcomment.cpp	1970-01-01 01:00:00.000000000 +0100
@@ -1,536 +0,0 @@
-/*
- * setcomment.cpp
- *
- * Copyright 2002 Bryce Nesbitt
- *
- * Based on wrjpgcom.c, Copyright (C) 1994-1997, Thomas G. Lane.
- * Part of the Independent JPEG Group's software release 6b of 27-Mar-1998
- *
- * This file contains a very simple stand-alone application that inserts
- * user-supplied text as a COM (comment) marker in a JPEG/JFIF file.
- * This may be useful as an example of the minimum logic needed to parse
- * JPEG markers.
- *
- * There can be an arbitrary number of COM blocks in each jpeg file, with
- * up to 64K of data each.  We, however, write just one COM and blow away
- * the rest.
- *
- *****************
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License as published by the Free Software Foundation version 2.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; see the file COPYING.  If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- * Boston, MA 02110-1301, USA.
- *
- */
-
-#undef  STANDALONE_COMPILE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <string.h>
-#include "config.h"
-
-extern int safe_copy_and_modify( const char * original_filename, const char * comment );
-    
-#ifdef DONT_USE_B_MODE          /* define mode parameters for fopen() */
-#define READ_BINARY     "r"
-#define WRITE_BINARY    "w"
-#else
-#ifdef VMS                      /* VMS is very nonstandard */
-#define READ_BINARY     "rb", "ctx=stm"
-#define WRITE_BINARY    "wb", "ctx=stm"
-#else                           /* standard ANSI-compliant case */
-#define READ_BINARY     "rb"
-#define WRITE_BINARY    "wb"
-#endif
-#endif
-
-#define WARNING_GARBAGE     1   /* Original file had some unspecified content */
-#define ERROR_NOT_A_JPEG    5   /* Original file not a proper jpeg (must be 1st) */
-#define ERROR_TEMP_FILE     6   /* Problem writing temporay file */
-#define ERROR_SCREWUP       7   /* Original file is now damaged.  Ooops. */
-#define ERROR_PREMATURE_EOF 8   /* Unexpected end of file */
-#define ERROR_BAD_MARKER    9   /* Marker with illegal length */
-#define ERROR_MARKER_ORDER  10  /* File seems to be mixed up */
-
-static int          global_error;   /* global error flag.  Once set, we're dead. */
-
-/****************************************************************************/
-/*
- * These macros are used to read the input file and write the output file.
- * To reuse this code in another application, you might need to change these.
- */
-static FILE * infile;           /* input JPEG file */
-
-/* Return next input byte, or EOF if no more */
-#define NEXTBYTE()  getc(infile)
-
-static FILE * outfile;          /* output JPEG file */
-
-/* Emit an output byte */
-#define PUTBYTE(x)  putc((x), outfile)
-
-
-/****************************************************************************/
-/* Read one byte, testing for EOF */
-static int
-read_1_byte (void)
-{
-  int c;
-
-  c = NEXTBYTE();
-  if (c == EOF) {
-    global_error = ERROR_PREMATURE_EOF;
-    }
-  return c;
-}
-
-/* Read 2 bytes, convert to unsigned int */
-/* All 2-byte quantities in JPEG markers are MSB first */
-static unsigned int
-read_2_bytes (void)
-{
-  int c1, c2;
-
-  c1 = NEXTBYTE();
-  if (c1 == EOF)
-    global_error = ERROR_PREMATURE_EOF;
-  c2 = NEXTBYTE();
-  if (c2 == EOF)
-    global_error = ERROR_PREMATURE_EOF;
-  return (((unsigned int) c1) << 8) + ((unsigned int) c2);
-}
-
-
-/****************************************************************************/
-/* Routines to write data to output file */
-static void
-write_1_byte (int c)
-{
-  PUTBYTE(c);
-}
-
-static void
-write_2_bytes (unsigned int val)
-{
-  PUTBYTE((val >> 8) & 0xFF);
-  PUTBYTE(val & 0xFF);
-}
-
-static void
-write_marker (int marker)
-{
-  PUTBYTE(0xFF);
-  PUTBYTE(marker);
-}
-
-static void
-copy_rest_of_file (void)
-{
-  int c;
-
-  while ((c = NEXTBYTE()) != EOF)
-    PUTBYTE(c);
-}
-
-
-/****************************************************************************/
-/*
- * JPEG markers consist of one or more 0xFF bytes, followed by a marker
- * code byte (which is not an FF).  Here are the marker codes of interest
- * in this program.  (See jdmarker.c for a more complete list.)
- */
-
-#define M_SOF0  0xC0            /* Start Of Frame N */
-#define M_SOF1  0xC1            /* N indicates which compression process */
-#define M_SOF2  0xC2            /* Only SOF0-SOF2 are now in common use */
-#define M_SOF3  0xC3
-#define M_SOF5  0xC5            /* NB: codes C4 and CC are NOT SOF markers */
-#define M_SOF6  0xC6
-#define M_SOF7  0xC7
-#define M_SOF9  0xC9
-#define M_SOF10 0xCA
-#define M_SOF11 0xCB
-#define M_SOF13 0xCD
-#define M_SOF14 0xCE
-#define M_SOF15 0xCF
-#define M_SOI   0xD8            /* Start Of Image (beginning of datastream) */
-#define M_EOI   0xD9            /* End Of Image (end of datastream) */
-#define M_SOS   0xDA            /* Start Of Scan (begins compressed data) */
-#define M_COM   0xFE            /* COMment */
-
-
-/*
- * Find the next JPEG marker and return its marker code.
- * We expect at least one FF byte, possibly more if the compressor used FFs
- * to pad the file.  (Padding FFs will NOT be replicated in the output file.)
- * There could also be non-FF garbage between markers.  The treatment of such
- * garbage is unspecified; we choose to skip over it but emit a warning msg.
- * NB: this routine must not be used after seeing SOS marker, since it will
- * not deal correctly with FF/00 sequences in the compressed image data...
- */
-static int
-next_marker (void)
-{
-  int c;
-  int discarded_bytes = 0;
-
-  /* Find 0xFF byte; count and skip any non-FFs. */
-  c = read_1_byte();
-  while (c != 0xFF) {
-    discarded_bytes++;
-    c = read_1_byte();
-  }
-  /* Get marker code byte, swallowing any duplicate FF bytes.  Extra FFs
-   * are legal as pad bytes, so don't count them in discarded_bytes.
-   */
-  do {
-    c = read_1_byte();
-  } while (c == 0xFF);
-
-  if (discarded_bytes != 0) {
-    global_error = WARNING_GARBAGE;
-  }
-
-  return c;
-}
-
-
-/*
- * Most types of marker are followed by a variable-length parameter segment.
- * This routine skips over the parameters for any marker we don't otherwise
- * want to process.
- * Note that we MUST skip the parameter segment explicitly in order not to
- * be fooled by 0xFF bytes that might appear within the parameter segment;
- * such bytes do NOT introduce new markers.
- */
-static void
-copy_variable (void)
-/* Copy an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  write_2_bytes(length);
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2) {
-    global_error = ERROR_BAD_MARKER;
-    length = 2;
-    }
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    write_1_byte(read_1_byte());
-    length--;
-  }
-}
-
-static void
-skip_variable (void)
-/* Skip over an unknown or uninteresting variable-length marker */
-{
-  unsigned int length;
-
-  /* Get the marker parameter length count */
-  length = read_2_bytes();
-  /* Length includes itself, so must be at least 2 */
-  if (length < 2) {
-    global_error = ERROR_BAD_MARKER;
-    length = 2;
-    }
-  length -= 2;
-  /* Skip over the remaining bytes */
-  while (length > 0) {
-    (void) read_1_byte();
-    length--;
-  }
-}
-
-
-static int
-scan_JPEG_header (int keep_COM)
-/*
- * Parse & copy the marker stream until SOFn or EOI is seen;
- * copy data to output, but discard COM markers unless keep_COM is true.
- */
-{
-  int c1, c2;
-  int marker;
-
-  /*
-   * Read the initial marker, which should be SOI.
-   * For a JFIF file, the first two bytes of the file should be literally
-   * 0xFF M_SOI.  To be more general, we could use next_marker, but if the
-   * input file weren't actually JPEG at all, next_marker might read the whole
-   * file and then return a misleading error message...
-   */
-  c1 = NEXTBYTE();
-  c2 = NEXTBYTE();
-  if (c1 != 0xFF || c2 != M_SOI) {
-    global_error = ERROR_NOT_A_JPEG;
-    return EOF;
-    }
-
-  write_marker(M_SOI);
-
-  /* Scan miscellaneous markers until we reach SOFn. */
-  for (;;) {
-    marker = next_marker();
-    switch (marker) {
-      /* Note that marker codes 0xC4, 0xC8, 0xCC are not, and must not be,
-       * treated as SOFn.  C4 in particular is actually DHT.
-       */
-      case M_SOF0:                /* Baseline */
-      case M_SOF1:                /* Extended sequential, Huffman */
-      case M_SOF2:                /* Progressive, Huffman */
-      case M_SOF3:                /* Lossless, Huffman */
-      case M_SOF5:                /* Differential sequential, Huffman */
-      case M_SOF6:                /* Differential progressive, Huffman */
-      case M_SOF7:                /* Differential lossless, Huffman */
-      case M_SOF9:                /* Extended sequential, arithmetic */
-      case M_SOF10:               /* Progressive, arithmetic */
-      case M_SOF11:               /* Lossless, arithmetic */
-      case M_SOF13:               /* Differential sequential, arithmetic */
-      case M_SOF14:               /* Differential progressive, arithmetic */
-      case M_SOF15:               /* Differential lossless, arithmetic */
-      return marker;
-
-    case M_SOS:                 /* should not see compressed data before SOF */
-      global_error = ERROR_MARKER_ORDER;
-      break;
-
-    case M_EOI:                 /* in case it's a tables-only JPEG stream */
-      return marker;
-
-    case M_COM:                 /* Existing COM: conditionally discard */
-      if (keep_COM) {
-        write_marker(marker);
-        copy_variable();
-      } else {
-        skip_variable();
-      }
-      break;
-
-    default:                    /* Anything else just gets copied */
-      write_marker(marker);
-      copy_variable();          /* we assume it has a parameter count... */
-      break;
-    }
-  } /* end loop */
-}
-
-
-/****************************************************************************/
-/*
-    Verify we know how to set the comment on this type of file.
-
-    TODO: The actual check!  This should verify
-    the image size promised in the headers matches the file,
-    and that all markers are properly formatted.
-*/
-static int validate_image_file( const char * filename )
-{
-int status = 1;
-int c1, c2;
-
-  if ( (infile = fopen(filename, READ_BINARY)) ) {
-    c1 = NEXTBYTE();
-    c2 = NEXTBYTE();
-    if (c1 != 0xFF || c2 != M_SOI) 
-      status = ERROR_NOT_A_JPEG;
-    else 
-      status = 0;
-    fclose( infile ); 
-  }
-  return( status );
-}
-
-
-/****************************************************************************/
-/*
-    Modify the file in place, but be paranoid and safe about it.
-    It's worth a few extra CPU cycles to make sure we never
-    destory an original image:
-    1) Validate the input file.
-    2) Open a temporary file.
-    3) Copy the data, writing a new comment block.
-    4) Validate the temporary file.
-    5) Move the temporary file over the original.
-
-    To be even more paranoid & safe we could:
-    5) Rename the original to a different temporary name.
-    6) Rename the temporary to the original.
-    7) Delete the original.
-*/
-extern int safe_copy_and_modify( const char * original_filename, const char * comment )
-{
-char *       temp_filename;
-int          temp_filename_length;
-int          comment_length  = 0;
-int          marker;
-int          i;
-struct stat  statbuf;
-
-  global_error  = 0;
-
-  /*
-   * Make sure we're dealing with a proper input file.  Safety first!
-   */
-  if( validate_image_file( original_filename ) ) {
-    fprintf(stderr, "error validating original file %s\n", original_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-
-  /* Get a unique temporary file in the same directory.  Hopefully 
-   * if things go wrong, this file will still be left for recovery purposes.
-   *
-   * NB: I hate these stupid string functions in C... the buffer length is too
-   * hard to manage...
-   */
-  outfile = NULL;
-  temp_filename_length = strlen( original_filename) + 4;
-  temp_filename = (char *)calloc( temp_filename_length, 1 );
-  for( i=0; i<10; i++ ) {
-    snprintf( temp_filename, temp_filename_length, "%s%d", original_filename, i );
-    if( stat( temp_filename, &statbuf ) ) {
-        outfile = fopen(temp_filename, WRITE_BINARY);
-        break;
-        }
-    }
-  if( !outfile ) {
-    fprintf(stderr, "failed opening temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-
-  /*
-   * Let's rock and roll! 
-   */
-  if ((infile = fopen(original_filename, READ_BINARY)) == NULL) {
-    fprintf(stderr, "can't open input file %s\n", original_filename);
-    free(temp_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-  /* Copy JPEG headers until SOFn marker;
-   * we will insert the new comment marker just before SOFn.
-   * This (a) causes the new comment to appear after, rather than before,
-   * existing comments; and (b) ensures that comments come after any JFIF
-   * or JFXX markers, as required by the JFIF specification.
-   */
-  marker = scan_JPEG_header(0);
-  /* Insert the new COM marker, but only if nonempty text has been supplied */
-  if (comment) {
-    comment_length = strlen( comment );
-    }
-  if (comment_length > 0) {
-    write_marker(M_COM);
-    write_2_bytes(comment_length + 2);
-    while (comment_length > 0) {
-      write_1_byte(*comment++);
-      comment_length--;
-      }
-    }
-  /* Duplicate the remainder of the source file.
-   * Note that any COM markers occurring after SOF will not be touched.
-   *
-   * :TODO: Discard COM markers occurring after SOF
-   */
-  write_marker(marker);
-  copy_rest_of_file();
-  fclose( infile );
-  fsync( fileno( outfile) );    /* Make sure its really on disk first.  !!!VERY IMPORTANT!!! */
-  if ( fclose( outfile ) ) {
-    fprintf(stderr, "error in temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-
-  /*
-   * Make sure we did it right.  We've already fsync()'ed the file.  Safety first!
-   */
-  if( validate_image_file( temp_filename ) ) {
-    fprintf(stderr, "error in temporary file %s\n", temp_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-
-  if( global_error >= ERROR_NOT_A_JPEG ) {
-    fprintf(stderr, "error %d processing %s\n", global_error, original_filename);
-    free(temp_filename);
-    return(ERROR_NOT_A_JPEG);
-    }
-
-  if( rename( temp_filename, original_filename ) ) {
-    fprintf(stderr, "error renaming %s to %s\n", temp_filename, original_filename);
-    free(temp_filename);
-    return(ERROR_TEMP_FILE);
-    }
-  free(temp_filename);
-
-  return(0);
-}
-
-
-#ifdef  STANDALONE_COMPILE
-int
-main (int argc, char **argv)
-{
-    char * progname;       /* program name for error messages */
-    char * filename;
-    char * comment;
-    FILE * fp;
-    int    error;
-
-    /* Process command line arguments... */
-    progname = argv[0];
-    if (progname == NULL || progname[0] == 0)
-        progname = "writejpgcomment";  /* in case C library doesn't provide it */
-    if( argc != 3) {
-        fprintf(stderr, "Usage: %s <filename> \"<comment>\"\nOverwrites the comment in a image file with the given comment.\n", progname);
-        return(5);
-        }
-    filename = argv[1];
-    comment  = argv[2];
-
-
-    /* Check if file is readable... */
-    if ((fp = fopen(filename, READ_BINARY)) == NULL) {
-      fprintf(stderr, "Error: Can't open file %s\n", filename);
-      fclose(fp);
-      return(5);
-    }
-    fclose(fp);
-
-    /* Check if we really have a commentable image file here... */
-    if( validate_image_file( filename ) ) {
-      fprintf(stderr, "Error: file %s is not of a supported type\n", filename);
-      return(5);
-      }
-
-    /* Lets do it... modify the comment in place */
-    if ((error = safe_copy_and_modify( filename, comment ) )) {
-        fprintf(stderr, "Error: %d setting jpg comment\n", error);
-        return(10);
-    }
-
-
-    /* TODO: Read comment back out of jpg and display it */
-    return( 0 );
-}
-#endif
--- kfile-plugins/jpeg/kfile_jpeg.cpp.sav	2006-10-23 16:25:33.000000000 +0200
+++ kfile-plugins/jpeg/kfile_jpeg.cpp	2006-10-23 16:45:25.000000000 +0200
@@ -36,7 +36,9 @@
 #include <qvalidator.h>
 #include <qimage.h>
 
-#include "exif.h"
+#include <libexif/exif-data.h>
+#include <libexif/exif-tag.h>
+
 
 #define EXIFGROUP "Jpeg EXIF Data"
 
@@ -44,107 +46,159 @@ typedef KGenericFactory<KJpegPlugin> Jpe
 
 K_EXPORT_COMPONENT_FACTORY(kfile_jpeg, JpegFactory("kfile_jpeg"))
 
+namespace
+{
+struct Tag
+    {
+    ExifTag tag;
+    QVariant::Type type;
+    KFileMimeTypeInfo::Hint hint;
+    KFileMimeTypeInfo::Unit unit;
+    };
+};
+#define NoHint KFileMimeTypeInfo::NoHint
+#define NoUnit KFileMimeTypeInfo::NoUnit
+static const Tag tags[] =
+{ // list extracted from 0.6.14
+    { EXIF_TAG_INTEROPERABILITY_INDEX, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_INTEROPERABILITY_VERSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_NEW_SUBFILE_TYPE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_IMAGE_WIDTH, QVariant::Double, KFileMimeTypeInfo::Width, NoUnit },
+    { EXIF_TAG_IMAGE_LENGTH, QVariant::Double, KFileMimeTypeInfo::Height, NoUnit },
+    { EXIF_TAG_BITS_PER_SAMPLE, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_COMPRESSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_PHOTOMETRIC_INTERPRETATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FILL_ORDER, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_DOCUMENT_NAME, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_IMAGE_DESCRIPTION, QVariant::String, KFileMimeTypeInfo::Description, NoUnit },
+    { EXIF_TAG_MAKE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_MODEL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_STRIP_OFFSETS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_ORIENTATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SAMPLES_PER_PIXEL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_ROWS_PER_STRIP, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_STRIP_BYTE_COUNTS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_X_RESOLUTION, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_Y_RESOLUTION, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_PLANAR_CONFIGURATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_RESOLUTION_UNIT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_TRANSFER_FUNCTION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SOFTWARE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_DATE_TIME, QVariant::DateTime, NoHint, NoUnit },
+    { EXIF_TAG_ARTIST, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_WHITE_POINT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_PRIMARY_CHROMATICITIES, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_TRANSFER_RANGE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUB_IFDS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_JPEG_PROC, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_JPEG_INTERCHANGE_FORMAT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_JPEG_INTERCHANGE_FORMAT_LENGTH, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_YCBCR_COEFFICIENTS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_YCBCR_SUB_SAMPLING, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_YCBCR_POSITIONING, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_REFERENCE_BLACK_WHITE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_XML_PACKET, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_RELATED_IMAGE_FILE_FORMAT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_RELATED_IMAGE_WIDTH, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_RELATED_IMAGE_LENGTH, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_CFA_REPEAT_PATTERN_DIM, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_CFA_PATTERN, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_BATTERY_LEVEL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_COPYRIGHT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXPOSURE_TIME, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FNUMBER, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_IPTC_NAA, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_IMAGE_RESOURCES, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXIF_IFD_POINTER, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_INTER_COLOR_PROFILE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXPOSURE_PROGRAM, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SPECTRAL_SENSITIVITY, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_GPS_INFO_IFD_POINTER, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_ISO_SPEED_RATINGS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_OECF, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXIF_VERSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_DATE_TIME_ORIGINAL, QVariant::DateTime, NoHint, NoUnit },
+    { EXIF_TAG_DATE_TIME_DIGITIZED, QVariant::DateTime, NoHint, NoUnit },
+    { EXIF_TAG_COMPONENTS_CONFIGURATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_COMPRESSED_BITS_PER_PIXEL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SHUTTER_SPEED_VALUE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_APERTURE_VALUE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_BRIGHTNESS_VALUE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXPOSURE_BIAS_VALUE, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_MAX_APERTURE_VALUE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUBJECT_DISTANCE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_METERING_MODE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_LIGHT_SOURCE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FLASH, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FOCAL_LENGTH, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUBJECT_AREA, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_TIFF_EP_STANDARD_ID, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_MAKER_NOTE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_USER_COMMENT, QVariant::String, KFileMimeTypeInfo::Description, NoUnit },
+    { EXIF_TAG_SUB_SEC_TIME, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUB_SEC_TIME_ORIGINAL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUB_SEC_TIME_DIGITIZED, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FLASH_PIX_VERSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_COLOR_SPACE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_PIXEL_X_DIMENSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_PIXEL_Y_DIMENSION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_RELATED_SOUND_FILE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_INTEROPERABILITY_IFD_POINTER, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FLASH_ENERGY, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SPATIAL_FREQUENCY_RESPONSE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FOCAL_PLANE_X_RESOLUTION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FOCAL_PLANE_Y_RESOLUTION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FOCAL_PLANE_RESOLUTION_UNIT, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUBJECT_LOCATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXPOSURE_INDEX, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SENSING_METHOD, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_FILE_SOURCE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SCENE_TYPE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_NEW_CFA_PATTERN, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_CUSTOM_RENDERED, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_EXPOSURE_MODE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_WHITE_BALANCE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_DIGITAL_ZOOM_RATIO, QVariant::Double, NoHint, NoUnit },
+    { EXIF_TAG_FOCAL_LENGTH_IN_35MM_FILM, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SCENE_CAPTURE_TYPE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_GAIN_CONTROL, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_CONTRAST, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SATURATION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SHARPNESS, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_DEVICE_SETTING_DESCRIPTION, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_SUBJECT_DISTANCE_RANGE, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_IMAGE_UNIQUE_ID, QVariant::String, NoHint, NoUnit },
+    { EXIF_TAG_GAMMA, QVariant::String, NoHint, NoUnit }
+};
+static const int NUM_TAGS = sizeof( tags ) / sizeof( tags[ 0 ] );
+
 KJpegPlugin::KJpegPlugin(QObject *parent, const char *name,
                        const QStringList &args )
     : KFilePlugin(parent, name, args)
 {
-  kdDebug(7034) << "jpeg plugin\n";
+    kdDebug(7034) << "JPEG Plugin" << endl;
 
   //
   // define all possible meta info items
   //
-  KFileMimeTypeInfo *info = addMimeTypeInfo("image/jpeg");
-  KFileMimeTypeInfo::GroupInfo *exifGroup = addGroupInfo( info, EXIFGROUP,
+    KFileMimeTypeInfo *info = addMimeTypeInfo("image/jpeg");
+    KFileMimeTypeInfo::GroupInfo *exifGroup = addGroupInfo( info, EXIFGROUP,
                                                           i18n("JPEG Exif") );
-  KFileMimeTypeInfo::ItemInfo* item;
-
-  item = addItemInfo( exifGroup, "Comment", i18n("Comment"), QVariant::String);
-  setAttributes( item,
-                 KFileMimeTypeInfo::Modifiable |
-                 KFileMimeTypeInfo::Addable |
-                 KFileMimeTypeInfo::MultiLine );
-
-  item = addItemInfo( exifGroup, "Manufacturer", i18n("Camera Manufacturer"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Model", i18n("Camera Model"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Date/time", i18n("Date/Time"),
-                      QVariant::DateTime );
-
-  item = addItemInfo( exifGroup, "CreationDate", i18n("Creation Date"),
-                      QVariant::Date );
-
-  item = addItemInfo( exifGroup, "CreationTime", i18n("Creation Time"),
-                      QVariant::Time );
-
-  item = addItemInfo( exifGroup, "Dimensions", i18n("Dimensions"),
-                      QVariant::Size );
-  setHint( item, KFileMimeTypeInfo::Size );
-  setUnit( item, KFileMimeTypeInfo::Pixels );
-
-  item = addItemInfo( exifGroup, "Orientation", i18n("Orientation"),
-                      QVariant::Int );
-
-  item = addItemInfo( exifGroup, "ColorMode", i18n("Color Mode"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Flash used", i18n("Flash Used"),
-                      QVariant::String );
-  item = addItemInfo( exifGroup, "Focal length", i18n("Focal Length"),
-                      QVariant::String );
-  setUnit( item, KFileMimeTypeInfo::Millimeters );
-
-  item = addItemInfo( exifGroup, "35mm equivalent", i18n("35mm Equivalent"),
-                      QVariant::Int );
-  setUnit( item, KFileMimeTypeInfo::Millimeters );
-
-  item = addItemInfo( exifGroup, "CCD width", i18n("CCD Width"),
-                      QVariant::String );
-  setUnit( item, KFileMimeTypeInfo::Millimeters );
-
-  item = addItemInfo( exifGroup, "Exposure time", i18n("Exposure Time"),
-                      QVariant::String );
-  setHint( item, KFileMimeTypeInfo::Seconds );
-
-  item = addItemInfo( exifGroup, "Aperture", i18n("Aperture"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Focus dist.", i18n("Focus Dist."),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Exposure bias", i18n("Exposure Bias"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Whitebalance", i18n("Whitebalance"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Metering mode", i18n("Metering Mode"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Exposure", i18n("Exposure"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "ISO equiv.", i18n("ISO Equiv."),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "JPEG quality", i18n("JPEG Quality"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "User comment", i18n("User Comment"),
-                      QVariant::String );
-  setHint(item,  KFileMimeTypeInfo::Description);
-
-  item = addItemInfo( exifGroup, "JPEG process", i18n("JPEG Process"),
-                      QVariant::String );
-
-  item = addItemInfo( exifGroup, "Thumbnail", i18n("Thumbnail"),
-                      QVariant::Image );
-  setHint( item, KFileMimeTypeInfo::Thumbnail );
-
-//  ###
-//   exifGroup.setSupportsVariableKeys(true);
+    for( int i = 0;
+        i < NUM_TAGS;
+        ++i ) {
+        const char* name = exif_tag_get_name( tags[ i ].tag );
+        const char* title = exif_tag_get_title( tags[ i ].tag );
+        if( name != NULL && title != NULL ) {
+            // tranlations for i18n should come from libexif
+            KFileMimeTypeInfo::ItemInfo* item = addItemInfo( exifGroup, name,
+                i18n( title ), tags[ i ].type );
+            if( tags[ i ].unit != KFileMimeTypeInfo::NoUnit )
+                setUnit( item, tags[ i ].unit );
+            if( tags[ i ].hint != KFileMimeTypeInfo::NoHint )
+                setHint( item, tags[ i ].hint );
+        }
+    }
 }
 
 QValidator* KJpegPlugin::createValidator(const KFileMetaInfoItem& /*item*/,
@@ -158,333 +212,91 @@ QValidator* KJpegPlugin::createValidator
     return 0L;
 }
 
-bool KJpegPlugin::writeInfo( const KFileMetaInfo& info ) const
+bool KJpegPlugin::writeInfo( const KFileMetaInfo& /*info*/ ) const
 {
-    QString comment = info[EXIFGROUP].value("Comment").toString();
-    QString path    = info.path();
-
-    kdDebug(7034) << "exif writeInfo: " << info.path() << " \"" << comment << "\"\n";
-
-    /*
-        Do a strictly safe insertion of the comment:
-
-        Scan original to verify it's a proper jpeg
-        Open a unique temporary file in this directory
-        Write temporary, replacing all COM blocks with this one.
-        Scan temporary, to verify it's a proper jpeg
-        Rename original to another unique name
-        Rename temporary to original
-        Unlink original
-    */
-    /*
-        The jpeg standard does not regulate the contents of the COM block.
-        I'm assuming the best thing to do here is write as unicode utf-8,
-        which is fully backwards compatible with readers expecting ascii.
-        Readers expecting a national character set are out of luck...
-    */
-    if( safe_copy_and_modify( QFile::encodeName( path ), comment.utf8() ) ) {
-            return false;
-        }
-    return true;
+    return false;
 }
 
-bool KJpegPlugin::readInfo( KFileMetaInfo& info, uint what )
+bool KJpegPlugin::readInfo( KFileMetaInfo& info, uint /*what*/ )
 {
     const QString path( info.path() );
     if ( path.isEmpty() ) // remote file
         return false;
 
-    QString tag;
-    ExifData ImageInfo;
-
-    // parse the jpeg file now
-    try {
-        if ( !ImageInfo.scan(info.path()) ) {
-            kdDebug(7034) << "Not a JPEG file!\n";
-            return false;
-        }
-    }
-    catch (FatalError& e) { // malformed exif data?
-        kdDebug(7034) << "Exception caught while parsing Exif data of: " << info.path() << endl;
-        e.debug_print();
+    ExifData* d = exif_data_new_from_file( QFile::encodeName( path ));
+    if( d == NULL ) {
+        kdDebug(7034) << "EXIF read failed:" << path << endl;
         return false;
     }
+    exif_data_ref( d );
 
     KFileMetaInfoGroup exifGroup = appendGroup( info, EXIFGROUP );
-
-    tag = ImageInfo.getComment();
-    if ( tag.length() ) {
-        kdDebug(7034) << "exif inserting Comment: " << tag << "\n";
-        appendItem( exifGroup, "Comment", tag );
-    } else {
-        appendItem( exifGroup, "Comment", tag );    // So user can add new comment
-    }
-
-    tag = ImageInfo.getCameraMake();
-    if (tag.length())
-    	appendItem( exifGroup, "Manufacturer", tag );
-
-    tag = ImageInfo.getCameraModel();
-    if (tag.length())
-        appendItem( exifGroup, "Model", tag );
-
-    tag = ImageInfo.getDateTime();
-    if (tag.length()){
-        QDateTime dt = parseDateTime( tag.stripWhiteSpace() );
-        if ( dt.isValid() ) {
-            appendItem( exifGroup, "Date/time", dt );
-            appendItem( exifGroup, "CreationDate", dt.date() );
-            appendItem( exifGroup, "CreationTime", dt.time() );
-        }
-    }
-
-    appendItem( exifGroup,"Dimensions", QSize( ImageInfo.getWidth(),
-                                               ImageInfo.getHeight() ) );
-
-    if ( ImageInfo.getOrientation() )
-        appendItem( exifGroup, "Orientation", ImageInfo.getOrientation() );
-
-    appendItem( exifGroup, "ColorMode", ImageInfo.getIsColor() ?
-                i18n("Color") : i18n("Black and white") );
-
-    int flashUsed = ImageInfo.getFlashUsed(); // -1, <set>
-    if ( flashUsed >= 0 ) {
-	 QString flash = i18n("Flash", "(unknown)");
-         switch ( flashUsed ) {
-         case 0: flash = i18n("Flash", "No");
-             break;
-         case 1:
-         case 5:
-         case 7:
-             flash = i18n("Flash", "Fired");
-             break;
-         case 9:
-         case 13:
-         case 15:
-             flash = i18n( "Flash", "Fill Fired" );
-             break;
-         case 16:
-             flash = i18n( "Flash", "Off" );
-             break;
-         case 24:
-             flash = i18n( "Flash", "Auto Off" );
-             break;
-         case 25:
-         case 29:
-         case 31:
-             flash = i18n( "Flash", "Auto Fired" );
-             break;
-         case 32:
-             flash = i18n( "Flash", "Not Available" );
-             break;
-         default:
-             break;
+    for( int i = 0;
+         i < EXIF_IFD_COUNT;
+         ++i ) {
+        ExifContent* content = d->ifd[ i ];
+        exif_content_ref( content );
+        for( unsigned int j = 0;
+             j < content->count;
+             ++j ) {
+            ExifEntry* entry = content->entries[ j  ];
+            exif_entry_ref( entry );
+            QCString tmp( 1024 );
+            exif_entry_get_value( entry, tmp.data(), tmp.size() - 1 );
+            tmp[ 1023 ] = '\0';
+            QString value = QString::fromLocal8Bit( tmp );
+            exif_entry_unref( entry );
+            if( value.isEmpty())
+                continue;
+            int index = -1;
+            for( int k = 0;
+                 k < NUM_TAGS;
+                 ++k )
+                if( entry->tag == tags[ k ].tag ) {
+                    index = k;
+                    break;
+                }
+            if( index == -1 ) {
+                kdDebug(7934) << "Unknown EXIF tag:" << entry->tag << endl;
+                continue;
+            }
+            insertValue( exifGroup, index, value );
         }
-        appendItem( exifGroup, "Flash used",
-                    flash );
-    }
-
-    if (ImageInfo.getFocalLength()){
-    	appendItem( exifGroup, "Focal length",
-                    QString().sprintf("%4.1f", ImageInfo.getFocalLength()) );
-
-        if (ImageInfo.getCCDWidth()){
-            appendItem( exifGroup, "35mm equivalent",
-                        (int)(ImageInfo.getFocalLength()/ImageInfo.getCCDWidth()*35 + 0.5) );
-	}
-    }
-
-    if (ImageInfo.getCCDWidth()){
-	appendItem( exifGroup, "CCD width",
-                    QString().sprintf("%4.2f", ImageInfo.getCCDWidth()) );
-    }
-
-    if (ImageInfo.getExposureTime()){
-        tag=QString().sprintf("%6.3f", ImageInfo.getExposureTime());
-        float exposureTime = ImageInfo.getExposureTime();
-	if (exposureTime > 0 && exposureTime <= 0.5){
-            tag+=QString().sprintf(" (1/%d)", (int)(0.5 + 1/exposureTime) );
-	}
-	appendItem( exifGroup, "Exposure time", tag );
-    }
-
-    if (ImageInfo.getApertureFNumber()){
-	appendItem( exifGroup, "Aperture",
-                    QString().sprintf("f/%3.1f",
-                                      (double)ImageInfo.getApertureFNumber()));
+        exif_content_unref( content );
     }
+    exif_data_unref( d );
+    return true;
+}
 
-    if (ImageInfo.getDistance()){
-        if (ImageInfo.getDistance() < 0){
-	    tag=i18n("Infinite");
-        }else{
-	    tag=QString().sprintf("%5.2fm",(double)ImageInfo.getDistance());
+void KJpegPlugin::insertValue( KFileMetaInfoGroup& exifGroup, int index, const QString& value )
+{
+    QString name = exif_tag_get_name( tags[ index ].tag );
+    switch( tags[ index ].type ) {
+        case QVariant::String: {
+            appendItem( exifGroup, name, value );
+            break;
         }
-    	appendItem( exifGroup, "Focus dist.", tag );
-    }
-
-    if (ImageInfo.getExposureBias()){
-	appendItem( exifGroup, "Exposure bias",
-                    QString().sprintf("%4.2f",
-                                      (double)ImageInfo.getExposureBias()) );
-    }
-
-    if (ImageInfo.getWhitebalance() != -1){
-        switch(ImageInfo.getWhitebalance()) {
-	case 0:
-	    tag=i18n("Unknown");
-	    break;
-	case 1:
-	    tag=i18n("Daylight");
-	    break;
-	case 2:
-	    tag=i18n("Fluorescent");
-	    break;
-	case 3:
-	    //tag=i18n("incandescent");
-	    tag=i18n("Tungsten");
-	    break;
-	case 17:
-	    tag=i18n("Standard light A");
-	    break;
-	case 18:
-	    tag=i18n("Standard light B");
-	    break;
-	case 19:
-	    tag=i18n("Standard light C");
-	    break;
-	case 20:
-	    tag=i18n("D55");
-	    break;
-	case 21:
-	    tag=i18n("D65");
-	    break;
-	case 22:
-	    tag=i18n("D75");
-	    break;
-	case 255:
-	    tag=i18n("Other");
-	    break;
-	default:
-            //23 to 254 = reserved
-	    tag=i18n("Unknown");
-	}
-  	appendItem( exifGroup, "Whitebalance", tag );
-    }
-
-    if (ImageInfo.getMeteringMode() != -1){
-        switch(ImageInfo.getMeteringMode()) {
-	case 0:
-	    tag=i18n("Unknown");
-	    break;
-	case 1:
-	    tag=i18n("Average");
-	    break;
-	case 2:
-	    tag=i18n("Center weighted average");
-	    break;
-	case 3:
-	    tag=i18n("Spot");
-	    break;
-	case 4:
-	    tag=i18n("MultiSpot");
-	    break;
-	case 5:
-	    tag=i18n("Pattern");
-	    break;
-	case 6:
-	    tag=i18n("Partial");
-	    break;
-	case 255:
-	    tag=i18n("Other");
-	    break;
-	default:
-	    // 7 to 254 = reserved
-	    tag=i18n("Unknown");
-	}
-	appendItem( exifGroup, "Metering mode", tag );
-    }
-
-    if (ImageInfo.getExposureProgram()){
-        switch(ImageInfo.getExposureProgram()) {
-	case 0:
-	    tag=i18n("Not defined");
-	    break;
-	case 1:
-	    tag=i18n("Manual");
-	    break;
-	case 2:
-	    tag=i18n("Normal program");
-	    break;
-	case 3:
-	    tag=i18n("Aperture priority");
-	    break;
-	case 4:
-	    tag=i18n("Shutter priority");
-	    break;
-	case 5:
-	    tag=i18n("Creative program\n(biased toward fast shutter speed)");
-	    break;
-	case 6:
-	    tag=i18n("Action program\n(biased toward fast shutter speed)");
-	    break;
-	case 7:
-	    tag=i18n("Portrait mode\n(for closeup photos with the background out of focus)");
-	    break;
-	case 8:
-	    tag=i18n("Landscape mode\n(for landscape photos with the background in focus)");
-	    break;
-	default:
-	    // 9 to 255 = reserved
-	    tag=i18n("Unknown");
-	}
-	appendItem( exifGroup, "Exposure", tag );
-    }
-
-    if (ImageInfo.getISOequivalent()){
-	appendItem( exifGroup, "ISO equiv.",
-                    QString().sprintf("%2d",
-                                      (int)ImageInfo.getISOequivalent()) );
-    }
-
-    if (ImageInfo.getCompressionLevel()){
-	switch(ImageInfo.getCompressionLevel()) {
-	case 1:
-	    tag=i18n("Basic");
+        case QVariant::Double: {
+            bool ok;
+            double val = value.toDouble( &ok );
+            if( ok )
+                appendItem( exifGroup, name, val );
+            else
+                kdDebug(7034) << "EXIF double tag " << tags[ index ].tag << " conversion failed." << endl;
             break;
-	case 2:
-	    tag=i18n("Normal");
-	    break;
-        case 4:
-	    tag=i18n("Fine");
-	    break;
-	default:
-	    tag=i18n("Unknown");
-	}
-	appendItem( exifGroup, "JPEG quality", tag );
-    }
-
-    tag = ImageInfo.getUserComment();
-    if (tag.length()){
-	appendItem( exifGroup, "EXIF comment", tag );
-    }
-
-    int a;
-    for (a=0;;a++){
-        if (ProcessTable[a].Tag == ImageInfo.getProcess() || ProcessTable[a].Tag == 0){
-    	    appendItem( exifGroup, "JPEG process",
-                        QString::fromUtf8( ProcessTable[a].Desc) );
+        }
+        case QVariant::DateTime: {
+            QDateTime dt = parseDateTime( value );
+            if( dt.isValid())
+                appendItem( exifGroup, name, dt );
+            else
+                kdDebug(7034) << "EXIF datetime tag " << tags[ index ].tag << " conversion failed." << endl;
             break;
         }
+        default:
+            abort();
     }
-
-    if ( what & KFileMetaInfo::Thumbnail && !ImageInfo.isNullThumbnail() ){
-        appendItem( exifGroup, "Thumbnail", ImageInfo.getThumbnail() );
-    }
-
-  return true;
 }
-
 // format of the string is:
 // YYYY:MM:DD HH:MM:SS
 QDateTime KJpegPlugin::parseDateTime( const QString& string )

Places

File better-exif.patch of Package kdegraphics3 (Revision c70c51f3c7af53b14a9e7ddea6bf2ac8)

Places