Clementine-audio-player-Mac-Linux-Windows/src/covers/coverexportrunnable.cpp

/* This file is part of Clementine.
   Copyright 2010, David Sansome <me@davidsansome.com>

   Clementine is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.

   Clementine is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with Clementine.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "albumcoverexporter.h"
#include "core/song.h"
#include "core/tagreaderclient.h"

#include <QFile>
#include <QUrl>

CoverExportRunnable::CoverExportRunnable(const AlbumCoverExport::DialogResult& dialog_result,
                                         const Song& song)
    : dialog_result_(dialog_result),
      song_(song)
{
}

void CoverExportRunnable::run() {
  QString cover_path = GetCoverPath();

  // manually unset?
  if(cover_path.isEmpty()) {
    EmitCoverSkipped();
  } else {
    if(dialog_result_.RequiresCoverProcessing()) {
      ProcessAndExportCover();
    } else {
      ExportCover();
    }

  }
}

QString CoverExportRunnable::GetCoverPath() {
  if(song_.has_manually_unset_cover()) {
    return QString();
  // Export downloaded covers?
  } else if(!song_.art_manual().isEmpty() && dialog_result_.export_downloaded_) {
    return song_.art_manual();
  // Export embedded covers?
  } else if(!song_.art_automatic().isEmpty()
          && song_.art_automatic() == Song::kEmbeddedCover
          && dialog_result_.export_embedded_) {
    return song_.art_automatic();
  } else {
    return QString();
  }
}

// Exports a single album cover using a "save QImage to file" approach.
// For performance reasons this method will be invoked only if loading
// and in memory processing of images is necessary for current settings
// which means that:
// - either the force size flag is being used
// - or the "overwrite smaller" mode is used
// In all other cases, the faster ExportCover() method will be used.
void CoverExportRunnable::ProcessAndExportCover() {
  QString cover_path = GetCoverPath();

  // either embedded or disk - the one we'll export for the current album
  QImage cover;

  QImage embedded_cover;
  QImage disk_cover;

  // load embedded cover if any
  if(song_.has_embedded_cover()) {
    embedded_cover = TagReaderClient::Instance()->LoadEmbeddedArtBlocking(song_.url().toLocalFile());

    if(embedded_cover.isNull()) {
      EmitCoverSkipped();
      return;
    }
    cover = embedded_cover;
  }

  // load a file cover which iss mandatory if there's no embedded cover
  disk_cover.load(cover_path);

  if(embedded_cover.isNull()) {
    if(disk_cover.isNull()) {
      EmitCoverSkipped();
      return;
    }
    cover = disk_cover;
  }

  // rescale if necessary
  if(dialog_result_.IsSizeForced()) {
    cover = cover.scaled(QSize(dialog_result_.width_, dialog_result_.height_), Qt::IgnoreAspectRatio);
  }

  QString dir = song_.url().toLocalFile().section('/', 0, -2);
  QString extension = cover_path.section('.', -1);

  QString new_file = dir + '/' + dialog_result_.fileName_ + '.' +
                         (cover_path == Song::kEmbeddedCover
                            ? "jpg"
                            : extension);

  // If the file exists, do not override!
  if(dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
    EmitCoverSkipped();
    return;
  }

  // we're handling overwrite as remove + copy so we need to delete the old file first
  if(QFile::exists(new_file) && dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode_None) {

    // if the mode is "overwrite smaller" then skip the cover if a bigger one
    // is already available in the folder
    if(dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_Smaller) {
      QImage existing;
      existing.load(new_file);

      if(existing.isNull() || existing.size().height() >= cover.size().height()
           || existing.size().width() >= cover.size().width()) {

        EmitCoverSkipped();
        return;

      }
    }

    if(!QFile::remove(new_file)) {
      EmitCoverSkipped();
      return;
    }
  }

  if(cover.save(new_file)) {
    EmitCoverExported();
  } else {
    EmitCoverSkipped();
  }
}

// Exports a single album cover using a "copy file" approach.
void CoverExportRunnable::ExportCover() {
  QString cover_path = GetCoverPath();

  QString dir = song_.url().toLocalFile().section('/', 0, -2);
  QString extension = cover_path.section('.', -1);

  QString new_file = dir + '/' + dialog_result_.fileName_ + '.' +
                         (cover_path == Song::kEmbeddedCover
                            ? "jpg"
                            : extension);

  // If the file exists, do not override!
  if(dialog_result_.overwrite_ == AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
    EmitCoverSkipped();
    return;
  }

  // we're handling overwrite as remove + copy so we need to delete the old file first
  if(dialog_result_.overwrite_ != AlbumCoverExport::OverwriteMode_None && QFile::exists(new_file)) {
    if(!QFile::remove(new_file)) {
      EmitCoverSkipped();
      return;
    }
  }

  if(cover_path == Song::kEmbeddedCover) {
    // an embedded cover
    QImage embedded = TagReaderClient::Instance()->LoadEmbeddedArtBlocking(song_.url().toLocalFile());
    if(!embedded.save(new_file)) {
      EmitCoverSkipped();
      return;
    }
  } else {
    // automatic or manual cover, available in an image file
    if(!QFile::copy(cover_path, new_file)) {
      EmitCoverSkipped();
      return;
    }
  }
  EmitCoverExported();
}

void CoverExportRunnable::EmitCoverExported() {
  emit CoverExported();
}


void CoverExportRunnable::EmitCoverSkipped() {
  emit CoverSkipped();
}