2 files changed, 12 insertions, 49 deletions

diff --git a/libopie2/opiemm/opieexif.cpp b/libopie2/opiemm/opieexif.cpp
index 0860ea8..de49937 100644
--- a/libopie2/opiemm/opieexif.cpp
+++ b/libopie2/opiemm/opieexif.cpp
@@ -88,385 +88,384 @@ static int BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
 #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
 
 
 
 namespace Opie {
 
 namespace MM {
 
 class FatalError {
     const char* ex;
 public:
     FatalError(const char* s) { ex = s; }
     void debug_print() const { owarn << "exception: " << ex << "" << oendl;  }
 };
 
 ExifData::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"}
 };
 
 //--------------------------------------------------------------------------
 // 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){
 
                 owarn << "too many padding bytes" << oendl;
                 return false;
 
             }
         }
 
         if (marker == 0xff){
             // 0xff is legal padding, but if we get that many, something's wrong.
             return false;
         }
 
         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) {
             return false;;
         }
 
         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){
             return false;
         }
         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 = QMAX( 0ul, infile.size()-infile.at() );
                     Data = (uchar *)malloc(size);
                     if (Data == NULL){
                         return false;
                     }
 
                     got = infile.readBlock((char*)Data,  size);
                     if (( unsigned ) got != size){
                         return false;
                     }
 
                     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
                 owarn << "No image in jpeg!" << oendl;
                 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);
                 }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);
             default:
                 break;
                 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.
                 return;
             }
         }
         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.
             return;
         }
 
         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);
 
                 return;
             }
             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);
