Ignore:
Timestamp:
Feb 11, 2010, 11:19:06 PM (15 years ago)
Author:
Dmitry A. Kuminov
Message:

trunk: Merged in qt 4.6.1 sources.

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk

  • trunk/src/plugins/imageformats/tiff/main.cpp

    r2 r561  
    22**
    33** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
    4 ** Contact: Qt Software Information (qt-info@nokia.com)
     4** All rights reserved.
     5** Contact: Nokia Corporation (qt-info@nokia.com)
    56**
    67** This file is part of the plugins of the Qt Toolkit.
    … …  
    2122** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    2223**
    23 ** In addition, as a special exception, Nokia gives you certain
    24 ** additional rights. These rights are described in the Nokia Qt LGPL
    25 ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
    26 ** package.
     24** In addition, as a special exception, Nokia gives you certain additional
     25** rights.  These rights are described in the Nokia Qt LGPL Exception
     26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    2727**
    2828** GNU General Public License Usage
    … …  
    3434** met: http://www.gnu.org/copyleft/gpl.html.
    3535**
    36 ** If you are unsure which license is appropriate for your use, please
    37 ** contact the sales department at qt-sales@nokia.com.
     36** If you have questions regarding the use of this file, please contact
     37** Nokia at qt-info@nokia.com.
    3838** $QT_END_LICENSE$
    3939**

  • trunk/src/plugins/imageformats/tiff/qtiffhandler.cpp

    r2 r561  
    22**
    33** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
    4 ** Contact: Qt Software Information (qt-info@nokia.com)
     4** All rights reserved.
     5** Contact: Nokia Corporation (qt-info@nokia.com)
    56**
    67** This file is part of the plugins of the Qt Toolkit.
    … …  
    2122** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    2223**
    23 ** In addition, as a special exception, Nokia gives you certain
    24 ** additional rights. These rights are described in the Nokia Qt LGPL
    25 ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
    26 ** package.
     24** In addition, as a special exception, Nokia gives you certain additional
     25** rights.  These rights are described in the Nokia Qt LGPL Exception
     26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    2727**
    2828** GNU General Public License Usage
    … …  
    3434** met: http://www.gnu.org/copyleft/gpl.html.
    3535**
    36 ** If you are unsure which license is appropriate for your use, please
    37 ** contact the sales department at qt-sales@nokia.com.
     36** If you have questions regarding the use of this file, please contact
     37** Nokia at qt-info@nokia.com.
    3838** $QT_END_LICENSE$
    3939**
    … …  
    9999}
    100100
     101// for 32 bits images
     102inline void rotate_right_mirror_horizontal(QImage *const image)// rotate right->mirrored horizontal
     103{
     104    const int height = image->height();
     105    const int width = image->width();
     106    QImage generated(/* width = */ height, /* height = */ width, image->format());
     107    const uint32 *originalPixel = reinterpret_cast<const uint32*>(image->bits());
     108    uint32 *const generatedPixels = reinterpret_cast<uint32*>(generated.bits());
     109    for (int row=0; row < height; ++row) {
     110        for (int col=0; col < width; ++col) {
     111            int idx = col * height + row;
     112            generatedPixels[idx] = *originalPixel;
     113            ++originalPixel;
     114        }
     115    }
     116    *image = generated;
     117}
     118
     119inline void rotate_right_mirror_vertical(QImage *const image) // rotate right->mirrored vertical
     120{
     121    const int height = image->height();
     122    const int width = image->width();
     123    QImage generated(/* width = */ height, /* height = */ width, image->format());
     124    const int lastCol = width - 1;
     125    const int lastRow = height - 1;
     126    const uint32 *pixel = reinterpret_cast<const uint32*>(image->bits());
     127    uint32 *const generatedBits = reinterpret_cast<uint32*>(generated.bits());
     128    for (int row=0; row < height; ++row) {
     129        for (int col=0; col < width; ++col) {
     130            int idx = (lastCol - col) * height + (lastRow - row);
     131            generatedBits[idx] = *pixel;
     132            ++pixel;
     133        }
     134    }
     135    *image = generated;
     136}
     137
    101138QTiffHandler::QTiffHandler() : QImageIOHandler()
    102139{
    … …  
    132169        return false;
    133170
    134     TIFF *tiff = TIFFClientOpen("foo",
    135                                 "r",
    136                                 this,
    137                                 qtiffReadProc,
    138                                 qtiffWriteProc,
    139                                 qtiffSeekProc,
    140                                 qtiffCloseProc,
    141                                 qtiffSizeProc,
    142                                 qtiffMapProc,
    143                                 qtiffUnmapProc);
    144 
    145     if (tiff) {
    146         uint32 width = 0;
    147         uint32 height = 0;
    148         TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &width);
    149         TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &height);
    150         if (image->size() != QSize(width, height) || image->format() != QImage::Format_ARGB32)
    151             *image = QImage(width, height, QImage::Format_ARGB32);
     171    TIFF *const tiff = TIFFClientOpen("foo",
     172                                      "r",
     173                                      this,
     174                                      qtiffReadProc,
     175                                      qtiffWriteProc,
     176                                      qtiffSeekProc,
     177                                      qtiffCloseProc,
     178                                      qtiffSizeProc,
     179                                      qtiffMapProc,
     180                                      qtiffUnmapProc);
     181
     182    if (!tiff) {
     183        return false;
     184    }
     185    uint32 width;
     186    uint32 height;
     187    uint16 photometric;
     188    if (!TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &width)
     189        || !TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &height)
     190        || !TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photometric)) {
     191        TIFFClose(tiff);
     192        return false;
     193    }
     194
     195    // BitsPerSample defaults to 1 according to the TIFF spec.
     196    uint16 bitPerSample;
     197    if (!TIFFGetField(tiff, TIFFTAG_BITSPERSAMPLE, &bitPerSample))
     198        bitPerSample = 1;
     199
     200    bool grayscale = photometric == PHOTOMETRIC_MINISBLACK || photometric == PHOTOMETRIC_MINISWHITE;
     201    if (grayscale && bitPerSample == 1) {
     202        if (image->size() != QSize(width, height) || image->format() != QImage::Format_Mono)
     203            *image = QImage(width, height, QImage::Format_Mono);
     204        QVector<QRgb> colortable(2);
     205        if (photometric == PHOTOMETRIC_MINISBLACK) {
     206            colortable[0] = 0xff000000;
     207            colortable[1] = 0xffffffff;
     208        } else {
     209            colortable[0] = 0xffffffff;
     210            colortable[1] = 0xff000000;
     211        }
     212        image->setColorTable(colortable);
     213
    152214        if (!image->isNull()) {
    153             if (TIFFReadRGBAImageOriented(tiff, width, height, reinterpret_cast<uint32 *>(image->bits()), ORIENTATION_TOPLEFT, 0)) {
    154                 uint16 resUnit = RESUNIT_NONE;
    155                 float resX = 0;
    156                 float resY = 0;
    157                 TIFFGetField(tiff, TIFFTAG_RESOLUTIONUNIT, &resUnit);
    158                 TIFFGetField(tiff, TIFFTAG_XRESOLUTION, &resX);
    159                 TIFFGetField(tiff, TIFFTAG_YRESOLUTION, &resY);
    160                 switch(resUnit) {
    161                     case RESUNIT_CENTIMETER:
    162                         image->setDotsPerMeterX(qRound(resX * 100));
    163                         image->setDotsPerMeterY(qRound(resY * 100));
    164                         break;
    165                     case RESUNIT_INCH:
    166                         image->setDotsPerMeterX(qRound(resX * (100 / 2.54)));
    167                         image->setDotsPerMeterY(qRound(resY * (100 / 2.54)));
    168                         break;
    169                     default:
    170                         // do nothing as defaults have already
    171                                                 // been set within the QImage class
    172                         break;
    173                 }
    174                 for (uint32 y=0; y<height; ++y)
    175                     convert32BitOrder(image->scanLine(y), width);
    176             } else {
    177                 *image = QImage();
    178             }
    179         }
     215            for (uint32 y=0; y<height; ++y) {
     216                if (TIFFReadScanline(tiff, image->scanLine(y), y, 0) < 0) {
     217                    TIFFClose(tiff);
     218                    return false;
     219                }
     220            }
     221        }
     222    } else {
     223        if ((grayscale || photometric == PHOTOMETRIC_PALETTE) && bitPerSample == 8) {
     224            if (image->size() != QSize(width, height) || image->format() != QImage::Format_Indexed8)
     225                *image = QImage(width, height, QImage::Format_Indexed8);
     226            if (!image->isNull()) {
     227                const uint16 tableSize = 256;
     228                QVector<QRgb> qtColorTable(tableSize);
     229                if (grayscale) {
     230                    for (int i = 0; i<tableSize; ++i) {
     231                        const int c = (photometric == PHOTOMETRIC_MINISBLACK) ? i : (255 - i);
     232                        qtColorTable[i] = qRgb(c, c, c);
     233                    }
     234                } else {
     235                    // create the color table
     236                    uint16 *redTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
     237                    uint16 *greenTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
     238                    uint16 *blueTable = static_cast<uint16 *>(qMalloc(tableSize * sizeof(uint16)));
     239                    if (!redTable || !greenTable || !blueTable) {
     240                        TIFFClose(tiff);
     241                        return false;
     242                    }
     243                    if (!TIFFGetField(tiff, TIFFTAG_COLORMAP, &redTable, &greenTable, &blueTable)) {
     244                        TIFFClose(tiff);
     245                        return false;
     246                    }
     247
     248                    for (int i = 0; i<tableSize ;++i) {
     249                        const int red = redTable[i] / 257;
     250                        const int green = greenTable[i] / 257;
     251                        const int blue = blueTable[i] / 257;
     252                        qtColorTable[i] = qRgb(red, green, blue);
     253                    }
     254                }
     255
     256                image->setColorTable(qtColorTable);
     257                for (uint32 y=0; y<height; ++y) {
     258                    if (TIFFReadScanline(tiff, image->scanLine(y), y, 0) < 0) {
     259                        TIFFClose(tiff);
     260                        return false;
     261                    }
     262                }
     263
     264                // free redTable, greenTable and greenTable done by libtiff
     265            }
     266        } else {
     267            if (image->size() != QSize(width, height) || image->format() != QImage::Format_ARGB32)
     268                *image = QImage(width, height, QImage::Format_ARGB32);
     269            if (!image->isNull()) {
     270                const int stopOnError = 1;
     271                if (TIFFReadRGBAImageOriented(tiff, width, height, reinterpret_cast<uint32 *>(image->bits()), ORIENTATION_TOPLEFT, stopOnError)) {
     272                    for (uint32 y=0; y<height; ++y)
     273                        convert32BitOrder(image->scanLine(y), width);
     274                } else {
     275                    TIFFClose(tiff);
     276                    return false;
     277                }
     278            }
     279        }
     280    }
     281
     282    if (image->isNull()) {
    180283        TIFFClose(tiff);
    181     }
    182 
    183     if (image->isNull())
    184         return false;
    185 
     284        return false;
     285    }
     286
     287    float resX = 0;
     288    float resY = 0;
     289    uint16 resUnit = RESUNIT_NONE;
     290    if (TIFFGetField(tiff, TIFFTAG_RESOLUTIONUNIT, &resUnit)
     291        && TIFFGetField(tiff, TIFFTAG_XRESOLUTION, &resX)
     292        && TIFFGetField(tiff, TIFFTAG_YRESOLUTION, &resY)) {
     293
     294        switch(resUnit) {
     295        case RESUNIT_CENTIMETER:
     296            image->setDotsPerMeterX(qRound(resX * 100));
     297            image->setDotsPerMeterY(qRound(resY * 100));
     298            break;
     299        case RESUNIT_INCH:
     300            image->setDotsPerMeterX(qRound(resX * (100 / 2.54)));
     301            image->setDotsPerMeterY(qRound(resY * (100 / 2.54)));
     302            break;
     303        default:
     304            // do nothing as defaults have already
     305            // been set within the QImage class
     306            break;
     307        }
     308    }
     309
     310    // rotate the image if the orientation is defined in the file
     311    uint16 orientationTag;
     312    if (TIFFGetField(tiff, TIFFTAG_ORIENTATION, &orientationTag)) {
     313        if (image->format() == QImage::Format_ARGB32) {
     314            // TIFFReadRGBAImageOriented() flip the image but does not rotate them
     315            switch (orientationTag) {
     316            case 5:
     317                rotate_right_mirror_horizontal(image);
     318                break;
     319            case 6:
     320                rotate_right_mirror_vertical(image);
     321                break;
     322            case 7:
     323                rotate_right_mirror_horizontal(image);
     324                break;
     325            case 8:
     326                rotate_right_mirror_vertical(image);
     327                break;
     328            }
     329        } else {
     330            switch (orientationTag) {
     331            case 1: // default orientation
     332                break;
     333            case 2: // mirror horizontal
     334                *image = image->mirrored(true, false);
     335                break;
     336            case 3: // mirror both
     337                *image = image->mirrored(true, true);
     338                break;
     339            case 4: // mirror vertical
     340                *image = image->mirrored(false, true);
     341                break;
     342            case 5: // rotate right mirror horizontal
     343                {
     344                    QMatrix transformation;
     345                    transformation.rotate(90);
     346                    *image = image->transformed(transformation);
     347                    *image = image->mirrored(true, false);
     348                    break;
     349                }
     350            case 6: // rotate right
     351                {
     352                    QMatrix transformation;
     353                    transformation.rotate(90);
     354                    *image = image->transformed(transformation);
     355                    break;
     356                }
     357            case 7: // rotate right, mirror vertical
     358                {
     359                    QMatrix transformation;
     360                    transformation.rotate(90);
     361                    *image = image->transformed(transformation);
     362                    *image = image->mirrored(false, true);
     363                    break;
     364                }
     365            case 8: // rotate left
     366                {
     367                    QMatrix transformation;
     368                    transformation.rotate(270);
     369                    *image = image->transformed(transformation);
     370                    break;
     371                }
     372            }
     373        }
     374    }
     375
     376
     377    TIFFClose(tiff);
    186378    return true;
    187379}
    188380
     381static bool checkGrayscale(const QVector<QRgb> &colorTable)
     382{
     383    if (colorTable.size() != 256)
     384        return false;
     385
     386    const bool increasing = (colorTable.at(0) == 0xff000000);
     387    for (int i = 0; i < 256; ++i) {
     388        if (increasing && colorTable.at(i) != qRgb(i, i, i)
     389            || !increasing && colorTable.at(i) != qRgb(255 - i, 255 - i, 255 - i))
     390            return false;
     391    }
     392    return true;
     393}
     394
    189395bool QTiffHandler::write(const QImage &image)
    190396{
    … …  
    192398        return false;
    193399
    194     TIFF *tiff = TIFFClientOpen("foo",
    195                                 "w",
    196                                 this,
    197                                 qtiffReadProc,
    198                                 qtiffWriteProc,
    199                                 qtiffSeekProc,
    200                                 qtiffCloseProc,
    201                                 qtiffSizeProc,
    202                                 qtiffMapProc,
    203                                 qtiffUnmapProc);
    204 
    205     if (tiff) {
    206         int width = image.width();
    207         int height = image.height();
    208         int depth = 32;
    209 
    210         if (!TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width)
    211                 || !TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height)
    212                 || !TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB)
    213                 || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_LZW)
    214                 || !TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, depth/8)
    215                 || !TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)
    216                 || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
     400    TIFF *const tiff = TIFFClientOpen("foo",
     401                                      "w",
     402                                      this,
     403                                      qtiffReadProc,
     404                                      qtiffWriteProc,
     405                                      qtiffSeekProc,
     406                                      qtiffCloseProc,
     407                                      qtiffSizeProc,
     408                                      qtiffMapProc,
     409                                      qtiffUnmapProc);
     410    if (!tiff)
     411        return false;
     412
     413    const int width = image.width();
     414    const int height = image.height();
     415
     416    if (!TIFFSetField(tiff, TIFFTAG_IMAGEWIDTH, width)
     417        || !TIFFSetField(tiff, TIFFTAG_IMAGELENGTH, height)
     418        || !TIFFSetField(tiff, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG)) {
     419        TIFFClose(tiff);
     420        return false;
     421    }
     422
     423    // set the resolution
     424    bool  resolutionSet = false;
     425    const int dotPerMeterX = image.dotsPerMeterX();
     426    const int dotPerMeterY = image.dotsPerMeterY();
     427    if ((dotPerMeterX % 100) == 0
     428        && (dotPerMeterY % 100) == 0) {
     429        resolutionSet = TIFFSetField(tiff, TIFFTAG_RESOLUTIONUNIT, RESUNIT_CENTIMETER)
     430                        && TIFFSetField(tiff, TIFFTAG_XRESOLUTION, dotPerMeterX/100.0)
     431                        && TIFFSetField(tiff, TIFFTAG_YRESOLUTION, dotPerMeterY/100.0);
     432    } else {
     433        resolutionSet = TIFFSetField(tiff, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH)
     434                        && TIFFSetField(tiff, TIFFTAG_XRESOLUTION, static_cast<float>(image.logicalDpiX()))
     435                        && TIFFSetField(tiff, TIFFTAG_YRESOLUTION, static_cast<float>(image.logicalDpiY()));
     436    }
     437    if (!resolutionSet) {
     438        TIFFClose(tiff);
     439        return false;
     440    }
     441
     442    // configure image depth
     443    const QImage::Format format = image.format();
     444    if (format == QImage::Format_Mono || format == QImage::Format_MonoLSB) {
     445        uint16 photometric = PHOTOMETRIC_MINISBLACK;
     446        if (image.colorTable().at(0) == 0xffffffff)
     447            photometric = PHOTOMETRIC_MINISWHITE;
     448        if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric)
     449            || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_CCITTRLE)
     450            || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 1)) {
    217451            TIFFClose(tiff);
    218452            return false;
    219453        }
    220454
     455        // try to do the conversion in chunks no greater than 16 MB
     456        int chunks = (width * height / (1024 * 1024 * 16)) + 1;
     457        int chunkHeight = qMax(height / chunks, 1);
     458
     459        int y = 0;
     460        while (y < height) {
     461            QImage chunk = image.copy(0, y, width, qMin(chunkHeight, height - y)).convertToFormat(QImage::Format_Mono);
     462
     463            int chunkStart = y;
     464            int chunkEnd = y + chunk.height();
     465            while (y < chunkEnd) {
     466                if (TIFFWriteScanline(tiff, reinterpret_cast<uint32 *>(chunk.scanLine(y - chunkStart)), y) != 1) {
     467                    TIFFClose(tiff);
     468                    return false;
     469                }
     470                ++y;
     471            }
     472        }
     473        TIFFClose(tiff);
     474    } else if (format == QImage::Format_Indexed8) {
     475        const QVector<QRgb> colorTable = image.colorTable();
     476        bool isGrayscale = checkGrayscale(colorTable);
     477        if (isGrayscale) {
     478            uint16 photometric = PHOTOMETRIC_MINISBLACK;
     479            if (image.colorTable().at(0) == 0xffffffff)
     480                photometric = PHOTOMETRIC_MINISWHITE;
     481            if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, photometric)
     482                    || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS)
     483                    || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
     484                TIFFClose(tiff);
     485                return false;
     486            }
     487        } else {
     488            if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_PALETTE)
     489                    || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_PACKBITS)
     490                    || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
     491                TIFFClose(tiff);
     492                return false;
     493            }
     494            //// write the color table
     495            // allocate the color tables
     496            uint16 *redTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
     497            uint16 *greenTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
     498            uint16 *blueTable = static_cast<uint16 *>(qMalloc(256 * sizeof(uint16)));
     499            if (!redTable || !greenTable || !blueTable) {
     500                TIFFClose(tiff);
     501                return false;
     502            }
     503
     504            // set the color table
     505            const int tableSize = colorTable.size();
     506            Q_ASSERT(tableSize <= 256);
     507            for (int i = 0; i<tableSize; ++i) {
     508                const QRgb color = colorTable.at(i);
     509                redTable[i] = qRed(color) * 257;
     510                greenTable[i] = qGreen(color) * 257;
     511                blueTable[i] = qBlue(color) * 257;
     512            }
     513
     514            const bool setColorTableSuccess = TIFFSetField(tiff, TIFFTAG_COLORMAP, redTable, greenTable, blueTable);
     515
     516            qFree(redTable);
     517            qFree(greenTable);
     518            qFree(blueTable);
     519
     520            if (!setColorTableSuccess) {
     521                TIFFClose(tiff);
     522                return false;
     523            }
     524        }
     525
     526        //// write the data
     527        // try to do the conversion in chunks no greater than 16 MB
     528        int chunks = (width * height/ (1024 * 1024 * 16)) + 1;
     529        int chunkHeight = qMax(height / chunks, 1);
     530
     531        int y = 0;
     532        while (y < height) {
     533            QImage chunk = image.copy(0, y, width, qMin(chunkHeight, height - y));
     534
     535            int chunkStart = y;
     536            int chunkEnd = y + chunk.height();
     537            while (y < chunkEnd) {
     538                if (TIFFWriteScanline(tiff, reinterpret_cast<uint32 *>(chunk.scanLine(y - chunkStart)), y) != 1) {
     539                    TIFFClose(tiff);
     540                    return false;
     541                }
     542                ++y;
     543            }
     544        }
     545        TIFFClose(tiff);
     546
     547    } else {
     548        if (!TIFFSetField(tiff, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB)
     549            || !TIFFSetField(tiff, TIFFTAG_COMPRESSION, compression == NoCompression ? COMPRESSION_NONE : COMPRESSION_LZW)
     550            || !TIFFSetField(tiff, TIFFTAG_SAMPLESPERPIXEL, 4)
     551            || !TIFFSetField(tiff, TIFFTAG_BITSPERSAMPLE, 8)) {
     552            TIFFClose(tiff);
     553            return false;
     554        }
    221555        // try to do the ARGB32 conversion in chunks no greater than 16 MB
    222556        int chunks = (width * height * 4 / (1024 * 1024 * 16)) + 1;
    … …  
    243577        }
    244578        TIFFClose(tiff);
    245     } else {
    246         return false;
    247     }
     579    }
     580
    248581    return true;
    249582}

  • trunk/src/plugins/imageformats/tiff/qtiffhandler.h

    r2 r561  
    22**
    33** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
    4 ** Contact: Qt Software Information (qt-info@nokia.com)
     4** All rights reserved.
     5** Contact: Nokia Corporation (qt-info@nokia.com)
    56**
    67** This file is part of the plugins of the Qt Toolkit.
    … …  
    2122** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
    2223**
    23 ** In addition, as a special exception, Nokia gives you certain
    24 ** additional rights. These rights are described in the Nokia Qt LGPL
    25 ** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
    26 ** package.
     24** In addition, as a special exception, Nokia gives you certain additional
     25** rights.  These rights are described in the Nokia Qt LGPL Exception
     26** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
    2727**
    2828** GNU General Public License Usage
    … …  
    3434** met: http://www.gnu.org/copyleft/gpl.html.
    3535**
    36 ** If you are unsure which license is appropriate for your use, please
    37 ** contact the sales department at qt-sales@nokia.com.
     36** If you have questions regarding the use of this file, please contact
     37** Nokia at qt-info@nokia.com.
    3838** $QT_END_LICENSE$
    3939**

  • trunk/src/plugins/imageformats/tiff/tiff.pro

    r165 r561  
    6060               SOURCES += ../../../corelib/kernel/qfunctions_wince.cpp
    6161            }
     62            symbian*: {
     63               SOURCES += ../../../3rdparty/libtiff/port/lfind.c
     64            }
    6265}
    6366
    … …  
    7275target.path += $$[QT_INSTALL_PLUGINS]/imageformats
    7376INSTALLS += target
     77
     78symbian:TARGET.UID3=0x2001E617
Note: See TracChangeset for help on using the changeset viewer.