X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Ftranscode_job.cc;h=fd4dfcef6dfc10c89b699777514377b1b47820b2;hb=d156b28048786468be10ede5f79147f74ab1d83a;hp=23a3d9fe8cd8f9b85afaae488de68a86897831db;hpb=9db7ed5f6499de903313a85d59bb70302e97e7ff;p=dcpomatic.git diff --git a/src/lib/transcode_job.cc b/src/lib/transcode_job.cc index 23a3d9fe8..7fe28d210 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-2019 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,60 +22,100 @@ * @brief A job which transcodes from one format to another. */ -#include -#include #include "transcode_job.h" +#include "dcp_encoder.h" +#include "upload_job.h" +#include "job_manager.h" #include "film.h" -#include "format.h" -#include "transcoder.h" -#include "log.h" #include "encoder.h" +#include "log.h" +#include "dcpomatic_log.h" +#include "compose.hpp" +#include "analytics.h" +#include +#include + +#include "i18n.h" using std::string; -using std::stringstream; using std::fixed; using std::setprecision; +using std::cout; using boost::shared_ptr; +using boost::optional; +using boost::dynamic_pointer_cast; -/** @param s Film to use. - * @param o Decode options. - * @param req Job that must be completed before this job is run. - */ -TranscodeJob::TranscodeJob (shared_ptr f, DecodeOptions o, shared_ptr req) - : Job (f, req) - , _decode_opt (o) +/** @param film Film to use */ +TranscodeJob::TranscodeJob (shared_ptr film) + : Job (film) { - + +} + +TranscodeJob::~TranscodeJob () +{ + /* We have to stop the job thread here as we're about to start tearing down + the Encoder, which is bad news if the job thread is still feeding it data. + */ + stop_thread (); } string TranscodeJob::name () const { - return String::compose ("Transcode %1", _film->name()); + return String::compose (_("Transcoding %1"), _film->name()); +} + +string +TranscodeJob::json_name () const +{ + return N_("transcode"); +} + +void +TranscodeJob::set_encoder (shared_ptr e) +{ + _encoder = e; } void TranscodeJob::run () { try { + struct timeval start; + gettimeofday (&start, 0); + LOG_GENERAL_NC (N_("Transcode job starting")); - _film->log()->log ("Transcode job starting"); - _film->log()->log (String::compose ("Audio delay is %1ms", _film->audio_delay())); + DCPOMATIC_ASSERT (_encoder); + _encoder->go (); - _encoder.reset (new Encoder (_film)); - Transcoder w (_film, _decode_opt, this, _encoder); - w.go (); - set_progress (1); - set_state (FINISHED_OK); + struct timeval finish; + gettimeofday (&finish, 0); - _film->log()->log ("Transcode job completed successfully"); + float fps = 0; + if (finish.tv_sec != start.tv_sec) { + fps = _encoder->frames_done() / (finish.tv_sec - start.tv_sec); + } - } catch (std::exception& e) { + LOG_GENERAL (N_("Transcode job completed successfully: %1 fps"), fps); + + if (dynamic_pointer_cast(_encoder)) { + Analytics::instance()->successful_dcp_encode(); + } + + /* XXX: this shouldn't be here */ + if (_film->upload_after_make_dcp() && dynamic_pointer_cast(_encoder)) { + shared_ptr job (new UploadJob (_film)); + JobManager::instance()->add (job); + } + + _encoder.reset (); set_progress (1); - set_state (FINISHED_ERROR); - _film->log()->log (String::compose ("Transcode job failed (%1)", e.what())); + set_state (FINISHED_OK); + } catch (...) { + _encoder.reset (); throw; } } @@ -83,43 +124,54 @@ string TranscodeJob::status () const { if (!_encoder) { - return "0%"; - } - - if (_encoder->skipping () && !finished ()) { - return "skipping already-encoded frames"; - } - - - float const fps = _encoder->current_frames_per_second (); - if (fps == 0) { return Job::status (); } - stringstream s; - s << Job::status (); - - if (!finished ()) { - s << "; " << fixed << setprecision (1) << fps << " frames per second"; + char buffer[256]; + if (finished() || _encoder->finishing()) { + strncpy (buffer, Job::status().c_str(), 255); + buffer[255] = '\0'; + } else { + snprintf ( + buffer, sizeof(buffer), "%s; %" PRId64 "/%" PRId64 " frames", + Job::status().c_str(), + _encoder->frames_done(), + _film->length().frames_round (_film->video_frame_rate ()) + ); + + optional const fps = _encoder->current_rate (); + if (fps) { + char fps_buffer[64]; + /// TRANSLATORS: fps here is an abbreviation for frames per second + snprintf (fps_buffer, sizeof(fps_buffer), _("; %.1f fps"), *fps); + strncat (buffer, fps_buffer, strlen(buffer) - 1); + } } - - return s.str (); + + return buffer; } +/** @return Approximate remaining time in seconds */ int TranscodeJob::remaining_time () const { - float fps = _encoder->current_frames_per_second (); - if (fps == 0) { - return 0; + /* _encoder might be destroyed by the job-runner thread */ + shared_ptr e = _encoder; + + if (!e || e->finishing()) { + /* We aren't doing any actual encoding so just use the job's guess */ + return Job::remaining_time (); } - if (!_film->dcp_length()) { + /* We're encoding so guess based on the current encoding rate */ + + optional fps = e->current_rate (); + + if (!fps) { return 0; } - /* We assume that dcp_length() is valid, if it is set */ - SourceFrame const left = _film->dcp_trim_start() + _film->dcp_length().get() - _encoder->video_frame(); - return left / fps; + /* Compute approximate proposed length here, as it's only here that we need it */ + return (_film->length().frames_round(_film->video_frame_rate()) - e->frames_done()) / *fps; }