xbmc/cdrip/CDDARipJob.cpp

   1 /*
   2  *  Copyright (C) 2012-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "CDDARipJob.h"
  10
  11 #include "Encoder.h"
  12 #include "EncoderAddon.h"
  13 #include "EncoderFFmpeg.h"
  14 #include "FileItem.h"
  15 #include "ServiceBroker.h"
  16 #include "Util.h"
  17 #include "addons/AddonManager.h"
  18 #include "addons/addoninfo/AddonType.h"
  19 #include "dialogs/GUIDialogExtendedProgressBar.h"
  20 #include "filesystem/File.h"
  21 #include "filesystem/SpecialProtocol.h"
  22 #include "guilib/GUIComponent.h"
  23 #include "guilib/GUIWindowManager.h"
  24 #include "guilib/LocalizeStrings.h"
  25 #include "network/NetworkFileItemClassify.h"
  26 #include "settings/AdvancedSettings.h"
  27 #include "settings/Settings.h"
  28 #include "settings/SettingsComponent.h"
  29 #include "storage/MediaManager.h"
  30 #include "utils/StringUtils.h"
  31 #include "utils/SystemInfo.h"
  32 #include "utils/log.h"
  33
  34 #if defined(TARGET_WINDOWS)
  35 #include "platform/win32/CharsetConverter.h"
  36 #endif
  37
  38 using namespace ADDON;
  39 using namespace MUSIC_INFO;
  40 using namespace XFILE;
  41 using namespace KODI;
  42 using namespace KODI::CDRIP;
  43
  44 CCDDARipJob::CCDDARipJob(const std::string& input,
  45                          const std::string& output,
  46                          const CMusicInfoTag& tag,
  47                          int encoder,
  48                          bool eject,
  49                          unsigned int rate,
  50                          unsigned int channels,
  51                          unsigned int bps)
  52   : m_rate(rate),
  53     m_channels(channels),
  54     m_bps(bps),
  55     m_tag(tag),
  56     m_input(input),
  57     m_output(CUtil::MakeLegalPath(output)),
  58     m_eject(eject),
  59     m_encoder(encoder)
  60 {
  61 }
  62
  63 CCDDARipJob::~CCDDARipJob() = default;
  64
  65 bool CCDDARipJob::DoWork()
  66 {
  67   CLog::Log(LOGINFO, "CCDDARipJob::{} - Start ripping track {} to {}", __func__, m_input, m_output);
  68
  69   // if we are ripping to a samba share, rip it to hd first and then copy it to the share
  70   CFileItem file(m_output, false);
  71   if (NETWORK::IsRemote(file))
  72     m_output = SetupTempFile();
  73
  74   if (m_output.empty())
  75   {
  76     CLog::Log(LOGERROR, "CCDDARipJob::{} - Error opening file", __func__);
  77     return false;
  78   }
  79
  80   // init ripper
  81   CFile reader;
  82   std::unique_ptr<CEncoder> encoder{};
  83   if (!reader.Open(m_input, READ_CACHED) || !(encoder = SetupEncoder(reader)))
  84   {
  85     CLog::Log(LOGERROR, "CCDDARipJob::{} - Opening failed", __func__);
  86     return false;
  87   }
  88
  89   // setup the progress dialog
  90   CGUIDialogExtendedProgressBar* pDlgProgress =
  91       CServiceBroker::GetGUI()->GetWindowManager().GetWindow<CGUIDialogExtendedProgressBar>(
  92           WINDOW_DIALOG_EXT_PROGRESS);
  93   CGUIDialogProgressBarHandle* handle = pDlgProgress->GetHandle(g_localizeStrings.Get(605));
  94
  95   int iTrack = atoi(m_input.substr(13, m_input.size() - 13 - 5).c_str());
  96   std::string strLine0 =
  97       StringUtils::Format("{:02}. {} - {}", iTrack, m_tag.GetArtistString(), m_tag.GetTitle());
  98   handle->SetText(strLine0);
  99
 100   // start ripping
 101   int percent = 0;
 102   int oldpercent = 0;
 103   bool cancelled{false};
 104   int result{-1};
 105   while (!cancelled && (result = RipChunk(reader, encoder, percent)) == 0)
 106   {
 107     cancelled = ShouldCancel(percent, 100);
 108     if (percent > oldpercent)
 109     {
 110       oldpercent = percent;
 111       handle->SetPercentage(static_cast<float>(percent));
 112     }
 113   }
 114
 115   // close encoder ripper
 116   encoder->EncoderClose();
 117   encoder.reset();
 118   reader.Close();
 119
 120   if (NETWORK::IsRemote(file) && !cancelled && result == 2)
 121   {
 122     // copy the ripped track to the share
 123     if (!CFile::Copy(m_output, file.GetPath()))
 124     {
 125       CLog::Log(LOGERROR, "CCDDARipJob::{} - Error copying file from {} to {}", __func__, m_output,
 126                 file.GetPath());
 127       CFile::Delete(m_output);
 128       return false;
 129     }
 130     // delete cached file
 131     CFile::Delete(m_output);
 132   }
 133
 134   if (cancelled)
 135   {
 136     CLog::Log(LOGWARNING, "CCDDARipJob::{} - User Cancelled CDDA Rip", __func__);
 137     CFile::Delete(m_output);
 138   }
 139   else if (result == 1)
 140     CLog::Log(LOGERROR, "CCDDARipJob::{} - Error ripping {}", __func__, m_input);
 141   else if (result < 0)
 142     CLog::Log(LOGERROR, "CCDDARipJob::{} - Error encoding {}", __func__, m_input);
 143   else
 144   {
 145     CLog::Log(LOGINFO, "CCDDARipJob::{} - Finished ripping {}", __func__, m_input);
 146     if (m_eject)
 147     {
 148       CLog::Log(LOGINFO, "CCDDARipJob::{} - Ejecting CD", __func__);
 149       CServiceBroker::GetMediaManager().EjectTray();
 150     }
 151   }
 152
 153   handle->MarkFinished();
 154
 155   return !cancelled && result == 2;
 156 }
 157
 158 int CCDDARipJob::RipChunk(CFile& reader, const std::unique_ptr<CEncoder>& encoder, int& percent)
 159 {
 160   percent = 0;
 161
 162   uint8_t stream[1024];
 163
 164   // get data
 165   ssize_t result = reader.Read(stream, 1024);
 166
 167   // return if rip is done or on some kind of error
 168   if (result <= 0)
 169     return 1;
 170
 171   // encode data
 172   ssize_t encres = encoder->EncoderEncode(stream, result);
 173
 174   // Get progress indication
 175   percent = static_cast<int>(reader.GetPosition() * 100 / reader.GetLength());
 176
 177   if (reader.GetPosition() == reader.GetLength())
 178     return 2;
 179
 180   return -(1 - encres);
 181 }
 182
 183 std::unique_ptr<CEncoder> CCDDARipJob::SetupEncoder(CFile& reader)
 184 {
 185   std::unique_ptr<CEncoder> encoder;
 186   const std::string audioEncoder = CServiceBroker::GetSettingsComponent()->GetSettings()->GetString(
 187       CSettings::SETTING_AUDIOCDS_ENCODER);
 188   if (audioEncoder == "audioencoder.kodi.builtin.aac" ||
 189       audioEncoder == "audioencoder.kodi.builtin.wma")
 190   {
 191     encoder = std::make_unique<CEncoderFFmpeg>();
 192   }
 193   else
 194   {
 195     const AddonInfoPtr addonInfo =
 196         CServiceBroker::GetAddonMgr().GetAddonInfo(audioEncoder, AddonType::AUDIOENCODER);
 197     if (addonInfo)
 198     {
 199       encoder = std::make_unique<CEncoderAddon>(addonInfo);
 200     }
 201   }
 202   if (!encoder)
 203     return std::unique_ptr<CEncoder>{};
 204
 205   // we have to set the tags before we init the Encoder
 206   const std::string strTrack = StringUtils::Format(
 207       "{}", std::stol(m_input.substr(13, m_input.size() - 13 - 5), nullptr, 10));
 208
 209   const std::string itemSeparator =
 210       CServiceBroker::GetSettingsComponent()->GetAdvancedSettings()->m_musicItemSeparator;
 211
 212   encoder->SetComment(std::string("Ripped with ") + CSysInfo::GetAppName());
 213   encoder->SetArtist(StringUtils::Join(m_tag.GetArtist(), itemSeparator));
 214   encoder->SetTitle(m_tag.GetTitle());
 215   encoder->SetAlbum(m_tag.GetAlbum());
 216   encoder->SetAlbumArtist(StringUtils::Join(m_tag.GetAlbumArtist(), itemSeparator));
 217   encoder->SetGenre(StringUtils::Join(m_tag.GetGenre(), itemSeparator));
 218   encoder->SetTrack(strTrack);
 219   encoder->SetTrackLength(static_cast<int>(reader.GetLength()));
 220   encoder->SetYear(m_tag.GetYearString());
 221
 222   // init encoder
 223   if (!encoder->EncoderInit(m_output, m_channels, m_rate, m_bps))
 224     encoder.reset();
 225
 226   return encoder;
 227 }
 228
 229 std::string CCDDARipJob::SetupTempFile()
 230 {
 231   char tmp[MAX_PATH + 1];
 232 #if defined(TARGET_WINDOWS)
 233   using namespace KODI::PLATFORM::WINDOWS;
 234   wchar_t tmpW[MAX_PATH];
 235   GetTempFileName(ToW(CSpecialProtocol::TranslatePath("special://temp/")).c_str(), L"riptrack", 0,
 236                   tmpW);
 237   auto tmpString = FromW(tmpW);
 238   strncpy_s(tmp, tmpString.length(), tmpString.c_str(), MAX_PATH);
 239 #else
 240   int fd;
 241   strncpy(tmp, CSpecialProtocol::TranslatePath("special://temp/riptrackXXXXXX").c_str(), MAX_PATH);
 242   if ((fd = mkstemp(tmp)) == -1)
 243     tmp[0] = '\0';
 244   if (fd != -1)
 245     close(fd);
 246 #endif
 247   return tmp;
 248 }
 249
 250 bool CCDDARipJob::operator==(const CJob* job) const
 251 {
 252   if (strcmp(job->GetType(), GetType()) == 0)
 253   {
 254     const CCDDARipJob* rjob = dynamic_cast<const CCDDARipJob*>(job);
 255     if (rjob)
 256     {
 257       return m_input == rjob->m_input && m_output == rjob->m_output;
 258     }
 259   }
 260   return false;
 261 }