{
VLC_COMMON_MEMBERS
- /** \name Thread properties and locks */
- /**@{*/
- vlc_mutex_t picture_lock; /**< picture heap lock */
- vlc_mutex_t change_lock; /**< thread change lock */
- /**@}*/
-
- /** \name Current display properties */
- /**@{*/
- uint16_t i_changes; /**< changes made to the thread.
- \see \ref vout_changes */
- unsigned b_fullscreen:1; /**< toogle fullscreen display */
- unsigned b_on_top:1; /**< stay always on top of other windows */
-
- /**@}*/
-
- /** \name Video heap and translation tables */
- /**@{*/
- picture_heap_t render; /**< rendered pictures */
- picture_heap_t output; /**< direct buffers */
-
video_format_t fmt_render; /* render format (from the decoder) */
video_format_t fmt_in; /* input (modified render) format */
video_format_t fmt_out; /* output format (for the video output) */
- /**@}*/
-
- /* Picture heap */
- picture_t p_picture[2*VOUT_MAX_PICTURES+1]; /**< pictures */
/* Private vout_thread data */
vout_thread_sys_t *p;
};
-#define I_OUTPUTPICTURES p_vout->output.i_pictures
-#define PP_OUTPUTPICTURE p_vout->output.pp_picture
-#define I_RENDERPICTURES p_vout->render.i_pictures
-#define PP_RENDERPICTURE p_vout->render.pp_picture
-
-/** \defgroup vout_changes Flags for changes
- * These flags are set in the vout_thread_t::i_changes field when another
- * thread changed a variable
- * @{
- */
-/** b_autoscale changed */
-#define VOUT_SCALE_CHANGE 0x0008
-/** b_on_top changed */
-#define VOUT_ON_TOP_CHANGE 0x0010
-/** b_fullscreen changed */
-#define VOUT_FULLSCREEN_CHANGE 0x0040
-/** i_zoom changed */
-#define VOUT_ZOOM_CHANGE 0x0080
-/** cropping parameters changed */
-#define VOUT_CROP_CHANGE 0x1000
-/** aspect ratio changed */
-#define VOUT_ASPECT_CHANGE 0x2000
-/** change/recreate picture buffers */
-#define VOUT_PICTURE_BUFFERS_CHANGE 0x4000
-/**@}*/
-
/* Alignment flags */
#define VOUT_ALIGN_LEFT 0x0001
#define VOUT_ALIGN_RIGHT 0x0002
{
vout_thread_t *p_vout = (vout_thread_t*)p_filter->p_owner;
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
vout_UsePictureLocked( p_vout, p_pic );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
static int video_filter_buffer_allocation_init( filter_t *p_filter, void *p_data )
/* If we now have a video output, check it has the right properties */
if( p_vout )
{
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
/* We don't directly check for the "vout-filter" variable for obvious
* performance reasons. */
p_vout->fmt_render.i_height != p_fmt->i_height ||
p_vout->p->b_filter_change )
{
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
/* We are not interested in this format, close this vout */
vout_CloseAndRelease( p_vout );
p_vout->fmt_render.i_sar_num = i_sar_num;
p_vout->fmt_render.i_sar_den = i_sar_den;
- p_vout->i_changes |= VOUT_ASPECT_CHANGE;
+ p_vout->p->i_changes |= VOUT_ASPECT_CHANGE;
}
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
vlc_object_release( p_vout );
}
* will be initialized later in InitThread */
for( i_index = 0; i_index < 2 * VOUT_MAX_PICTURES + 1; i_index++)
{
- p_vout->p_picture[i_index].i_status = FREE_PICTURE;
- p_vout->p_picture[i_index].i_type = EMPTY_PICTURE;
- p_vout->p_picture[i_index].b_slow = 0;
+ p_vout->p->p_picture[i_index].i_status = FREE_PICTURE;
+ p_vout->p->p_picture[i_index].i_type = EMPTY_PICTURE;
+ p_vout->p->p_picture[i_index].b_slow = 0;
}
/* Initialize the rendering heap */
video_format_FixRgb( &p_vout->fmt_render );
video_format_FixRgb( &p_vout->fmt_in );
- p_vout->render.i_last_used_pic = -1;
+ p_vout->p->render.i_last_used_pic = -1;
/* Zero the output heap */
I_OUTPUTPICTURES = 0;
/* Initialize misc stuff */
- p_vout->i_changes = 0;
- p_vout->b_fullscreen = 0;
+ p_vout->p->i_changes = 0;
+ p_vout->p->b_fullscreen = 0;
p_vout->p->render_time = 10;
p_vout->p->c_fps_samples = 0;
vout_statistic_Init( &p_vout->p->statistic );
vout_snapshot_Init( &p_vout->p->snapshot );
/* Initialize locks */
- vlc_mutex_init( &p_vout->picture_lock );
+ vlc_mutex_init( &p_vout->p->picture_lock );
vlc_cond_init( &p_vout->p->picture_wait );
- vlc_mutex_init( &p_vout->change_lock );
+ vlc_mutex_init( &p_vout->p->change_lock );
vlc_mutex_init( &p_vout->p->vfilter_lock );
/* Mouse coordinates */
return NULL;
}
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
while( !p_vout->p->b_ready )
{ /* We are (ab)using the same condition in opposite directions for
* b_ready and b_done. This works because of the strict ordering. */
assert( !p_vout->p->b_done );
- vlc_cond_wait( &p_vout->p->change_wait, &p_vout->change_lock );
+ vlc_cond_wait( &p_vout->p->change_wait, &p_vout->p->change_lock );
}
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
if( p_vout->p->b_error )
{
{
assert( p_vout );
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
p_vout->p->b_done = true;
vlc_cond_signal( &p_vout->p->change_wait );
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
vout_snapshot_End( &p_vout->p->snapshot );
/* Destroy the locks */
vlc_cond_destroy( &p_vout->p->change_wait );
vlc_cond_destroy( &p_vout->p->picture_wait );
- vlc_mutex_destroy( &p_vout->picture_lock );
- vlc_mutex_destroy( &p_vout->change_lock );
+ vlc_mutex_destroy( &p_vout->p->picture_lock );
+ vlc_mutex_destroy( &p_vout->p->change_lock );
vlc_mutex_destroy( &p_vout->p->vfilter_lock );
/* */
/* */
void vout_ChangePause( vout_thread_t *p_vout, bool b_paused, mtime_t i_date )
{
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
assert( !p_vout->p->b_paused || !b_paused );
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
p_vout->p->i_picture_displayed_date = 0;
p_pic->date += i_duration;
}
vlc_cond_signal( &p_vout->p->picture_wait );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
spu_OffsetSubtitleDate( p_vout->p->p_spu, i_duration );
}
else
{
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
p_vout->p->b_paused = b_paused;
p_vout->p->i_pause_date = i_date;
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
}
void vout_GetResetStatistic( vout_thread_t *p_vout, int *pi_displayed, int *pi_lost )
void vout_Flush( vout_thread_t *p_vout, mtime_t i_date )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
p_vout->p->i_picture_displayed_date = 0;
- for( int i = 0; i < p_vout->render.i_pictures; i++ )
+ for( int i = 0; i < p_vout->p->render.i_pictures; i++ )
{
- picture_t *p_pic = p_vout->render.pp_picture[i];
+ picture_t *p_pic = p_vout->p->render.pp_picture[i];
if( p_pic->i_status == READY_PICTURE ||
p_pic->i_status == DISPLAYED_PICTURE )
}
}
vlc_cond_signal( &p_vout->p->picture_wait );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
void vout_FixLeaks( vout_thread_t *p_vout, bool b_forced )
{
int i_pic, i_ready_pic;
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
- for( i_pic = 0, i_ready_pic = 0; i_pic < p_vout->render.i_pictures && !b_forced; i_pic++ )
+ for( i_pic = 0, i_ready_pic = 0; i_pic < p_vout->p->render.i_pictures && !b_forced; i_pic++ )
{
- const picture_t *p_pic = p_vout->render.pp_picture[i_pic];
+ const picture_t *p_pic = p_vout->p->render.pp_picture[i_pic];
if( p_pic->i_status == READY_PICTURE )
{
break;
}
}
- if( i_pic < p_vout->render.i_pictures && !b_forced )
+ if( i_pic < p_vout->p->render.i_pictures && !b_forced )
{
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
return;
}
msg_Err( p_vout, "pictures leaked, resetting the heap" );
/* Just free all the pictures */
- for( i_pic = 0; i_pic < p_vout->render.i_pictures; i_pic++ )
+ for( i_pic = 0; i_pic < p_vout->p->render.i_pictures; i_pic++ )
{
- picture_t *p_pic = p_vout->render.pp_picture[i_pic];
+ picture_t *p_pic = p_vout->p->render.pp_picture[i_pic];
msg_Dbg( p_vout, "[%d] %d %d", i_pic, p_pic->i_status, p_pic->i_refcount );
p_pic->i_refcount = 0;
}
}
vlc_cond_signal( &p_vout->p->picture_wait );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
void vout_NextPicture( vout_thread_t *p_vout, mtime_t *pi_duration )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
const mtime_t i_displayed_date = p_vout->p->i_picture_displayed_date;
}
while( !p_vout->p->b_picture_displayed && !p_vout->p->b_picture_empty )
- vlc_cond_wait( &p_vout->p->picture_wait, &p_vout->picture_lock );
+ vlc_cond_wait( &p_vout->p->picture_wait, &p_vout->p->picture_lock );
*pi_duration = __MAX( p_vout->p->i_picture_displayed_date - i_displayed_date, 0 );
/* TODO advance subpicture by the duration ... */
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
void vout_DisplayTitle( vout_thread_t *p_vout, const char *psz_title )
if( !var_InheritBool( p_vout, "osd" ) )
return;
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
free( p_vout->p->psz_title );
p_vout->p->psz_title = strdup( psz_title );
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
}
spu_t *vout_GetSpu( vout_thread_t *p_vout )
* for memcpy operations */
for( i = 1; i < VOUT_MAX_PICTURES; i++ )
{
- if( p_vout->p_picture[ i ].i_type != DIRECT_PICTURE &&
+ if( p_vout->p->p_picture[ i ].i_type != DIRECT_PICTURE &&
I_RENDERPICTURES >= VOUT_MIN_DIRECT_PICTURES - 1 &&
- p_vout->p_picture[ i - 1 ].i_type == DIRECT_PICTURE )
+ p_vout->p->p_picture[ i - 1 ].i_type == DIRECT_PICTURE )
{
/* We have enough direct buffers so there's no need to
* try to use system memory buffers. */
break;
}
- PP_RENDERPICTURE[ I_RENDERPICTURES ] = &p_vout->p_picture[ i ];
+ PP_RENDERPICTURE[ I_RENDERPICTURES ] = &p_vout->p->p_picture[ i ];
I_RENDERPICTURES++;
}
*/
b_has_wrapper = !vout_OpenWrapper( p_vout, p_vout->p->psz_module_name );
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
if( b_has_wrapper )
p_vout->p->b_error = InitThread( p_vout );
if( p_vout->p->b_title_show && p_vout->p->psz_title )
DisplayTitleOnOSD( p_vout );
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
/* Look for the earliest picture but after the last displayed one */
picture_t *p_last = p_vout->p->p_picture_displayed;;
const bool b_picture_interlaced = p_vout->p->b_picture_interlaced;
const int i_picture_interlaced_state = (!!p_vout->p->b_picture_interlaced) - (!!b_picture_interlaced_last);
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
if( p_picture == NULL )
i_idle_loops++;
}
/* Give back change lock */
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
/* Sleep a while or until a given date */
if( display_date != 0 )
else
{
/* Wait until a frame is being sent or a spurious wakeup (not a problem here) */
- vlc_mutex_lock( &p_vout->picture_lock );
- vlc_cond_timedwait( &p_vout->p->picture_wait, &p_vout->picture_lock, current_date + VOUT_IDLE_SLEEP );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
+ vlc_cond_timedwait( &p_vout->p->picture_wait, &p_vout->p->picture_lock, current_date + VOUT_IDLE_SLEEP );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
/* On awakening, take back lock and send immediately picture
* to display. */
/* Note: p_vout->p->b_done could be true here and now */
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
/*
* Display the previously rendered picture
/* Drop the filtered picture if created by video filters */
if( p_filtered_picture != NULL && p_filtered_picture != p_picture )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
vout_UsePictureLocked( p_vout, p_filtered_picture );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
if( p_picture != NULL )
break;
}
- if( p_vout->i_changes & VOUT_ON_TOP_CHANGE )
- p_vout->i_changes &= ~VOUT_ON_TOP_CHANGE;
+ if( p_vout->p->i_changes & VOUT_ON_TOP_CHANGE )
+ p_vout->p->i_changes &= ~VOUT_ON_TOP_CHANGE;
- if( p_vout->i_changes & VOUT_PICTURE_BUFFERS_CHANGE )
+ if( p_vout->p->i_changes & VOUT_PICTURE_BUFFERS_CHANGE )
{
/* This happens when the picture buffers need to be recreated.
* This is useful on multimonitor displays for instance.
*
* Warning: This only works when the vout creates only 1 picture
* buffer!! */
- p_vout->i_changes &= ~VOUT_PICTURE_BUFFERS_CHANGE;
+ p_vout->p->i_changes &= ~VOUT_PICTURE_BUFFERS_CHANGE;
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
vout_EndWrapper( p_vout );
msg_Err( p_vout, "InitThread after VOUT_PICTURE_BUFFERS_CHANGE failed" );
vlc_cond_signal( &p_vout->p->picture_wait );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
if( p_vout->p->b_error )
break;
exit_thread:
/* End of thread */
EndThread( p_vout );
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
if( b_has_wrapper )
vout_CloseWrapper( p_vout );
{
/* Wait until a `close' order */
while( !p_vout->p->b_done )
- vlc_cond_wait( &p_vout->p->change_wait, &p_vout->change_lock );
+ vlc_cond_wait( &p_vout->p->change_wait, &p_vout->p->change_lock );
}
/*****************************************************************************
/* Destroy all remaining pictures */
for( i_index = 0; i_index < 2 * VOUT_MAX_PICTURES + 1; i_index++ )
{
- if ( p_vout->p_picture[i_index].i_type == MEMORY_PICTURE )
+ if ( p_vout->p->p_picture[i_index].i_type == MEMORY_PICTURE )
{
- free( p_vout->p_picture[i_index].p_data_orig );
+ free( p_vout->p->p_picture[i_index].p_data_orig );
}
}
if( i_stop <= i_start )
return;
- vlc_assert_locked( &p_vout->change_lock );
+ vlc_assert_locked( &p_vout->p->change_lock );
vout_ShowTextAbsolute( p_vout, DEFAULT_CHAN,
p_vout->p->psz_title, NULL,
/* */
vlc_mouse_t mouse;
+
+ /* */
+ vlc_mutex_t picture_lock; /**< picture heap lock */
+ vlc_mutex_t change_lock; /**< thread change lock */
+
+ uint16_t i_changes; /**< changes made to the thread.
+ \see \ref vout_changes */
+ unsigned b_fullscreen:1; /**< toogle fullscreen display */
+ unsigned b_on_top:1; /**< stay always on top of other windows */
+
+ picture_heap_t render; /**< rendered pictures */
+ picture_heap_t output; /**< direct buffers */
+
+ picture_t p_picture[2*VOUT_MAX_PICTURES+1]; /**< pictures */
};
+#define I_OUTPUTPICTURES p_vout->p->output.i_pictures
+#define PP_OUTPUTPICTURE p_vout->p->output.pp_picture
+#define I_RENDERPICTURES p_vout->p->render.i_pictures
+#define PP_RENDERPICTURE p_vout->p->render.pp_picture
+
+/** \defgroup vout_changes Flags for changes
+ * These flags are set in the vout_thread_t::i_changes field when another
+ * thread changed a variable
+ * @{
+ */
+/** b_autoscale changed */
+#define VOUT_SCALE_CHANGE 0x0008
+/** b_on_top changed */
+#define VOUT_ON_TOP_CHANGE 0x0010
+/** b_fullscreen changed */
+#define VOUT_FULLSCREEN_CHANGE 0x0040
+/** i_zoom changed */
+#define VOUT_ZOOM_CHANGE 0x0080
+/** cropping parameters changed */
+#define VOUT_CROP_CHANGE 0x1000
+/** aspect ratio changed */
+#define VOUT_ASPECT_CHANGE 0x2000
+/** change/recreate picture buffers */
+#define VOUT_PICTURE_BUFFERS_CHANGE 0x4000
+/**@}*/
+
+
/* */
int vout_AllocatePicture( vlc_object_t *, picture_t *, uint32_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den );
#define vout_AllocatePicture(a,b,c,d,e,f,g) \
if( var_CreateGetBoolCommand( p_vout, "fullscreen" ) )
{
/* user requested fullscreen */
- p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
+ p_vout->p->i_changes |= VOUT_FULLSCREEN_CHANGE;
}
text.psz_string = _("Fullscreen");
var_Change( p_vout, "fullscreen", VLC_VAR_SETTEXT, &text, NULL );
}
crop_end:
- p_vout->i_changes |= VOUT_CROP_CHANGE;
+ p_vout->p->i_changes |= VOUT_CROP_CHANGE;
msg_Dbg( p_vout, "cropping picture %ix%i to %i,%i,%ix%i",
p_vout->fmt_in.i_width, p_vout->fmt_in.i_height,
p_vout->fmt_in.i_sar_den *= p_vout->p->i_par_num;
}
- p_vout->i_changes |= VOUT_ASPECT_CHANGE;
+ p_vout->p->i_changes |= VOUT_ASPECT_CHANGE;
msg_Dbg( p_vout, "new aspect-ratio %i:%i, sample aspect-ratio %i:%i",
p_vout->fmt_in.i_sar_num * p_vout->fmt_in.i_width,
vout_thread_t *p_vout = (vout_thread_t *)p_this;
(void)oldval; (void)newval; (void)p_data;
- vlc_mutex_lock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
if( !strcmp( psz_cmd, "autoscale" ) )
{
- p_vout->i_changes |= VOUT_SCALE_CHANGE;
+ p_vout->p->i_changes |= VOUT_SCALE_CHANGE;
}
else if( !strcmp( psz_cmd, "scale" ) )
{
- p_vout->i_changes |= VOUT_ZOOM_CHANGE;
+ p_vout->p->i_changes |= VOUT_ZOOM_CHANGE;
}
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_unlock( &p_vout->p->change_lock );
return VLC_SUCCESS;
}
{
vout_thread_t *p_vout = (vout_thread_t *)p_this;
- vlc_mutex_lock( &p_vout->change_lock );
- p_vout->i_changes |= VOUT_ON_TOP_CHANGE;
- p_vout->b_on_top = newval.b_bool;
- vlc_mutex_unlock( &p_vout->change_lock );
+ vlc_mutex_lock( &p_vout->p->change_lock );
+ p_vout->p->i_changes |= VOUT_ON_TOP_CHANGE;
+ p_vout->p->b_on_top = newval.b_bool;
+ vlc_mutex_unlock( &p_vout->p->change_lock );
(void)psz_cmd; (void)oldval; (void)p_data;
return VLC_SUCCESS;
if( oldval.b_bool == newval.b_bool )
return VLC_SUCCESS; /* no-op */
- p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
+ p_vout->p->i_changes |= VOUT_FULLSCREEN_CHANGE;
val.b_bool = true;
var_Set( p_vout, "intf-change", val );
*/
void vout_DisplayPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
if( p_pic->i_status == RESERVED_PICTURE )
{
p_vout->p->i_picture_qtype = p_pic->i_qtype;
p_vout->p->b_picture_interlaced = !p_pic->b_progressive;
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
/**
int i_free = 0;
int i_pic;
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
for( i_pic = 0; i_pic < I_RENDERPICTURES; i_pic++ )
{
- picture_t *p_pic = PP_RENDERPICTURE[(p_vout->render.i_last_used_pic + i_pic + 1) % I_RENDERPICTURES];
+ picture_t *p_pic = PP_RENDERPICTURE[(p_vout->p->render.i_last_used_pic + i_pic + 1) % I_RENDERPICTURES];
switch( p_pic->i_status )
{
break;
}
}
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
return i_free;
}
picture_t * p_freepic = NULL; /* first free picture */
/* Get lock */
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
/*
* Look for an empty place in the picture heap.
*/
for( i_pic = 0; i_pic < I_RENDERPICTURES; i_pic++ )
{
- p_pic = PP_RENDERPICTURE[(p_vout->render.i_last_used_pic + i_pic + 1)
+ p_pic = PP_RENDERPICTURE[(p_vout->p->render.i_last_used_pic + i_pic + 1)
% I_RENDERPICTURES];
switch( p_pic->i_status )
p_pic->i_nb_fields = i_nb_fields;
p_pic->b_top_field_first = b_top_field_first;
- p_vout->render.i_last_used_pic =
- ( p_vout->render.i_last_used_pic + i_pic + 1 )
+ p_vout->p->render.i_last_used_pic =
+ ( p_vout->p->render.i_last_used_pic + i_pic + 1 )
% I_RENDERPICTURES;
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
return( p_pic );
case FREE_PICTURE:
/* Picture is empty and ready for allocation */
- p_vout->render.i_last_used_pic =
- ( p_vout->render.i_last_used_pic + i_pic + 1 )
+ p_vout->p->render.i_last_used_pic =
+ ( p_vout->p->render.i_last_used_pic + i_pic + 1 )
% I_RENDERPICTURES;
p_freepic = p_pic;
break;
msg_Err( p_vout, "picture allocation failed" );
}
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
return( p_freepic );
}
/* No free or destroyed picture could be found, but the decoder
* will try again in a while. */
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
return( NULL );
}
/* */
static void DestroyPicture( vout_thread_t *p_vout, picture_t *p_picture )
{
- vlc_assert_locked( &p_vout->picture_lock );
+ vlc_assert_locked( &p_vout->p->picture_lock );
p_picture->i_status = DESTROYED_PICTURE;
picture_CleanupQuant( p_picture );
{
#ifndef NDEBUG
/* Check if picture status is valid */
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
if( p_pic->i_status != RESERVED_PICTURE )
{
msg_Err( p_vout, "picture to destroy %p has invalid status %d",
p_pic, p_pic->i_status );
}
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
#endif
vout_DropPicture( p_vout, p_pic );
/* */
void vout_UsePictureLocked( vout_thread_t *p_vout, picture_t *p_picture )
{
- vlc_assert_locked( &p_vout->picture_lock );
+ vlc_assert_locked( &p_vout->p->picture_lock );
if( p_picture->i_refcount > 0 )
{
/* Pretend we displayed the picture, but don't destroy
/* */
void vout_DropPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
if( p_pic->i_status == READY_PICTURE )
{
vout_UsePictureLocked( p_vout, p_pic );
}
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
/**
*/
void vout_LinkPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
p_pic->i_refcount++;
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
/**
*/
void vout_UnlinkPicture( vout_thread_t *p_vout, picture_t *p_pic )
{
- vlc_mutex_lock( &p_vout->picture_lock );
+ vlc_mutex_lock( &p_vout->p->picture_lock );
if( p_pic->i_refcount > 0 )
p_pic->i_refcount--;
( p_pic->i_status == DISPLAYED_PICTURE || p_pic->i_status == RESERVED_PICTURE ) )
DestroyPicture( p_vout, p_pic );
- vlc_mutex_unlock( &p_vout->picture_lock );
+ vlc_mutex_unlock( &p_vout->p->picture_lock );
}
/**
/* The picture buffer is in slow memory. We'll use
* the "2 * VOUT_MAX_PICTURES + 1" picture as a temporary
* one for subpictures rendering. */
- p_render = &p_vout->p_picture[2 * VOUT_MAX_PICTURES];
+ p_render = &p_vout->p->p_picture[2 * VOUT_MAX_PICTURES];
if( p_render->i_status == FREE_PICTURE )
{
vout_AllocatePicture( VLC_OBJECT(p_vout),
vout->fmt_in.i_visible_height != source.i_visible_height ||
vout->fmt_in.i_x_offset != source.i_x_offset ||
vout->fmt_in.i_y_offset != source.i_y_offset )
- vout->i_changes |= VOUT_CROP_CHANGE;
+ vout->p->i_changes |= VOUT_CROP_CHANGE;
- if (vout->b_on_top)
+ if (vout->p->b_on_top)
vout_SetWindowState(vd, VOUT_WINDOW_STATE_ABOVE);
/* XXX For non dr case, the current vout implementation force us to
sys->use_dr = !vout_IsDisplayFiltered(vd);
const bool allow_dr = !vd->info.has_pictures_invalid && sys->use_dr;
const int picture_max = allow_dr ? VOUT_MAX_PICTURES : 1;
- for (vout->output.i_pictures = 0;
- vout->output.i_pictures < picture_max;
- vout->output.i_pictures++) {
+ for (vout->p->output.i_pictures = 0;
+ vout->p->output.i_pictures < picture_max;
+ vout->p->output.i_pictures++) {
/* Find an empty picture slot */
picture_t *picture = NULL;
for (int index = 0; index < VOUT_MAX_PICTURES; index++) {
- if (vout->p_picture[index].i_status == FREE_PICTURE) {
- picture = &vout->p_picture[index];
+ if (vout->p->p_picture[index].i_status == FREE_PICTURE) {
+ picture = &vout->p->p_picture[index];
break;
}
}
picture->i_status = DESTROYED_PICTURE;
picture->i_type = DIRECT_PICTURE;
- vout->output.pp_picture[vout->output.i_pictures] = picture;
+ vout->p->output.pp_picture[vout->p->output.i_pictures] = picture;
}
return VLC_SUCCESS;
}
vout_sys_t *sys = vout->p->p_sys;
for (int i = 0; i < VOUT_MAX_PICTURES; i++) {
- picture_t *picture = &vout->p_picture[i];
+ picture_t *picture = &vout->p->p_picture[i];
if (picture->i_type != DIRECT_PICTURE)
continue;
vout_sys_t *sys = vout->p->p_sys;
vout_display_t *vd = sys->vd;
- while (vout->i_changes & (VOUT_FULLSCREEN_CHANGE |
+ while (vout->p->i_changes & (VOUT_FULLSCREEN_CHANGE |
VOUT_ASPECT_CHANGE |
VOUT_ZOOM_CHANGE |
VOUT_SCALE_CHANGE |
VOUT_ON_TOP_CHANGE |
VOUT_CROP_CHANGE)) {
/* */
- if (vout->i_changes & VOUT_FULLSCREEN_CHANGE) {
- vout->b_fullscreen = !vout->b_fullscreen;
+ if (vout->p->i_changes & VOUT_FULLSCREEN_CHANGE) {
+ vout->p->b_fullscreen = !vout->p->b_fullscreen;
- var_SetBool(vout, "fullscreen", vout->b_fullscreen);
- vout_SetDisplayFullscreen(vd, vout->b_fullscreen);
- vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
+ var_SetBool(vout, "fullscreen", vout->p->b_fullscreen);
+ vout_SetDisplayFullscreen(vd, vout->p->b_fullscreen);
+ vout->p->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
}
- if (vout->i_changes & VOUT_ASPECT_CHANGE) {
+ if (vout->p->i_changes & VOUT_ASPECT_CHANGE) {
vout->fmt_out.i_sar_num = vout->fmt_in.i_sar_num;
vout->fmt_out.i_sar_den = vout->fmt_in.i_sar_den;
vout_SetDisplayAspect(vd, vout->fmt_in.i_sar_num, vout->fmt_in.i_sar_den);
- vout->i_changes &= ~VOUT_ASPECT_CHANGE;
+ vout->p->i_changes &= ~VOUT_ASPECT_CHANGE;
}
- if (vout->i_changes & VOUT_ZOOM_CHANGE) {
+ if (vout->p->i_changes & VOUT_ZOOM_CHANGE) {
const float zoom = var_GetFloat(vout, "scale");
unsigned den = ZOOM_FP_FACTOR;
vout_SetDisplayZoom(vd, num, den);
- vout->i_changes &= ~VOUT_ZOOM_CHANGE;
+ vout->p->i_changes &= ~VOUT_ZOOM_CHANGE;
}
- if (vout->i_changes & VOUT_SCALE_CHANGE) {
+ if (vout->p->i_changes & VOUT_SCALE_CHANGE) {
const bool is_display_filled = var_GetBool(vout, "autoscale");
vout_SetDisplayFilled(vd, is_display_filled);
- vout->i_changes &= ~VOUT_SCALE_CHANGE;
+ vout->p->i_changes &= ~VOUT_SCALE_CHANGE;
}
- if (vout->i_changes & VOUT_ON_TOP_CHANGE) {
- vout_SetWindowState(vd, vout->b_on_top
+ if (vout->p->i_changes & VOUT_ON_TOP_CHANGE) {
+ vout_SetWindowState(vd, vout->p->b_on_top
? VOUT_WINDOW_STATE_ABOVE
: VOUT_WINDOW_STATE_NORMAL);
- vout->i_changes &= ~VOUT_ON_TOP_CHANGE;
+ vout->p->i_changes &= ~VOUT_ON_TOP_CHANGE;
}
- if (vout->i_changes & VOUT_CROP_CHANGE) {
+ if (vout->p->i_changes & VOUT_CROP_CHANGE) {
const video_format_t crop = vout->fmt_in;
const video_format_t org = vout->fmt_render;
/* FIXME because of rounding errors, the reconstructed ratio is wrong */
vout_SetDisplayCrop(vd, num, den,
crop.i_x_offset, crop.i_y_offset,
crop.i_visible_width, crop.i_visible_height);
- vout->i_changes &= ~VOUT_CROP_CHANGE;
+ vout->p->i_changes &= ~VOUT_CROP_CHANGE;
}
}
if (sys->use_dr && vout_AreDisplayPicturesInvalid(vd)) {
- vout->i_changes |= VOUT_PICTURE_BUFFERS_CHANGE;
+ vout->p->i_changes |= VOUT_PICTURE_BUFFERS_CHANGE;
}
vout_ManageDisplay(vd, !sys->use_dr);
return VLC_SUCCESS;
projects / vlc / commitdiff