src/wx/film_editor.cc

   1 /*
   2     Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /** @file src/film_editor.cc
  21  *  @brief A wx widget to edit a film's metadata, and perform various functions.
  22  */
  23
  24 #include <iostream>
  25 #include <iomanip>
  26 #include <wx/wx.h>
  27 #include <wx/notebook.h>
  28 #include <boost/thread.hpp>
  29 #include <boost/filesystem.hpp>
  30 #include <boost/lexical_cast.hpp>
  31 #include "lib/format.h"
  32 #include "lib/film.h"
  33 #include "lib/transcode_job.h"
  34 #include "lib/exceptions.h"
  35 #include "lib/ab_transcode_job.h"
  36 #include "lib/job_manager.h"
  37 #include "lib/filter.h"
  38 #include "lib/config.h"
  39 #include "lib/ffmpeg_decoder.h"
  40 #include "lib/external_audio_decoder.h"
  41 #include "filter_dialog.h"
  42 #include "wx_util.h"
  43 #include "film_editor.h"
  44 #include "gain_calculator_dialog.h"
  45 #include "sound_processor.h"
  46 #include "dci_name_dialog.h"
  47 #include "scaler.h"
  48
  49 using std::string;
  50 using std::cout;
  51 using std::stringstream;
  52 using std::pair;
  53 using std::fixed;
  54 using std::setprecision;
  55 using std::list;
  56 using std::vector;
  57 using boost::shared_ptr;
  58 using boost::dynamic_pointer_cast;
  59
  60 /** @param f Film to edit */
  61 FilmEditor::FilmEditor (shared_ptr<Film> f, wxWindow* parent)
  62         : wxPanel (parent)
  63         , _film (f)
  64         , _generally_sensitive (true)
  65 {
  66         wxBoxSizer* s = new wxBoxSizer (wxVERTICAL);
  67         SetSizer (s);
  68         _notebook = new wxNotebook (this, wxID_ANY);
  69         s->Add (_notebook, 1);
  70
  71         make_film_panel ();
  72         _notebook->AddPage (_film_panel, _("Film"), true);
  73         make_video_panel ();
  74         _notebook->AddPage (_video_panel, _("Video"), false);
  75         make_audio_panel ();
  76         _notebook->AddPage (_audio_panel, _("Audio"), false);
  77         make_subtitle_panel ();
  78         _notebook->AddPage (_subtitle_panel, _("Subtitles"), false);
  79
  80         set_film (_film);
  81         connect_to_widgets ();
  82
  83         JobManager::instance()->ActiveJobsChanged.connect (
  84                 bind (&FilmEditor::active_jobs_changed, this, _1)
  85                 );
  86
  87         setup_visibility ();
  88         setup_formats ();
  89 }
  90
  91 void
  92 FilmEditor::make_film_panel ()
  93 {
  94         _film_panel = new wxPanel (_notebook);
  95         _film_sizer = new wxFlexGridSizer (2, 4, 4);
  96         wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
  97         pad->Add (_film_sizer, 0, wxALL, 8);
  98         _film_panel->SetSizer (pad);
  99
 100         add_label_to_sizer (_film_sizer, _film_panel, "Name");
 101         _name = new wxTextCtrl (_film_panel, wxID_ANY);
 102         _film_sizer->Add (_name, 1, wxEXPAND);
 103
 104         add_label_to_sizer (_film_sizer, _film_panel, "DCP Name");
 105         _dcp_name = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 106         _film_sizer->Add (_dcp_name, 0, wxALIGN_CENTER_VERTICAL | wxSHRINK);
 107
 108         _use_dci_name = new wxCheckBox (_film_panel, wxID_ANY, wxT ("Use DCI name"));
 109         _film_sizer->Add (_use_dci_name, 1, wxEXPAND);
 110         _edit_dci_button = new wxButton (_film_panel, wxID_ANY, wxT ("Details..."));
 111         _film_sizer->Add (_edit_dci_button, 0);
 112
 113         add_label_to_sizer (_film_sizer, _film_panel, "Content");
 114         _content = new wxFilePickerCtrl (_film_panel, wxID_ANY, wxT (""), wxT ("Select Content File"), wxT("*.*"));
 115         _film_sizer->Add (_content, 1, wxEXPAND);
 116
 117         _trust_content_header = new wxCheckBox (_film_panel, wxID_ANY, wxT ("Trust content's header"));
 118         video_control (_trust_content_header);
 119         _film_sizer->Add (_trust_content_header, 1);
 120         _film_sizer->AddSpacer (0);
 121
 122         add_label_to_sizer (_film_sizer, _film_panel, "Content Type");
 123         _dcp_content_type = new wxComboBox (_film_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
 124         _film_sizer->Add (_dcp_content_type);
 125
 126         video_control (add_label_to_sizer (_film_sizer, _film_panel, "Frames Per Second"));
 127         _frames_per_second = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 128         _film_sizer->Add (video_control (_frames_per_second), 1, wxALIGN_CENTER_VERTICAL);
 129
 130         video_control (add_label_to_sizer (_film_sizer, _film_panel, "Original Size"));
 131         _original_size = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 132         _film_sizer->Add (video_control (_original_size), 1, wxALIGN_CENTER_VERTICAL);
 133
 134         video_control (add_label_to_sizer (_film_sizer, _film_panel, "Length"));
 135         _length = new wxStaticText (_film_panel, wxID_ANY, wxT (""));
 136         _film_sizer->Add (video_control (_length), 1, wxALIGN_CENTER_VERTICAL);
 137
 138
 139         {
 140                 video_control (add_label_to_sizer (_film_sizer, _film_panel, "Trim frames"));
 141                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 142                 video_control (add_label_to_sizer (s, _film_panel, "Start"));
 143                 _dcp_trim_start = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 144                 s->Add (video_control (_dcp_trim_start));
 145                 video_control (add_label_to_sizer (s, _film_panel, "End"));
 146                 _dcp_trim_end = new wxSpinCtrl (_film_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 147                 s->Add (video_control (_dcp_trim_end));
 148
 149                 _film_sizer->Add (s);
 150         }
 151
 152         _encrypted = new wxCheckBox (_film_panel, wxID_ANY, wxT ("Encrypted"));
 153         _film_sizer->Add (_encrypted, 1);
 154         _film_sizer->AddSpacer (0);
 155
 156         _dcp_ab = new wxCheckBox (_film_panel, wxID_ANY, wxT ("A/B"));
 157         video_control (_dcp_ab);
 158         _film_sizer->Add (_dcp_ab, 1);
 159         _film_sizer->AddSpacer (0);
 160
 161         /* STILL-only stuff */
 162         {
 163                 still_control (add_label_to_sizer (_film_sizer, _film_panel, "Duration"));
 164                 wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 165                 _still_duration = new wxSpinCtrl (_film_panel);
 166                 still_control (_still_duration);
 167                 s->Add (_still_duration, 1, wxEXPAND);
 168                 still_control (add_label_to_sizer (s, _film_panel, "s"));
 169                 _film_sizer->Add (s);
 170         }
 171
 172         vector<DCPContentType const *> const ct = DCPContentType::all ();
 173         for (vector<DCPContentType const *>::const_iterator i = ct.begin(); i != ct.end(); ++i) {
 174                 _dcp_content_type->Append (std_to_wx ((*i)->pretty_name ()));
 175         }
 176 }
 177
 178 void
 179 FilmEditor::connect_to_widgets ()
 180 {
 181         _name->Connect (wxID_ANY, wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler (FilmEditor::name_changed), 0, this);
 182         _use_dci_name->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::use_dci_name_toggled), 0, this);
 183         _edit_dci_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_dci_button_clicked), 0, this);
 184         _format->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::format_changed), 0, this);
 185         _content->Connect (wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::content_changed), 0, this);
 186         _trust_content_header->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::trust_content_header_changed), 0, this);
 187         _left_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::left_crop_changed), 0, this);
 188         _right_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::right_crop_changed), 0, this);
 189         _top_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::top_crop_changed), 0, this);
 190         _bottom_crop->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::bottom_crop_changed), 0, this);
 191         _filters_button->Connect (wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::edit_filters_clicked), 0, this);
 192         _scaler->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::scaler_changed), 0, this);
 193         _dcp_content_type->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::dcp_content_type_changed), 0, this);
 194         _dcp_ab->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::dcp_ab_toggled), 0, this);
 195         _encrypted->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::encrypted_toggled), 0, this);
 196         _still_duration->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::still_duration_changed), 0, this);
 197         _dcp_trim_start->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::dcp_trim_start_changed), 0, this);
 198         _dcp_trim_end->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::dcp_trim_end_changed), 0, this);
 199         _with_subtitles->Connect (wxID_ANY, wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler (FilmEditor::with_subtitles_toggled), 0, this);
 200         _subtitle_offset->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_offset_changed), 0, this);
 201         _subtitle_scale->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::subtitle_scale_changed), 0, this);
 202         _subtitle_stream->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::subtitle_stream_changed), 0, this);
 203         _audio_stream->Connect (wxID_ANY, wxEVT_COMMAND_COMBOBOX_SELECTED, wxCommandEventHandler (FilmEditor::audio_stream_changed), 0, this);
 204         _audio_gain->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_gain_changed), 0, this);
 205         _audio_gain_calculate_button->Connect (
 206                 wxID_ANY, wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler (FilmEditor::audio_gain_calculate_button_clicked), 0, this
 207                 );
 208         _audio_delay->Connect (wxID_ANY, wxEVT_COMMAND_SPINCTRL_UPDATED, wxCommandEventHandler (FilmEditor::audio_delay_changed), 0, this);
 209         _use_content_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
 210         _use_external_audio->Connect (wxID_ANY, wxEVT_COMMAND_RADIOBUTTON_SELECTED, wxCommandEventHandler (FilmEditor::use_audio_changed), 0, this);
 211         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
 212                 _external_audio[i]->Connect (
 213                         wxID_ANY, wxEVT_COMMAND_FILEPICKER_CHANGED, wxCommandEventHandler (FilmEditor::external_audio_changed), 0, this
 214                         );
 215         }
 216 }
 217
 218 void
 219 FilmEditor::make_video_panel ()
 220 {
 221         _video_panel = new wxPanel (_notebook);
 222         _video_sizer = new wxFlexGridSizer (2, 4, 4);
 223         wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
 224         pad->Add (_video_sizer, 0, wxALL, 8);
 225         _video_panel->SetSizer (pad);
 226
 227         add_label_to_sizer (_video_sizer, _video_panel, "Format");
 228         _format = new wxComboBox (_video_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
 229         _video_sizer->Add (_format);
 230
 231         {
 232                 add_label_to_sizer (_video_sizer, _video_panel, "Crop");
 233                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 234
 235                 add_label_to_sizer (s, _video_panel, "L");
 236                 _left_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 237                 s->Add (_left_crop, 0);
 238                 add_label_to_sizer (s, _video_panel, "R");
 239                 _right_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 240                 s->Add (_right_crop, 0);
 241                 add_label_to_sizer (s, _video_panel, "T");
 242                 _top_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 243                 s->Add (_top_crop, 0);
 244                 add_label_to_sizer (s, _video_panel, "B");
 245                 _bottom_crop = new wxSpinCtrl (_video_panel, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize (64, -1));
 246                 s->Add (_bottom_crop, 0);
 247
 248                 _video_sizer->Add (s);
 249         }
 250
 251         /* VIDEO-only stuff */
 252         {
 253                 video_control (add_label_to_sizer (_video_sizer, _video_panel, "Filters"));
 254                 wxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 255                 _filters = new wxStaticText (_video_panel, wxID_ANY, wxT ("None"));
 256                 video_control (_filters);
 257                 s->Add (_filters, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL | wxTOP | wxBOTTOM | wxRIGHT, 6);
 258                 _filters_button = new wxButton (_video_panel, wxID_ANY, wxT ("Edit..."));
 259                 video_control (_filters_button);
 260                 s->Add (_filters_button, 0);
 261                 _video_sizer->Add (s, 1);
 262         }
 263
 264         video_control (add_label_to_sizer (_video_sizer, _video_panel, "Scaler"));
 265         _scaler = new wxComboBox (_video_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
 266         _video_sizer->Add (video_control (_scaler), 1);
 267
 268         vector<Scaler const *> const sc = Scaler::all ();
 269         for (vector<Scaler const *>::const_iterator i = sc.begin(); i != sc.end(); ++i) {
 270                 _scaler->Append (std_to_wx ((*i)->name()));
 271         }
 272
 273         _left_crop->SetRange (0, 1024);
 274         _top_crop->SetRange (0, 1024);
 275         _right_crop->SetRange (0, 1024);
 276         _bottom_crop->SetRange (0, 1024);
 277         _still_duration->SetRange (1, 60 * 60);
 278         _dcp_trim_start->SetRange (0, 100);
 279         _dcp_trim_end->SetRange (0, 100);
 280 }
 281
 282 void
 283 FilmEditor::make_audio_panel ()
 284 {
 285         _audio_panel = new wxPanel (_notebook);
 286         _audio_sizer = new wxFlexGridSizer (2, 4, 4);
 287         wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
 288         pad->Add (_audio_sizer, 0, wxALL, 8);
 289         _audio_panel->SetSizer (pad);
 290
 291         {
 292                 video_control (add_label_to_sizer (_audio_sizer, _audio_panel, "Audio Gain"));
 293                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 294                 _audio_gain = new wxSpinCtrl (_audio_panel);
 295                 s->Add (video_control (_audio_gain), 1);
 296                 video_control (add_label_to_sizer (s, _audio_panel, "dB"));
 297                 _audio_gain_calculate_button = new wxButton (_audio_panel, wxID_ANY, _("Calculate..."));
 298                 video_control (_audio_gain_calculate_button);
 299                 s->Add (_audio_gain_calculate_button, 1, wxEXPAND);
 300                 _audio_sizer->Add (s);
 301         }
 302
 303         {
 304                 video_control (add_label_to_sizer (_audio_sizer, _audio_panel, "Audio Delay"));
 305                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 306                 _audio_delay = new wxSpinCtrl (_audio_panel);
 307                 s->Add (video_control (_audio_delay), 1);
 308                 video_control (add_label_to_sizer (s, _audio_panel, "ms"));
 309                 _audio_sizer->Add (s);
 310         }
 311
 312         {
 313                 _use_content_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use content's audio"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
 314                 _audio_sizer->Add (video_control (_use_content_audio));
 315                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 316                 _audio_stream = new wxComboBox (_audio_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
 317                 s->Add (video_control (_audio_stream), 1);
 318                 _audio = new wxStaticText (_audio_panel, wxID_ANY, wxT (""));
 319                 s->Add (video_control (_audio), 1, wxALIGN_CENTER_VERTICAL | wxLEFT, 8);
 320                 _audio_sizer->Add (s, 1, wxEXPAND);
 321         }
 322
 323         _use_external_audio = new wxRadioButton (_audio_panel, wxID_ANY, _("Use external audio"));
 324         _audio_sizer->Add (_use_external_audio);
 325         _audio_sizer->AddSpacer (0);
 326
 327         assert (MAX_AUDIO_CHANNELS == 6);
 328
 329         char const * channels[] = {
 330                 "Left",
 331                 "Right",
 332                 "Centre",
 333                 "Lfe (sub)",
 334                 "Left surround",
 335                 "Right surround"
 336         };
 337
 338         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
 339                 add_label_to_sizer (_audio_sizer, _audio_panel, channels[i]);
 340                 _external_audio[i] = new wxFilePickerCtrl (_audio_panel, wxID_ANY, wxT (""), wxT ("Select Audio File"), wxT ("*.wav"));
 341                 _audio_sizer->Add (_external_audio[i], 1, wxEXPAND);
 342         }
 343
 344         _audio_gain->SetRange (-60, 60);
 345         _audio_delay->SetRange (-1000, 1000);
 346 }
 347
 348 void
 349 FilmEditor::make_subtitle_panel ()
 350 {
 351         _subtitle_panel = new wxPanel (_notebook);
 352         _subtitle_sizer = new wxFlexGridSizer (2, 4, 4);
 353         wxBoxSizer* pad = new wxBoxSizer (wxVERTICAL);
 354         pad->Add (_subtitle_sizer, 0, wxALL, 8);
 355         _subtitle_panel->SetSizer (pad);
 356
 357         _with_subtitles = new wxCheckBox (_subtitle_panel, wxID_ANY, wxT("With Subtitles"));
 358         video_control (_with_subtitles);
 359         _subtitle_sizer->Add (_with_subtitles, 1);
 360
 361         _subtitle_stream = new wxComboBox (_subtitle_panel, wxID_ANY, wxT (""), wxDefaultPosition, wxDefaultSize, 0, 0, wxCB_READONLY);
 362         _subtitle_sizer->Add (video_control (_subtitle_stream));
 363
 364         video_control (add_label_to_sizer (_subtitle_sizer, _subtitle_panel, "Subtitle Offset"));
 365         _subtitle_offset = new wxSpinCtrl (_subtitle_panel);
 366         _subtitle_sizer->Add (video_control (_subtitle_offset), 1);
 367
 368         {
 369                 video_control (add_label_to_sizer (_subtitle_sizer, _subtitle_panel, "Subtitle Scale"));
 370                 wxBoxSizer* s = new wxBoxSizer (wxHORIZONTAL);
 371                 _subtitle_scale = new wxSpinCtrl (_subtitle_panel);
 372                 s->Add (video_control (_subtitle_scale));
 373                 video_control (add_label_to_sizer (s, _subtitle_panel, "%"));
 374                 _subtitle_sizer->Add (s);
 375         }
 376
 377         _subtitle_offset->SetRange (-1024, 1024);
 378         _subtitle_scale->SetRange (1, 1000);
 379 }
 380
 381 /** Called when the left crop widget has been changed */
 382 void
 383 FilmEditor::left_crop_changed (wxCommandEvent &)
 384 {
 385         if (!_film) {
 386                 return;
 387         }
 388
 389         _film->set_left_crop (_left_crop->GetValue ());
 390 }
 391
 392 /** Called when the right crop widget has been changed */
 393 void
 394 FilmEditor::right_crop_changed (wxCommandEvent &)
 395 {
 396         if (!_film) {
 397                 return;
 398         }
 399
 400         _film->set_right_crop (_right_crop->GetValue ());
 401 }
 402
 403 /** Called when the top crop widget has been changed */
 404 void
 405 FilmEditor::top_crop_changed (wxCommandEvent &)
 406 {
 407         if (!_film) {
 408                 return;
 409         }
 410
 411         _film->set_top_crop (_top_crop->GetValue ());
 412 }
 413
 414 /** Called when the bottom crop value has been changed */
 415 void
 416 FilmEditor::bottom_crop_changed (wxCommandEvent &)
 417 {
 418         if (!_film) {
 419                 return;
 420         }
 421
 422         _film->set_bottom_crop (_bottom_crop->GetValue ());
 423 }
 424
 425 /** Called when the content filename has been changed */
 426 void
 427 FilmEditor::content_changed (wxCommandEvent &)
 428 {
 429         if (!_film) {
 430                 return;
 431         }
 432
 433         try {
 434                 _film->set_content (wx_to_std (_content->GetPath ()));
 435         } catch (std::exception& e) {
 436                 _content->SetPath (std_to_wx (_film->directory ()));
 437                 error_dialog (this, String::compose ("Could not set content: %1", e.what ()));
 438         }
 439 }
 440
 441 void
 442 FilmEditor::trust_content_header_changed (wxCommandEvent &)
 443 {
 444         if (!_film) {
 445                 return;
 446         }
 447
 448         _film->set_trust_content_header (_trust_content_header->GetValue ());
 449 }
 450
 451 /** Called when the DCP A/B switch has been toggled */
 452 void
 453 FilmEditor::dcp_ab_toggled (wxCommandEvent &)
 454 {
 455         if (!_film) {
 456                 return;
 457         }
 458
 459         _film->set_dcp_ab (_dcp_ab->GetValue ());
 460 }
 461
 462 void
 463 FilmEditor::encrypted_toggled (wxCommandEvent &)
 464 {
 465         if (!_film) {
 466                 return;
 467         }
 468
 469         _film->set_encrypted (_encrypted->GetValue ());
 470 }
 471
 472 /** Called when the name widget has been changed */
 473 void
 474 FilmEditor::name_changed (wxCommandEvent &)
 475 {
 476         if (!_film) {
 477                 return;
 478         }
 479
 480         _film->set_name (string (_name->GetValue().mb_str()));
 481 }
 482
 483 void
 484 FilmEditor::subtitle_offset_changed (wxCommandEvent &)
 485 {
 486         if (!_film) {
 487                 return;
 488         }
 489
 490         _film->set_subtitle_offset (_subtitle_offset->GetValue ());
 491 }
 492
 493 void
 494 FilmEditor::subtitle_scale_changed (wxCommandEvent &)
 495 {
 496         if (!_film) {
 497                 return;
 498         }
 499
 500         _film->set_subtitle_scale (_subtitle_scale->GetValue() / 100.0);
 501 }
 502
 503
 504 /** Called when the metadata stored in the Film object has changed;
 505  *  so that we can update the GUI.
 506  *  @param p Property of the Film that has changed.
 507  */
 508 void
 509 FilmEditor::film_changed (Film::Property p)
 510 {
 511         ensure_ui_thread ();
 512
 513         if (!_film) {
 514                 return;
 515         }
 516
 517         stringstream s;
 518
 519         switch (p) {
 520         case Film::NONE:
 521                 break;
 522         case Film::CONTENT:
 523                 checked_set (_content, _film->content ());
 524                 setup_visibility ();
 525                 setup_formats ();
 526                 setup_subtitle_control_sensitivity ();
 527                 setup_streams ();
 528                 break;
 529         case Film::TRUST_CONTENT_HEADER:
 530                 checked_set (_trust_content_header, _film->trust_content_header ());
 531                 break;
 532         case Film::SUBTITLE_STREAMS:
 533                 setup_subtitle_control_sensitivity ();
 534                 setup_streams ();
 535                 break;
 536         case Film::CONTENT_AUDIO_STREAMS:
 537                 setup_streams ();
 538                 break;
 539         case Film::FORMAT:
 540         {
 541                 int n = 0;
 542                 vector<Format const *>::iterator i = _formats.begin ();
 543                 while (i != _formats.end() && *i != _film->format ()) {
 544                         ++i;
 545                         ++n;
 546                 }
 547                 if (i == _formats.end()) {
 548                         checked_set (_format, -1);
 549                 } else {
 550                         checked_set (_format, n);
 551                 }
 552                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 553                 break;
 554         }
 555         case Film::CROP:
 556                 checked_set (_left_crop, _film->crop().left);
 557                 checked_set (_right_crop, _film->crop().right);
 558                 checked_set (_top_crop, _film->crop().top);
 559                 checked_set (_bottom_crop, _film->crop().bottom);
 560                 break;
 561         case Film::FILTERS:
 562         {
 563                 pair<string, string> p = Filter::ffmpeg_strings (_film->filters ());
 564                 if (p.first.empty () && p.second.empty ()) {
 565                         _filters->SetLabel (_("None"));
 566                 } else {
 567                         string const b = p.first + " " + p.second;
 568                         _filters->SetLabel (std_to_wx (b));
 569                 }
 570                 _film_sizer->Layout ();
 571                 break;
 572         }
 573         case Film::NAME:
 574                 checked_set (_name, _film->name());
 575                 _film->set_dci_date_today ();
 576                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 577                 break;
 578         case Film::FRAMES_PER_SECOND:
 579                 s << fixed << setprecision(2) << _film->frames_per_second();
 580                 _frames_per_second->SetLabel (std_to_wx (s.str ()));
 581                 break;
 582         case Film::SIZE:
 583                 if (_film->size().width == 0 && _film->size().height == 0) {
 584                         _original_size->SetLabel (wxT (""));
 585                 } else {
 586                         s << _film->size().width << " x " << _film->size().height;
 587                         _original_size->SetLabel (std_to_wx (s.str ()));
 588                 }
 589                 break;
 590         case Film::LENGTH:
 591                 if (_film->frames_per_second() > 0 && _film->length()) {
 592                         s << _film->length().get() << " frames; " << seconds_to_hms (_film->length().get() / _film->frames_per_second());
 593                 } else if (_film->length()) {
 594                         s << _film->length().get() << " frames";
 595                 }
 596                 _length->SetLabel (std_to_wx (s.str ()));
 597                 if (_film->length()) {
 598                         _dcp_trim_start->SetRange (0, _film->length().get());
 599                         _dcp_trim_end->SetRange (0, _film->length().get());
 600                 }
 601                 break;
 602         case Film::DCP_CONTENT_TYPE:
 603                 checked_set (_dcp_content_type, DCPContentType::as_index (_film->dcp_content_type ()));
 604                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 605                 break;
 606         case Film::DCP_AB:
 607                 checked_set (_dcp_ab, _film->dcp_ab ());
 608                 break;
 609         case Film::SCALER:
 610                 checked_set (_scaler, Scaler::as_index (_film->scaler ()));
 611                 break;
 612         case Film::DCP_TRIM_START:
 613                 checked_set (_dcp_trim_start, _film->dcp_trim_start());
 614                 break;
 615         case Film::DCP_TRIM_END:
 616                 checked_set (_dcp_trim_end, _film->dcp_trim_end());
 617                 break;
 618         case Film::AUDIO_GAIN:
 619                 checked_set (_audio_gain, _film->audio_gain ());
 620                 break;
 621         case Film::AUDIO_DELAY:
 622                 checked_set (_audio_delay, _film->audio_delay ());
 623                 break;
 624         case Film::STILL_DURATION:
 625                 checked_set (_still_duration, _film->still_duration ());
 626                 break;
 627         case Film::WITH_SUBTITLES:
 628                 checked_set (_with_subtitles, _film->with_subtitles ());
 629                 setup_subtitle_control_sensitivity ();
 630                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 631                 break;
 632         case Film::SUBTITLE_OFFSET:
 633                 checked_set (_subtitle_offset, _film->subtitle_offset ());
 634                 break;
 635         case Film::SUBTITLE_SCALE:
 636                 checked_set (_subtitle_scale, _film->subtitle_scale() * 100);
 637                 break;
 638         case Film::ENCRYPTED:
 639                 checked_set (_encrypted, _film->encrypted ());
 640                 break;
 641         case Film::USE_DCI_NAME:
 642                 checked_set (_use_dci_name, _film->use_dci_name ());
 643                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 644                 break;
 645         case Film::DCI_METADATA:
 646                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 647                 break;
 648         case Film::CONTENT_AUDIO_STREAM:
 649                 if (_film->content_audio_stream()) {
 650                         checked_set (_audio_stream, _film->content_audio_stream()->to_string());
 651                 }
 652                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 653                 setup_audio_details ();
 654                 setup_audio_control_sensitivity ();
 655                 break;
 656         case Film::USE_CONTENT_AUDIO:
 657                 checked_set (_use_content_audio, _film->use_content_audio());
 658                 checked_set (_use_external_audio, !_film->use_content_audio());
 659                 _dcp_name->SetLabel (std_to_wx (_film->dcp_name ()));
 660                 setup_audio_details ();
 661                 setup_audio_control_sensitivity ();
 662                 break;
 663         case Film::SUBTITLE_STREAM:
 664                 if (_film->subtitle_stream()) {
 665                         checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
 666                 }
 667                 break;
 668         case Film::EXTERNAL_AUDIO:
 669         {
 670                 vector<string> a = _film->external_audio ();
 671                 for (size_t i = 0; i < a.size() && i < MAX_AUDIO_CHANNELS; ++i) {
 672                         checked_set (_external_audio[i], a[i]);
 673                 }
 674                 setup_audio_details ();
 675                 break;
 676         }
 677         }
 678 }
 679
 680 /** Called when the format widget has been changed */
 681 void
 682 FilmEditor::format_changed (wxCommandEvent &)
 683 {
 684         if (!_film) {
 685                 return;
 686         }
 687
 688         int const n = _format->GetSelection ();
 689         if (n >= 0) {
 690                 assert (n < int (_formats.size()));
 691                 _film->set_format (_formats[n]);
 692         }
 693 }
 694
 695 /** Called when the DCP content type widget has been changed */
 696 void
 697 FilmEditor::dcp_content_type_changed (wxCommandEvent &)
 698 {
 699         if (!_film) {
 700                 return;
 701         }
 702
 703         int const n = _dcp_content_type->GetSelection ();
 704         if (n != wxNOT_FOUND) {
 705                 _film->set_dcp_content_type (DCPContentType::from_index (n));
 706         }
 707 }
 708
 709 /** Sets the Film that we are editing */
 710 void
 711 FilmEditor::set_film (shared_ptr<Film> f)
 712 {
 713         _film = f;
 714
 715         set_things_sensitive (_film != 0);
 716
 717         if (_film) {
 718                 _film->Changed.connect (bind (&FilmEditor::film_changed, this, _1));
 719         }
 720
 721         if (_film) {
 722                 FileChanged (_film->directory ());
 723         } else {
 724                 FileChanged ("");
 725         }
 726
 727         film_changed (Film::NAME);
 728         film_changed (Film::USE_DCI_NAME);
 729         film_changed (Film::CONTENT);
 730         film_changed (Film::TRUST_CONTENT_HEADER);
 731         film_changed (Film::DCP_CONTENT_TYPE);
 732         film_changed (Film::FORMAT);
 733         film_changed (Film::CROP);
 734         film_changed (Film::FILTERS);
 735         film_changed (Film::SCALER);
 736         film_changed (Film::DCP_TRIM_START);
 737         film_changed (Film::DCP_TRIM_END);
 738         film_changed (Film::DCP_AB);
 739         film_changed (Film::CONTENT_AUDIO_STREAM);
 740         film_changed (Film::EXTERNAL_AUDIO);
 741         film_changed (Film::USE_CONTENT_AUDIO);
 742         film_changed (Film::AUDIO_GAIN);
 743         film_changed (Film::AUDIO_DELAY);
 744         film_changed (Film::STILL_DURATION);
 745         film_changed (Film::WITH_SUBTITLES);
 746         film_changed (Film::SUBTITLE_OFFSET);
 747         film_changed (Film::SUBTITLE_SCALE);
 748         film_changed (Film::ENCRYPTED);
 749         film_changed (Film::DCI_METADATA);
 750         film_changed (Film::SIZE);
 751         film_changed (Film::LENGTH);
 752         film_changed (Film::CONTENT_AUDIO_STREAMS);
 753         film_changed (Film::SUBTITLE_STREAMS);
 754         film_changed (Film::FRAMES_PER_SECOND);
 755 }
 756
 757 /** Updates the sensitivity of lots of widgets to a given value.
 758  *  @param s true to make sensitive, false to make insensitive.
 759  */
 760 void
 761 FilmEditor::set_things_sensitive (bool s)
 762 {
 763         _generally_sensitive = s;
 764
 765         _name->Enable (s);
 766         _use_dci_name->Enable (s);
 767         _edit_dci_button->Enable (s);
 768         _format->Enable (s);
 769         _content->Enable (s);
 770         _trust_content_header->Enable (s);
 771         _left_crop->Enable (s);
 772         _right_crop->Enable (s);
 773         _top_crop->Enable (s);
 774         _bottom_crop->Enable (s);
 775         _filters_button->Enable (s);
 776         _scaler->Enable (s);
 777         _audio_stream->Enable (s);
 778         _dcp_content_type->Enable (s);
 779         _dcp_trim_start->Enable (s);
 780         _dcp_trim_end->Enable (s);
 781         _dcp_ab->Enable (s);
 782         _encrypted->Enable (s);
 783         _audio_gain->Enable (s);
 784         _audio_gain_calculate_button->Enable (s);
 785         _audio_delay->Enable (s);
 786         _still_duration->Enable (s);
 787
 788         setup_subtitle_control_sensitivity ();
 789         setup_audio_control_sensitivity ();
 790 }
 791
 792 /** Called when the `Edit filters' button has been clicked */
 793 void
 794 FilmEditor::edit_filters_clicked (wxCommandEvent &)
 795 {
 796         FilterDialog* d = new FilterDialog (this, _film->filters());
 797         d->ActiveChanged.connect (bind (&Film::set_filters, _film, _1));
 798         d->ShowModal ();
 799         d->Destroy ();
 800 }
 801
 802 /** Called when the scaler widget has been changed */
 803 void
 804 FilmEditor::scaler_changed (wxCommandEvent &)
 805 {
 806         if (!_film) {
 807                 return;
 808         }
 809
 810         int const n = _scaler->GetSelection ();
 811         if (n >= 0) {
 812                 _film->set_scaler (Scaler::from_index (n));
 813         }
 814 }
 815
 816 void
 817 FilmEditor::audio_gain_changed (wxCommandEvent &)
 818 {
 819         if (!_film) {
 820                 return;
 821         }
 822
 823         _film->set_audio_gain (_audio_gain->GetValue ());
 824 }
 825
 826 void
 827 FilmEditor::audio_delay_changed (wxCommandEvent &)
 828 {
 829         if (!_film) {
 830                 return;
 831         }
 832
 833         _film->set_audio_delay (_audio_delay->GetValue ());
 834 }
 835
 836 wxControl *
 837 FilmEditor::video_control (wxControl* c)
 838 {
 839         _video_controls.push_back (c);
 840         return c;
 841 }
 842
 843 wxControl *
 844 FilmEditor::still_control (wxControl* c)
 845 {
 846         _still_controls.push_back (c);
 847         return c;
 848 }
 849
 850 void
 851 FilmEditor::setup_visibility ()
 852 {
 853         ContentType c = VIDEO;
 854
 855         if (_film) {
 856                 c = _film->content_type ();
 857         }
 858
 859         for (list<wxControl*>::iterator i = _video_controls.begin(); i != _video_controls.end(); ++i) {
 860                 (*i)->Show (c == VIDEO);
 861         }
 862
 863         for (list<wxControl*>::iterator i = _still_controls.begin(); i != _still_controls.end(); ++i) {
 864                 (*i)->Show (c == STILL);
 865         }
 866
 867         _notebook->InvalidateBestSize ();
 868
 869         _film_sizer->Layout ();
 870         _film_sizer->SetSizeHints (_film_panel);
 871         _video_sizer->Layout ();
 872         _video_sizer->SetSizeHints (_video_panel);
 873         _audio_sizer->Layout ();
 874         _audio_sizer->SetSizeHints (_audio_panel);
 875         _subtitle_sizer->Layout ();
 876         _subtitle_sizer->SetSizeHints (_subtitle_panel);
 877
 878         _notebook->Fit ();
 879         Fit ();
 880 }
 881
 882 void
 883 FilmEditor::still_duration_changed (wxCommandEvent &)
 884 {
 885         if (!_film) {
 886                 return;
 887         }
 888
 889         _film->set_still_duration (_still_duration->GetValue ());
 890 }
 891
 892 void
 893 FilmEditor::dcp_trim_start_changed (wxCommandEvent &)
 894 {
 895         if (!_film) {
 896                 return;
 897         }
 898
 899         _film->set_dcp_trim_start (_dcp_trim_start->GetValue ());
 900 }
 901
 902 void
 903 FilmEditor::dcp_trim_end_changed (wxCommandEvent &)
 904 {
 905         if (!_film) {
 906                 return;
 907         }
 908
 909         _film->set_dcp_trim_end (_dcp_trim_end->GetValue ());
 910 }
 911
 912 void
 913 FilmEditor::audio_gain_calculate_button_clicked (wxCommandEvent &)
 914 {
 915         GainCalculatorDialog* d = new GainCalculatorDialog (this);
 916         d->ShowModal ();
 917
 918         if (d->wanted_fader() == 0 || d->actual_fader() == 0) {
 919                 d->Destroy ();
 920                 return;
 921         }
 922
 923         _audio_gain->SetValue (
 924                 Config::instance()->sound_processor()->db_for_fader_change (
 925                         d->wanted_fader (),
 926                         d->actual_fader ()
 927                         )
 928                 );
 929
 930         /* This appears to be necessary, as the change is not signalled,
 931            I think.
 932         */
 933         wxCommandEvent dummy;
 934         audio_gain_changed (dummy);
 935
 936         d->Destroy ();
 937 }
 938
 939 void
 940 FilmEditor::setup_formats ()
 941 {
 942         ContentType c = VIDEO;
 943
 944         if (_film) {
 945                 c = _film->content_type ();
 946         }
 947
 948         _formats.clear ();
 949
 950         vector<Format const *> fmt = Format::all ();
 951         for (vector<Format const *>::iterator i = fmt.begin(); i != fmt.end(); ++i) {
 952                 if (c == VIDEO && dynamic_cast<FixedFormat const *> (*i)) {
 953                         _formats.push_back (*i);
 954                 } else if (c == STILL && dynamic_cast<VariableFormat const *> (*i)) {
 955                         _formats.push_back (*i);
 956                 }
 957         }
 958
 959         _format->Clear ();
 960         for (vector<Format const *>::iterator i = _formats.begin(); i != _formats.end(); ++i) {
 961                 _format->Append (std_to_wx ((*i)->name ()));
 962         }
 963
 964         _film_sizer->Layout ();
 965 }
 966
 967 void
 968 FilmEditor::with_subtitles_toggled (wxCommandEvent &)
 969 {
 970         if (!_film) {
 971                 return;
 972         }
 973
 974         _film->set_with_subtitles (_with_subtitles->GetValue ());
 975 }
 976
 977 void
 978 FilmEditor::setup_subtitle_control_sensitivity ()
 979 {
 980         bool h = false;
 981         if (_generally_sensitive && _film) {
 982                 h = !_film->subtitle_streams().empty();
 983         }
 984
 985         _with_subtitles->Enable (h);
 986
 987         bool j = false;
 988         if (_film) {
 989                 j = _film->with_subtitles ();
 990         }
 991
 992         _subtitle_stream->Enable (j);
 993         _subtitle_offset->Enable (j);
 994         _subtitle_scale->Enable (j);
 995 }
 996
 997 void
 998 FilmEditor::setup_audio_control_sensitivity ()
 999 {
1000         _use_content_audio->Enable (_generally_sensitive);
1001         _use_external_audio->Enable (_generally_sensitive);
1002
1003         bool const source = _generally_sensitive && _use_content_audio->GetValue();
1004         bool const external = _generally_sensitive && _use_external_audio->GetValue();
1005
1006         _audio_stream->Enable (source);
1007         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
1008                 _external_audio[i]->Enable (external);
1009         }
1010 }
1011
1012 void
1013 FilmEditor::use_dci_name_toggled (wxCommandEvent &)
1014 {
1015         if (!_film) {
1016                 return;
1017         }
1018
1019         _film->set_use_dci_name (_use_dci_name->GetValue ());
1020 }
1021
1022 void
1023 FilmEditor::edit_dci_button_clicked (wxCommandEvent &)
1024 {
1025         if (!_film) {
1026                 return;
1027         }
1028
1029         DCINameDialog* d = new DCINameDialog (this, _film);
1030         d->ShowModal ();
1031         d->Destroy ();
1032 }
1033
1034 void
1035 FilmEditor::setup_streams ()
1036 {
1037         _audio_stream->Clear ();
1038         vector<shared_ptr<AudioStream> > a = _film->content_audio_streams ();
1039         for (vector<shared_ptr<AudioStream> >::iterator i = a.begin(); i != a.end(); ++i) {
1040                 shared_ptr<FFmpegAudioStream> ffa = dynamic_pointer_cast<FFmpegAudioStream> (*i);
1041                 assert (ffa);
1042                 _audio_stream->Append (std_to_wx (ffa->name()), new wxStringClientData (std_to_wx (ffa->to_string ())));
1043         }
1044
1045         if (_film->use_content_audio() && _film->audio_stream()) {
1046                 checked_set (_audio_stream, _film->audio_stream()->to_string());
1047         }
1048
1049         _subtitle_stream->Clear ();
1050         vector<shared_ptr<SubtitleStream> > s = _film->subtitle_streams ();
1051         for (vector<shared_ptr<SubtitleStream> >::iterator i = s.begin(); i != s.end(); ++i) {
1052                 _subtitle_stream->Append (std_to_wx ((*i)->name()), new wxStringClientData (std_to_wx ((*i)->to_string ())));
1053         }
1054         if (_film->subtitle_stream()) {
1055                 checked_set (_subtitle_stream, _film->subtitle_stream()->to_string());
1056         } else {
1057                 _subtitle_stream->SetValue (wxT (""));
1058         }
1059 }
1060
1061 void
1062 FilmEditor::audio_stream_changed (wxCommandEvent &)
1063 {
1064         if (!_film) {
1065                 return;
1066         }
1067
1068         _film->set_content_audio_stream (
1069                 audio_stream_factory (
1070                         string_client_data (_audio_stream->GetClientObject (_audio_stream->GetSelection ())),
1071                         Film::state_version
1072                         )
1073                 );
1074 }
1075
1076 void
1077 FilmEditor::subtitle_stream_changed (wxCommandEvent &)
1078 {
1079         if (!_film) {
1080                 return;
1081         }
1082
1083         _film->set_subtitle_stream (
1084                 subtitle_stream_factory (
1085                         string_client_data (_subtitle_stream->GetClientObject (_subtitle_stream->GetSelection ())),
1086                         Film::state_version
1087                         )
1088                 );
1089 }
1090
1091 void
1092 FilmEditor::setup_audio_details ()
1093 {
1094         if (!_film->audio_stream()) {
1095                 _audio->SetLabel (wxT (""));
1096         } else {
1097                 stringstream s;
1098                 if (_film->audio_stream()->channels() == 1) {
1099                         s << "1 channel";
1100                 } else {
1101                         s << _film->audio_stream()->channels () << " channels";
1102                 }
1103                 s << ", " << _film->audio_stream()->sample_rate() << "Hz";
1104                 _audio->SetLabel (std_to_wx (s.str ()));
1105         }
1106 }
1107
1108 void
1109 FilmEditor::active_jobs_changed (bool a)
1110 {
1111         set_things_sensitive (!a);
1112 }
1113
1114 void
1115 FilmEditor::use_audio_changed (wxCommandEvent &)
1116 {
1117         _film->set_use_content_audio (_use_content_audio->GetValue());
1118 }
1119
1120 void
1121 FilmEditor::external_audio_changed (wxCommandEvent &)
1122 {
1123         vector<string> a;
1124         for (int i = 0; i < MAX_AUDIO_CHANNELS; ++i) {
1125                 a.push_back (wx_to_std (_external_audio[i]->GetPath()));
1126         }
1127
1128         _film->set_external_audio (a);
1129 }