void PlaylistComponent::loadTemporaryPlaylist(FilenameGetter filenameGetter) { if (! ensureAskInEditMode()) return; const QString file = filenameGetter(); if (! file.isEmpty()) { if (QFileInfo(file).isFile()) { const std::string errorMessage = temporaryTree_->load(QtUtilities::qStringToString(file)); if (! errorMessage.empty()) { temporaryTree_->topLevelNodes().clear(); inputController_.showMessage( loadingFailed(), loadingErrorFullMessage( QtUtilities::toQString(errorMessage))); } treeWidget_.updateTree(); } else { inputController_.showMessage( loadingFailed(), loadingErrorFullMessage( tr("\"%1\" - no such file.").arg(file))); } } }
void DImgPreviewItem::slotGotImagePreview(const LoadingDescription& description, const DImg& image) { Q_D(DImgPreviewItem); if (description.filePath != d->path || description.isThumbnail()) { return; } setImage(image); if (image.isNull()) { d->state = ImageLoadingFailed; emit stateChanged(d->state); emit loadingFailed(); } else { d->state = ImageLoaded; emit stateChanged(d->state); emit loaded(); } preloadNext(); }
void KoOdfCollectionLoader::load() { QDir dir(m_path); m_fileList = dir.entryList(QStringList() << "*.odg" << "*.svg", QDir::Files); if(m_fileList.isEmpty()) { kError() << "Found no shapes in the collection!" << m_path; emit loadingFailed(i18n("Found no shapes in the collection! %1", m_path)); return; } nextFile(); }
bool QImageLoader::load(const QString& filePath, DImgLoaderObserver* const observer) { // Loading is opaque to us. No support for stopping from observer, // progress info are only pseudo values QImage image(filePath); if (observer) { observer->progressInfo(m_image, 0.9F); } if (image.isNull()) { kDebug() << "Can not load \"" << filePath << "\" using DImg::QImageLoader!"; loadingFailed(); return false; } int colorModel = DImg::COLORMODELUNKNOWN; int originalDepth = 0; switch (image.format()) { case QImage::Format_Invalid: default: colorModel = DImg::COLORMODELUNKNOWN; originalDepth = 0; break; case QImage::Format_Mono: case QImage::Format_MonoLSB: colorModel = DImg::MONOCHROME; originalDepth = 1; break; case QImage::Format_Indexed8: colorModel = DImg::INDEXED; originalDepth = 0; break; case QImage::Format_RGB32: colorModel = DImg::RGB; originalDepth = 8; break; case QImage::Format_ARGB32: case QImage::Format_ARGB32_Premultiplied: colorModel = DImg::RGB; originalDepth = 8; break; } m_hasAlpha = image.hasAlphaChannel(); QImage target = image.convertToFormat(QImage::Format_ARGB32); uint w = target.width(); uint h = target.height(); uchar* const data = new_failureTolerant(w, h, 4); if (!data) { kDebug() << "Failed to allocate memory for loading" << filePath; loadingFailed(); return false; } uint* sptr = reinterpret_cast<uint*>(target.bits()); uchar* dptr = data; for (uint i = 0 ; i < w * h ; ++i) { dptr[0] = qBlue(*sptr); dptr[1] = qGreen(*sptr); dptr[2] = qRed(*sptr); dptr[3] = qAlpha(*sptr); dptr += 4; sptr++; } if (observer) { observer->progressInfo(m_image, 1.0); } imageWidth() = w; imageHeight() = h; imageData() = data; // We considering that PNG is the most representative format of an image loaded by Qt imageSetAttribute("format", "PNG"); imageSetAttribute("originalColorModel", colorModel); imageSetAttribute("originalBitDepth", originalDepth); imageSetAttribute("originalSize", QSize(w, h)); return true; }
PlaylistComponent::PlaylistComponent( QMainWindow & mainWindow, const Actions & actions, QtUtilities::Widgets::InputController & inputController, const Preferences & preferences, CommonTypes::PlayItems playItems, const std::string & preferencesDir, bool & cancelled) : actions_(actions), inputController_(inputController), addingPatterns_(preferences.addingPatterns), addingPolicy_(preferences.addingPolicy), playItems_(std::move(playItems)), itemsFilename_(preferencesDir + "items"), qItemsFilename_(QtUtilities::toQString(itemsFilename_)), qBackupItemsFilename_(qItemsFilename_ + ".backup"), treeAutoCleanup_(preferences.treeAutoCleanup), treeWidget_(itemTree_, temporaryTree_, preferences.customActions, playItems_) { # ifdef DEBUG_VENTUROUS_PLAYLIST_COMPONENT std::cout << "itemsFilename_ = " << itemsFilename_ << std::endl; # endif treeWidget_.setAutoUnfoldedLevels(preferences.treeAutoUnfoldedLevels); if (QFileInfo(qItemsFilename_).isFile()) { if (QtUtilities::Widgets::HandleErrors { [&] { const std::string errorMessage = itemTree_.load(itemsFilename_); return errorMessage.empty() ? QString() : loadingErrorFullMessage(QtUtilities::toQString(errorMessage)); } } .blocking(inputController_, loadingFailed(), & cancelled)) { itemTree_.nodesChanged(); treeWidget_.updateTree(); } else if (cancelled) return; else { itemTree_.topLevelNodes().clear(); itemTree_.nodesChanged(); } } else cancelled = false; mainWindow.setCentralWidget(& treeWidget_); connect(actions.playback.nextRandom, SIGNAL(triggered(bool)), SLOT(playbackNextRandom())); connect(actions.playback.playAll, SIGNAL(triggered(bool)), SLOT(playbackPlayAll())); { const Actions::Playlist & p = actions.playlist; connect(p.editMode, SIGNAL(triggered(bool)), SLOT(onEditModeStateChanged())); connect(p.applyChanges, SIGNAL(triggered(bool)), SLOT(applyChanges())); connect(p.cancelChanges, SIGNAL(triggered(bool)), SLOT(cancelChanges())); connect(p.addFiles, SIGNAL(triggered(bool)), SLOT(onAddFiles())); connect(p.addDirectory, SIGNAL(triggered(bool)), SLOT(onAddDirectory())); connect(p.cleanUp, SIGNAL(triggered(bool)), SLOT(onCleanUp())); connect(p.clear, SIGNAL(triggered(bool)), SLOT(onClear())); connect(p.restorePrevious, SIGNAL(triggered(bool)), SLOT(onRestorePrevious())); connect(p.load, SIGNAL(triggered(bool)), SLOT(onLoad())); connect(p.saveAs, SIGNAL(triggered(bool)), SLOT(onSaveAs())); } updateActionsState(); }
void initTools() { File elementsDir( NULL, "gameElements" ); if( !elementsDir.exists() || !elementsDir.isDirectory() ) { return; } File *toolsDir = elementsDir.getChildFile( "tools" ); if( toolsDir == NULL ) { return; } else if( !toolsDir->exists() || !toolsDir->isDirectory() ) { delete toolsDir; return; } int numTools; File **toolNameDirs = toolsDir->getChildFiles( &numTools ); delete toolsDir; if( toolNameDirs == NULL ) { return; } for( int i=0; i<numTools; i++ ) { File *f = toolNameDirs[i]; if( f->exists() && f->isDirectory() ) { char completeRecord = true; toolRecord r; r.name = f->getFileName(); r.description = NULL; r.descriptionPlural = NULL; r.sprite = NULL; File *infoFile = f->getChildFile( "info.txt" ); completeRecord = readInfoFile( infoFile, &( r.id ), &( r.description ) ); delete infoFile; if( completeRecord ) { File *pluralFile = f->getChildFile( "plural.txt" ); completeRecord = readPluralFile( pluralFile, &( r.descriptionPlural ) ); delete pluralFile; } if( completeRecord ) { // read reach, if present (if not, default to 1) r.reach = 1; File *reachFile = f->getChildFile( "reach.txt" ); if( reachFile->exists() ) { char *reach = reachFile->readFileContents(); sscanf( reach, "%d", &( r.reach ) ); delete [] reach; } delete reachFile; File *reachSigFile = f->getChildFile( "reachSignature.txt" ); char *reachSigContents = NULL; if( reachSigFile->exists() ) { reachSigContents = reachSigFile->readFileContents(); } delete reachSigFile; char reachSigOK = true; if( regenerateReachSignatures ) { // ignore reachSignature.txt and generate a new one char *newSig = computeReachSignature( &r ); File *childFile = f->getChildFile( "reachSignature.txt" ); if( childFile != NULL ) { childFile->writeToFile( newSig ); delete childFile; } delete [] newSig; } else if( reachSigContents == NULL ) { reachSigOK = false; } else { // else check it char *sig = trimWhitespace( reachSigContents ); char *trueSig = computeReachSignature( &r ); if( strcmp( trueSig, sig ) != 0 ) { reachSigOK = false; } delete [] sig; delete [] trueSig; } if( reachSigContents != NULL ) { delete [] reachSigContents; } if( !reachSigOK ) { char *dirName = f->getFullFileName(); char *message = autoSprintf( "%s\n%s", translate( "badReachSignature" ), dirName ); delete [] dirName; loadingFailed( message ); delete [] message; } // look for sprite TGA int numChildFiles; File **childFiles = f->getChildFiles( &numChildFiles ); char *tgaPath = NULL; char *shadeMapTgaPath = NULL; for( int j=0; j<numChildFiles; j++ ) { File *f = childFiles[j]; char *name = f->getFileName(); if( strstr( name, "_shadeMap.tga" ) != NULL ) { if( shadeMapTgaPath != NULL ) { delete [] shadeMapTgaPath; } shadeMapTgaPath = f->getFullFileName(); } else if( strstr( name, ".tga" ) != NULL ) { if( tgaPath != NULL ) { delete [] tgaPath; } tgaPath = f->getFullFileName(); } delete [] name; delete childFiles[j]; } delete [] childFiles; if( tgaPath != NULL ) { // assume only one orientation here // discard extras SpriteHandle readSprites[ MAX_ORIENTATIONS ]; int numOrientations = readShadeMappedSprites( tgaPath, shadeMapTgaPath, readSprites ); if( numOrientations == 0 ) { completeRecord = false; } else { r.sprite = readSprites[0]; for( int o=1; o<numOrientations; o++ ) { freeSprite( readSprites[o] ); } } } else { if( shadeMapTgaPath != NULL ) { delete [] shadeMapTgaPath; } completeRecord = false; } } if( completeRecord ) { if( r.id >= idSpaceSize ) { idSpaceSize = r.id + 1; } tools.push_back( r ); } else { delete [] r.name; if( r.description != NULL ) { delete [] r.description; } if( r.descriptionPlural != NULL ) { delete [] r.descriptionPlural; } if( r.sprite != NULL ) { freeSprite( r.sprite ); } } } delete f; } delete [] toolNameDirs; // build map idToIndexMap = new int[idSpaceSize]; for( int i=0; i<idSpaceSize; i++ ) { idToIndexMap[i] = -1; } for( int i=0; i<tools.size(); i++ ) { toolRecord r = *( tools.getElement( i ) ); idToIndexMap[r.id] = i; } }
bool PGFLoader::load(const QString& filePath, DImgLoaderObserver* const observer) { m_observer = observer; readMetadata(filePath, DImg::PGF); FILE* file = fopen(QFile::encodeName(filePath).constData(), "rb"); if (!file) { qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Error: Could not open source file."; loadingFailed(); return false; } unsigned char header[3]; if (fread(&header, 3, 1, file) != 1) { fclose(file); loadingFailed(); return false; } unsigned char pgfID[3] = { 0x50, 0x47, 0x46 }; if (memcmp(&header[0], &pgfID, 3) != 0) { // not a PGF file fclose(file); loadingFailed(); return false; } fclose(file); // ------------------------------------------------------------------- // Initialize PGF API. #ifdef WIN32 #ifdef UNICODE HANDLE fd = CreateFile((LPCWSTR)(QFile::encodeName(filePath).constData()), GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); #else HANDLE fd = CreateFile(QFile::encodeName(filePath).constData(), GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0); #endif if (fd == INVALID_HANDLE_VALUE) { loadingFailed(); return false; } #else int fd = open(QFile::encodeName(filePath).constData(), O_RDONLY); if (fd == -1) { loadingFailed(); return false; } #endif CPGFFileStream stream(fd); CPGFImage pgf; int colorModel = DImg::COLORMODELUNKNOWN; try { // open pgf image pgf.Open(&stream); switch (pgf.Mode()) { case ImageModeRGBColor: case ImageModeRGB48: m_hasAlpha = false; colorModel = DImg::RGB; break; case ImageModeRGBA: m_hasAlpha = true; colorModel = DImg::RGB; break; default: qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Cannot load PGF image: color mode not supported (" << pgf.Mode() << ")"; loadingFailed(); return false; break; } switch (pgf.Channels()) { case 3: case 4: break; default: qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Cannot load PGF image: color channels number not supported (" << pgf.Channels() << ")"; loadingFailed(); return false; break; } int bitDepth = pgf.BPP(); switch (bitDepth) { case 24: // RGB 8 bits. case 32: // RGBA 8 bits. m_sixteenBit = false; break; case 48: // RGB 16 bits. case 64: // RGBA 16 bits. m_sixteenBit = true; break; default: qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Cannot load PGF image: color bits depth not supported (" << bitDepth << ")"; loadingFailed(); return false; break; } if(DIGIKAM_DIMG_LOG_PGF().isDebugEnabled()) { const PGFHeader* header = pgf.GetHeader(); qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF width = " << header->width; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF height = " << header->height; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF bbp = " << header->bpp; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF channels = " << header->channels; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF quality = " << header->quality; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "PGF mode = " << header->mode; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "Has Alpha = " << m_hasAlpha; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "Is 16 bits = " << m_sixteenBit; } // NOTE: see bug #273765 : Loading PGF thumbs with OpenMP support through a separated thread do not work properlly with libppgf 6.11.24 pgf.ConfigureDecoder(false); int width = pgf.Width(); int height = pgf.Height(); uchar* data = 0; QSize originalSize(width, height); if (m_loadFlags & LoadImageData) { // ------------------------------------------------------------------- // Find out if we do the fast-track loading with reduced size. PGF specific. int level = 0; QVariant attribute = imageGetAttribute(QLatin1String("scaledLoadingSize")); if (attribute.isValid() && pgf.Levels() > 0) { int scaledLoadingSize = attribute.toInt(); int i, w, h; for (i = pgf.Levels() - 1 ; i >= 0 ; --i) { w = pgf.Width(i); h = pgf.Height(i); if (qMin(w, h) >= scaledLoadingSize) { break; } } if (i >= 0) { width = w; height = h; level = i; qCDebug(DIGIKAM_DIMG_LOG_PGF) << "Loading PGF scaled version at level " << i << " (" << w << " x " << h << ") for size " << scaledLoadingSize; } } if (m_sixteenBit) { data = new_failureTolerant(width, height, 8); // 16 bits/color/pixel } else { data = new_failureTolerant(width, height, 4); // 8 bits/color/pixel } // Fill all with 255 including alpha channel. memset(data, 0xFF, width * height * (m_sixteenBit ? 8 : 4)); pgf.Read(level, CallbackForLibPGF, this); pgf.GetBitmap(m_sixteenBit ? width * 8 : width * 4, (UINT8*)data, m_sixteenBit ? 64 : 32, NULL, CallbackForLibPGF, this); if (observer) { observer->progressInfo(m_image, 1.0); } } // ------------------------------------------------------------------- // Get ICC color profile. if (m_loadFlags & LoadICCData) { // TODO: Implement proper storage in PGF for color profiles checkExifWorkingColorSpace(); } imageWidth() = width; imageHeight() = height; imageData() = data; imageSetAttribute(QLatin1String("format"), QLatin1String("PGF")); imageSetAttribute(QLatin1String("originalColorModel"), colorModel); imageSetAttribute(QLatin1String("originalBitDepth"), bitDepth); imageSetAttribute(QLatin1String("originalSize"), originalSize); #ifdef WIN32 CloseHandle(fd); #else close(fd); #endif return true; } catch (IOException& e) { int err = e.error; if (err >= AppError) { err -= AppError; } qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Error: Opening and reading PGF image failed (" << err << ")!"; #ifdef WIN32 CloseHandle(fd); #else close(fd); #endif loadingFailed(); return false; } catch (std::bad_alloc& e) { qCWarning(DIGIKAM_DIMG_LOG_PGF) << "Failed to allocate memory for loading" << filePath << e.what(); #ifdef WIN32 CloseHandle(fd); #else close(fd); #endif loadingFailed(); return false; } return true; }
void KoOdfCollectionLoader::loadNativeFile(const QString& path) { delete m_shapeLoadingContext; delete m_loadingContext; m_shapeLoadingContext = 0; m_loadingContext = 0; if(m_odfStore) { delete m_odfStore->store(); delete m_odfStore; m_odfStore = 0; } KoStore* store = KoStore::createStore(path, KoStore::Read); if(store->bad()) { emit loadingFailed(i18n("Not a valid KOffice file: %1", m_path)); delete store; return; } store->disallowNameExpansion(); m_odfStore = new KoOdfReadStore(store); QString errorMessage; if(!m_odfStore->loadAndParse(errorMessage)) { emit loadingFailed(errorMessage); return; } KoOdfLoadingContext* m_loadingContext = new KoOdfLoadingContext(m_odfStore->styles(), m_odfStore->store()); // it ok here to pass an empty dataCenterMap as we don't have a document // tz: not sure if that is 100% correct what if an image is loaded in the collection it needs a image collection QMap<QString, KoDataCenter *> dataCenterMap; m_shapeLoadingContext = new KoShapeLoadingContext(*m_loadingContext, dataCenterMap); KoXmlElement content = m_odfStore->contentDoc().documentElement(); KoXmlElement realBody ( KoXml::namedItemNS( content, KoXmlNS::office, "body" ) ); if (realBody.isNull()) { kError() << "No body tag found!" << endl; emit loadingFailed(i18n("No body tag found in file: %1", path)); return; } m_body = KoXml::namedItemNS(realBody, KoXmlNS::office, "drawing"); if (m_body.isNull()) { kError() << "No office:drawing tag found!" << endl; emit loadingFailed(i18n("No office:drawing tag found in file: %1", path)); return; } m_page = m_body.firstChild().toElement(); if (m_page.isNull()) { kError() << "No shapes found!" << endl; emit loadingFailed(i18n("No shapes found in file: %1", path)); return; } m_shape = m_page.firstChild().toElement(); if (m_shape.isNull()) { kError() << "No shapes found!" << endl; emit loadingFailed(i18n("No shapes found in file: %1", path)); return; } m_loadingTimer->start(); }
void KoOdfCollectionLoader::nextFile() { QString file = m_fileList.takeFirst(); QString filepath = m_path + file; KUrl u; u.setPath(filepath); QString mimetype = findMimeTypeByUrl(u); QString importedFile = filepath; if(mimetype != KoOdf::mimeType(KoOdf::Graphics)) { if(!m_filterManager) m_filterManager = new KoFilterManager(QByteArray(KoOdf::mimeType(KoOdf::Graphics))); KoFilter::ConversionStatus status; importedFile = m_filterManager->importDocument(filepath, status); //kDebug() << "File:" << filepath << "Import:" << importedFile; if(status != KoFilter::OK) { QString msg; switch(status) { case KoFilter::OK: break; case KoFilter::CreationError: msg = i18n( "Creation error" ); break; case KoFilter::FileNotFound: msg = i18n( "File not found" ); break; case KoFilter::StorageCreationError: msg = i18n( "Cannot create storage" ); break; case KoFilter::BadMimeType: msg = i18n( "Bad MIME type" ); break; case KoFilter::EmbeddedDocError: msg = i18n( "Error in embedded document" ); break; case KoFilter::WrongFormat: msg = i18n( "Format not recognized" ); break; case KoFilter::NotImplemented: msg = i18n( "Not implemented" ); break; case KoFilter::ParsingError: msg = i18n( "Parsing error" ); break; case KoFilter::PasswordProtected: msg = i18n( "Document is password protected" ); break; case KoFilter::InternalError: case KoFilter::UnexpectedEOF: case KoFilter::UnexpectedOpcode: case KoFilter::StupidError: // ?? what is this ?? case KoFilter::UsageError: msg = i18n( "Internal error" ); break; case KoFilter::OutOfMemory: msg = i18n( "Out of memory" ); break; case KoFilter::UserCancelled: case KoFilter::BadConversionGraph: // intentionally we do not prompt the error message here break; default: msg = i18n( "Unknown error" ); break; } if(!msg.isEmpty()) { QString errorMsg(i18n("Could not open\n%2.\nReason: %1", msg, filepath)); emit loadingFailed(errorMsg); } return; } } if(!importedFile.isEmpty()) // Something to load (tmp or native file) ? { loadNativeFile(importedFile); if (importedFile != filepath) { QFile::remove(importedFile); } } else { emit loadingFailed(i18n("Failed to import the file: %1", filepath)); } }
bool JP2KLoader::load(const QString& filePath, DImgLoaderObserver* observer) { readMetadata(filePath, DImg::JPEG); FILE* file = fopen(QFile::encodeName(filePath), "rb"); if (!file) { loadingFailed(); return false; } unsigned char header[9]; if (fread(&header, 9, 1, file) != 1) { fclose(file); loadingFailed(); return false; } unsigned char jp2ID[5] = { 0x6A, 0x50, 0x20, 0x20, 0x0D, }; unsigned char jpcID[2] = { 0xFF, 0x4F }; if (memcmp(&header[4], &jp2ID, 5) != 0 && memcmp(&header, &jpcID, 2) != 0) { // not a jpeg2000 file fclose(file); loadingFailed(); return false; } fclose(file); imageSetAttribute("format", "JP2K"); if (!(m_loadFlags & LoadImageData) && !(m_loadFlags & LoadICCData)) { // libjasper will load the full image in memory already when calling jas_image_decode. // This is bad when scanning. See bugs 215458 and 195583. //FIXME: Use Exiv2 or OpenJPEG to extract this info DMetadata metadata(filePath); QSize size = metadata.getImageDimensions(); if (size.isValid()) { imageWidth() = size.width(); imageHeight() = size.height(); } return true; } // ------------------------------------------------------------------- // Initialize JPEG 2000 API. register long i, x, y; int components[4]; unsigned int maximum_component_depth, scale[4], x_step[4], y_step[4]; unsigned long number_components; jas_image_t* jp2_image = 0; jas_stream_t* jp2_stream = 0; jas_matrix_t* pixels[4]; int init = jas_init(); if (init != 0) { kDebug() << "Unable to init JPEG2000 decoder"; loadingFailed(); return false; } jp2_stream = jas_stream_fopen(QFile::encodeName(filePath), "rb"); if (jp2_stream == 0) { kDebug() << "Unable to open JPEG2000 stream"; loadingFailed(); return false; } jp2_image = jas_image_decode(jp2_stream, -1, 0); if (jp2_image == 0) { jas_stream_close(jp2_stream); kDebug() << "Unable to decode JPEG2000 image"; loadingFailed(); return false; } jas_stream_close(jp2_stream); // some pseudo-progress if (observer) { observer->progressInfo(m_image, 0.1F); } // ------------------------------------------------------------------- // Check color space. int colorModel; switch (jas_clrspc_fam(jas_image_clrspc(jp2_image))) { case JAS_CLRSPC_FAM_RGB: { components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_R); components[1] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_G); components[2] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_RGB_B); if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0)) { jas_image_destroy(jp2_image); kDebug() << "Error parsing JPEG2000 image : Missing Image Channel"; loadingFailed(); return false; } number_components = 3; components[3] = jas_image_getcmptbytype(jp2_image, 3); if (components[3] > 0) { m_hasAlpha = true; ++number_components; } colorModel = DImg::RGB; break; } case JAS_CLRSPC_FAM_GRAY: { components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_GRAY_Y); if (components[0] < 0) { jas_image_destroy(jp2_image); kDebug() << "Error parsing JP2000 image : Missing Image Channel"; loadingFailed(); return false; } number_components = 1; colorModel = DImg::GRAYSCALE; break; } case JAS_CLRSPC_FAM_YCBCR: { components[0] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_Y); components[1] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_CB); components[2] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_YCBCR_CR); if ((components[0] < 0) || (components[1] < 0) || (components[2] < 0)) { jas_image_destroy(jp2_image); kDebug() << "Error parsing JP2000 image : Missing Image Channel"; loadingFailed(); return false; } number_components = 3; components[3] = jas_image_getcmptbytype(jp2_image, JAS_IMAGE_CT_UNKNOWN); if (components[3] > 0) { m_hasAlpha = true; ++number_components; } // FIXME : image->colorspace=YCbCrColorspace; colorModel = DImg::YCBCR; break; } default: { jas_image_destroy(jp2_image); kDebug() << "Error parsing JP2000 image : Colorspace Model Is Not Supported"; loadingFailed(); return false; } } // ------------------------------------------------------------------- // Check image geometry. imageWidth() = jas_image_width(jp2_image); imageHeight() = jas_image_height(jp2_image); for (i = 0; i < (long)number_components; ++i) { if ((((jas_image_cmptwidth(jp2_image, components[i])* jas_image_cmpthstep(jp2_image, components[i])) != (long)imageWidth())) || (((jas_image_cmptheight(jp2_image, components[i])* jas_image_cmptvstep(jp2_image, components[i])) != (long)imageHeight())) || (jas_image_cmpttlx(jp2_image, components[i]) != 0) || (jas_image_cmpttly(jp2_image, components[i]) != 0) || (jas_image_cmptsgnd(jp2_image, components[i]) != false)) { jas_image_destroy(jp2_image); kDebug() << "Error parsing JPEG2000 image : Irregular Channel Geometry Not Supported"; loadingFailed(); return false; } x_step[i] = jas_image_cmpthstep(jp2_image, components[i]); y_step[i] = jas_image_cmptvstep(jp2_image, components[i]); } // ------------------------------------------------------------------- // Get image format. m_hasAlpha = number_components > 3; maximum_component_depth = 0; for (i = 0; i < (long)number_components; ++i) { maximum_component_depth = qMax((long)jas_image_cmptprec(jp2_image,components[i]), (long)maximum_component_depth); pixels[i] = jas_matrix_create(1, ((unsigned int)imageWidth())/x_step[i]); if (!pixels[i]) { jas_image_destroy(jp2_image); kDebug() << "Error decoding JPEG2000 image data : Memory Allocation Failed"; loadingFailed(); return false; } } if (maximum_component_depth > 8) { m_sixteenBit = true; } for (i = 0 ; i < (long)number_components ; ++i) { scale[i] = 1; int prec = jas_image_cmptprec(jp2_image, components[i]); if (m_sixteenBit && prec < 16) { scale[i] = (1 << (16 - jas_image_cmptprec(jp2_image, components[i]))); } } // ------------------------------------------------------------------- // Get image data. uchar* data = 0; if (m_loadFlags & LoadImageData) { if (m_sixteenBit) // 16 bits image. { data = new_failureTolerant(imageWidth()*imageHeight()*8); } else { data = new_failureTolerant(imageWidth()*imageHeight()*4); } if (!data) { kDebug() << "Error decoding JPEG2000 image data : Memory Allocation Failed"; jas_image_destroy(jp2_image); for (i = 0 ; i < (long)number_components ; ++i) { jas_matrix_destroy(pixels[i]); } jas_cleanup(); loadingFailed(); return false; } uint checkPoint = 0; uchar* dst = data; unsigned short* dst16 = (unsigned short*)data; for (y = 0 ; y < (long)imageHeight() ; ++y) { for (i = 0 ; i < (long)number_components; ++i) { int ret = jas_image_readcmpt(jp2_image, (short)components[i], 0, ((unsigned int) y) / y_step[i], ((unsigned int) imageWidth()) / x_step[i], 1, pixels[i]); if (ret != 0) { kDebug() << "Error decoding JPEG2000 image data"; delete [] data; jas_image_destroy(jp2_image); for (i = 0 ; i < (long)number_components ; ++i) { jas_matrix_destroy(pixels[i]); } jas_cleanup(); loadingFailed(); return false; } } switch (number_components) { case 1: // Grayscale. { for (x = 0 ; x < (long)imageWidth() ; ++x) { dst[0] = (uchar)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0])); dst[1] = dst[0]; dst[2] = dst[0]; dst[3] = 0xFF; dst += 4; } break; } case 3: // RGB. { if (!m_sixteenBit) // 8 bits image. { for (x = 0 ; x < (long)imageWidth() ; ++x) { // Blue dst[0] = (uchar)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2])); // Green dst[1] = (uchar)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1])); // Red dst[2] = (uchar)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0])); // Alpha dst[3] = 0xFF; dst += 4; } } else // 16 bits image. { for (x = 0 ; x < (long)imageWidth() ; ++x) { // Blue dst16[0] = (unsigned short)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2])); // Green dst16[1] = (unsigned short)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1])); // Red dst16[2] = (unsigned short)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0])); // Alpha dst16[3] = 0xFFFF; dst16 += 4; } } break; } case 4: // RGBA. { if (!m_sixteenBit) // 8 bits image. { for (x = 0 ; x < (long)imageWidth() ; ++x) { // Blue dst[0] = (uchar)(scale[2] * jas_matrix_getv(pixels[2], x/x_step[2])); // Green dst[1] = (uchar)(scale[1] * jas_matrix_getv(pixels[1], x/x_step[1])); // Red dst[2] = (uchar)(scale[0] * jas_matrix_getv(pixels[0], x/x_step[0])); // Alpha dst[3] = (uchar)(scale[3] * jas_matrix_getv(pixels[3], x/x_step[3])); dst += 4; } } else // 16 bits image. { for (x = 0 ; x < (long)imageWidth() ; ++x) { // Blue dst16[0] = (unsigned short)(scale[2]*jas_matrix_getv(pixels[2], x/x_step[2])); // Green dst16[1] = (unsigned short)(scale[1]*jas_matrix_getv(pixels[1], x/x_step[1])); // Red dst16[2] = (unsigned short)(scale[0]*jas_matrix_getv(pixels[0], x/x_step[0])); // Alpha dst16[3] = (unsigned short)(scale[3]*jas_matrix_getv(pixels[3], x/x_step[3])); dst16 += 4; } } break; } } // use 0-10% and 90-100% for pseudo-progress if (observer && y >= (long)checkPoint) { checkPoint += granularity(observer, y, 0.8F); if (!observer->continueQuery(m_image)) { delete [] data; jas_image_destroy(jp2_image); for (i = 0 ; i < (long)number_components ; ++i) { jas_matrix_destroy(pixels[i]); } jas_cleanup(); loadingFailed(); return false; } observer->progressInfo(m_image, 0.1 + (0.8 * ( ((float)y)/((float)imageHeight()) ))); } } } // ------------------------------------------------------------------- // Get ICC color profile. if (m_loadFlags & LoadICCData) { jas_iccprof_t* icc_profile = 0; jas_stream_t* icc_stream = 0; jas_cmprof_t* cm_profile = 0; cm_profile = jas_image_cmprof(jp2_image); if (cm_profile != 0) { icc_profile = jas_iccprof_createfromcmprof(cm_profile); } if (icc_profile != 0) { icc_stream = jas_stream_memopen(NULL, 0); if (icc_stream != 0) { if (jas_iccprof_save(icc_profile, icc_stream) == 0) { if (jas_stream_flush(icc_stream) == 0) { jas_stream_memobj_t* blob = (jas_stream_memobj_t*) icc_stream->obj_; QByteArray profile_rawdata; profile_rawdata.resize(blob->len_); memcpy(profile_rawdata.data(), blob->buf_, blob->len_); imageSetIccProfile(profile_rawdata); jas_stream_close(icc_stream); } } } } } if (observer) { observer->progressInfo(m_image, 1.0); } imageData() = data; imageSetAttribute("format", "JP2K"); imageSetAttribute("originalColorModel", colorModel); imageSetAttribute("originalBitDepth", maximum_component_depth); imageSetAttribute("originalSize", QSize(imageWidth(), imageHeight())); jas_image_destroy(jp2_image); for (i = 0 ; i < (long)number_components ; ++i) { jas_matrix_destroy(pixels[i]); } jas_cleanup(); return true; }
bool PPMLoader::load(const QString& filePath, DImgLoaderObserver* observer) { //TODO: progress information int width, height, rgbmax; char nl; FILE* file = fopen(QFile::encodeName(filePath), "rb"); if (!file) { kDebug() << "Cannot open image file."; loadingFailed(); return false; } ushort header; if (fread(&header, 2, 1, file) != 1) { kDebug() << "Cannot read header of file."; fclose(file); loadingFailed(); return false; } uchar* c = (uchar*) &header; if (*c != 'P') { kDebug() << "Not a PPM file."; fclose(file); loadingFailed(); return false; } ++c; if (*c != '6') { kDebug() << "Not a PPM file."; fclose(file); loadingFailed(); return false; } rewind(file); if (fscanf (file, "P6 %d %d %d%c", &width, &height, &rgbmax, &nl) != 4) { kDebug() << "Corrupted PPM file."; fclose (file); loadingFailed(); return false; } if (rgbmax <= 255) { kDebug() << "Not a 16 bits per color per pixel PPM file."; fclose (file); loadingFailed(); return false; } if (observer) { observer->progressInfo(m_image, 0.1F); } unsigned short* data = 0; if (m_loadFlags & LoadImageData) { data = new_short_failureTolerant(width*height*4); if (!data) { kDebug() << "Failed to allocate memory for loading" << filePath; fclose(file); loadingFailed(); return false; } unsigned short* dst = data; uchar src[6]; float fac = 65535.0 / rgbmax; int checkpoint = 0; #ifdef ENABLE_DEBUG_MESSAGES kDebug() << "rgbmax=" << rgbmax << " fac=" << fac; #endif for (int h = 0; h < height; ++h) { if (observer && h == checkpoint) { checkpoint += granularity(observer, height, 0.9F); if (!observer->continueQuery(m_image)) { delete [] data; fclose( file ); loadingFailed(); return false; } observer->progressInfo(m_image, 0.1 + (0.9 * ( ((float)h)/((float)height) ))); } for (int w = 0; w < width; ++w) { fread (src, 6 *sizeof(unsigned char), 1, file); dst[0] = (unsigned short)((src[4]*256 + src[5]) * fac); // Blue dst[1] = (unsigned short)((src[2]*256 + src[3]) * fac); // Green dst[2] = (unsigned short)((src[0]*256 + src[1]) * fac); // Red dst[3] = 0xFFFF; dst += 4; } } } fclose( file ); //---------------------------------------------------------- imageWidth() = width; imageHeight() = height; imageData() = (uchar*)data; imageSetAttribute("format", "PPM"); imageSetAttribute("originalColorFormat", DImg::RGB); imageSetAttribute("originalBitDepth", 8); imageSetAttribute("originalSize", QSize(width, height)); return true; }
void MessageDefinitionLoader::threadFinished() { if (impl_.error_.isEmpty()) emit loadingFinished(); else emit loadingFailed(impl_.error_); }