src/lib/video_content_scale.cc

   1 /*
   2     Copyright (C) 2013-2015 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 #include "video_content_scale.h"
  21 #include "video_content.h"
  22 #include "ratio.h"
  23 #include "safe_stringstream.h"
  24 #include "util.h"
  25 #include <libcxml/cxml.h>
  26 #include <libxml++/libxml++.h>
  27 #include <boost/optional.hpp>
  28 #include <iostream>
  29
  30 #include "i18n.h"
  31
  32 using std::vector;
  33 using std::string;
  34 using std::min;
  35 using std::cout;
  36 using boost::shared_ptr;
  37 using boost::optional;
  38
  39 vector<VideoContentScale> VideoContentScale::_scales;
  40
  41 VideoContentScale::VideoContentScale (Ratio const * r)
  42         : _ratio (r)
  43         , _scale (true)
  44 {
  45
  46 }
  47
  48 VideoContentScale::VideoContentScale ()
  49         : _ratio (0)
  50         , _scale (false)
  51 {
  52
  53 }
  54
  55 VideoContentScale::VideoContentScale (bool scale)
  56         : _ratio (0)
  57         , _scale (scale)
  58 {
  59
  60 }
  61
  62 VideoContentScale::VideoContentScale (shared_ptr<cxml::Node> node)
  63         : _ratio (0)
  64         , _scale (true)
  65 {
  66         optional<string> r = node->optional_string_child ("Ratio");
  67         if (r) {
  68                 _ratio = Ratio::from_id (r.get ());
  69         } else {
  70                 _scale = node->bool_child ("Scale");
  71         }
  72 }
  73
  74 void
  75 VideoContentScale::as_xml (xmlpp::Node* node) const
  76 {
  77         if (_ratio) {
  78                 node->add_child("Ratio")->add_child_text (_ratio->id ());
  79         } else {
  80                 node->add_child("Scale")->add_child_text (_scale ? "1" : "0");
  81         }
  82 }
  83
  84 string
  85 VideoContentScale::id () const
  86 {
  87         SafeStringStream s;
  88
  89         if (_ratio) {
  90                 s << _ratio->id ();
  91         } else {
  92                 s << (_scale ? "S1" : "S0");
  93         }
  94
  95         return s.str ();
  96 }
  97
  98 string
  99 VideoContentScale::name () const
 100 {
 101         if (_ratio) {
 102                 return _ratio->nickname ();
 103         }
 104
 105         if (_scale) {
 106                 return _("No stretch");
 107         }
 108
 109         return _("No scale");
 110 }
 111
 112 VideoContentScale
 113 VideoContentScale::from_id (string id)
 114 {
 115         Ratio const * r = Ratio::from_id (id);
 116         if (r) {
 117                 return VideoContentScale (r);
 118         }
 119
 120         if (id == "S0") {
 121                 return VideoContentScale (false);
 122         }
 123
 124         return VideoContentScale (true);
 125 }
 126
 127 /** @param display_container Size of the container that we are displaying this content in.
 128  *  @param film_container The size of the film's image.
 129  */
 130 dcp::Size
 131 VideoContentScale::size (shared_ptr<const VideoContent> c, dcp::Size display_container, dcp::Size film_container) const
 132 {
 133         /* Work out the size of the content if it were put inside film_container */
 134
 135         dcp::Size const video_size_after_crop = c->video_size_after_crop ();
 136
 137         dcp::Size size;
 138
 139         if (_ratio) {
 140                 /* Stretch to fit the requested ratio */
 141                 size = fit_ratio_within (_ratio->ratio (), film_container);
 142         } else if (_scale || video_size_after_crop.width > film_container.width || video_size_after_crop.height > film_container.height) {
 143                 /* Scale, preserving aspect ratio; this is either if we have been asked to scale with no stretch
 144                    or if the unscaled content is too big for film_container.
 145                 */
 146                 size = fit_ratio_within (video_size_after_crop.ratio(), film_container);
 147         } else {
 148                 /* No stretch nor scale */
 149                 size = video_size_after_crop;
 150         }
 151
 152         /* Now scale it down if the display container is smaller than the film container */
 153         if (display_container != film_container) {
 154                 float const scale = min (
 155                         float (display_container.width) / film_container.width,
 156                         float (display_container.height) / film_container.height
 157                         );
 158
 159                 size.width = lrintf (size.width * scale);
 160                 size.height = lrintf (size.height * scale);
 161         }
 162
 163         return size;
 164 }
 165
 166 void
 167 VideoContentScale::setup_scales ()
 168 {
 169         vector<Ratio const *> ratios = Ratio::all ();
 170         for (vector<Ratio const *>::const_iterator i = ratios.begin(); i != ratios.end(); ++i) {
 171                 _scales.push_back (VideoContentScale (*i));
 172         }
 173
 174         _scales.push_back (VideoContentScale (true));
 175         _scales.push_back (VideoContentScale (false));
 176 }
 177
 178 bool
 179 operator== (VideoContentScale const & a, VideoContentScale const & b)
 180 {
 181         return (a.ratio() == b.ratio() && a.scale() == b.scale());
 182 }
 183
 184 bool
 185 operator!= (VideoContentScale const & a, VideoContentScale const & b)
 186 {
 187         return (a.ratio() != b.ratio() || a.scale() != b.scale());
 188 }