*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*****************************************************************************
* Preamble
*****************************************************************************/
+#include <vlc/vlc.h>
+
#include <stdlib.h> /* free() */
+#include <string.h>
-#include <vlc/vlc.h>
#ifdef HAVE_SYS_TIMES_H
# include <sys/times.h>
#include <vlc/input.h> /* for input_thread_t and i_pts_delay */
#include "vlc_playlist.h"
-#if defined( SYS_DARWIN )
+#include "vlc_filter.h"
+
+#if defined( __APPLE__ )
#include "darwin_specific.h"
#endif
vlc_value_t, vlc_value_t, void * );
static int FilterCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
+static int VideoFilter2Callback( vlc_object_t *, char const *,
+ vlc_value_t, vlc_value_t, void * );
/* From vout_intf.c */
int vout_Snapshot( vout_thread_t *, picture_t * );
+/* Video filter2 parsing */
+static int ParseVideoFilter2Chain( vout_thread_t *, char * );
+static void RemoveVideoFilters2( vout_thread_t *p_vout );
+
+/*****************************************************************************
+ * Video Filter2 functions
+ *****************************************************************************/
+struct filter_owner_sys_t
+{
+ vout_thread_t *p_vout;
+};
+
+static picture_t *video_new_buffer_filter( filter_t *p_filter )
+{
+ picture_t *p_picture;
+ vout_thread_t *p_vout = p_filter->p_owner->p_vout;
+
+ p_picture = vout_CreatePicture( p_vout, 0, 0, 0 );
+
+ return p_picture;
+}
+
+static void video_del_buffer_filter( filter_t *p_filter, picture_t *p_pic )
+{
+ vout_DestroyPicture( p_filter->p_owner->p_vout, p_pic );
+}
+
/*****************************************************************************
* vout_Request: find a video output thread, create one, or destroy one.
*****************************************************************************
{
if( !p_fmt )
{
- /* Reattach video output to input before bailing out */
+ /* Reattach video output to playlist before bailing out */
if( p_vout )
{
- vlc_object_t *p_playlist;
-
- p_playlist = vlc_object_find( p_this, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
-
- if( p_playlist )
- {
- spu_Attach( p_vout->p_spu, p_this, VLC_FALSE );
- vlc_object_detach( p_vout );
- vlc_object_attach( p_vout, p_playlist );
-
- vlc_object_release( p_playlist );
- }
- else
- {
- msg_Dbg( p_this, "cannot find playlist, destroying vout" );
- vlc_object_detach( p_vout );
- vout_Destroy( p_vout );
- }
+ playlist_t *p_playlist = pl_Yield( p_this );
+ spu_Attach( p_vout->p_spu, p_this, VLC_FALSE );
+ vlc_object_detach( p_vout );
+ vlc_object_attach( p_vout, p_playlist );
+ pl_Release( p_this );
}
return NULL;
}
if( !p_vout )
{
- playlist_t *p_playlist;
-
- p_playlist = vlc_object_find( p_this,
- VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
- if( p_playlist )
+ playlist_t *p_playlist = pl_Yield( p_this );
+ vlc_mutex_lock( &p_playlist->gc_lock );
+ p_vout = vlc_object_find( p_playlist,
+ VLC_OBJECT_VOUT, FIND_CHILD );
+ /* only first children of p_input for unused vout */
+ if( p_vout && p_vout->p_parent != (vlc_object_t *)p_playlist )
{
- vlc_mutex_lock( &p_playlist->gc_lock );
- p_vout = vlc_object_find( p_playlist,
- VLC_OBJECT_VOUT, FIND_CHILD );
- /* only first children of p_input for unused vout */
- if( p_vout && p_vout->p_parent != (vlc_object_t *)p_playlist )
- {
- vlc_object_release( p_vout );
- p_vout = NULL;
- }
- vlc_mutex_unlock( &p_playlist->gc_lock );
- vlc_object_release( p_playlist );
+ vlc_object_release( p_vout );
+ p_vout = NULL;
}
+ vlc_mutex_unlock( &p_playlist->gc_lock );
+ pl_Release( p_this );
}
}
var_Create( p_vout, "vout-filter", VLC_VAR_STRING | VLC_VAR_DOINHERIT );
var_Get( p_vout, "vout-filter", &val );
p_vout->psz_filter_chain = val.psz_string;
+
+ /* Apply video filter2 objects on the first vout */
+ var_Create( p_vout, "video-filter",
+ VLC_VAR_STRING | VLC_VAR_DOINHERIT );
+ var_Get( p_vout, "video-filter", &val );
+ ParseVideoFilter2Chain( p_vout, val.psz_string );
+ free( val.psz_string );
}
else
{
if( psz_end && *(psz_end+1) )
p_vout->psz_filter_chain = strdup( psz_end+1 );
else p_vout->psz_filter_chain = NULL;
+
+ /* Create a video filter2 var ... but don't inherit values */
+ var_Create( p_vout, "video-filter", VLC_VAR_STRING );
+ ParseVideoFilter2Chain( p_vout, NULL );
}
+ var_AddCallback( p_vout, "video-filter", VideoFilter2Callback, NULL );
+ p_vout->b_vfilter_change = VLC_TRUE;
+ p_vout->i_vfilters = 0;
+
/* Choose the video output module */
if( !p_vout->psz_filter_chain || !*p_vout->psz_filter_chain )
{
*****************************************************************************/
void vout_Destroy( vout_thread_t *p_vout )
{
- vlc_object_t *p_playlist;
+ vout_thread_t *p_another_vout;
+ playlist_t *p_playlist = pl_Yield( p_vout );
/* Request thread destruction */
p_vout->b_die = VLC_TRUE;
var_Destroy( p_vout, "intf-change" );
- p_playlist = vlc_object_find( p_vout, VLC_OBJECT_PLAYLIST,
- FIND_ANYWHERE );
-
if( p_vout->psz_filter_chain ) free( p_vout->psz_filter_chain );
/* Free structure */
vlc_object_destroy( p_vout );
- /* If it was the last vout, tell the interface to show up */
- if( p_playlist != NULL )
+ p_another_vout = vlc_object_find( p_playlist,
+ VLC_OBJECT_VOUT, FIND_ANYWHERE );
+ if( p_another_vout == NULL )
{
- vout_thread_t *p_another_vout = vlc_object_find( p_playlist,
- VLC_OBJECT_VOUT, FIND_ANYWHERE );
- if( p_another_vout == NULL )
- {
- vlc_value_t val;
- val.b_bool = VLC_TRUE;
- var_Set( p_playlist, "intf-show", val );
- }
- else
- {
- vlc_object_release( p_another_vout );
- }
- vlc_object_release( p_playlist );
+ vlc_value_t val;
+ val.b_bool = VLC_TRUE;
+ var_Set( p_playlist, "intf-show", val );
+ }
+ else
+ {
+ vlc_object_release( p_another_vout );
}
+ vlc_object_release( p_playlist );
}
/*****************************************************************************
subpicture_t * p_subpic = NULL; /* subpicture pointer */
+ input_thread_t *p_input = NULL ; /* Parent input, if it exists */
+
+ vlc_value_t val;
+ vlc_bool_t b_drop_late;
+
+ int i_displayed = 0, i_lost = 0, i_loops = 0;
+
/*
* Initialize thread
*/
p_vout->b_error = InitThread( p_vout );
+ var_Create( p_vout, "drop-late-frames", VLC_VAR_BOOL | VLC_VAR_DOINHERIT );
+ var_Get( p_vout, "drop-late-frames", &val );
+ b_drop_late = val.b_bool;
+
/* signal the creation of the vout */
vlc_thread_ready( p_vout );
display_date = 0;
current_date = mdate();
+ if( p_input && p_input->b_die )
+ {
+ vlc_object_release( p_input );
+ p_input = NULL;
+ }
+
+ i_loops++;
+ if( i_loops % 20 == 0 )
+ {
+ if( !p_input )
+ {
+ p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT,
+ FIND_PARENT );
+ }
+ if( p_input )
+ {
+ vlc_mutex_lock( &p_input->counters.counters_lock );
+ stats_UpdateInteger( p_vout, p_input->counters.p_lost_pictures,
+ i_lost , NULL);
+ stats_UpdateInteger( p_vout,
+ p_input->counters.p_displayed_pictures,
+ i_displayed , NULL);
+ i_displayed = i_lost = 0;
+ vlc_mutex_unlock( &p_input->counters.counters_lock );
+ }
+ }
#if 0
p_vout->c_loops++;
if( !(p_vout->c_loops % VOUT_STATS_NB_LOOPS) )
p_vout->p_fps_sample[ p_vout->c_fps_samples++ % VOUT_FPS_SAMPLES ]
= display_date;
- /* XXX: config_GetInt is slow, but this kind of frame dropping
- * should not happen that often. */
if( !p_picture->b_force &&
p_picture != p_last_picture &&
display_date < current_date + p_vout->render_time &&
- config_GetInt( p_vout, "skip-frames" ) )
+ b_drop_late )
{
/* Picture is late: it will be destroyed and the thread
* will directly choose the next picture */
}
msg_Warn( p_vout, "late picture skipped ("I64Fd")",
current_date - display_date );
+ i_lost++;
vlc_mutex_unlock( &p_vout->picture_lock );
continue;
p_picture->i_status = DESTROYED_PICTURE;
p_vout->i_heap_size--;
}
+ i_lost++;
msg_Warn( p_vout, "vout warning: early picture skipped "
"("I64Fd")", display_date - current_date
- p_vout->i_pts_delay );
i_idle_loops++;
}
+ /* Video Filter2 stuff */
+ if( p_vout->b_vfilter_change == VLC_TRUE )
+ {
+ int i;
+ RemoveVideoFilters2( p_vout );
+ for( i = 0; i < p_vout->i_vfilters_cfg; i++ )
+ {
+ filter_t *p_vfilter =
+ p_vout->pp_vfilters[p_vout->i_vfilters] =
+ vlc_object_create( p_vout, VLC_OBJECT_FILTER );
+
+ vlc_object_attach( p_vfilter, p_vout );
+
+ p_vfilter->pf_vout_buffer_new = video_new_buffer_filter;
+ p_vfilter->pf_vout_buffer_del = video_del_buffer_filter;
+
+ if( !p_vout->i_vfilters )
+ {
+ p_vfilter->fmt_in.video = p_vout->fmt_render;
+ }
+ else
+ {
+ p_vfilter->fmt_in.video = (p_vfilter-1)->fmt_out.video;
+ }
+ /* TODO: one day filters in the middle of the chain might
+ * have a different fmt_out.video than fmt_render ... */
+ p_vfilter->fmt_out.video = p_vout->fmt_render;
+
+ p_vfilter->p_cfg = p_vout->p_vfilters_cfg[i];
+ p_vfilter->p_module = module_Need( p_vfilter, "video filter2",
+ p_vout->psz_vfilters[i], 0 );
+
+ if( p_vfilter->p_module )
+ {
+ p_vfilter->p_owner =
+ malloc( sizeof( filter_owner_sys_t ) );
+ p_vfilter->p_owner->p_vout = p_vout;
+ p_vout->i_vfilters++;
+ msg_Dbg( p_vout, "video filter found (%s)",
+ p_vout->psz_vfilters[i] );
+ }
+ else
+ {
+ msg_Err( p_vout, "no video filter found (%s)",
+ p_vout->psz_vfilters[i] );
+ vlc_object_detach( p_vfilter );
+ vlc_object_destroy( p_vfilter );
+ }
+ }
+ p_vout->b_vfilter_change = VLC_FALSE;
+ }
+
+ if( p_picture )
+ {
+ int i;
+ for( i = 0; i < p_vout->i_vfilters; i++ )
+ {
+ picture_t *p_old = p_picture;
+ p_picture = p_vout->pp_vfilters[i]->pf_video_filter(
+ p_vout->pp_vfilters[i], p_picture );
+ if( !p_picture )
+ {
+ break;
+ }
+ /* FIXME: this is kind of wrong
+ * if you have 2 or more vfilters and the 2nd breaks,
+ * on the next loop the 1st one will be applied again */
+
+ /* if p_old and p_picture are the same (ie the filter
+ * worked on the old picture), then following code is
+ * still alright since i_status gets changed back to
+ * the right value */
+ if( p_old->i_refcount )
+ {
+ p_old->i_status = DISPLAYED_PICTURE;
+ }
+ else
+ {
+ p_old->i_status = DESTROYED_PICTURE;
+ }
+ p_picture->i_status = READY_PICTURE;
+ }
+ }
+
if( p_picture && p_vout->b_snapshot )
{
p_vout->b_snapshot = VLC_FALSE;
*/
if( display_date > 0 )
{
- p_subpic = spu_SortSubpictures( p_vout->p_spu, display_date );
+ if( !p_input )
+ {
+ p_input = vlc_object_find( p_vout, VLC_OBJECT_INPUT,
+ FIND_PARENT );
+ }
+ p_subpic = spu_SortSubpictures( p_vout->p_spu, display_date,
+ p_input ? var_GetBool( p_input, "state" ) == PAUSE_S : VLC_FALSE );
}
/*
* Perform rendering
*/
+ i_displayed++;
p_directbuffer = vout_RenderPicture( p_vout, p_picture, p_subpic );
/*
}
}
+ if( p_input )
+ {
+ vlc_object_release( p_input );
+ }
+
/*
* Error loop - wait until the thread destruction is requested
*/
spu_Attach( p_vout->p_spu, VLC_OBJECT(p_vout), VLC_FALSE );
spu_Destroy( p_vout->p_spu );
+ /* Destroy the video filters2 */
+ RemoveVideoFilters2( p_vout );
+
/* Destroy translation tables */
p_vout->pf_end( p_vout );
}
/* Get bits */
- i_low = i_mask & (- (int32_t)i_mask); /* lower bit of the mask */
- i_high = i_mask + i_low; /* higher bit of the mask */
+ i_low = i_high = i_mask;
- /* Transform bits into an index */
+ i_low &= - (int32_t)i_low; /* lower bit of the mask */
+ i_high += i_low; /* higher bit of the mask */
+
+ /* Transform bits into an index. Also deal with i_high overflow, which
+ * is faster than changing the BinaryLog code to handle 64 bit integers. */
i_low = BinaryLog (i_low);
- i_high = BinaryLog (i_high);
+ i_high = i_high ? BinaryLog (i_high) : 32;
/* Update pointers and return */
*pi_left = i_low;
return VLC_SUCCESS;
}
+
+/*****************************************************************************
+ * Video Filter2 stuff
+ *****************************************************************************/
+static int ParseVideoFilter2Chain( vout_thread_t *p_vout, char *psz_vfilters )
+{
+ int i;
+ for( i = 0; i < p_vout->i_vfilters_cfg; i++ )
+ {
+ struct config_chain_t *p_cfg =
+ p_vout->p_vfilters_cfg[p_vout->i_vfilters_cfg];
+ config_ChainDestroy( p_cfg );
+ free( p_vout->psz_vfilters[p_vout->i_vfilters_cfg] );
+ }
+ p_vout->i_vfilters_cfg = 0;
+ if( psz_vfilters && *psz_vfilters )
+ {
+ char *psz_parser = psz_vfilters;
+
+ while( psz_parser && *psz_parser )
+ {
+ psz_parser = config_ChainCreate(
+ &p_vout->psz_vfilters[p_vout->i_vfilters_cfg],
+ &p_vout->p_vfilters_cfg[p_vout->i_vfilters_cfg],
+ psz_parser );
+ msg_Dbg( p_vout, "adding vfilter: %s",
+ p_vout->psz_vfilters[p_vout->i_vfilters_cfg] );
+ p_vout->i_vfilters_cfg++;
+ if( psz_parser && psz_parser )
+ {
+ if( p_vout->i_vfilters_cfg == MAX_VFILTERS )
+ {
+ msg_Warn( p_vout,
+ "maximum number of video filters reached. \"%s\" discarded",
+ psz_parser );
+ break;
+ }
+ }
+ }
+ }
+ return VLC_SUCCESS;
+}
+
+static int VideoFilter2Callback( vlc_object_t *p_this, char const *psz_cmd,
+ vlc_value_t oldval, vlc_value_t newval, void *p_data )
+{
+ vout_thread_t *p_vout = (vout_thread_t *)p_this;
+
+ ParseVideoFilter2Chain( p_vout, newval.psz_string );
+ p_vout->b_vfilter_change = VLC_TRUE;
+
+ return VLC_SUCCESS;
+}
+
+static void RemoveVideoFilters2( vout_thread_t *p_vout )
+{
+ int i;
+ for( i = 0; i < p_vout->i_vfilters; i++ )
+ {
+ vlc_object_detach( p_vout->pp_vfilters[i] );
+ if( p_vout->pp_vfilters[i]->p_module )
+ {
+ module_Unneed( p_vout->pp_vfilters[i],
+ p_vout->pp_vfilters[i]->p_module );
+ }
+
+ free( p_vout->pp_vfilters[i]->p_owner );
+ vlc_object_destroy( p_vout->pp_vfilters[i] );
+ }
+ p_vout->i_vfilters = 0;
+}