X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fvideo_decoder.cc;h=5bf0672832405125ea9577457fb830475a09c55a;hp=0b97e5e8771561b2bf470c78ff0901369ab75c5e;hb=dd9be86db6cde0afa5da0d1d1ac43b42e05dca26;hpb=11c07c6fd98620c859c7d3dcf6a4bbf6a05e567e

diff --git a/src/lib/video_decoder.cc b/src/lib/video_decoder.cc
index 0b97e5e87..5bf067283 100644
--- a/src/lib/video_decoder.cc
+++ b/src/lib/video_decoder.cc
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2012-2018 Carl Hetherington <cth@carlh.net>
+    Copyright (C) 2012-2020 Carl Hetherington <cth@carlh.net>
 
     This file is part of DCP-o-matic.
 
@@ -23,6 +23,7 @@
 #include "raw_image_proxy.h"
 #include "film.h"
 #include "log.h"
+#include "frame_interval_checker.h"
 #include "compose.hpp"
 #include <boost/foreach.hpp>
 #include <iostream>
@@ -33,13 +34,14 @@ using std::cout;
 using std::list;
 using std::max;
 using std::back_inserter;
-using boost::shared_ptr;
+using std::shared_ptr;
 using boost::optional;
 using namespace dcpomatic;
 
 VideoDecoder::VideoDecoder (Decoder* parent, shared_ptr<const Content> c)
 	: DecoderPart (parent)
 	, _content (c)
+	, _frame_interval_checker (new FrameIntervalChecker())
 {
 
 }
@@ -54,26 +56,24 @@ VideoDecoder::VideoDecoder (Decoder* parent, shared_ptr<const Content> c)
  *  and so on.
  */
 void
-VideoDecoder::emit (shared_ptr<const Film> film, shared_ptr<const ImageProxy> image, Frame frame)
+VideoDecoder::emit (shared_ptr<const Film> film, shared_ptr<const ImageProxy> image, Frame decoder_frame)
 {
 	if (ignore ()) {
 		return;
 	}
 
-	switch (_content->video->frame_type ()) {
-	case VIDEO_FRAME_TYPE_2D:
-		Data (ContentVideo (image, frame, EYES_BOTH, PART_WHOLE));
-		break;
-	case VIDEO_FRAME_TYPE_3D:
-	{
-		/* We should receive the same frame index twice for 3D; hence we know which
-		   frame this one is.
-		*/
-		bool const same = (_last_emitted_frame && _last_emitted_frame.get() == frame);
-		if (!same && _last_emitted_eyes && *_last_emitted_eyes == EYES_LEFT) {
-			/* We just got a new frame index but the last frame was left-eye; it looks like
-			   this content is not really 3D.
-			*/
+	double const afr = _content->active_video_frame_rate(film);
+	VideoFrameType const vft = _content->video->frame_type();
+
+	ContentTime frame_time = ContentTime::from_frames (decoder_frame, afr);
+
+	/* Do some heuristics to try and spot the case where the user sets content to 3D
+	 * when it is not.  We try to tell this by looking at the differences in time between
+	 * the first few frames.  Real 3D content should have two frames for each timestamp.
+	 */
+	if (_frame_interval_checker) {
+		_frame_interval_checker->feed (frame_time, afr);
+		if (_frame_interval_checker->guess() == FrameIntervalChecker::PROBABLY_NOT_3D && vft == VIDEO_FRAME_TYPE_3D) {
 			boost::throw_exception (
 				DecodeError(
 					String::compose(
@@ -84,16 +84,62 @@ VideoDecoder::emit (shared_ptr<const Film> film, shared_ptr<const ImageProxy> im
 					)
 				);
 		}
-		Eyes const eyes = same ? EYES_RIGHT : EYES_LEFT;
+
+		if (_frame_interval_checker->guess() != FrameIntervalChecker::AGAIN) {
+			_frame_interval_checker.reset ();
+		}
+	}
+
+	Frame frame;
+	Eyes eyes = EYES_BOTH;
+	if (!_position) {
+		/* This is the first data we have received since initialisation or seek.  Set
+		   the position based on the frame that was given.  After this first time
+		   we just cound frames, since (as with audio) it seems that ContentTimes
+		   are unreliable from FFmpegDecoder.  They are much better than audio times
+		   but still we get the occasional one which is duplicated.  In this case
+		   ffmpeg seems to carry on regardless, processing the video frame as normal.
+		   If we drop the frame with the duplicated timestamp we obviously lose sync.
+		*/
+		_position = ContentTime::from_frames (decoder_frame, afr);
+		if (vft == VIDEO_FRAME_TYPE_3D_ALTERNATE) {
+			frame = decoder_frame / 2;
+			_last_emitted_eyes = EYES_RIGHT;
+		} else {
+			frame = decoder_frame;
+		}
+	} else {
+		if (vft == VIDEO_FRAME_TYPE_3D || vft == VIDEO_FRAME_TYPE_3D_ALTERNATE) {
+			DCPOMATIC_ASSERT (_last_emitted_eyes);
+			if (_last_emitted_eyes.get() == EYES_RIGHT) {
+				frame = _position->frames_round(afr) + 1;
+				eyes = EYES_LEFT;
+			} else {
+				frame = _position->frames_round(afr);
+				eyes = EYES_RIGHT;
+			}
+		} else {
+			frame = _position->frames_round(afr) + 1;
+		}
+	}
+
+	switch (vft) {
+	case VIDEO_FRAME_TYPE_2D:
+		Data (ContentVideo (image, frame, EYES_BOTH, PART_WHOLE));
+		break;
+	case VIDEO_FRAME_TYPE_3D:
+	{
 		Data (ContentVideo (image, frame, eyes, PART_WHOLE));
 		_last_emitted_frame = frame;
 		_last_emitted_eyes = eyes;
 		break;
 	}
 	case VIDEO_FRAME_TYPE_3D_ALTERNATE:
-		Data (ContentVideo (image, frame / 2, (frame % 2) ? EYES_RIGHT : EYES_LEFT, PART_WHOLE));
-		frame /= 2;
+	{
+		Data (ContentVideo (image, frame, eyes, PART_WHOLE));
+		_last_emitted_eyes = eyes;
 		break;
+	}
 	case VIDEO_FRAME_TYPE_3D_LEFT_RIGHT:
 		Data (ContentVideo (image, frame, EYES_LEFT, PART_LEFT_HALF));
 		Data (ContentVideo (image, frame, EYES_RIGHT, PART_RIGHT_HALF));
@@ -112,13 +158,14 @@ VideoDecoder::emit (shared_ptr<const Film> film, shared_ptr<const ImageProxy> im
 		DCPOMATIC_ASSERT (false);
 	}
 
-	_position = ContentTime::from_frames (frame, _content->active_video_frame_rate(film));
+	_position = ContentTime::from_frames (frame, afr);
 }
 
 void
 VideoDecoder::seek ()
 {
-	_position = ContentTime();
+	_position = boost::none;
 	_last_emitted_frame.reset ();
 	_last_emitted_eyes.reset ();
+	_frame_interval_checker.reset (new FrameIntervalChecker());
 }