X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fvideo_parser%2Fvpar_synchro.c;h=d96433e64db3f6e492a8dd620d2268df07da40db;hb=647cca0ebb2e897a570018ba80483bb81a7d90c6;hp=49f8849b11381e4ce05e575acc648be28fd772de;hpb=f6268f60f4d02aadbb8b14046f0aa96b39af63a8;p=vlc diff --git a/src/video_parser/vpar_synchro.c b/src/video_parser/vpar_synchro.c index 49f8849b11..d96433e64d 100644 --- a/src/video_parser/vpar_synchro.c +++ b/src/video_parser/vpar_synchro.c @@ -1,9 +1,12 @@ /***************************************************************************** - * vpar_motion.c : motion vectors parsing + * vpar_synchro.c : frame dropping routines ***************************************************************************** * Copyright (C) 1999, 2000 VideoLAN + * $Id: vpar_synchro.c,v 1.78 2001/01/18 05:13:23 sam Exp $ * - * Authors: + * Authors: Christophe Massiot + * Samuel Hocevar + * Jean-Marc Dressler * * 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 @@ -20,15 +23,81 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. *****************************************************************************/ +/* + * DISCUSSION : How to Write an efficient Frame-Dropping Algorithm + * ========== + * + * This implementation is based on mathematical and statistical + * developments. Older implementations used an enslavement, considering + * that if we're late when reading an I picture, we will decode one frame + * less. It had a tendancy to derive, and wasn't responsive enough, which + * would have caused trouble with the stream control stuff. + * + * 1. Structure of a picture stream + * ============================= + * Between 2 I's, we have for instance : + * I B P B P B P B P B P B I + * t0 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 + * Please bear in mind that B's and IP's will be inverted when displaying + * (decoding order != presentation order). Thus, t1 < t0. + * + * FIXME: write a few words about stream structure changes. + * + * 2. Definitions + * =========== + * t[0..12] : Presentation timestamps of pictures 0..12. + * t : Current timestamp, at the moment of the decoding. + * T : Picture period, T = 1/frame_rate. + * tau[I,P,B] : Mean time to decode an [I,P,B] picture. + * tauYUV : Mean time to render a picture (given by the video_output). + * tau´[I,P,B] = 2 * tau[I,P,B] + tauYUV + * : Mean time + typical difference (estimated to tau/2, that + * needs to be confirmed) + render time. + * DELTA : A given error margin. + * + * 3. General considerations + * ====================== + * We define three types of machines : + * 14T > tauI : machines capable of decoding all I pictures + * 2T > tauP : machines capable of decoding all P pictures + * T > tauB : machines capable of decoding all B pictures + * + * 4. Decoding of an I picture + * ======================== + * On fast machines, we decode all I's. + * Otherwise : + * We can decode an I picture if we simply have enough time to decode it + * before displaying : + * t0 - t > tau´I + DELTA + * + * 5. Decoding of a P picture + * ======================= + * On fast machines, we decode all P's. + * Otherwise : + * First criterion : have time to decode it. + * t2 - t > tau´P + DELTA + * + * Second criterion : it shouldn't prevent us from displaying the forthcoming + * I picture, which is more important. + * t12 - t > tau´P + tau´I + DELTA + * + * 6. Decoding of a B picture + * ======================= + * On fast machines, we decode all B's. Otherwise : + * t1 - t > tau´B + DELTA + * Since the next displayed I or P is already decoded, we don't have to + * worry about it. + * + * I hope you will have a pleasant flight and do not forget your life + * jacket. + * --Meuuh (2000-12-29) + */ + /***************************************************************************** * Preamble *****************************************************************************/ #include "defs.h" -#include /* free() */ -#include /* on BSD, uio.h needs types.h */ -#include /* "input.h" */ - #include "config.h" #include "common.h" #include "threads.h" @@ -37,277 +106,304 @@ #include "intf_msg.h" -#include "input.h" -#include "decoder_fifo.h" +#include "stream_control.h" +#include "input_ext-dec.h" + #include "video.h" #include "video_output.h" -#include "vdec_idct.h" #include "video_decoder.h" #include "vdec_motion.h" +#include "../video_decoder/vdec_idct.h" #include "vpar_blocks.h" -#include "vpar_headers.h" -#include "vpar_synchro.h" -#include "video_parser.h" +#include "../video_decoder/vpar_headers.h" +#include "../video_decoder/vpar_synchro.h" +#include "../video_decoder/video_parser.h" -#define MAX_COUNT 3 +#include "main.h" /* * Local prototypes */ +static int SynchroType( void ); -#ifdef SAM_SYNCHRO +/* Error margins */ +#define DELTA (int)(0.040*CLOCK_FREQ) + +#define DEFAULT_NB_P 5 +#define DEFAULT_NB_B 1 /***************************************************************************** - * vpar_SynchroUpdateStructures : Update the synchro structures + * vpar_SynchroInit : You know what ? *****************************************************************************/ -void vpar_SynchroUpdateStructures( vpar_thread_t * p_vpar, - int i_coding_type, boolean_t b_kept ) +void vpar_SynchroInit( vpar_thread_t * p_vpar ) { - int i_can_display; - mtime_t i_pts; - pes_packet_t * p_pes = p_vpar->bit_stream.p_decoder_fifo->buffer[ - p_vpar->bit_stream.p_decoder_fifo->i_start ]; - - /* try to guess the current DTS and PTS */ - if( p_pes->b_has_pts ) - { - i_pts = p_pes->i_pts; - - /* if the image is I type, then the presentation timestamp is - * the PTS of the PES. Otherwise, we calculate it with the - * theorical framerate value */ - if( i_coding_type == I_CODING_TYPE ) - { - p_vpar->synchro.i_last_pts = p_pes->i_pts; - } - else - { - p_vpar->synchro.i_last_pts += p_vpar->synchro.i_theorical_delay; - } + p_vpar->synchro.i_type = SynchroType(); + p_vpar->synchro.i_start = p_vpar->synchro.i_end = 0; + vlc_mutex_init( &p_vpar->synchro.fifo_lock ); + + /* We use a fake stream pattern, which is often right. */ + p_vpar->synchro.i_n_p = p_vpar->synchro.i_eta_p = DEFAULT_NB_P; + p_vpar->synchro.i_n_b = p_vpar->synchro.i_eta_b = DEFAULT_NB_B; + memset( p_vpar->synchro.p_tau, 0, 4 * sizeof(mtime_t) ); + memset( p_vpar->synchro.pi_meaningful, 0, 4 * sizeof(unsigned int) ); + p_vpar->synchro.b_dropped_last = 0; + p_vpar->synchro.current_pts = mdate() + DEFAULT_PTS_DELAY; + p_vpar->synchro.backward_pts = 0; + p_vpar->synchro.i_current_period = p_vpar->synchro.i_backward_period = 0; +#ifdef STATS + p_vpar->synchro.i_trashed_pic = p_vpar->synchro.i_not_chosen_pic = + p_vpar->synchro.i_pic = 0; +#endif +} - p_pes->b_has_pts = 0; - } - else - { - p_vpar->synchro.i_last_pts += p_vpar->synchro.i_theorical_delay; - i_pts = p_vpar->synchro.i_last_pts; - } +/***************************************************************************** + * vpar_SynchroChoose : Decide whether we will decode a picture or not + *****************************************************************************/ +boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, + int i_structure ) +{ + /* For clarity reasons, we separated the special synchros code from the + * mathematical synchro */ - /* update structures */ - switch(i_coding_type) + if( p_vpar->synchro.i_type != VPAR_SYNCHRO_DEFAULT ) { - case P_CODING_TYPE: - - p_vpar->synchro.i_P_seen += 1024; - if( b_kept ) p_vpar->synchro.i_P_kept += 1024; - break; - - case B_CODING_TYPE: - p_vpar->synchro.i_B_seen += 1024; - if( b_kept ) p_vpar->synchro.i_B_kept += 1024; - break; - + switch( i_coding_type ) + { case I_CODING_TYPE: - - /* update the last I PTS we have, we need it to - * calculate the theorical framerate */ - if (i_pts != p_vpar->synchro.i_last_seen_I_pts) + /* I, IP, IP+, IPB */ + if( p_vpar->synchro.i_type == VPAR_SYNCHRO_Iplus ) { - if ( p_vpar->synchro.i_last_seen_I_pts ) - { - p_vpar->synchro.i_theorical_delay = - 1024 * ( i_pts - p_vpar->synchro.i_last_seen_I_pts ) - / ( 1024 + p_vpar->synchro.i_B_seen - + p_vpar->synchro.i_P_seen); - } - p_vpar->synchro.i_last_seen_I_pts = i_pts; + p_vpar->synchro.b_dropped_last = 1; } + return( 1 ); - /* now we calculated all statistics, it's time to - * decide what we have the time to display */ - i_can_display = - ( (i_pts - p_vpar->synchro.i_last_kept_I_pts) << 10 ) - / p_vpar->synchro.i_delay; - - p_vpar->synchro.b_all_I = 0; - p_vpar->synchro.b_all_B = 0; - p_vpar->synchro.b_all_P = 0; - p_vpar->synchro.displayable_p = 0; - p_vpar->synchro.displayable_b = 0; - - if( ( p_vpar->synchro.b_all_I = ( i_can_display >= 1024 ) ) ) + case P_CODING_TYPE: + if( p_vpar->synchro.i_type == VPAR_SYNCHRO_I ) /* I */ { - i_can_display -= 1024; + return( 0 ); + } - if( !( p_vpar->synchro.b_all_P - = ( i_can_display > p_vpar->synchro.i_P_seen ) ) ) + if( p_vpar->synchro.i_type == VPAR_SYNCHRO_Iplus ) /* I+ */ + { + if( p_vpar->synchro.b_dropped_last ) { - p_vpar->synchro.displayable_p = i_can_display; + p_vpar->synchro.b_dropped_last = 0; + return( 1 ); } else { - i_can_display -= p_vpar->synchro.i_P_seen; - - if( !( p_vpar->synchro.b_all_B - = ( i_can_display > p_vpar->synchro.i_B_seen ) ) ) - { - p_vpar->synchro.displayable_b = i_can_display; - } + return( 0 ); } } -#if 1 - if( p_vpar->synchro.b_all_I ) - intf_ErrMsg( " I: 1024/1024 " ); - if( p_vpar->synchro.b_all_P ) - intf_ErrMsg( "P: %i/%i ", p_vpar->synchro.i_P_seen, - p_vpar->synchro.i_P_seen ); - else if( p_vpar->synchro.displayable_p > 0 ) - intf_ErrMsg( "P: %i/%i ", p_vpar->synchro.displayable_p, - p_vpar->synchro.i_P_seen ); - if( p_vpar->synchro.b_all_B ) - intf_ErrMsg( "B: %i/%i", p_vpar->synchro.i_B_seen, - p_vpar->synchro.i_B_seen ); - else if( p_vpar->synchro.displayable_b > 0 ) - intf_ErrMsg( "B: %i/%i", p_vpar->synchro.displayable_b, - p_vpar->synchro.i_B_seen ); -// intf_ErrMsg( " " ); - intf_ErrMsg( "\n" ); -#endif - p_vpar->synchro.i_P_seen = 0; - p_vpar->synchro.i_B_seen = 0; + return( 1 ); /* IP, IP+, IPB */ - /* update some values */ - if( b_kept ) + case B_CODING_TYPE: + if( p_vpar->synchro.i_type <= VPAR_SYNCHRO_IP ) /* I, IP */ + { + return( 0 ); + } + else if( p_vpar->synchro.i_type == VPAR_SYNCHRO_IPB ) /* IPB */ { - p_vpar->synchro.i_last_kept_I_pts = i_pts; - p_vpar->synchro.i_P_kept = 0; - p_vpar->synchro.i_B_kept = 0; + return( 1 ); } - break; + p_vpar->synchro.b_dropped_last ^= 1; /* IP+ */ + return( !p_vpar->synchro.b_dropped_last ); + } + return( 0 ); /* never reached but gcc yells at me */ } -} - -/***************************************************************************** - * vpar_SynchroChoose : Decide whether we will decode a picture or not - *****************************************************************************/ -boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) -{ - mtime_t i_delay = p_vpar->synchro.i_last_pts - mdate(); - - switch( i_coding_type ) + else { - case I_CODING_TYPE: +#define TAU_PRIME( coding_type ) (p_vpar->synchro.p_tau[(coding_type)] \ + + (p_vpar->synchro.p_tau[(coding_type)] >> 1) \ + + tau_yuv) +#define S p_vpar->synchro + /* VPAR_SYNCHRO_DEFAULT */ + mtime_t now, pts, period, tau_yuv; + boolean_t b_decode = 0; +#ifdef DEBUG_VPAR + char p_date[MSTRTIME_MAX_SIZE]; +#endif - //intf_ErrMsg( " I %f %f\nI ", 1000000.0 / p_vpar->synchro.i_theorical_delay, 1000000.0 / p_vpar->synchro.i_delay ); - return( p_vpar->synchro.b_all_I ); + now = mdate(); + period = 1000000 * 1001 / p_vpar->sequence.i_frame_rate; - case P_CODING_TYPE: + vlc_mutex_lock( &p_vpar->p_vout->change_lock ); + tau_yuv = p_vpar->p_vout->render_time; + vlc_mutex_unlock( &p_vpar->p_vout->change_lock ); - //return(1); - if( p_vpar->synchro.b_all_P ) + vlc_mutex_lock( &p_vpar->synchro.fifo_lock ); + + switch( i_coding_type ) + { + case I_CODING_TYPE: + if( S.backward_pts ) { - //intf_ErrMsg( " p " ); - return( 1 ); + pts = S.backward_pts; } - - if( p_vpar->synchro.displayable_p * i_delay - < p_vpar->synchro.i_delay ) + else { - //intf_ErrMsg( " - " ); - return( 0 ); + /* displaying order : B B P B B I + * ^ ^ + * | +- current picture + * +- current PTS + */ + pts = S.current_pts + period * (S.i_n_b + 2); } - p_vpar->synchro.displayable_p--; - //intf_ErrMsg( " p> " ); - return( 1 ); - - case B_CODING_TYPE: - - if( p_vpar->synchro.b_all_B ) + if( (1 + S.i_n_p * (S.i_n_b + 1)) * period > + S.p_tau[I_CODING_TYPE] ) { - //intf_ErrMsg( "b " ); - return( 1 ); + b_decode = 1; + } + else + { + b_decode = (pts - now) > (TAU_PRIME(I_CODING_TYPE) + DELTA); } + if( !b_decode ) + intf_WarnMsg( 3, "vpar synchro warning: trashing I" ); + break; - if( p_vpar->synchro.displayable_b <= 0 ) + case P_CODING_TYPE: + if( S.backward_pts ) { - //intf_ErrMsg( " " ); - return( 0 ); + pts = S.backward_pts; + } + else + { + pts = S.current_pts + period * (S.i_n_b + 1); } - if( i_delay < 0 ) + if( (1 + S.i_n_p * (S.i_n_b + 1)) * period > + S.p_tau[I_CODING_TYPE] ) { - //intf_ErrMsg( "· " ); - p_vpar->synchro.displayable_b -= 0.5; - return( 0 ); + if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] ) + { + /* Security in case we're _really_ late */ + b_decode = (pts - now > 0); + } + else + { + b_decode = (pts - now) > (TAU_PRIME(P_CODING_TYPE) + DELTA); + /* next I */ + b_decode &= (pts - now + + period + * ( (S.i_n_p - S.i_eta_p) * (1 + S.i_n_b) - 1 )) + > (TAU_PRIME(P_CODING_TYPE) + + TAU_PRIME(I_CODING_TYPE) + DELTA); + } + } + else + { + b_decode = 0; } + break; - //intf_ErrMsg( "b " ); - p_vpar->synchro.displayable_b--; - return( 1 ); - } + case B_CODING_TYPE: + pts = S.current_pts; - return( 0 ); + if( (S.i_n_b + 1) * period > S.p_tau[P_CODING_TYPE] ) + { + b_decode = (pts - now) > (TAU_PRIME(B_CODING_TYPE) + DELTA); + } + else + { + b_decode = 0; + } + } + vlc_mutex_unlock( &p_vpar->synchro.fifo_lock ); +#ifdef DEBUG_VPAR + intf_DbgMsg("vpar synchro debug: %s picture scheduled for %s, %s (%lld)", + i_coding_type == B_CODING_TYPE ? "B" : + (i_coding_type == P_CODING_TYPE ? "P" : "I"), + mstrtime(p_date, pts), b_decode ? "decoding" : "trashed", + S.p_tau[i_coding_type]); +#endif +#ifdef STATS + if( !b_decode ) + { + S.i_not_chosen_pic++; + } +#endif + return( b_decode ); +#undef S +#undef TAU_PRIME + } } /***************************************************************************** - * vpar_SynchroTrash : Update timers when we trash a picture + * vpar_SynchroTrash : Update counters when we trash a picture *****************************************************************************/ void vpar_SynchroTrash( vpar_thread_t * p_vpar, int i_coding_type, int i_structure ) { - vpar_SynchroUpdateStructures (p_vpar, i_coding_type, 0); - +#ifdef STATS + p_vpar->synchro.i_trashed_pic++; +#endif } /***************************************************************************** * vpar_SynchroDecode : Update timers when we decide to decode a picture *****************************************************************************/ void vpar_SynchroDecode( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) + int i_structure ) { - vpar_SynchroUpdateStructures (p_vpar, i_coding_type, 1); + vlc_mutex_lock( &p_vpar->synchro.fifo_lock ); - p_vpar->synchro.i_date_fifo[p_vpar->synchro.i_stop] = mdate(); - - FIFO_INCREMENT( i_stop ); + if( ((p_vpar->synchro.i_end + 1 - p_vpar->synchro.i_start) + % MAX_DECODING_PIC) ) + { + p_vpar->synchro.p_date_fifo[p_vpar->synchro.i_end] = mdate(); + p_vpar->synchro.pi_coding_types[p_vpar->synchro.i_end] = i_coding_type; + FIFO_INCREMENT( i_end ); + } + else + { + /* FIFO full, panic() */ + intf_ErrMsg("vpar error: synchro fifo full, estimations will be biased"); + } + vlc_mutex_unlock( &p_vpar->synchro.fifo_lock ); } /***************************************************************************** * vpar_SynchroEnd : Called when the image is totally decoded *****************************************************************************/ -void vpar_SynchroEnd( vpar_thread_t * p_vpar ) +void vpar_SynchroEnd( vpar_thread_t * p_vpar, int i_garbage ) { - if( p_vpar->synchro.i_stop != p_vpar->synchro.i_start ) - { - mtime_t i_delay; - - i_delay = ( mdate() - - p_vpar->synchro.i_date_fifo[p_vpar->synchro.i_start] ) - / ( (p_vpar->synchro.i_stop - p_vpar->synchro.i_start) & 0x0f ); + mtime_t tau; + int i_coding_type; - p_vpar->synchro.i_delay = - ( 7 * p_vpar->synchro.i_delay + i_delay ) >> 3; + vlc_mutex_lock( &p_vpar->synchro.fifo_lock ); -#if 0 - intf_ErrMsg( "decode %lli (mean %lli, theorical %lli)\n", - i_delay, p_vpar->synchro.i_delay, - p_vpar->synchro.i_theorical_delay ); -#endif - } - else + if (!i_garbage) { - intf_ErrMsg( "vpar error: critical ! fifo full\n" ); + tau = mdate() - p_vpar->synchro.p_date_fifo[p_vpar->synchro.i_start]; + i_coding_type = p_vpar->synchro.pi_coding_types[p_vpar->synchro.i_start]; + + /* Mean with average tau, to ensure stability. */ + p_vpar->synchro.p_tau[i_coding_type] = + (p_vpar->synchro.pi_meaningful[i_coding_type] + * p_vpar->synchro.p_tau[i_coding_type] + tau) + / (p_vpar->synchro.pi_meaningful[i_coding_type] + 1); + if( p_vpar->synchro.pi_meaningful[i_coding_type] < MAX_PIC_AVERAGE ) + { + p_vpar->synchro.pi_meaningful[i_coding_type]++; + } +#ifdef DEBUG_VPAR + intf_DbgMsg("vpar synchro debug: finished decoding %s (%lld)", + i_coding_type == B_CODING_TYPE ? "B" : + (i_coding_type == P_CODING_TYPE ? "P" : "I"), tau); +#endif } FIFO_INCREMENT( i_start ); + + vlc_mutex_unlock( &p_vpar->synchro.fifo_lock ); } /***************************************************************************** @@ -315,291 +411,205 @@ void vpar_SynchroEnd( vpar_thread_t * p_vpar ) *****************************************************************************/ mtime_t vpar_SynchroDate( vpar_thread_t * p_vpar ) { -#if 0 - - mtime_t i_displaydate = p_vpar->synchro.i_last_pts; - - static mtime_t i_delta = 0; - - intf_ErrMsg( "displaying image with delay %lli and delta %lli\n", - i_displaydate - mdate(), - i_displaydate - i_delta ); - - intf_ErrMsg ( "theorical fps: %f - actual fps: %f \n", - 1000000.0 / p_vpar->synchro.i_theorical_delay, 1000000.0 / p_vpar->synchro.i_delay ); - - i_delta = i_displaydate; - - return i_displaydate; -#else - - return p_vpar->synchro.i_last_pts; - -#endif + /* No need to lock, since PTS are only used by the video parser. */ + return( p_vpar->synchro.current_pts ); } -#endif - -#ifdef MEUUH_SYNCHRO - -/* synchro a deux balles backportee du decodeur de reference. NE MARCHE PAS -AVEC LES IMAGES MONOTRAMES */ - -boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) +/***************************************************************************** + * vpar_SynchroNewPicture: Update stream structure and PTS + *****************************************************************************/ +void vpar_SynchroNewPicture( vpar_thread_t * p_vpar, int i_coding_type, + int i_repeat_field ) { - switch (i_coding_type) + mtime_t period = 1000000 * 1001 / p_vpar->sequence.i_frame_rate; + + switch( i_coding_type ) { - case B_CODING_TYPE: - if ((p_vpar->synchro.kludge_level <= p_vpar->synchro.kludge_nbp)) + case I_CODING_TYPE: + if( p_vpar->synchro.i_eta_p + && p_vpar->synchro.i_eta_p != p_vpar->synchro.i_n_p ) { - p_vpar->synchro.kludge_b++; - return( 0 ); + intf_WarnMsg( 1, "Stream periodicity changed from P[%d] to P[%d]", + p_vpar->synchro.i_n_p, p_vpar->synchro.i_eta_p ); + p_vpar->synchro.i_n_p = p_vpar->synchro.i_eta_p; } - if (p_vpar->synchro.kludge_b % - (p_vpar->synchro.kludge_nbb / - (p_vpar->synchro.kludge_level - p_vpar->synchro.kludge_nbp))) + p_vpar->synchro.i_eta_p = p_vpar->synchro.i_eta_b = 0; +#ifdef STATS + if( p_vpar->synchro.i_type == VPAR_SYNCHRO_DEFAULT ) { - p_vpar->synchro.kludge_b++; - return( 0 ); + intf_Msg( "vpar synchro stats: I(%lld) P(%lld)[%d] B(%lld)[%d] YUV(%lld) : trashed %d:%d/%d", + p_vpar->synchro.p_tau[I_CODING_TYPE], + p_vpar->synchro.p_tau[P_CODING_TYPE], + p_vpar->synchro.i_n_p, + p_vpar->synchro.p_tau[B_CODING_TYPE], + p_vpar->synchro.i_n_b, + p_vpar->p_vout->render_time, + p_vpar->synchro.i_not_chosen_pic, + p_vpar->synchro.i_trashed_pic - + p_vpar->synchro.i_not_chosen_pic, + p_vpar->synchro.i_pic ); + p_vpar->synchro.i_trashed_pic = p_vpar->synchro.i_not_chosen_pic + = p_vpar->synchro.i_pic = 0; } - p_vpar->synchro.kludge_b++; - return( 1 ); - +#endif + break; case P_CODING_TYPE: - if (p_vpar->synchro.kludge_p++ >= p_vpar->synchro.kludge_level) + p_vpar->synchro.i_eta_p++; + if( p_vpar->synchro.i_eta_b + && p_vpar->synchro.i_eta_b != p_vpar->synchro.i_n_b ) { - return( 0 ); + intf_WarnMsg( 1, "Stream periodicity changed from B[%d] to B[%d]", + p_vpar->synchro.i_n_b, p_vpar->synchro.i_eta_b ); + p_vpar->synchro.i_n_b = p_vpar->synchro.i_eta_b; } - return( 1 ); - - default: - return( 1 ); - } -} - -void vpar_SynchroTrash( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) -{ - if (DECODER_FIFO_START(p_vpar->fifo)->b_has_pts && i_coding_type == I_CODING_TYPE) - { - p_vpar->synchro.kludge_nbframes = 0; - p_vpar->synchro.kludge_date = DECODER_FIFO_START(p_vpar->fifo)->i_pts; - } - else - p_vpar->synchro.kludge_nbframes++; - DECODER_FIFO_START(p_vpar->fifo)->b_has_pts = 0; -} - -void vpar_SynchroDecode( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) -{ - if (DECODER_FIFO_START(p_vpar->fifo)->b_has_pts && i_coding_type == I_CODING_TYPE) - { - p_vpar->synchro.kludge_nbframes = 0; - p_vpar->synchro.kludge_date = DECODER_FIFO_START(p_vpar->fifo)->i_pts; - DECODER_FIFO_START(p_vpar->fifo)->b_has_pts = 0; + p_vpar->synchro.i_eta_b = 0; + break; + case B_CODING_TYPE: + p_vpar->synchro.i_eta_b++; + break; } - else - p_vpar->synchro.kludge_nbframes++; -} - -mtime_t vpar_SynchroDate( vpar_thread_t * p_vpar ) -{ - return( p_vpar->synchro.kludge_date - + p_vpar->synchro.kludge_nbframes * 1000000 - / (p_vpar->sequence.i_frame_rate ) * 1001 ); -} - -void vpar_SynchroEnd( vpar_thread_t * p_vpar ) -{ -} - -void vpar_SynchroKludge( vpar_thread_t * p_vpar, mtime_t date ) -{ - mtime_t show_date; - int temp = p_vpar->synchro.kludge_level; - p_vpar->synchro.kludge_nbp = p_vpar->synchro.kludge_p ? p_vpar->synchro.kludge_p : 5; - p_vpar->synchro.kludge_nbb = p_vpar->synchro.kludge_b ? p_vpar->synchro.kludge_b : 6; - show_date = date - mdate(); - p_vpar->synchro.kludge_p = 0; - p_vpar->synchro.kludge_b = 0; + p_vpar->synchro.current_pts += p_vpar->synchro.i_current_period + * (period >> 1); - if (show_date < (SYNC_DELAY - SYNC_TOLERATE) && show_date <= p_vpar->synchro.kludge_prevdate) - { - p_vpar->synchro.kludge_level--; - if (p_vpar->synchro.kludge_level < 0) - p_vpar->synchro.kludge_level = 0; - else if (p_vpar->synchro.kludge_level > - p_vpar->synchro.kludge_nbp + p_vpar->synchro.kludge_nbb) - p_vpar->synchro.kludge_level = p_vpar->synchro.kludge_nbp + p_vpar->synchro.kludge_nbb; -#ifdef DEBUG - if (temp != p_vpar->synchro.kludge_level) - intf_DbgMsg("vdec debug: Level changed from %d to %d (%Ld)\n", - temp, p_vpar->synchro.kludge_level, show_date ); -#endif - } - else if (show_date > (SYNC_DELAY + SYNC_TOLERATE) && show_date >= p_vpar->synchro.kludge_prevdate) +#define PTS_THRESHOLD (period >> 2) + if( i_coding_type == B_CODING_TYPE ) { - p_vpar->synchro.kludge_level++; - if (p_vpar->synchro.kludge_level > p_vpar->synchro.kludge_nbp + p_vpar->synchro.kludge_nbb) - p_vpar->synchro.kludge_level = p_vpar->synchro.kludge_nbp + p_vpar->synchro.kludge_nbb; -#ifdef DEBUG - if (temp != p_vpar->synchro.kludge_level) - intf_DbgMsg("vdec debug: Level changed from %d to %d (%Ld)\n", - temp, p_vpar->synchro.kludge_level, show_date ); -#endif - } - - p_vpar->synchro.kludge_prevdate = show_date; - if ((p_vpar->synchro.kludge_level - p_vpar->synchro.kludge_nbp) > p_vpar->synchro.kludge_nbb) - p_vpar->synchro.kludge_level = p_vpar->synchro.kludge_nbb + p_vpar->synchro.kludge_nbp; -} - -#endif + /* A video frame can be displayed 1, 2 or 3 times, according to + * repeat_first_field, top_field_first, progressive_sequence and + * progressive_frame. */ + p_vpar->synchro.i_current_period = i_repeat_field; - -#ifdef POLUX_SYNCHRO - -void vpar_SynchroSetCurrentDate( vpar_thread_t * p_vpar, int i_coding_type ) -{ - pes_packet_t * p_pes = - p_vpar->bit_stream.p_decoder_fifo->buffer[p_vpar->bit_stream.p_decoder_fifo->i_start]; - - - switch( i_coding_type ) - { - case B_CODING_TYPE: - if( p_pes->b_has_pts ) + if( p_vpar->sequence.next_pts ) { - if( p_pes->i_pts < p_vpar->synchro.i_current_frame_date ) + if( p_vpar->sequence.next_pts - p_vpar->synchro.current_pts + > PTS_THRESHOLD + || p_vpar->synchro.current_pts - p_vpar->sequence.next_pts + > PTS_THRESHOLD ) { - intf_ErrMsg( "vpar warning: pts_date < current_date\n" ); + intf_WarnMsg( 2, + "vpar synchro warning: pts != current_date (%lld)", + p_vpar->synchro.current_pts + - p_vpar->sequence.next_pts ); } - p_vpar->synchro.i_current_frame_date = p_pes->i_pts; - p_pes->b_has_pts = 0; + p_vpar->synchro.current_pts = p_vpar->sequence.next_pts; + p_vpar->sequence.next_pts = 0; } - else - { - p_vpar->synchro.i_current_frame_date += 1000000 / (p_vpar->sequence.i_frame_rate) * 1001; - } - break; - - default: + } + else + { + p_vpar->synchro.i_current_period = p_vpar->synchro.i_backward_period; + p_vpar->synchro.i_backward_period = i_repeat_field; - if( p_vpar->synchro.i_backward_frame_date == 0 ) + if( p_vpar->synchro.backward_pts ) { - p_vpar->synchro.i_current_frame_date += 1000000 / (p_vpar->sequence.i_frame_rate) * 1001; + if( p_vpar->sequence.next_dts && + (p_vpar->sequence.next_dts - p_vpar->synchro.backward_pts + > PTS_THRESHOLD + || p_vpar->synchro.backward_pts - p_vpar->sequence.next_dts + > PTS_THRESHOLD) ) + { + intf_WarnMsg( 2, + "vpar synchro warning: backward_pts != dts (%lld)", + p_vpar->sequence.next_dts + - p_vpar->synchro.backward_pts ); + } + if( p_vpar->synchro.backward_pts - p_vpar->synchro.current_pts + > PTS_THRESHOLD + || p_vpar->synchro.current_pts - p_vpar->synchro.backward_pts + > PTS_THRESHOLD ) + { + intf_WarnMsg( 2, + "vpar synchro warning: backward_pts != current_pts (%lld)", + p_vpar->synchro.current_pts - p_vpar->synchro.backward_pts ); + } + p_vpar->synchro.current_pts = p_vpar->synchro.backward_pts; + p_vpar->synchro.backward_pts = 0; } - else + else if( p_vpar->sequence.next_dts ) { - if( p_vpar->synchro.i_backward_frame_date < p_vpar->synchro.i_current_frame_date ) + if( p_vpar->sequence.next_dts - p_vpar->synchro.current_pts + > PTS_THRESHOLD + || p_vpar->synchro.current_pts - p_vpar->sequence.next_dts + > PTS_THRESHOLD ) { - intf_ErrMsg( "vpar warning: backward_date < current_date (%Ld)\n", - p_vpar->synchro.i_backward_frame_date - p_vpar->synchro.i_current_frame_date ); + intf_WarnMsg( 2, + "vpar synchro warning: dts != current_pts (%lld)", + p_vpar->synchro.current_pts + - p_vpar->sequence.next_dts ); } - p_vpar->synchro.i_current_frame_date = p_vpar->synchro.i_backward_frame_date; - p_vpar->synchro.i_backward_frame_date = 0; + /* By definition of a DTS. */ + p_vpar->synchro.current_pts = p_vpar->sequence.next_dts; + p_vpar->sequence.next_dts = 0; } - if( p_pes->b_has_pts ) + if( p_vpar->sequence.next_pts ) { - p_vpar->synchro.i_backward_frame_date = p_pes->i_pts; - p_pes->b_has_pts = 0; + /* Store the PTS for the next time we have to date an I picture. */ + p_vpar->synchro.backward_pts = p_vpar->sequence.next_pts; + p_vpar->sequence.next_pts = 0; } - break; } +#undef PTS_THRESHOLD + +#ifdef STATS + p_vpar->synchro.i_pic++; +#endif } -boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) +/***************************************************************************** + * SynchroType: Get the user's synchro type + ***************************************************************************** + * This function is called at initialization. + *****************************************************************************/ +static int SynchroType( void ) { - boolean_t b_result = 1; - int i_synchro_level = p_vpar->p_vout->i_synchro_level; - - vpar_SynchroSetCurrentDate( p_vpar, i_coding_type ); + char * psz_synchro = main_GetPszVariable( VPAR_SYNCHRO_VAR, NULL ); - /* - * The synchro level is updated by the video input (see SynchroLevelUpdate) - * so we just use the synchro_level to decide which frame to trash - */ + if( psz_synchro == NULL ) + { + return VPAR_SYNCHRO_DEFAULT; + } - switch( i_coding_type ) + switch( *psz_synchro++ ) { - case I_CODING_TYPE: + case 'i': + case 'I': + switch( *psz_synchro++ ) + { + case '\0': + return VPAR_SYNCHRO_I; - p_vpar->synchro.r_p_average = - (p_vpar->synchro.r_p_average*(SYNC_AVERAGE_COUNT-1)+p_vpar->synchro.i_p_count)/SYNC_AVERAGE_COUNT; - p_vpar->synchro.r_b_average = - (p_vpar->synchro.r_b_average*(SYNC_AVERAGE_COUNT-1)+p_vpar->synchro.i_b_count)/SYNC_AVERAGE_COUNT; + case '+': + if( *psz_synchro ) return 0; + return VPAR_SYNCHRO_Iplus; - p_vpar->synchro.i_p_nb = (int)(p_vpar->synchro.r_p_average+0.5); - p_vpar->synchro.i_b_nb = (int)(p_vpar->synchro.r_b_average+0.5); + case 'p': + case 'P': + switch( *psz_synchro++ ) + { + case '\0': + return VPAR_SYNCHRO_IP; - p_vpar->synchro.i_p_count = p_vpar->synchro.i_b_count = 0; - p_vpar->synchro.i_b_trasher = p_vpar->synchro.i_b_nb / 2; - p_vpar->synchro.i_i_count++; - break; + case '+': + if( *psz_synchro ) return 0; + return VPAR_SYNCHRO_IPplus; - case P_CODING_TYPE: - p_vpar->synchro.i_p_count++; - if( p_vpar->synchro.i_p_count > i_synchro_level ) - { - b_result = 0; - } - break; + case 'b': + case 'B': + if( *psz_synchro ) return 0; + return VPAR_SYNCHRO_IPB; - case B_CODING_TYPE: - p_vpar->synchro.i_b_count++; - if( p_vpar->synchro.i_p_nb >= i_synchro_level ) - { - /* We must trash all the B */ - b_result = 0; - } - else - { - /* We use the brensenham algorithm to decide which B to trash */ - p_vpar->synchro.i_b_trasher += - p_vpar->synchro.i_b_nb - (i_synchro_level-p_vpar->synchro.i_p_nb); - if( p_vpar->synchro.i_b_trasher >= p_vpar->synchro.i_b_nb ) - { - b_result = 0; - p_vpar->synchro.i_b_trasher -= p_vpar->synchro.i_b_nb; + default: + return VPAR_SYNCHRO_DEFAULT; + } + + default: + return VPAR_SYNCHRO_DEFAULT; } - break; } - return( b_result ); -} - -void vpar_SynchroTrash( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) -{ - vpar_SynchroChoose( p_vpar, i_coding_type, i_structure ); -} - -void vpar_SynchroUpdateLevel() -{ - //vlc_mutex_lock( &level_lock ); - //vlc_mutex_unlock( &level_lock ); -} - -mtime_t vpar_SynchroDate( vpar_thread_t * p_vpar ) -{ - return( p_vpar->synchro.i_current_frame_date ); -} - -/* functions with no use */ - -void vpar_SynchroEnd( vpar_thread_t * p_vpar ) -{ -} - -void vpar_SynchroDecode( vpar_thread_t * p_vpar, int i_coding_type, - int i_structure ) -{ + return VPAR_SYNCHRO_DEFAULT; } -#endif