X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Ftranscode_job.cc;h=8e56603302e1200382197965d51b8c0cbf0f1ee1;hb=422be0eece2bf6ee80db1d3c21553cd82efff789;hp=3776ea4c1d6404e11f5842daaea9baffc41f10ff;hpb=d6e74fb7dbc5b01c9ce42f8fe780bb16262d13b1;p=dcpomatic.git diff --git a/src/lib/transcode_job.cc b/src/lib/transcode_job.cc index 3776ea4c1..8e5660330 100644 --- a/src/lib/transcode_job.cc +++ b/src/lib/transcode_job.cc @@ -1,19 +1,20 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2015 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic 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 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic 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 this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ @@ -21,57 +22,80 @@ * @brief A job which transcodes from one format to another. */ -#include -#include #include "transcode_job.h" -#include "j2k_wav_encoder.h" +#include "upload_job.h" +#include "job_manager.h" #include "film.h" -#include "format.h" #include "transcoder.h" -#include "film_state.h" #include "log.h" -#include "encoder_factory.h" +#include +#include "compose.hpp" +#include +#include + +#include "i18n.h" + +#define LOG_GENERAL(...) _film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL); +#define LOG_GENERAL_NC(...) _film->log()->log (__VA_ARGS__, LogEntry::TYPE_GENERAL); +#define LOG_ERROR_NC(...) _film->log()->log (__VA_ARGS__, LogEntry::TYPE_ERROR); -using namespace std; -using namespace boost; +using std::string; +using std::fixed; +using std::setprecision; +using std::cout; +using boost::shared_ptr; -/** @param s FilmState to use. - * @param o Options. - * @param l A log that we can write to. +/** @param s Film to use. */ -TranscodeJob::TranscodeJob (shared_ptr s, shared_ptr o, Log* l, shared_ptr req) - : Job (s, o, l, req) +TranscodeJob::TranscodeJob (shared_ptr film) + : Job (film) { - + } string TranscodeJob::name () const { - return String::compose ("Transcode %1", _fs->name()); + return String::compose (_("Transcode %1"), _film->name()); +} + +string +TranscodeJob::json_name () const +{ + return N_("transcode"); } void TranscodeJob::run () { try { + struct timeval start; + gettimeofday (&start, 0); + LOG_GENERAL_NC (N_("Transcode job starting")); - _log->log ("Transcode job starting"); - - _encoder = encoder_factory (_fs, _opt, _log); - Transcoder w (_fs, _opt, this, _log, _encoder); - w.go (); + _transcoder.reset (new Transcoder (_film, shared_from_this ())); + _transcoder->go (); set_progress (1); set_state (FINISHED_OK); - _log->log ("Transcode job completed successfully"); + struct timeval finish; + gettimeofday (&finish, 0); - } catch (std::exception& e) { + float fps = 0; + if (finish.tv_sec != start.tv_sec) { + fps = _transcoder->video_frames_enqueued() / (finish.tv_sec - start.tv_sec); + } - set_progress (1); - set_state (FINISHED_ERROR); - _log->log (String::compose ("Transcode job failed (%1)", e.what())); + LOG_GENERAL (N_("Transcode job completed successfully: %1 fps"), fps); + _transcoder.reset (); + + if (_film->upload_after_make_dcp ()) { + shared_ptr job (new UploadJob (_film)); + JobManager::instance()->add (job); + } + } catch (...) { + _transcoder.reset (); throw; } } @@ -79,33 +103,49 @@ TranscodeJob::run () string TranscodeJob::status () const { - if (!_encoder) { - return "0%"; + if (!_transcoder) { + return Job::status (); } - if (_encoder->skipping () && !finished ()) { - return "skipping already-encoded frames"; - } - - - float const fps = _encoder->current_frames_per_second (); + float const fps = _transcoder->current_encoding_rate (); if (fps == 0) { return Job::status (); } - stringstream s; + locked_stringstream s; + + s << Job::status (); + + if (!finished () && !_transcoder->finishing ()) { + /// TRANSLATORS: fps here is an abbreviation for frames per second + s << "; " << _transcoder->video_frames_enqueued() << "/" + << _film->length().frames_round (_film->video_frame_rate ()) << " " << _("frames") << "; " + << fixed << setprecision (1) << fps << " " << _("fps"); + } - s << Job::status () << "; " << fixed << setprecision (1) << fps << " frames per second"; return s.str (); } +/** @return Approximate remaining time in seconds */ int TranscodeJob::remaining_time () const { - float fps = _encoder->current_frames_per_second (); + /* _transcoder might be destroyed by the job-runner thread */ + shared_ptr t = _transcoder; + + if (!t || t->finishing()) { + /* We aren't doing any actual encoding so just use the job's guess */ + return Job::remaining_time (); + } + + /* We're encoding so guess based on the current encoding rate */ + + float fps = t->current_encoding_rate (); + if (fps == 0) { return 0; } - return ((_fs->dcp_length() - _encoder->last_frame()) / fps); + /* Compute approximate proposed length here, as it's only here that we need it */ + return (_film->length().frames_round (_film->video_frame_rate ()) - t->video_frames_enqueued()) / fps; }