1 files changed, 11 insertions, 7 deletions

diff --git a/noncore/graphics/opie-eye/slave/jpeg_slave.cpp b/noncore/graphics/opie-eye/slave/jpeg_slave.cpp
index 086b47f..fb7d5de 100644
--- a/noncore/graphics/opie-eye/slave/jpeg_slave.cpp
+++ b/noncore/graphics/opie-eye/slave/jpeg_slave.cpp
@@ -1,31 +1,35 @@
 #include  "jpeg_slave.h"
-
 #include "thumbnailtool.h"
 
 PHUNK_VIEW_INTERFACE( "JPEG", JpegSlave )
 
-#include <qtopia/timestring.h>
+/* OPIE */
+#include <opie2/odebug.h>
+#include <qpe/timestring.h>
+using namespace Opie::Core;
+
+/* QT */
 #include <qobject.h>
 #include <qimage.h>
 
 /**
         exif.h
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
 #include <time.h>
 
 #include <qstring.h>
 #include <qfile.h>
 #include <qimage.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.
@@ -98,49 +102,49 @@ public:
     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 { qWarning("exception: %s", ex ); }
+    void debug_print() const { owarn << "exception: " << ex << "" << oendl;  }
 };
 
 
 
 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
@@ -241,49 +245,49 @@ static int BytesPerFormat[] = {0,1,1,2,4,8,1,1,2,4,8,4,8};
 //--------------------------------------------------------------------------
 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){
 
-                qWarning( "too many padding bytes" );
+                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;
 
@@ -306,49 +310,49 @@ int ExifData::ReadJpegSections (QFile & infile, ReadMode_t ReadMode)
                 // 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
-                qWarning( "No image in jpeg!" );
+                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{
@@ -705,49 +709,49 @@ void ExifData::ProcessExifDir(unsigned char * DirStart, unsigned char * OffsetBa
             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
-                        qWarning( "Thumbnail removed with Jhead 1.3 or earlier" );
+                        owarn << "Thumbnail removed with Jhead 1.3 or earlier" << oendl; 
                     }else{
                         return;
                     }
                 }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
@@ -892,49 +896,49 @@ ExifData::ExifData()
     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);
     f.open(IO_ReadOnly);
 
     // Scan the JPEG headers.
     ret = ReadJpegSections(f, READ_EXIF);
 
     if (ret == false){
-        qWarning(  "Not JPEG file!" );
+        owarn << "Not JPEG file!" << oendl; 
         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;