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