Esempio n. 1
0
void ut_load::testUnsupportedFormat()
{
    QuillImageFilter *filter =
        QuillImageFilterFactory::createImageFilter("org.maemo.load");
    QFile unsupportedFile("/usr/share/quillimagefilter-tests/images/16_color_palette.xcf");
    QImage unsupportedImage(unsupportedFile.fileName());
    filter->setOption(QuillImageFilter::FileName,
                      QVariant( unsupportedFile.fileName()));
    filter->setOption(QuillImageFilter::FileFormat,
                      QVariant("xcf"));
    filter->apply(unsupportedImage);
    QCOMPARE(filter->error(),QuillImageFilter::UnsupportedFormatError);
    unsupportedFile.close();
    delete filter;
}
Esempio n. 2
0
WinHelpPicture::WinHelpPicture(QIODevice &device, qint64 off) : pictures()
{
    PRINT_DBG("Reading WinHelp picture at: %lld", off);
    seekFile(device, off);
    PictureHeader pictHdr(device, off);
    for(int i = 0; i < pictHdr.getNumberOfPictures(); i++)
    {
        qint64 pictOffset = off +
            static_cast<qint64>(pictHdr.getPictureOffset(i));
        PictureInfoHeader pictInfoHdr(device, pictOffset);
        switch(pictInfoHdr.getPictureType())
        {
        case DDB_PICTURE:
        {
            BitmapHeader bitmapHdr(device, pictOffset + PictureInfoHeader::size);
            seekFile(device, pictOffset + bitmapHdr.getCompressedOffset());
            switch(pictInfoHdr.getPackingMethod())
            {
            case UNCOMPRESSED_PICTURE:
            {
                this->pictures.append(LoadDDB(device, pictOffset +
                                static_cast<qint64>(bitmapHdr.
                                    getCompressedOffset()),
                                static_cast<size_t>(bitmapHdr.getCompressedSize()),
                                bitmapHdr));
            }
            break;

            case RUNLEN_COMPRESSED_PICTURE:
            {
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackRLEUnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            uncompressedBuffer);
                this->pictures.append(LoadDDB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr));
                uncompressedBuffer.close();
            }
            break;

            case LZ77_COMPRESSED_PICTURE:
            {
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackLZ77UnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            uncompressedBuffer);
                this->pictures.append(LoadDDB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr));
                uncompressedBuffer.close();
            }
            break;

            case LZ77_AND_RUNLEN_COMPRESSED_PICTURE:
            {
                QBuffer unpackedBuffer;
                unpackedBuffer.open(QIODevice::ReadWrite);
                size_t szUnpacked = unpackLZ77UnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            unpackedBuffer);
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackRLEUnknownOutputSize(unpackedBuffer,
                            Q_INT64_C(0),
                            szUnpacked,
                            uncompressedBuffer);
                this->pictures.append(LoadDDB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr));
                uncompressedBuffer.close();
            }
            break;

            default:
                throw std::runtime_error("Unknown image compression method");
            }
        }
        break;

        case DIB_PICTURE:
        {
            BitmapHeader bitmapHdr(device, pictOffset + PictureInfoHeader::size);
            int paletteSize = bitmapHdr.getColorsUsed();
            QScopedArrayPointer<QRgb> palette;
            if(paletteSize != 0)
            {
                if(paletteSize > 256)
                {
                    throw std::runtime_error("Palette is too big");
                }
                QScopedArrayPointer<QRgb>(new QRgb[paletteSize]).swap(palette);
                for(int i = 0; i < paletteSize; i++)
                {
                    palette[i] = readBGRDword(device);
                }
            }
            seekFile(device, pictOffset + bitmapHdr.getCompressedOffset());
            switch(pictInfoHdr.getPackingMethod())
            {
            case UNCOMPRESSED_PICTURE:
            {
                this->pictures.append(LoadDIB(device, pictOffset +
                                static_cast<qint64>(bitmapHdr.
                                    getCompressedOffset()),
                                static_cast<size_t>(bitmapHdr.getCompressedSize()),
                                bitmapHdr, palette));
            }
            break;

            case RUNLEN_COMPRESSED_PICTURE:
            {
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackRLEUnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            uncompressedBuffer);
                this->pictures.append(LoadDIB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr, palette));
                uncompressedBuffer.close();
            }
            break;

            case LZ77_COMPRESSED_PICTURE:
            {
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackLZ77UnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            uncompressedBuffer);
                this->pictures.append(LoadDIB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr, palette));
                uncompressedBuffer.close();
            }
            break;

            case LZ77_AND_RUNLEN_COMPRESSED_PICTURE:
            {
                QBuffer unpackedBuffer;
                unpackedBuffer.open(QIODevice::ReadWrite);
                size_t szUnpacked = unpackLZ77UnknownOutputSize(device,
                            pictOffset +
                            static_cast<qint64>(bitmapHdr.getCompressedOffset()),
                            static_cast<size_t>(bitmapHdr.getCompressedSize()),
                            unpackedBuffer);
                QBuffer uncompressedBuffer;
                uncompressedBuffer.open(QIODevice::ReadWrite);
                size_t sz = unpackRLEUnknownOutputSize(unpackedBuffer,
                            Q_INT64_C(0),
                            szUnpacked,
                            uncompressedBuffer);
                this->pictures.append(LoadDIB(uncompressedBuffer, Q_INT64_C(0),
                                sz, bitmapHdr, palette));
                uncompressedBuffer.close();
            }
            break;

            default:
                throw std::runtime_error("Unknown image compression method");
            }
        }
        break;

        case METAFILE_PICTURE:
        {
            MetafileHeader metafileHdr(device,
                    pictOffset + PictureInfoHeader::size);
            qDebug() << "Metafiles are not supported";
            if(((metafileHdr.getWidth()/20) * (metafileHdr.getHeight()/20)) <= 1920000)
            {
                QImage unsupportedImage(
                        metafileHdr.getWidth()/20,
                        metafileHdr.getHeight()/20, QImage::Format_ARGB32);
                QPainter painter;
                painter.begin(&unsupportedImage);
                painter.fillRect(0, 0,
                        metafileHdr.getWidth(),
                        metafileHdr.getHeight(), Qt::white);
                painter.drawText(20, 20, "Unsupported");
                painter.end();
                this->pictures.append(unsupportedImage);
            }
            else
            {
                qDebug() << "Metafile is too large";
                QImage unsupportedImage(100, 100, QImage::Format_ARGB32);
                QPainter painter;
                painter.begin(&unsupportedImage);
                painter.fillRect(0, 0,
                        metafileHdr.getWidth(),
                        metafileHdr.getHeight(), Qt::white);
                painter.drawText(20, 20, "Unsupported");
                painter.end();
                this->pictures.append(unsupportedImage);
            }
        }
        break;

        default:
            throw std::runtime_error( "Unknown picture type");
        }
    }
    PRINT_DBG("WinHelp picture loaded successfully");
}