src/gtk/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 GTK widget to edit a film's metadata, and perform various functions.
  22  */
  23
  24 #include <iostream>
  25 #include <gtkmm.h>
  26 #include <boost/thread.hpp>
  27 #include <boost/filesystem.hpp>
  28 #include "lib/format.h"
  29 #include "lib/film.h"
  30 #include "lib/transcode_job.h"
  31 #include "lib/exceptions.h"
  32 #include "lib/ab_transcode_job.h"
  33 #include "lib/thumbs_job.h"
  34 #include "lib/make_mxf_job.h"
  35 #include "lib/job_manager.h"
  36 #include "lib/filter.h"
  37 #include "lib/screen.h"
  38 #include "lib/config.h"
  39 #include "lib/scp_dcp_job.h"
  40 #include "filter_dialog.h"
  41 #include "gtk_util.h"
  42 #include "film_editor.h"
  43 #include "dcp_range_dialog.h"
  44
  45 using namespace std;
  46 using namespace boost;
  47 using namespace Gtk;
  48
  49 /** @param f Film to edit */
  50 FilmEditor::FilmEditor (Film* f)
  51         : _film (f)
  52         , _filters_button ("Edit...")
  53         , _change_dcp_range_button ("Edit...")
  54         , _dcp_ab ("A/B")
  55 {
  56         _vbox.set_border_width (12);
  57         _vbox.set_spacing (12);
  58
  59         /* Set up our editing widgets */
  60         _left_crop.set_range (0, 1024);
  61         _left_crop.set_increments (1, 16);
  62         _top_crop.set_range (0, 1024);
  63         _top_crop.set_increments (1, 16);
  64         _right_crop.set_range (0, 1024);
  65         _right_crop.set_increments (1, 16);
  66         _bottom_crop.set_range (0, 1024);
  67         _bottom_crop.set_increments (1, 16);
  68         _filters.set_alignment (0, 0.5);
  69         _audio_gain.set_range (-60, 60);
  70         _audio_gain.set_increments (1, 3);
  71         _audio_delay.set_range (-1000, 1000);
  72         _audio_delay.set_increments (1, 20);
  73         _still_duration.set_range (0, 60 * 60);
  74         _still_duration.set_increments (1, 5);
  75         _dcp_range.set_alignment (0, 0.5);
  76
  77         vector<Format const *> fmt = Format::all ();
  78         for (vector<Format const *>::iterator i = fmt.begin(); i != fmt.end(); ++i) {
  79                 _format.append_text ((*i)->name ());
  80         }
  81
  82         _frames_per_second.set_increments (1, 5);
  83         _frames_per_second.set_digits (2);
  84         _frames_per_second.set_range (0, 60);
  85
  86         vector<DCPContentType const *> const ct = DCPContentType::all ();
  87         for (vector<DCPContentType const *>::const_iterator i = ct.begin(); i != ct.end(); ++i) {
  88                 _dcp_content_type.append_text ((*i)->pretty_name ());
  89         }
  90
  91         vector<Scaler const *> const sc = Scaler::all ();
  92         for (vector<Scaler const *>::const_iterator i = sc.begin(); i != sc.end(); ++i) {
  93                 _scaler.append_text ((*i)->name ());
  94         }
  95
  96         _original_size.set_alignment (0, 0.5);
  97         _length.set_alignment (0, 0.5);
  98         _audio.set_alignment (0, 0.5);
  99
 100         /* And set their values from the Film */
 101         set_film (f);
 102
 103         /* Now connect to them, since initial values are safely set */
 104         _name.signal_changed().connect (sigc::mem_fun (*this, &FilmEditor::name_changed));
 105         _frames_per_second.signal_changed().connect (sigc::mem_fun (*this, &FilmEditor::frames_per_second_changed));
 106         _format.signal_changed().connect (sigc::mem_fun (*this, &FilmEditor::format_changed));
 107         _content.signal_file_set().connect (sigc::mem_fun (*this, &FilmEditor::content_changed));
 108         _left_crop.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::left_crop_changed));
 109         _right_crop.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::right_crop_changed));
 110         _top_crop.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::top_crop_changed));
 111         _bottom_crop.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::bottom_crop_changed));
 112         _filters_button.signal_clicked().connect (sigc::mem_fun (*this, &FilmEditor::edit_filters_clicked));
 113         _scaler.signal_changed().connect (sigc::mem_fun (*this, &FilmEditor::scaler_changed));
 114         _dcp_content_type.signal_changed().connect (sigc::mem_fun (*this, &FilmEditor::dcp_content_type_changed));
 115         _dcp_ab.signal_toggled().connect (sigc::mem_fun (*this, &FilmEditor::dcp_ab_toggled));
 116         _audio_gain.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::audio_gain_changed));
 117         _audio_delay.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::audio_delay_changed));
 118         _still_duration.signal_value_changed().connect (sigc::mem_fun (*this, &FilmEditor::still_duration_changed));
 119         _change_dcp_range_button.signal_clicked().connect (sigc::mem_fun (*this, &FilmEditor::change_dcp_range_clicked));
 120
 121         /* Set up the table */
 122
 123         Table* t = manage (new Table);
 124
 125         t->set_row_spacings (4);
 126         t->set_col_spacings (12);
 127
 128         int n = 0;
 129         t->attach (left_aligned_label ("Name"), 0, 1, n, n + 1);
 130         t->attach (_name, 1, 2, n, n + 1);
 131         ++n;
 132         t->attach (left_aligned_label ("Content"), 0, 1, n, n + 1);
 133         t->attach (_content, 1, 2, n, n + 1);
 134         ++n;
 135         t->attach (left_aligned_label ("Content Type"), 0, 1, n, n + 1);
 136         t->attach (_dcp_content_type, 1, 2, n, n + 1);
 137         ++n;
 138         t->attach (video_widget (left_aligned_label ("Frames Per Second")), 0, 1, n, n + 1);
 139         t->attach (video_widget (_frames_per_second), 1, 2, n, n + 1);
 140         ++n;
 141         t->attach (left_aligned_label ("Format"), 0, 1, n, n + 1);
 142         t->attach (_format, 1, 2, n, n + 1);
 143         ++n;
 144         t->attach (left_aligned_label ("Crop"), 0, 1, n, n + 1);
 145         HBox* c = manage (new HBox);
 146         c->set_spacing (4);
 147         c->pack_start (left_aligned_label ("L"), false, false);
 148         c->pack_start (_left_crop, true, true);
 149         c->pack_start (left_aligned_label ("R"), false, false);
 150         c->pack_start (_right_crop, true, true);
 151         c->pack_start (left_aligned_label ("T"), false, false);
 152         c->pack_start (_top_crop, true, true);
 153         c->pack_start (left_aligned_label ("B"), false, false);
 154         c->pack_start (_bottom_crop, true, true);
 155         t->attach (*c, 1, 2, n, n + 1);
 156         ++n;
 157
 158         /* VIDEO-only stuff */
 159         int const special = n;
 160         t->attach (video_widget (left_aligned_label ("Filters")), 0, 1, n, n + 1);
 161         HBox* fb = manage (new HBox);
 162         fb->set_spacing (4);
 163         fb->pack_start (video_widget (_filters), true, true);
 164         fb->pack_start (video_widget (_filters_button), false, false);
 165         t->attach (*fb, 1, 2, n, n + 1);
 166         ++n;
 167         t->attach (video_widget (left_aligned_label ("Scaler")), 0, 1, n, n + 1);
 168         t->attach (video_widget (_scaler), 1, 2, n, n + 1);
 169         ++n;
 170         t->attach (video_widget (left_aligned_label ("Audio Gain")), 0, 1, n, n + 1);
 171         t->attach (video_widget (_audio_gain), 1, 2, n, n + 1);
 172         t->attach (video_widget (left_aligned_label ("dB")), 2, 3, n, n + 1);
 173         ++n;
 174         t->attach (video_widget (left_aligned_label ("Audio Delay")), 0, 1, n, n + 1);
 175         t->attach (video_widget (_audio_delay), 1, 2, n, n + 1);
 176         t->attach (video_widget (left_aligned_label ("ms")), 2, 3, n, n + 1);
 177         ++n;
 178         t->attach (video_widget (left_aligned_label ("Original Size")), 0, 1, n, n + 1);
 179         t->attach (video_widget (_original_size), 1, 2, n, n + 1);
 180         ++n;
 181         t->attach (video_widget (left_aligned_label ("Length")), 0, 1, n, n + 1);
 182         t->attach (video_widget (_length), 1, 2, n, n + 1);
 183         ++n;
 184         t->attach (video_widget (left_aligned_label ("Audio")), 0, 1, n, n + 1);
 185         t->attach (video_widget (_audio), 1, 2, n, n + 1);
 186         ++n;
 187         t->attach (video_widget (left_aligned_label ("Range")), 0, 1, n, n + 1);
 188         Gtk::HBox* db = manage (new Gtk::HBox);
 189         db->pack_start (_dcp_range, true, true);
 190         db->pack_start (_change_dcp_range_button, false, false);
 191         t->attach (*db, 1, 2, n, n + 1);
 192         ++n;
 193         t->attach (_dcp_ab, 0, 3, n, n + 1);
 194
 195         /* STILL-only stuff */
 196         n = special;
 197         t->attach (still_widget (left_aligned_label ("Duration")), 0, 1, n, n + 1);
 198         t->attach (still_widget (_still_duration), 1, 2, n, n + 1);
 199         t->attach (still_widget (left_aligned_label ("s")), 2, 3, n, n + 1);
 200         ++n;
 201
 202         t->show_all ();
 203         _vbox.pack_start (*t, false, false);
 204 }
 205
 206 /** @return Our main widget, which contains everything else */
 207 Widget&
 208 FilmEditor::widget ()
 209 {
 210         return _vbox;
 211 }
 212
 213 /** Called when the left crop widget has been changed */
 214 void
 215 FilmEditor::left_crop_changed ()
 216 {
 217         if (_film) {
 218                 _film->set_left_crop (_left_crop.get_value ());
 219         }
 220 }
 221
 222 /** Called when the right crop widget has been changed */
 223 void
 224 FilmEditor::right_crop_changed ()
 225 {
 226         if (_film) {
 227                 _film->set_right_crop (_right_crop.get_value ());
 228         }
 229 }
 230
 231 /** Called when the top crop widget has been changed */
 232 void
 233 FilmEditor::top_crop_changed ()
 234 {
 235         if (_film) {
 236                 _film->set_top_crop (_top_crop.get_value ());
 237         }
 238 }
 239
 240 /** Called when the bottom crop value has been changed */
 241 void
 242 FilmEditor::bottom_crop_changed ()
 243 {
 244         if (_film) {
 245                 _film->set_bottom_crop (_bottom_crop.get_value ());
 246         }
 247 }
 248
 249 /** Called when the content filename has been changed */
 250 void
 251 FilmEditor::content_changed ()
 252 {
 253         if (!_film) {
 254                 return;
 255         }
 256
 257         try {
 258                 _film->set_content (_content.get_filename ());
 259         } catch (std::exception& e) {
 260                 _content.set_filename (_film->directory ());
 261                 stringstream m;
 262                 m << "Could not set content: " << e.what() << ".";
 263                 Gtk::MessageDialog d (m.str(), false, MESSAGE_ERROR);
 264                 d.set_title ("DVD-o-matic");
 265                 d.run ();
 266         }
 267 }
 268
 269 /** Called when the DCP A/B switch has been toggled */
 270 void
 271 FilmEditor::dcp_ab_toggled ()
 272 {
 273         if (_film) {
 274                 _film->set_dcp_ab (_dcp_ab.get_active ());
 275         }
 276 }
 277
 278 /** Called when the name widget has been changed */
 279 void
 280 FilmEditor::name_changed ()
 281 {
 282         if (_film) {
 283                 _film->set_name (_name.get_text ());
 284         }
 285 }
 286
 287 /** Called when the metadata stored in the Film object has changed;
 288  *  so that we can update the GUI.
 289  *  @param p Property of the Film that has changed.
 290  */
 291 void
 292 FilmEditor::film_changed (Film::Property p)
 293 {
 294         if (!_film) {
 295                 return;
 296         }
 297
 298         stringstream s;
 299
 300         switch (p) {
 301         case Film::CONTENT:
 302                 _content.set_filename (_film->content ());
 303                 setup_visibility ();
 304                 break;
 305         case Film::FORMAT:
 306                 _format.set_active (Format::as_index (_film->format ()));
 307                 break;
 308         case Film::LEFT_CROP:
 309                 _left_crop.set_value (_film->left_crop ());
 310                 break;
 311         case Film::RIGHT_CROP:
 312                 _right_crop.set_value (_film->right_crop ());
 313                 break;
 314         case Film::TOP_CROP:
 315                 _top_crop.set_value (_film->top_crop ());
 316                 break;
 317         case Film::BOTTOM_CROP:
 318                 _bottom_crop.set_value (_film->bottom_crop ());
 319                 break;
 320         case Film::FILTERS:
 321         {
 322                 pair<string, string> p = Filter::ffmpeg_strings (_film->filters ());
 323                 _filters.set_text (p.first + " " + p.second);
 324                 break;
 325         }
 326         case Film::NAME:
 327                 _name.set_text (_film->name ());
 328                 break;
 329         case Film::FRAMES_PER_SECOND:
 330                 _frames_per_second.set_value (_film->frames_per_second ());
 331                 break;
 332         case Film::AUDIO_CHANNELS:
 333         case Film::AUDIO_SAMPLE_RATE:
 334                 s << _film->audio_channels () << " channels, " << _film->audio_sample_rate() << "Hz";
 335                 _audio.set_text (s.str ());
 336                 break;
 337         case Film::SIZE:
 338                 s << _film->size().width << " x " << _film->size().height;
 339                 _original_size.set_text (s.str ());
 340                 break;
 341         case Film::LENGTH:
 342                 if (_film->frames_per_second() > 0) {
 343                         s << _film->length() << " frames; " << seconds_to_hms (_film->length() / _film->frames_per_second());
 344                 } else {
 345                         s << _film->length() << " frames";
 346                 }
 347                 _length.set_text (s.str ());
 348                 break;
 349         case Film::DCP_CONTENT_TYPE:
 350                 _dcp_content_type.set_active (DCPContentType::as_index (_film->dcp_content_type ()));
 351                 break;
 352         case Film::THUMBS:
 353                 break;
 354         case Film::DCP_FRAMES:
 355                 if (_film->dcp_frames() == 0) {
 356                         _dcp_range.set_text ("Whole film");
 357                 } else {
 358                         stringstream s;
 359                         s << "First " << _film->dcp_frames() << " frames";
 360                         _dcp_range.set_text (s.str ());
 361                 }
 362                 break;
 363         case Film::DCP_TRIM_ACTION:
 364                 break;
 365         case Film::DCP_AB:
 366                 _dcp_ab.set_active (_film->dcp_ab ());
 367                 break;
 368         case Film::SCALER:
 369                 _scaler.set_active (Scaler::as_index (_film->scaler ()));
 370                 break;
 371         case Film::AUDIO_GAIN:
 372                 _audio_gain.set_value (_film->audio_gain ());
 373                 break;
 374         case Film::AUDIO_DELAY:
 375                 _audio_delay.set_value (_film->audio_delay ());
 376                 break;
 377         case Film::STILL_DURATION:
 378                 _still_duration.set_value (_film->still_duration ());
 379                 break;
 380         }
 381 }
 382
 383 /** Called when the format widget has been changed */
 384 void
 385 FilmEditor::format_changed ()
 386 {
 387         if (_film) {
 388                 int const n = _format.get_active_row_number ();
 389                 if (n >= 0) {
 390                         _film->set_format (Format::from_index (n));
 391                 }
 392         }
 393 }
 394
 395 /** Called when the DCP content type widget has been changed */
 396 void
 397 FilmEditor::dcp_content_type_changed ()
 398 {
 399         if (_film) {
 400                 int const n = _dcp_content_type.get_active_row_number ();
 401                 if (n >= 0) {
 402                         _film->set_dcp_content_type (DCPContentType::from_index (n));
 403                 }
 404         }
 405 }
 406
 407 /** Sets the Film that we are editing */
 408 void
 409 FilmEditor::set_film (Film* f)
 410 {
 411         _film = f;
 412
 413         set_things_sensitive (_film != 0);
 414
 415         if (_film) {
 416                 _film->Changed.connect (sigc::mem_fun (*this, &FilmEditor::film_changed));
 417         }
 418
 419         if (_film) {
 420                 FileChanged (_film->directory ());
 421         } else {
 422                 FileChanged ("");
 423         }
 424
 425         film_changed (Film::NAME);
 426         film_changed (Film::CONTENT);
 427         film_changed (Film::DCP_CONTENT_TYPE);
 428         film_changed (Film::FORMAT);
 429         film_changed (Film::LEFT_CROP);
 430         film_changed (Film::RIGHT_CROP);
 431         film_changed (Film::TOP_CROP);
 432         film_changed (Film::BOTTOM_CROP);
 433         film_changed (Film::FILTERS);
 434         film_changed (Film::DCP_FRAMES);
 435         film_changed (Film::DCP_TRIM_ACTION);
 436         film_changed (Film::DCP_AB);
 437         film_changed (Film::SIZE);
 438         film_changed (Film::LENGTH);
 439         film_changed (Film::FRAMES_PER_SECOND);
 440         film_changed (Film::AUDIO_CHANNELS);
 441         film_changed (Film::AUDIO_SAMPLE_RATE);
 442         film_changed (Film::SCALER);
 443         film_changed (Film::AUDIO_GAIN);
 444         film_changed (Film::AUDIO_DELAY);
 445         film_changed (Film::STILL_DURATION);
 446 }
 447
 448 /** Updates the sensitivity of lots of widgets to a given value.
 449  *  @param s true to make sensitive, false to make insensitive.
 450  */
 451 void
 452 FilmEditor::set_things_sensitive (bool s)
 453 {
 454         _name.set_sensitive (s);
 455         _frames_per_second.set_sensitive (s);
 456         _format.set_sensitive (s);
 457         _content.set_sensitive (s);
 458         _left_crop.set_sensitive (s);
 459         _right_crop.set_sensitive (s);
 460         _top_crop.set_sensitive (s);
 461         _bottom_crop.set_sensitive (s);
 462         _filters_button.set_sensitive (s);
 463         _scaler.set_sensitive (s);
 464         _dcp_content_type.set_sensitive (s);
 465         _dcp_range.set_sensitive (s);
 466         _change_dcp_range_button.set_sensitive (s);
 467         _dcp_ab.set_sensitive (s);
 468         _audio_gain.set_sensitive (s);
 469         _audio_delay.set_sensitive (s);
 470         _still_duration.set_sensitive (s);
 471 }
 472
 473 /** Called when the `Edit filters' button has been clicked */
 474 void
 475 FilmEditor::edit_filters_clicked ()
 476 {
 477         FilterDialog d (_film->filters ());
 478         d.ActiveChanged.connect (sigc::mem_fun (*_film, &Film::set_filters));
 479         d.run ();
 480 }
 481
 482 /** Called when the scaler widget has been changed */
 483 void
 484 FilmEditor::scaler_changed ()
 485 {
 486         if (_film) {
 487                 int const n = _scaler.get_active_row_number ();
 488                 if (n >= 0) {
 489                         _film->set_scaler (Scaler::from_index (n));
 490                 }
 491         }
 492 }
 493
 494 /** Called when the frames per second widget has been changed */
 495 void
 496 FilmEditor::frames_per_second_changed ()
 497 {
 498         if (_film) {
 499                 _film->set_frames_per_second (_frames_per_second.get_value ());
 500         }
 501 }
 502
 503 void
 504 FilmEditor::audio_gain_changed ()
 505 {
 506         if (_film) {
 507                 _film->set_audio_gain (_audio_gain.get_value ());
 508         }
 509 }
 510
 511 void
 512 FilmEditor::audio_delay_changed ()
 513 {
 514         if (_film) {
 515                 _film->set_audio_delay (_audio_delay.get_value ());
 516         }
 517 }
 518
 519 Widget&
 520 FilmEditor::video_widget (Widget& w)
 521 {
 522         _video_widgets.push_back (&w);
 523         return w;
 524 }
 525
 526 Widget&
 527 FilmEditor::still_widget (Widget& w)
 528 {
 529         _still_widgets.push_back (&w);
 530         return w;
 531 }
 532
 533 void
 534 FilmEditor::setup_visibility ()
 535 {
 536         if (!_film) {
 537                 return;
 538         }
 539
 540         ContentType const c = _film->content_type ();
 541
 542         for (list<Widget *>::iterator i = _video_widgets.begin(); i != _video_widgets.end(); ++i) {
 543                 (*i)->property_visible() = (c == VIDEO);
 544         }
 545
 546         for (list<Widget *>::iterator i = _still_widgets.begin(); i != _still_widgets.end(); ++i) {
 547                 (*i)->property_visible() = (c == STILL);
 548         }
 549 }
 550
 551 void
 552 FilmEditor::still_duration_changed ()
 553 {
 554         if (_film) {
 555                 _film->set_still_duration (_still_duration.get_value ());
 556         }
 557 }
 558
 559 void
 560 FilmEditor::change_dcp_range_clicked ()
 561 {
 562         DCPRangeDialog d (_film);
 563         d.Changed.connect (sigc::mem_fun (*this, &FilmEditor::dcp_range_changed));
 564         d.run ();
 565 }
 566
 567 void
 568 FilmEditor::dcp_range_changed (int frames, TrimAction action)
 569 {
 570         _film->set_dcp_frames (frames);
 571         _film->set_dcp_trim_action (action);
 572 }