Ticket #12990: git-diff-master-mythplayer-20170807.txt

File git-diff-master-mythplayer-20170807.txt, 15.6 KB (added by blm-ubunet@…, 7 years ago)

git diff patch for lib/mythtv/mythplayer

Line 
1diff --git a/mythtv/libs/libmythtv/mythplayer.cpp b/mythtv/libs/libmythtv/mythplayer.cpp
2index 702abc0..a7b7a74 100644
3--- a/mythtv/libs/libmythtv/mythplayer.cpp
4+++ b/mythtv/libs/libmythtv/mythplayer.cpp
5@@ -79,7 +79,7 @@ const double MythPlayer::kInaccuracyNone = 0;
6 // By default, when seeking, snap to a keyframe if the keyframe's
7 // distance from the target frame is less than 10% of the total seek
8 // distance.
9-const double MythPlayer::kInaccuracyDefault = 0.1;
10+const double MythPlayer::kInaccuracyDefault = 0.2;
11 
12 // Allow greater inaccuracy (50%) in the cutlist editor (unless the
13 // editor seek distance is set to 1 frame or 1 keyframe).
14@@ -202,13 +202,13 @@ MythPlayer::MythPlayer(PlayerFlags flags)
15       decoder_lock(QMutex::Recursive),
16       next_play_speed(1.0f),        next_normal_speed(true),
17       play_speed(1.0f),             normal_speed(true),
18-      frame_interval((int)(1000000.0f / 30)), m_frame_interval(0),
19+      frame_interval((int)(1000000.0f / 25)), m_frame_interval(0),
20       ffrew_skip(1),ffrew_adjust(0),
21       // Audio and video synchronization stuff
22       videosync(NULL),              avsync_delay(0),
23       avsync_adjustment(0),         avsync_avg(0),
24       avsync_predictor(0),          avsync_predictor_enabled(false),
25-      refreshrate(0),
26+      refreshinterval(0),
27       lastsync(false),              repeat_delay(0),
28       disp_timecode(0),             avsync_audiopaused(false),
29       // AVSync for Raspberry Pi digital streams
30@@ -424,6 +424,7 @@ void MythPlayer::PauseVideo(void)
31     needNewPauseFrame = true;
32     videoPaused = true;
33     videoPauseLock.unlock();
34+    first_time = true;
35 }
36 
37 void MythPlayer::UnpauseVideo(void)
38@@ -666,9 +667,7 @@ FrameScanType MythPlayer::detectInterlace(FrameScanType newScan,
39         // isn't, we have to guess.
40 
41         scan = kScan_Interlaced; // default to interlaced
42-        if (720 == video_height) // ATSC 720p
43-            scan = kScan_Progressive;
44-        else if (fps > 45) // software deinterlacing
45+        if (fps > 45) // software deinterlacing
46             scan = kScan_Progressive;
47 
48         if (kScan_Detect != newScan)
49@@ -1773,23 +1772,25 @@ int MythPlayer::NextCaptionTrack(int mode)
50 void MythPlayer::SetFrameInterval(FrameScanType scan, double frame_period)
51 {
52     frame_interval = (int)(1000000.0f * frame_period + 0.5f);
53+//    int frameDelay = m_double_framerate ? frame_interval / 2 : frame_interval;
54+
55     if (!avsync_predictor_enabled)
56         avsync_predictor = 0;
57     avsync_predictor_enabled = false;
58 
59     LOG(VB_PLAYBACK, LOG_INFO, LOC + QString("SetFrameInterval ps:%1 scan:%2")
60             .arg(play_speed).arg(scan));
61-    if (play_speed < 1 || play_speed > 2 || refreshrate <= 0)
62+    if (play_speed < 1 || play_speed > 2 || refreshinterval <= 0)
63         return;
64 
65     avsync_predictor_enabled = ((frame_interval-(frame_interval/200)) <
66-                                refreshrate);
67+                                refreshinterval);
68 }
69 
70 void MythPlayer::ResetAVSync(void)
71 {
72     avsync_avg = 0;
73-    if (!avsync_predictor_enabled || avsync_predictor >= refreshrate)
74+    if (!avsync_predictor_enabled || avsync_predictor >= refreshinterval)
75         avsync_predictor = 0;
76     prevtc = 0;
77     avsync_next = avsync_interval;      // Frames till next sync check
78@@ -1804,7 +1805,7 @@ void MythPlayer::InitAVSync(void)
79 
80     repeat_delay = 0;
81 
82-    refreshrate = MythDisplay::GetDisplayInfo(frame_interval).Rate();
83+    refreshinterval = MythDisplay::GetDisplayInfo(frame_interval).Rate();
84 
85     // Number of frames over which to average time divergence
86     avsync_averaging=4;
87@@ -1831,7 +1832,7 @@ void MythPlayer::InitAVSync(void)
88         QString msg = QString("Video timing method: %1").arg(timing_type);
89         LOG(VB_GENERAL, LOG_INFO, LOC + msg);
90         msg = QString("Display Refresh Rate: %1 Video Frame Rate: %2")
91-                       .arg(1000000.0 / refreshrate, 0, 'f', 3)
92+                       .arg(1000000.0 / refreshinterval, 0, 'f', 3)
93                        .arg(1000000.0 / frame_interval, 0, 'f', 3);
94         LOG(VB_PLAYBACK, LOG_INFO, LOC + msg);
95 
96@@ -1865,7 +1866,6 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
97     }
98 
99     float diverge = 0.0f;
100-    int frameDelay = m_double_framerate ? frame_interval / 2 : frame_interval;
101     int vsync_delay_clock = 0;
102     //int64_t currentaudiotime = 0;
103 
104@@ -1891,21 +1891,19 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
105         avsync_next = avsync_interval/divisor;
106     }
107 
108-    FrameScanType ps = m_scan;
109-    if (kScan_Detect == m_scan || kScan_Ignore == m_scan)
110-        ps = kScan_Progressive;
111-
112     bool max_video_behind = diverge < -max_diverge;
113     bool dropframe = false;
114     QString dbg;
115 
116+    dropframe = !m_double_framerate && drop_field;
117+
118     if (avsync_predictor_enabled)
119     {
120         avsync_predictor += frame_interval;
121-        if (avsync_predictor >= refreshrate)
122+        if (avsync_predictor >= refreshinterval)
123         {
124-            int refreshperiodsinframe = avsync_predictor/refreshrate;
125-            avsync_predictor -= refreshrate * refreshperiodsinframe;
126+            int refreshperiodsinframe = avsync_predictor/refreshinterval;
127+            avsync_predictor -= refreshinterval * refreshperiodsinframe;
128         }
129         else
130         {
131@@ -1914,6 +1912,9 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
132         }
133     }
134 
135+    int frameDelay = frame_interval + avsync_adjustment + repeat_delay;
136+    frameDelay = m_double_framerate ? frameDelay / 2 : frameDelay;
137+
138     if (max_video_behind)
139     {
140         dropframe = true;
141@@ -1928,6 +1929,10 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
142         audio.Pause(false);
143     }
144 
145+    FrameScanType ps = m_scan;
146+    if (kScan_Detect == m_scan || kScan_Ignore == m_scan)
147+        ps = kScan_Progressive;
148+
149     if (!dropframe)
150     {
151         // PGB this was orignally in the calling methods
152@@ -1967,8 +1972,7 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
153             LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO,
154                 LOC + QString("AVSync waitforframe %1 %2")
155                     .arg(avsync_adjustment).arg(m_double_framerate));
156-            vsync_delay_clock = videosync->WaitForFrame
157-                                (frameDelay + avsync_adjustment + repeat_delay);
158+            vsync_delay_clock = videosync->WaitForFrame(frameDelay);
159         }
160         else
161         {
162@@ -1976,7 +1980,7 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
163             lastsync = true;
164         }
165         //currentaudiotime = AVSyncGetAudiotime();
166-        LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC + "AVSync show");
167+        // LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC + "AVSync show");
168         videoOutput->Show(ps);
169 
170         if (videoOutput->IsErrored())
171@@ -1987,12 +1991,13 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
172             return;
173         }
174 
175-        if (m_double_framerate)
176+        if (!drop_field && m_double_framerate)
177         {
178             //second stage of deinterlacer processing
179             ps = (kScan_Intr2ndField == ps) ?
180                 kScan_Interlaced : kScan_Intr2ndField;
181             osdLock.lock();
182+
183             if (m_double_process && ps != kScan_Progressive)
184             {
185                 videofiltersLock.lock();
186@@ -2005,8 +2010,7 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
187             osdLock.unlock();
188             // Display the second field
189             if (!player_ctx->IsPBP() || player_ctx->IsPrimaryPBP())
190-                vsync_delay_clock = videosync->WaitForFrame(frameDelay +
191-                                                        avsync_adjustment);
192+                vsync_delay_clock += videosync->WaitForFrame(repeat_field ? (frameDelay * 2) : frameDelay);
193             videoOutput->Show(ps);
194         }
195 
196@@ -2019,7 +2023,7 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
197     }
198     else
199     {
200-        vsync_delay_clock = videosync->WaitForFrame(frameDelay);
201+        vsync_delay_clock = videosync->WaitForFrame(frame_interval);
202         //currentaudiotime = AVSyncGetAudiotime();
203     }
204 
205@@ -2049,12 +2053,12 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
206         // must be sampled here due to Show delays
207         int64_t currentaudiotime = audio.GetAudioTime();
208         LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC +
209-            QString("A/V timecodes audio %1 video %2 frameinterval %3 "
210+            QString("A/V timecodes audio %1 video %2 framedelay %3 "
211                     "avdel %4 avg %5 tcoffset %6 avp %7 avpen %8 avdc %9 "
212                     "diverge %10")
213                 .arg(currentaudiotime)
214                 .arg(timecode)
215-                .arg(frame_interval)
216+                .arg(frameDelay)
217                 .arg(timecode - currentaudiotime -
218                      (int)(vsync_delay_clock*audio.GetStretchFactor()+500)/1000)
219                 .arg(avsync_avg)
220@@ -2099,7 +2103,10 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
221 
222             // prevents major jitter when pts resets during dvd title
223             if (avsync_delay > 2000000 && limit_delay)
224+            {
225                 avsync_delay = 90000;
226+                avsync_avg = 0;
227+            }
228             avsync_avg = (avsync_delay + (avsync_avg * (avsync_averaging-1))) / avsync_averaging;
229 
230             int avsync_used = avsync_avg;
231@@ -2108,16 +2115,37 @@ void MythPlayer::AVSync(VideoFrame *buffer, bool limit_delay)
232 
233             /* If the audio time codes and video diverge, shift
234                the video by one interlaced field (1/2 frame) */
235-            if (!lastsync)
236+            if (true)   //(!lastsync)
237             {
238-                if (avsync_used > refreshrate)
239+                diverge = (float)avsync_avg / (float)refreshinterval;
240+                // limit damage to spread any AV shift
241+                if (diverge >  3)
242+                    diverge = 3;
243+                if (diverge < -3)
244+                    diverge = -3;
245+                // target +/- 0.5 * refreshinterval
246+
247+                frameDelay = m_double_framerate ? frame_interval / 2 : frame_interval;
248+                repeat_field = false;
249+                drop_field = false;
250+                avsync_adjustment = refreshinterval - frameDelay;
251+                avsync_adjustment = (refreshinterval > frameDelay) ? frameDelay : avsync_adjustment;
252+
253+                if (avsync_used > frameDelay)
254                 {
255-                    avsync_adjustment += refreshrate;
256+                    avsync_adjustment = 0;
257+                    repeat_field = true;
258                 }
259-                else if (avsync_used < 0 - refreshrate)
260+                else if (avsync_used < 0 - frameDelay)
261                 {
262-                    avsync_adjustment -= refreshrate;
263+                    // drop field or frame
264+                    avsync_adjustment = 0;
265+                    drop_field = true;
266                 }
267+
268+                LOG(VB_PLAYBACK | VB_TIMESTAMP, LOG_INFO, LOC +
269+                    QString("avsync_used(us) %1  av_adj %2").arg(avsync_used).arg(avsync_adjustment));
270+
271             }
272             else
273                 lastsync = false;
274@@ -2175,13 +2203,29 @@ void MythPlayer::DisplayPauseFrame(void)
275     RefreshPauseFrame();
276     PreProcessNormalFrame(); // Allow interactiveTV to draw on pause frame
277 
278+    // retrieve the next frame
279+    videoOutput->StartDisplayingFrame();
280+    VideoFrame *frame = videoOutput->GetLastShownFrame();
281+   
282+    FrameScanType ps = m_scan;
283+    if (kScan_Detect == m_scan || kScan_Ignore == m_scan)
284+        ps = kScan_Progressive;
285+
286+    if (m_double_process && ps != kScan_Progressive)
287+    {
288+        //second stage of deinterlacer processing
289+        ps = kScan_Intr2ndField;
290+    }     
291+
292+//    ps = kScan_Ignore;
293+
294     osdLock.lock();
295     videofiltersLock.lock();
296-    videoOutput->ProcessFrame(NULL, osd, videoFilters, pip_players);
297+    videoOutput->ProcessFrame(frame, osd, videoFilters, pip_players, ps);
298     videofiltersLock.unlock();
299-    videoOutput->PrepareFrame(NULL, kScan_Ignore, osd);
300+    videoOutput->PrepareFrame(frame, ps, osd);
301     osdLock.unlock();
302-    videoOutput->Show(kScan_Ignore);
303+    videoOutput->Show(ps);
304     videosync->Start();
305 }
306 
307@@ -2316,10 +2360,6 @@ void MythPlayer::DisplayNormalFrame(bool check_prebuffer)
308     AutoDeint(frame);
309     detect_letter_box->SwitchTo(frame);
310 
311-    FrameScanType ps = m_scan;
312-    if (kScan_Detect == m_scan || kScan_Ignore == m_scan)
313-        ps = kScan_Progressive;
314-
315     AVSync(frame, 0);
316     // If PiP then keep this frame for MythPlayer::GetCurrentFrame
317     if (!player_ctx->IsPIP())
318@@ -2444,11 +2484,11 @@ void MythPlayer::VideoStart(void)
319     avsync_delay = 0;
320     avsync_avg = 0;
321     avsync_next = avsync_interval;      // Frames till next sync check
322-    refreshrate = 0;
323+    refreshinterval = 0;
324     lastsync = false;
325 
326     EnableFrameRateMonitor();
327-    refreshrate = frame_interval;
328+    refreshinterval = frame_interval;
329 
330     float temp_speed = (play_speed == 0.0) ? audio.GetStretchFactor() : play_speed;
331     int fr_int = (1000000.0 / video_frame_rate / temp_speed);
332@@ -3787,7 +3827,7 @@ void MythPlayer::ChangeSpeed(void)
333 
334         // If using bob deinterlace, turn on or off if we
335         // changed to or from synchronous playback speed.
336-        bool play_1 = play_speed > 0.99f && play_speed < 1.01f && normal_speed;
337+        bool play_1 = true;   //play_speed > 0.99f && play_speed < 1.01f && normal_speed;
338         bool inter  = (kScan_Interlaced   == m_scan  ||
339                        kScan_Intr2ndField == m_scan);
340 
341diff --git a/mythtv/libs/libmythtv/mythplayer.h b/mythtv/libs/libmythtv/mythplayer.h
342index 1a23e2f..9c9fb64 100644
343--- a/mythtv/libs/libmythtv/mythplayer.h
344+++ b/mythtv/libs/libmythtv/mythplayer.h
345@@ -656,6 +656,7 @@ class MTV_PUBLIC MythPlayer
346     int64_t        decoderSeek;
347     bool           decodeOneFrame;
348     bool           needNewPauseFrame;
349+    bool           first_time;
350     mutable QMutex bufferPauseLock;
351     mutable QMutex videoPauseLock;
352     mutable QMutex pauseLock;
353@@ -809,8 +810,8 @@ class MTV_PUBLIC MythPlayer
354 
355     float      play_speed;
356     bool       normal_speed;
357-    int        frame_interval;///< always adjusted for play_speed
358-    int        m_frame_interval;///< used to detect changes to frame_interval
359+    int        frame_interval;   ///< always adjusted for play_speed
360+    int        m_frame_interval; ///< used to detect changes to frame_interval
361 
362     int        ffrew_skip;
363     int        ffrew_adjust;
364@@ -822,10 +823,12 @@ class MTV_PUBLIC MythPlayer
365     int        avsync_avg;
366     int        avsync_predictor;
367     bool       avsync_predictor_enabled;
368-    int        refreshrate;
369+    int        refreshinterval;  // time (us)
370     bool       lastsync;
371     bool       decode_extra_audio;
372     int        repeat_delay;
373+    bool       drop_field;
374+    bool       repeat_field;
375     int64_t    disp_timecode;
376     bool       avsync_audiopaused;
377     float      max_diverge;  // from setting PlayerMaxDiverge default 2
378diff --git a/mythtv/libs/libmythtv/videoout_vdpau.cpp b/mythtv/libs/libmythtv/videoout_vdpau.cpp
379index 07f6e6d..fd8fa59 100644
380--- a/mythtv/libs/libmythtv/videoout_vdpau.cpp
381+++ b/mythtv/libs/libmythtv/videoout_vdpau.cpp
382@@ -505,9 +505,9 @@ void VideoOutputVDPAU::PrepareFrame(VideoFrame *frame, FrameScanType scan,
383                 VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD :
384                 VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
385     }
386-    else if (!frame && m_deinterlacing)
387+    else if (m_deinterlacing && !frame)
388     {
389-        field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_TOP_FIELD;
390+        field = VDP_VIDEO_MIXER_PICTURE_STRUCTURE_BOTTOM_FIELD;
391     }
392 
393     m_render->WaitForFlip();
394