/*
- Copyright (C) 2013-2015 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2013-2016 Carl Hetherington <cth@carlh.net>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
#include "video_content.h"
+#include "content.h"
#include "video_examiner.h"
#include "compose.hpp"
#include "ratio.h"
#include <dcp/colour_matrix.h>
#include <libxml++/libxml++.h>
#include <iomanip>
+#include <iostream>
#include "i18n.h"
-#define LOG_GENERAL(...) film->log()->log (String::compose (__VA_ARGS__), Log::TYPE_GENERAL);
+#define LOG_GENERAL(...) film->log()->log (String::compose (__VA_ARGS__), LogEntry::TYPE_GENERAL);
int const VideoContentProperty::VIDEO_SIZE = 0;
int const VideoContentProperty::VIDEO_FRAME_RATE = 1;
using std::vector;
using std::min;
using std::max;
-using std::stringstream;
using std::fixed;
using std::setprecision;
using std::list;
using boost::optional;
using boost::dynamic_pointer_cast;
-VideoContent::VideoContent (shared_ptr<const Film> film)
- : Content (film)
+VideoContent::VideoContent (Content* parent, shared_ptr<const Film> film)
+ : _parent (parent)
+ , _film (film)
, _video_length (0)
- , _video_frame_rate (0)
, _video_frame_type (VIDEO_FRAME_TYPE_2D)
, _scale (VideoContentScale (Ratio::from_id ("178")))
+ , _yuv (true)
, _fade_in (0)
, _fade_out (0)
{
- set_default_colour_conversion ();
-}
-VideoContent::VideoContent (shared_ptr<const Film> film, DCPTime s, Frame len)
- : Content (film, s)
- , _video_length (len)
- , _video_frame_rate (0)
- , _video_frame_type (VIDEO_FRAME_TYPE_2D)
- , _scale (VideoContentScale (Ratio::from_id ("178")))
- , _fade_in (0)
- , _fade_out (0)
-{
- set_default_colour_conversion ();
}
-VideoContent::VideoContent (shared_ptr<const Film> film, boost::filesystem::path p)
- : Content (film, p)
- , _video_length (0)
- , _video_frame_rate (0)
- , _video_frame_type (VIDEO_FRAME_TYPE_2D)
- , _scale (VideoContentScale (Ratio::from_id ("178")))
- , _fade_in (0)
- , _fade_out (0)
-{
- set_default_colour_conversion ();
-}
-
-VideoContent::VideoContent (shared_ptr<const Film> film, cxml::ConstNodePtr node, int version)
- : Content (film, node)
+VideoContent::VideoContent (Content* parent, shared_ptr<const Film> film, cxml::ConstNodePtr node, int version)
+ : _parent (parent)
+ , _film (film)
{
_video_size.width = node->number_child<int> ("VideoWidth");
_video_size.height = node->number_child<int> ("VideoHeight");
- _video_frame_rate = node->number_child<double> ("VideoFrameRate");
+ _video_frame_rate = node->optional_number_child<double> ("VideoFrameRate");
_video_length = node->number_child<Frame> ("VideoLength");
_video_frame_type = static_cast<VideoFrameType> (node->number_child<int> ("VideoFrameType"));
_sample_aspect_ratio = node->optional_number_child<double> ("SampleAspectRatio");
if (node->optional_node_child ("ColourConversion")) {
_colour_conversion = ColourConversion (node->node_child ("ColourConversion"), version);
}
+
+ _yuv = node->optional_bool_child("YUV").get_value_or (true);
+
if (version >= 32) {
_fade_in = node->number_child<Frame> ("FadeIn");
_fade_out = node->number_child<Frame> ("FadeOut");
}
}
-VideoContent::VideoContent (shared_ptr<const Film> film, vector<shared_ptr<Content> > c)
- : Content (film, c)
+VideoContent::VideoContent (Content* parent, shared_ptr<const Film> film, vector<shared_ptr<Content> > c)
+ : _parent (parent)
+ , _film (film)
, _video_length (0)
+ , _yuv (false)
{
shared_ptr<VideoContent> ref = dynamic_pointer_cast<VideoContent> (c[0]);
DCPOMATIC_ASSERT (ref);
}
_video_length += vc->video_length ();
+
+ if (vc->yuv ()) {
+ _yuv = true;
+ }
}
_video_size = ref->video_size ();
node->add_child("VideoLength")->add_child_text (raw_convert<string> (_video_length));
node->add_child("VideoWidth")->add_child_text (raw_convert<string> (_video_size.width));
node->add_child("VideoHeight")->add_child_text (raw_convert<string> (_video_size.height));
- node->add_child("VideoFrameRate")->add_child_text (raw_convert<string> (_video_frame_rate));
+ if (_video_frame_rate) {
+ node->add_child("VideoFrameRate")->add_child_text (raw_convert<string> (_video_frame_rate.get()));
+ }
node->add_child("VideoFrameType")->add_child_text (raw_convert<string> (static_cast<int> (_video_frame_type)));
if (_sample_aspect_ratio) {
node->add_child("SampleAspectRatio")->add_child_text (raw_convert<string> (_sample_aspect_ratio.get ()));
if (_colour_conversion) {
_colour_conversion.get().as_xml (node->add_child("ColourConversion"));
}
+ node->add_child("YUV")->add_child_text (_yuv ? "1" : "0");
node->add_child("FadeIn")->add_child_text (raw_convert<string> (_fade_in));
node->add_child("FadeOut")->add_child_text (raw_convert<string> (_fade_out));
}
optional<double> const vfr = d->video_frame_rate ();
Frame vl = d->video_length ();
optional<double> const ar = d->sample_aspect_ratio ();
+ bool const yuv = d->yuv ();
{
boost::mutex::scoped_lock lm (_mutex);
_video_size = vs;
- /* Default video frame rate to 24fps if the examiner doesn't know */
- _video_frame_rate = vfr.get_value_or (24);
+ _video_frame_rate = vfr;
_video_length = vl;
_sample_aspect_ratio = ar;
+ _yuv = yuv;
/* Guess correct scale from size and sample aspect ratio */
_scale = VideoContentScale (
DCPOMATIC_ASSERT (film);
LOG_GENERAL ("Video length obtained from header as %1 frames", _video_length);
- set_default_colour_conversion ();
-
- signal_changed (VideoContentProperty::VIDEO_SIZE);
- signal_changed (VideoContentProperty::VIDEO_FRAME_RATE);
- signal_changed (VideoContentProperty::VIDEO_SCALE);
- signal_changed (ContentProperty::LENGTH);
+ _parent->signal_changed (VideoContentProperty::VIDEO_SIZE);
+ _parent->signal_changed (VideoContentProperty::VIDEO_FRAME_RATE);
+ _parent->signal_changed (VideoContentProperty::VIDEO_SCALE);
+ _parent->signal_changed (ContentProperty::LENGTH);
}
void
_crop.left = c;
}
- signal_changed (VideoContentProperty::VIDEO_CROP);
+ _parent->signal_changed (VideoContentProperty::VIDEO_CROP);
}
void
_crop.right = c;
}
- signal_changed (VideoContentProperty::VIDEO_CROP);
+ _parent->signal_changed (VideoContentProperty::VIDEO_CROP);
}
void
_crop.top = c;
}
- signal_changed (VideoContentProperty::VIDEO_CROP);
+ _parent->signal_changed (VideoContentProperty::VIDEO_CROP);
}
void
_crop.bottom = c;
}
- signal_changed (VideoContentProperty::VIDEO_CROP);
+ _parent->signal_changed (VideoContentProperty::VIDEO_CROP);
}
void
_scale = s;
}
- signal_changed (VideoContentProperty::VIDEO_SCALE);
+ _parent->signal_changed (VideoContentProperty::VIDEO_SCALE);
}
/** @return string which includes everything about how this content looks */
VideoContent::identifier () const
{
SafeStringStream s;
- s << Content::identifier()
- << "_" << crop().left
+ s << crop().left
<< "_" << crop().right
<< "_" << crop().top
<< "_" << crop().bottom
_video_frame_type = t;
}
- signal_changed (VideoContentProperty::VIDEO_FRAME_TYPE);
+ _parent->signal_changed (VideoContentProperty::VIDEO_FRAME_TYPE);
}
string
_colour_conversion = boost::optional<ColourConversion> ();
}
- signal_changed (VideoContentProperty::COLOUR_CONVERSION);
+ _parent->signal_changed (VideoContentProperty::COLOUR_CONVERSION);
}
void
_colour_conversion = c;
}
- signal_changed (VideoContentProperty::COLOUR_CONVERSION);
+ _parent->signal_changed (VideoContentProperty::COLOUR_CONVERSION);
}
void
_fade_in = t;
}
- signal_changed (VideoContentProperty::VIDEO_FADE_IN);
+ _parent->signal_changed (VideoContentProperty::VIDEO_FADE_IN);
}
void
_fade_out = t;
}
- signal_changed (VideoContentProperty::VIDEO_FADE_OUT);
+ _parent->signal_changed (VideoContentProperty::VIDEO_FADE_OUT);
}
/** @return Video size after 3D split and crop */
{
shared_ptr<const Film> film = _film.lock ();
DCPOMATIC_ASSERT (film);
-
set_scale (VideoContentScale (film->container ()));
int const crop = max (0, int (video_size().height - double (film->frame_size().height) * video_size().width / film->frame_size().width));
+ set_left_crop (0);
+ set_right_crop (0);
set_top_crop (crop / 2);
set_bottom_crop (crop / 2);
}
{
shared_ptr<const Film> film = _film.lock ();
DCPOMATIC_ASSERT (film);
-
set_scale (VideoContentScale (film->container ()));
int const crop = max (0, int (video_size().width - double (film->frame_size().width) * video_size().height / film->frame_size().height));
set_left_crop (crop / 2);
set_right_crop (crop / 2);
+ set_top_crop (0);
+ set_bottom_crop (0);
}
void
_video_frame_rate = r;
}
- signal_changed (VideoContentProperty::VIDEO_FRAME_RATE);
+ _parent->signal_changed (VideoContentProperty::VIDEO_FRAME_RATE);
}
+/** @param f Frame index within the whole (untrimmed) content */
optional<double>
VideoContent::fade (Frame f) const
{
DCPOMATIC_ASSERT (f >= 0);
- if (f < fade_in()) {
- return double (f) / fade_in();
+ Frame const ts = _parent->trim_start().frames_round(video_frame_rate());
+ if ((f - ts) < fade_in()) {
+ return double (f - ts) / fade_in();
}
- Frame fade_out_start = video_length() - fade_out();
+ Frame fade_out_start = video_length() - _parent->trim_end().frames_round(video_frame_rate()) - fade_out();
if (f >= fade_out_start) {
return 1 - double (f - fade_out_start) / fade_out();
}
VideoContent::processing_description () const
{
/* stringstream is OK here as this string is just for presentation to the user */
- stringstream d;
+ SafeStringStream d;
if (video_size().width && video_size().height) {
d << String::compose (
shared_ptr<const Film> film = _film.lock ();
DCPOMATIC_ASSERT (film);
-
dcp::Size const container_size = film->frame_size ();
- dcp::Size const scaled = scale().size (dynamic_pointer_cast<const VideoContent> (shared_from_this ()), container_size, container_size);
+ dcp::Size const scaled = scale().size (shared_from_this(), container_size, container_size);
if (scaled != video_size_after_crop ()) {
d << String::compose (
}
void
-VideoContent::add_properties (list<pair<string, string> >& p) const
+VideoContent::add_properties (list<UserProperty>& p) const
+{
+ p.push_back (UserProperty (_("Video"), _("Length"), raw_convert<string> (video_length ()), _("video frames")));
+ p.push_back (UserProperty (_("Video"), _("Size"), raw_convert<string> (video_size().width) + "x" + raw_convert<string> (video_size().height)));
+ p.push_back (UserProperty (_("Video"), _("Frame rate"), raw_convert<string> (video_frame_rate(), 5), _("frames per second")));
+}
+
+double
+VideoContent::video_frame_rate () const
+{
+ boost::mutex::scoped_lock lm (_mutex);
+ shared_ptr<const Film> film = _film.lock ();
+ DCPOMATIC_ASSERT (film);
+ return _video_frame_rate.get_value_or (film->video_frame_rate ());
+}
+
+void
+VideoContent::set_video_length (Frame len)
{
- p.push_back (make_pair (_("Video length"), raw_convert<string> (video_length ()) + " " + _("video frames")));
- p.push_back (make_pair (_("Video size"), raw_convert<string> (video_size().width) + "x" + raw_convert<string> (video_size().height)));
- p.push_back (make_pair (_("Video frame rate"), raw_convert<string> (video_frame_rate()) + " " + _("frames per second")));
+ {
+ boost::mutex::scoped_lock lm (_mutex);
+ _video_length = len;
+ }
+
+ _parent->signal_changed (ContentProperty::LENGTH);
}
projects / dcpomatic.git / blobdiff