bool KDcraw::loadHalfPreview(QByteArray& imgData, const QBuffer& inBuffer)
{
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
LibRaw raw;
QByteArray inData = inBuffer.data();
int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
if (ret != LIBRAW_SUCCESS)
{
kDebug() << "LibRaw: failed to run dcraw_make_mem_image: " << libraw_strerror(ret);
raw.recycle();
return false;
}
QImage image;
if (!Private::loadHalfPreview(image, raw))
{
kDebug() << "KDcraw: failed to get half preview: " << libraw_strerror(ret);
return false;
}
QBuffer buffer(&imgData);
buffer.open(QIODevice::WriteOnly);
image.save(&buffer, "JPG");
return true;
}
bool KDcraw::loadHalfPreview(QByteArray& imgData, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
kDebug() << "Try to use reduced RAW picture extraction";
LibRaw raw;
int ret = raw.open_file(QFile::encodeName(path));
if (ret != LIBRAW_SUCCESS)
{
kDebug() << "LibRaw: failed to run dcraw_process: " << libraw_strerror(ret);
raw.recycle();
return false;
}
QImage image;
if (!Private::loadHalfPreview(image, raw))
{
kDebug() << "KDcraw: failed to get half preview: " << libraw_strerror(ret);
return false;
}
QBuffer buffer(&imgData);
buffer.open(QIODevice::WriteOnly);
image.save(&buffer, "JPEG");
return true;
}
bool Utils::isRAW(const QString& file)
{
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
QFileInfo fileInfo(file);
if (rawFilesExt.toUpper().contains( fileInfo.suffix().toUpper() ))
return true;
return false;
}
bool KDcraw::loadFullImage(QImage& image, const QString& path, const RawDecodingSettings& settings)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
qCDebug(LIBKDCRAW_LOG) << "Try to load full RAW picture...";
RawDecodingSettings prm = settings;
prm.sixteenBitsImage = false;
QByteArray imgData;
int width, height, rgbmax;
KDcraw decoder;
bool ret = decoder.decodeRAWImage(path, prm, imgData, width, height, rgbmax);
if (!ret)
{
qCDebug(LIBKDCRAW_LOG) << "Failled to load full RAW picture";
return false;
}
uchar* sptr = (uchar*)imgData.data();
uchar tmp8[2];
// Set RGB color components.
for (int i = 0 ; i < width * height ; ++i)
{
// Swap Red and Blue
tmp8[0] = sptr[2];
tmp8[1] = sptr[0];
sptr[0] = tmp8[0];
sptr[2] = tmp8[1];
sptr += 3;
}
image = QImage(width, height, QImage::Format_ARGB32);
uint* dptr = reinterpret_cast<uint*>(image.bits());
sptr = (uchar*)imgData.data();
for (int i = 0 ; i < width * height ; ++i)
{
*dptr++ = qRgba(sptr[2], sptr[1], sptr[0], 0xFF);
sptr += 3;
}
qCDebug(LIBKDCRAW_LOG) << "Load full RAW picture done";
return true;
}
QImage TPhoto::loadPhoto()
{
QImage photo;
// Check if RAW file.
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
QFileInfo fileInfo(filename.path());
if (rawFilesExt.toUpper().contains( fileInfo.suffix().toUpper()))
KDcrawIface::KDcraw::loadDcrawPreview(photo, filename.path());
else
photo.load(filename.path()); // PENDING(blackie) handle URL
return photo;
}
bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QBuffer& buffer)
{
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
LibRaw raw;
QByteArray inData = buffer.data();
int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_buffer: " << libraw_strerror(ret);
raw.recycle();
return false;
}
return (Private::loadEmbeddedPreview(imgData, raw));
}
bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
LibRaw raw;
int ret = raw.open_file((const char*)(QFile::encodeName(path)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
return (Private::loadEmbeddedPreview(imgData, raw));
}
bool KDcraw::loadHalfPreview(QImage& image, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
qCDebug(LIBKDCRAW_LOG) << "Try to use reduced RAW picture extraction";
LibRaw raw;
raw.imgdata.params.use_auto_wb = 1; // Use automatic white balance.
raw.imgdata.params.use_camera_wb = 1; // Use camera white balance, if possible.
raw.imgdata.params.half_size = 1; // Half-size color image (3x faster than -q).
int ret = raw.open_file((const char*)(QFile::encodeName(path)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if(!Private::loadHalfPreview(image, raw))
{
qCDebug(LIBKDCRAW_LOG) << "Failed to get half preview from LibRaw!";
return false;
}
qCDebug(LIBKDCRAW_LOG) << "Using reduced RAW picture extraction";
return true;
}
bool KDcraw::extractRAWData(const QString& filePath, QByteArray& rawData, DcrawInfoContainer& identify, unsigned int shotSelect)
{
QFileInfo fileInfo(filePath);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
identify.isDecodable = false;
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
if (m_cancel)
return false;
d->setProgress(0.1);
LibRaw raw;
// Set progress call back function.
raw.set_progress_handler(callbackForLibRaw, d);
int ret = raw.open_file((const char*)(QFile::encodeName(filePath)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.3);
raw.imgdata.params.output_bps = 16;
raw.imgdata.params.shot_select = shotSelect;
ret = raw.unpack();
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run unpack: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.4);
ret = raw.raw2image();
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run raw2image: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.6);
Private::fillIndentifyInfo(&raw, identify);
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.8);
rawData = QByteArray();
if (raw.imgdata.idata.filters == 0)
{
rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * raw.imgdata.idata.colors * sizeof(unsigned short)));
unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
for (unsigned int row = 0; row < raw.imgdata.sizes.iheight; row++)
{
for (unsigned int col = 0; col < raw.imgdata.sizes.iwidth; col++)
{
for (int color = 0; color < raw.imgdata.idata.colors; color++)
{
*output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][color];
output++;
}
}
}
}
else
{
rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * sizeof(unsigned short)));
unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
for (uint row = 0; row < raw.imgdata.sizes.iheight; row++)
{
for (uint col = 0; col < raw.imgdata.sizes.iwidth; col++)
{
*output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][raw.COLOR(row, col)];
output++;
}
}
}
raw.recycle();
d->setProgress(1.0);
return true;
}
bool ClockPhotoDialog::setImage(const KUrl &imageFile)
{
bool success = false;
// Raw housekeeping.
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
QFileInfo info(imageFile.path());
// Try to load the image into the d->image variable.
bool imageLoaded;
if (rawFilesExt.toUpper().contains(info.suffix().toUpper()))
{
// In case of raw images, load the image the a QImage and convert it to
// the QPixmap for display.
QImage tmp = QImage();
imageLoaded = KDcrawIface::KDcraw::loadDcrawPreview(tmp, imageFile.path());
delete d->image;
d->image = new QPixmap(d->image->fromImage(tmp));
}
else
{
imageLoaded = d->image->load(imageFile.path());
}
if (imageLoaded)
{
// Try to read the datetime data.
KExiv2Iface::KExiv2 exiv2Iface;
bool result = exiv2Iface.load(imageFile.path());
if (result)
{
delete d->photoDateTime;
d->photoDateTime = new QDateTime(exiv2Iface.getImageDateTime());
if (d->photoDateTime->isValid()) {
// Set the datetime widget to the photo datetime.
d->calendar->setDateTime(*(d->photoDateTime));
d->calendar->setEnabled(true);
success = true;
}
else
{
// If datetime information couldn't be loaded, display a
// warning and disable the datetime widget.
QString warning = i18n("<font color=\"red\"><b>Could not "
"obtain date and time information "
"from image %1.</b></font>",
imageFile.fileName());
d->imageLabel->setText(warning);
}
}
}
else
{
// If the image couldn't be loaded, display a warning, disable all the
// GUI elements and load an empty photo into d->image.
QString warning = i18n("<font color=\"red\"><b>Could not load "
"image %1.</b></font>",
imageFile.fileName());
d->imageLabel->setText(warning);
}
if (success)
{
// Load the photo and enable all image display GUI elements.
d->imageLabel->setPixmap(*(d->image));
// The following line is a bit of a hack: if the QLabel is shown for
// the first time, it is broken (parts of it are missing). After a scale
// action, this problem is solved. So we first scale it here.
d->imageLabel->resize(d->image->width(), d->image->height());
d->zoomSlider->setEnabled(true);
d->zoomOutButton->setEnabled(true);
d->zoomInButton->setEnabled(true);
// Fit the image to the viewport.
adjustToWindowSize(true);
}
else
{
// Disable all the GUI elements.
d->zoomSlider->setEnabled(false);
d->zoomOutButton->setEnabled(false);
d->zoomInButton->setEnabled(false);
d->calendar->setEnabled(false);
// Make sure we de-load a previous image if a faulty url was provided.
delete d->image;
d->image = new QPixmap();
// Scale the imageLabel so that the warning shows up.
d->imageLabel->resize(d->scrollArea->viewport()->size());
}
return success;
}
bool ImageResize::imageResize(const EmailSettingsContainer& settings,
const KUrl& orgUrl, const QString& destName, QString& err)
{
EmailSettingsContainer emailSettings = settings;
QFileInfo fi(orgUrl.path());
if (!fi.exists() || !fi.isReadable())
{
err = i18n("Error opening input file");
return false;
}
QFileInfo tmp(destName);
QFileInfo tmpDir(tmp.dir().absolutePath());
kDebug() << "tmpDir: " << tmp.dir().absolutePath();
if (!tmpDir.exists() || !tmpDir.isWritable())
{
err = i18n("Error opening temporary folder");
return false;
}
QImage img;
// Check if RAW file.
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
if (rawFilesExt.toUpper().contains( fi.suffix().toUpper() ))
KDcrawIface::KDcraw::loadDcrawPreview(img, orgUrl.path());
else
img.load(orgUrl.path());
int sizeFactor = emailSettings.size();
if ( !img.isNull() )
{
int w = img.width();
int h = img.height();
if( w > sizeFactor || h > sizeFactor )
{
if( w > h )
{
h = (int)( (double)( h * sizeFactor ) / w );
if ( h == 0 ) h = 1;
w = sizeFactor;
Q_ASSERT( h <= sizeFactor );
}
else
{
w = (int)( (double)( w * sizeFactor ) / h );
if ( w == 0 ) w = 1;
h = sizeFactor;
Q_ASSERT( w <= sizeFactor );
}
const QImage scaledImg(img.scaled(w, h, Qt::IgnoreAspectRatio, Qt::SmoothTransformation));
if ( scaledImg.width() != w || scaledImg.height() != h )
{
err = i18n("Cannot resize image. Aborting.");
return false;
}
img = scaledImg;
}
QString destPath = destName;
KExiv2Iface::KExiv2 meta;
meta.load(orgUrl.path());
meta.setImageProgramId(QString("Kipi-plugins"), QString(kipiplugins_version));
meta.setImageDimensions(img.size());
if (emailSettings.format() == QString("JPEG"))
{
if ( !img.save(destPath, emailSettings.format().toLatin1(), emailSettings.imageCompression) )
{
err = i18n("Cannot save resized image (JPEG). Aborting.");
return false;
}
else
{
meta.save(destPath);
}
}
else if (emailSettings.format() == QString("PNG"))
{
QByteArray data((const char*)img.bits(), img.numBytes());
KIPIPlugins::KPWriteImage wImageIface;
wImageIface.setImageData(data, img.width(), img.height(), false, true, QByteArray(), meta);
if ( !wImageIface.write2PNG(destPath) )
{
err = i18n("Cannot save resized image (PNG). Aborting.");
return false;
}
}
return true;
}
return false;
}
void CalPainter::paint(int month)
{
if (!device())
{
return;
}
int width = device()->width();
int height = device()->height();
CalSettings* settings = CalSettings::instance();
CalParams& params = CalSettings::instance()->params;
// --------------------------------------------------
// FIXME: magic number 42
int days[42];
int startDayOffset = KGlobal::locale()->weekStartDay();
for (int i = 0; i < 42; ++i)
{
days[i] = -1;
}
QDate d;
KGlobal::locale()->calendar()->setDate(d, params.year, month, 1);
int s = d.dayOfWeek();
if (s + 7 - startDayOffset >= 7)
{
s = s - 7;
}
for (int i = s; i < (s + KGlobal::locale()->calendar()->daysInMonth(d)); ++i)
{
days[i + (7 - startDayOffset)] = i - s + 1;
}
// -----------------------------------------------
QRect rCal(0, 0, 0, 0);
QRect rImage(0, 0, 0, 0);
QRect rCalHeader(0, 0, 0, 0);
int cellSizeX;
int cellSizeY;
switch (params.imgPos)
{
case (CalParams::Top):
{
rImage.setWidth(width);
rImage.setHeight((int)(height * params.ratio / (params.ratio + 100)));
int remainingHeight = height - rImage.height();
cellSizeX = (width - 20) / 7;
cellSizeY = remainingHeight / 8;
rCal.setWidth(cellSizeX * 7);
rCal.setHeight(cellSizeY * 7);
rCalHeader.setWidth(rCal.width());
rCalHeader.setHeight(cellSizeY);
rCalHeader.moveTop(rImage.bottom());
rCalHeader.moveLeft(width / 2 - rCalHeader.width() / 2);
rCal.moveTopLeft(rCalHeader.bottomLeft());
break;
}
case (CalParams::Left):
{
rImage.setHeight(height);
rImage.setWidth((int)(width * params.ratio / (params.ratio + 100)));
int remainingWidth = width - rImage.width();
cellSizeX = (remainingWidth - 20) / 8;
cellSizeY = height / 8;
rCal.setWidth(cellSizeX * 7);
rCal.setHeight(cellSizeY * 7);
rCalHeader.setWidth(rCal.width());
rCalHeader.setHeight(cellSizeY);
rCalHeader.moveLeft(rImage.right() + cellSizeX);
rCal.moveTopLeft(rCalHeader.bottomLeft());
break;
}
case (CalParams::Right):
{
rImage.setHeight(height);
rImage.setWidth((int)(width * params.ratio / (params.ratio + 100)));
int remainingWidth = width - rImage.width();
cellSizeX = (remainingWidth - 20) / 8;
cellSizeY = height / 8;
rCal.setWidth(cellSizeX * 7);
rCal.setHeight(cellSizeY * 7);
rCalHeader.setWidth(rCal.width());
rCalHeader.setHeight(cellSizeY);
rCal.moveTop(rCalHeader.bottom());
rImage.moveLeft(width - rImage.width());
break;
}
default:
return;
}
int fontPixels = cellSizeX / 3;
params.baseFont.setPixelSize(fontPixels);
// ---------------------------------------------------------------
fillRect(0, 0, width, height, Qt::white);
setFont(params.baseFont);
// ---------------------------------------------------------------
save();
QFont f(params.baseFont);
f.setBold(true);
f.setPixelSize(f.pixelSize() + 5);
setFont(f);
drawText(rCalHeader, Qt::AlignLeft | Qt::AlignVCenter, QString::number(params.year));
drawText(rCalHeader, Qt::AlignRight | Qt::AlignVCenter,
KGlobal::locale()->calendar()->monthName(month, params.year));
restore();
// ---------------------------------------------------------------
int sx, sy;
QRect r, rsmall, rSpecial;
r.setWidth(cellSizeX);
r.setHeight(cellSizeY);
int index = 0;
save();
setPen(Qt::red);
sy = rCal.top();
for (int i = 0; i < 7; ++i)
{
int dayname = i + startDayOffset;
if (dayname > 7)
{
dayname = dayname - 7;
}
sx = cellSizeX * i + rCal.left();
r.moveTopLeft(QPoint(sx, sy));
rsmall = r;
rsmall.setWidth(r.width() - 2);
rsmall.setHeight(r.height() - 2);
drawText(rsmall, Qt::AlignRight | Qt::AlignBottom,
KGlobal::locale()->calendar()->weekDayName(dayname, KCalendarSystem::ShortDayName));
}
restore();
for (int j = 0; j < 6; ++j)
{
sy = cellSizeY * (j + 1) + rCal.top();
for (int i = 0; i < 7; ++i)
{
sx = cellSizeX * i + rCal.left();
r.moveTopLeft(QPoint(sx, sy));
rsmall = r;
rsmall.setWidth(r.width() - 2);
rsmall.setHeight(r.height() - 2);
if (days[index] != -1)
{
if (settings->isSpecial(month, days[index]))
{
save();
setPen(settings->getDayColor(month, days[index]));
drawText(rsmall, Qt::AlignRight | Qt::AlignBottom,
QString::number(days[index]));
QString descr = settings->getDayDescr(month, days[index]);
kDebug() << "Painting special info: '" << descr
<< "' for date " << days[index] << "/"
<< month;
rSpecial = rsmall;
rSpecial.translate(2, 0);
QFont f(params.baseFont);
f.setPixelSize(f.pixelSize() / 3);
setFont(f);
drawText(rSpecial, Qt::AlignLeft | Qt::AlignTop, descr);
restore();
}
else
{
drawText(rsmall, Qt::AlignRight | Qt::AlignBottom,
QString::number(days[index]));
}
}
index++;
}
}
// ---------------------------------------------------------------
if (params.drawLines)
{
sx = rCal.left();
for (int j = 0; j < 8; ++j)
{
sy = cellSizeY * j + rCal.top();
drawLine(sx, sy, rCal.right(), sy);
}
sy = rCal.top();
for (int i = 0; i < 8; ++i)
{
sx = cellSizeX * i + rCal.left();
drawLine(sx, sy, sx, rCal.bottom());
}
}
// Check if RAW file.
QFileInfo fi(imagePath_.path());
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
if (rawFilesExt.toUpper().contains(fi.suffix().toUpper()))
{
KDcrawIface::KDcraw::loadDcrawPreview(image_, imagePath_.path());
}
else
{
image_.load(imagePath_.path());
}
if (image_.isNull())
{
fillRect(rImage, Qt::blue);
}
else
{
if ( orientation_ != KPMetadata::ORIENTATION_UNSPECIFIED )
{
QMatrix matrix = RotationMatrix::toMatrix(orientation_);
image_ = image_.transformed( matrix );
}
emit signalProgress(0);
image_ = image_.scaled(rImage.width(), rImage.height(), Qt::KeepAspectRatio, Qt::SmoothTransformation);
emit signalTotal(image_.height());
int h = image_.height();
int x = rImage.bottomLeft().x() + (rImage.width() - image_.width()) / 2;
int y = (rImage.height() - h) / 2;
int blockSize = 10;
int block = 0;
while (block < h && !cancelled_)
{
if (block + blockSize > h)
{
blockSize = h - block;
}
drawImage(x, y + block, image_, 0, block, image_.width(), blockSize);
block += blockSize;
emit signalProgress(block);
}
emit signalFinished();
}
}
void DsWindow::uploadNextPhoto()
{
if (m_transferQueue.isEmpty())
{
m_widget->progressBar()->hide();
return;
}
m_widget->m_imgList->processing(m_transferQueue.first());
QString imgPath = m_transferQueue.first().toLocalFile();
m_widget->progressBar()->setMaximum(m_imagesTotal);
m_widget->progressBar()->setValue(m_imagesCount);
// screenshots.debian.net only accepts PNG images, 800x600 max
MassageType massageRequired = DsWindow::None;
// check if format is PNG
QImageReader imgReader(imgPath);
QByteArray imgFormat = imgReader.format();
if( QString::compare(QString(imgFormat), QString("PNG"), Qt::CaseInsensitive) != 0 )
{
massageRequired = DsWindow::NotPNG;
}
// check if image > 800x600
QImage img = imgReader.read();
if( (img.width() > maxWidth) || (img.height() > maxHeight) )
{
massageRequired = DsWindow::ResizeRequired;
}
// check if we have to RAW file -> use preview image then
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
QFileInfo fileInfo(imgPath);
if( rawFilesExt.toUpper().contains(fileInfo.suffix().toUpper()) )
{
massageRequired = DsWindow::ImageIsRaw;
}
bool res;
if (massageRequired)
{
if (!prepareImageForUpload(imgPath, massageRequired))
{
slotAddScreenshotDone(666, i18n("Cannot open file"));
return;
}
res = m_talker->addScreenshot(m_tmpPath, m_widget->m_pkgLineEdit->text(),
m_widget->m_versionsComboBox->currentText(),
m_widget->m_descriptionLineEdit->text());
}
else
{
m_tmpPath.clear();
res = m_talker->addScreenshot(imgPath, m_widget->m_pkgLineEdit->text(),
m_widget->m_versionsComboBox->currentText(),
m_widget->m_descriptionLineEdit->text());
}
if (!res)
{
slotAddScreenshotDone(666, i18n("Cannot open file"));
return;
}
}