@@ -820,376 +819,333 @@ bool ExifData::scan(const QString & path)
         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);
 }
 
 
 
 static QImage flip_image( const QImage& img );
 static QImage rotate_90( const QImage& img );
 static QImage rotate_180( const QImage& );
 static QImage rotate_270( const QImage& );
 
 //--------------------------------------------------------------------------
 // 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
 
   QImage dest = Thumbnail;
   switch (Orientation) {  // notice intentional fallthroughs
     case 2: dest = flip_image( dest ); break;
     case 4: dest = flip_image( dest );
     case 3: dest =rotate_180( dest ); break;
     case 5: dest = flip_image( dest );
     case 6: dest = rotate_90( dest ); break;
     case 7: dest = flip_image( dest );
     case 8: dest = rotate_270( dest ); break;
     default: break; // should never happen
   }
   return dest;
 }
 
 
 /*
  *
  */
 static QImage flip_image( const QImage& img ) {
     return img.mirror( TRUE, FALSE );
 }
 
 
 static QImage dest;
 static int x, y;
 static unsigned int  *srcData, *destData; // we're not threaded anyway
 static unsigned char *srcData8, *destData8; // 8 bit is char
 static unsigned int *srcTable,  *destTable; // destination table
 
 
 static QImage rotate_90_8( const QImage &img ) {
     dest.create(img.height(), img.width(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData8 = (unsigned char *)dest.scanLine(x);
             destData8[img.height()-y-1] = srcData8[x];
         }
     }
     return dest;
 }
 
 static QImage rotate_90_all(  const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     for ( y=0; y < img.height(); ++y )    {
         srcData = (unsigned int *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ) {
             destData = (unsigned int *)dest.scanLine(x);
             destData[img.height()-y-1] = srcData[x];
         }
     }
 
     return dest;
 }
 
 
 static QImage  rotate_90( const QImage & img ) {
     if ( img.depth() > 8)
         return rotate_90_all( img );
     else
         return rotate_90_8( img );
 }
 
 static QImage rotate_180_all( const QImage& img ) {
     dest.create(img.width(), img.height(), img.depth());
     for ( y=0; y < img.height(); ++y ){
         srcData = (unsigned int *)img.scanLine(y);
         destData = (unsigned int *)dest.scanLine(img.height()-y-1);
         for ( x=0; x < img.width(); ++x )
             destData[img.width()-x-1] = srcData[x];
     }
     return dest;
 }
 
 static QImage rotate_180_8( const QImage& img ) {
     dest.create(img.width(), img.height(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         destData8 = (unsigned char *)dest.scanLine(img.height()-y-1);
         for ( x=0; x < img.width(); ++x )
             destData8[img.width()-x-1] = srcData8[x];
     }
     return dest;
 }
 
 static QImage rotate_180( const QImage& img ) {
     if ( img.depth() > 8 )
         return rotate_180_all( img );
     else
         return rotate_180_8( img );
 }
 
 
 static QImage rotate_270_8( const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     dest.setNumColors(img.numColors());
     srcTable = (unsigned int *)img.colorTable();
     destTable = (unsigned int *)dest.colorTable();
     for ( x=0; x < img.numColors(); ++x )
         destTable[x] = srcTable[x];
     for ( y=0; y < img.height(); ++y ){
         srcData8 = (unsigned char *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData8 = (unsigned char *)dest.scanLine(img.width()-x-1);
             destData8[y] = srcData8[x];
         }
     }
 
     return dest;
 }
 
 static QImage rotate_270_all( const QImage& img ) {
     dest.create(img.height(), img.width(), img.depth());
     for ( y=0; y < img.height(); ++y ){
         srcData = (unsigned int *)img.scanLine(y);
         for ( x=0; x < img.width(); ++x ){
             destData = (unsigned int *)dest.scanLine(img.width()-x-1);
             destData[y] = srcData[x];
         }
     }
     return dest;
 }
 
 static QImage rotate_270( const QImage& img ) {
     if (  img.depth() > 8 )
         return rotate_270_all( img );
     else
         return rotate_270_8( img );
 }
 
-
-static QString color_mode_to_string( bool b ) {
+QString ExifData::color_mode_to_string( bool b ) {
     return b ? QObject::tr( "Colormode: Color\n" ) : QObject::tr( "Colormode: Black and white\n" );
 }
 
-static QString compression_to_string( int level ) {
+QString ExifData::compression_to_string( int level ) {
     QString str;
     switch( level ) {
     case 1:
         str = QObject::tr( "Basic" );
         break;
     case 2:
         str = QObject::tr( "Normal" );
         break;
     case 4:
         str = QObject::tr( "Fine" );
         break;
     default:
         str = QObject::tr( "Unknown" );
 
     }
     return QObject::tr("Quality: %1\n").arg(str);
 }
 
-
-static QDateTime parseDateTime( const QString& string )
-{
-    QDateTime dt;
-    if ( string.length() != 19 )
-        return dt;
-
-    QString year    = string.left( 4 );
-    QString month   = string.mid( 5, 2 );
-    QString day     = string.mid( 8, 2 );
-    QString hour    = string.mid( 11, 2 );
-    QString minute  = string.mid( 14, 2 );
-    QString seconds = string.mid( 18, 2 );
-
-    bool ok;
-    bool allOk = true;
-    int y  = year.toInt( &ok );
-    allOk &= ok;
-
-    int mo = month.toInt( &ok );
-    allOk &= ok;
-
-    int d  = day.toInt( &ok );
-    allOk &= ok;
-
-    int h  = hour.toInt( &ok );
-    allOk &= ok;
-
-    int mi = minute.toInt( &ok );
-    allOk &= ok;
-
-    int s  = seconds.toInt( &ok );
-    allOk &= ok;
-
-    if ( allOk ) {
-        dt.setDate( QDate( y, mo, d ) );
-        dt.setTime( QTime( h, mi, s ) );
-    }
-
-    return dt;
-}
-
-static QString white_balance_string( int i ) {
+QString ExifData::white_balance_string( int i ) {
     QString balance;
     switch ( i ) {
     case 0:
         balance = QObject::tr( "Unknown" );
         break;
     case 1:
         balance = QObject::tr( "Daylight" );
         break;
     case 2:
         balance = QObject::tr( "Fluorescent" );
         break;
     case 3:
         balance = QObject::tr( "Tungsten" );
         break;
     case 17:
         balance = QObject::tr( "Standard light A" );
         break;
     case 18:
         balance = QObject::tr( "Standard light B" );
         break;
     case 19:
         balance = QObject::tr( "Standard light C" );
         break;
     case 20:
         balance = QObject::tr( "D55" );
         break;
     case 21:
         balance = QObject::tr( "D65" );
         break;
     case 22:
         balance = QObject::tr( "D75" );
         break;
     case 255:
         balance = QObject::tr( "Other" );
         break;
     default:
         balance = QObject::tr( "Unknown" );
     }
     return QObject::tr( "White Balance: %1\n" ).arg( balance );
 
 }
 
 
-static QString metering_mode( int i) {
+QString ExifData::metering_mode( int i) {
     QString meter;
     switch( i ) {
     case 0:
         meter = QObject::tr( "Unknown" );
         break;
     case 1:
         meter = QObject::tr( "Average" );
         break;
     case 2:
         meter = QObject::tr( "Center weighted average" );
         break;
     case 3:
         meter = QObject::tr( "Spot" );
         break;
     case 4:
         meter = QObject::tr( "MultiSpot" );
         break;
     case 5:
         meter = QObject::tr( "Pattern" );
         break;
     case 6:
         meter = QObject::tr( "Partial" );
         break;
     case 255:
         meter = QObject::tr( "Other" );
         break;
     default:
         meter = QObject::tr( "Unknown" );
     }
 
     return QObject::tr( "Metering Mode: %1\n" ).arg( meter );
 }
 
 
-static QString exposure_program( int i ) {
+QString ExifData::exposure_program( int i ) {
     QString exp;
     switch( i ) {
     case 0:
         exp = QObject::tr( "Not defined" );
         break;
     case 1:
         exp = QObject::tr( "Manual" );
         break;
     case 2:
         exp = QObject::tr( "Normal progam" );
         break;
     case 3:
         exp = QObject::tr( "Aperture priority" );
         break;
     case 4:
         exp = QObject::tr( "Shutter priority" );
         break;
     case 5:
         exp = QObject::tr( "Creative progam\n(biased toward fast shutter speed" );
         break;
     case 6:
         exp = QObject::tr( "Action progam\n(biased toward fast shutter speed)" );
         break;
     case 7:
         exp = QObject::tr( "Portrait mode\n(for closeup photos with the background out of focus)" );
         break;
     case 8:
         exp = QObject::tr( "Landscape mode\n(for landscape photos with the background in focus)" );
         break;
     default:
         exp = QObject::tr( "Unknown" );
     }
 
     return QObject::tr( "Exposure Program: %1\n" ).arg( exp );
 }
 
 } // namespace MM
 } // namespace OPIE
diff --git a/libopie2/opiemm/opieexif.h b/libopie2/opiemm/opieexif.h
index efaed71..fb06bf8 100644
--- a/libopie2/opiemm/opieexif.h
+++ b/libopie2/opiemm/opieexif.h
@@ -1,139 +1,146 @@
 #ifndef _OPIE_EXIF_H
 #define _OPIE_EXIF_H
 
 #include <qt.h>
 #include <qstring.h>
 #include <qimage.h>
 #include <qfile.h>
 
 #include <time.h>
 
 namespace Opie { namespace MM {
 
 #ifndef uchar
 typedef unsigned char uchar;
 #endif
 
 //#define MAX_SECTIONS 20
 //#define PSEUDO_IMAGE_MARKER 0x123; // Extra value.
 
 //! Class for reading exif data from images
 /*!
  * This class is mostly used inside OImageScrollView for testing jpegs headers for a faster
  * loading and scaling. It is taken from libexif and converted into an C++ structure.
  *
  * \see OImageScrollView
  * \since 1.2
  */
 class ExifData {
 public:
     enum ReadMode_t {
         READ_EXIF = 1,
         READ_IMAGE = 2,
         READ_ALL = 3
     };
 
     //--------------------------------------------------------------------------
     // This structure is used to store jpeg file sections in memory.
     struct Section_t {
         uchar *  Data;
         int      Type;
         unsigned Size;
     };
 
     struct TagTable_t {
         unsigned short Tag;
         const char*const Desc;
     };
 
 private:
     static const int MAX_SECTIONS=20;
     static const unsigned int PSEUDO_IMAGE_MARKER=0x123;
     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;
 
     unsigned char * LastExifRefd;
     int ExifSettingsLength;
     double FocalplaneXRes;
     double FocalplaneUnits;
     int MotorolaOrder;
     int SectionsRead;
 
     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:
     //! Contructor for initialising
     ExifData();
     //! destructor
     virtual ~ExifData();
     //! scan a given file
     /*!
      * try to scan the EXIF data of a image file
      * \param aFile the file to scan
      * \return true if success, otherwise false
      */
     bool scan(const QString &aFile);
     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(); }
+
+    // some helpers
+    static QString color_mode_to_string( bool b );
+    static QString compression_to_string( int level );
+    static QString white_balance_string( int i );
+    static QString metering_mode( int i);
+    static QString exposure_program( int i );
 };
 
 }
 }
 #endif