Skip to content

V
vlc-1.1
Commit 4961a425 authored by Laurent Aimar's avatar Laurent Aimar
Browse files
Options

Clean up subpicture allocation and unused fields.

parent a74e2c4c
Hide whitespace changes
Inline Side-by-side
Showing with 325 additions and 312 deletions
include/vlc_osd.h
View file @ 4961a425
...@@ -100,6 +100,7 @@ VLC_EXPORT( void, spu_Destroy, ( spu_t * ) ); ...@@ -100,6 +100,7 @@ VLC_EXPORT( void, spu_Destroy, ( spu_t * ) );
void spu_Attach( spu_t *, vlc_object_t *, bool ); void spu_Attach( spu_t *, vlc_object_t *, bool );
VLC_EXPORT( subpicture_t *, spu_CreateSubpicture, ( spu_t * ) ); VLC_EXPORT( subpicture_t *, spu_CreateSubpicture, ( spu_t * ) );
/* XXX you cannot call spu_DestroySubpicture on a displayed picture */
VLC_EXPORT( void, spu_DestroySubpicture, ( spu_t *, subpicture_t * ) ); VLC_EXPORT( void, spu_DestroySubpicture, ( spu_t *, subpicture_t * ) );
VLC_EXPORT( void, spu_DisplaySubpicture, ( spu_t *, subpicture_t * ) ); VLC_EXPORT( void, spu_DisplaySubpicture, ( spu_t *, subpicture_t * ) );
......
include/vlc_vout.h
View file @ 4961a425
...@@ -363,8 +363,6 @@ struct subpicture_t ...@@ -363,8 +363,6 @@ struct subpicture_t
Should NOT be modified except by the vout thread */ Should NOT be modified except by the vout thread */
/**@{*/ /**@{*/
int64_t i_order; /** an increasing unique number */ int64_t i_order; /** an increasing unique number */
int i_type; /**< type */
int i_status; /**< flags */
subpicture_t * p_next; /**< next subtitle to be displayed */ subpicture_t * p_next; /**< next subtitle to be displayed */
/**@}*/ /**@}*/
...@@ -406,18 +404,9 @@ struct subpicture_t ...@@ -406,18 +404,9 @@ struct subpicture_t
subpicture_sys_t *p_sys; /* subpicture data */ subpicture_sys_t *p_sys; /* subpicture data */
}; };
/* Subpicture type */
#define EMPTY_SUBPICTURE 0 /* subtitle slot is empty and available */
#define MEMORY_SUBPICTURE 100 /* subpicture stored in memory */
/* Default subpicture channel ID */ /* Default subpicture channel ID */
#define DEFAULT_CHAN 1 #define DEFAULT_CHAN 1
/* Subpicture status */
#define FREE_SUBPICTURE 0 /* free and not allocated */
#define RESERVED_SUBPICTURE 1 /* allocated and reserved */
#define READY_SUBPICTURE 2 /* ready for display */
/* Subpicture position flags */ /* Subpicture position flags */
#define SUBPICTURE_ALIGN_LEFT 0x1 #define SUBPICTURE_ALIGN_LEFT 0x1
#define SUBPICTURE_ALIGN_RIGHT 0x2 #define SUBPICTURE_ALIGN_RIGHT 0x2
......
src/video_output/vout_subpictures.c
View file @ 4961a425
...@@ -43,10 +43,29 @@ ...@@ -43,10 +43,29 @@
/***************************************************************************** /*****************************************************************************
* Local prototypes * Local prototypes
*****************************************************************************/ *****************************************************************************/
#define VLC_FOURCC_YUVP VLC_FOURCC('Y','U','V','P')
#define VLC_FOURCC_YUVA VLC_FOURCC('Y','U','V','A')
#define VLC_FOURCC_RGBA VLC_FOURCC('R','G','B','A')
#define VLC_FOURCC_TEXT VLC_FOURCC('T','E','X','T')
typedef struct
{
subpicture_t *p_subpicture;
bool b_reject;
} spu_heap_entry_t;
typedef struct
{
spu_heap_entry_t p_entry[VOUT_MAX_SUBPICTURES];
} spu_heap_t;
struct spu_private_t struct spu_private_t
{ {
vlc_mutex_t subpicture_lock; /**< subpicture heap lock */ vlc_mutex_t lock; /* lock to protect all followings fields */
subpicture_t p_subpicture[VOUT_MAX_SUBPICTURES]; /**< subpictures */
spu_heap_t heap;
int i_channel; /**< number of subpicture channels registered */ int i_channel; /**< number of subpicture channels registered */
int64_t i_subpicture_order; /**< number of created subpicture since spu creation */ int64_t i_subpicture_order; /**< number of created subpicture since spu creation */
...@@ -65,45 +84,206 @@ struct spu_private_t ...@@ -65,45 +84,206 @@ struct spu_private_t
filter_chain_t *p_chain; filter_chain_t *p_chain;
}; };
/* */
struct subpicture_region_private_t
{
video_format_t fmt;
picture_t *p_picture;
};
static void SpuRegionPrivateDestroy( subpicture_region_private_t *p_private );
static void UpdateSPU ( spu_t *, vlc_object_t * ); static void UpdateSPU ( spu_t *, vlc_object_t * );
static int CropCallback( vlc_object_t *, char const *, static int CropCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * ); vlc_value_t, vlc_value_t, void * );
static int SpuControl( spu_t *, int, va_list ); static int SpuControl( spu_t *, int, va_list );
static subpicture_t *sub_new_buffer( filter_t * ); static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked );
static void sub_del_buffer( filter_t *, subpicture_t * );
/* Buffer allocation for SPU filter (blend, scale, ...) */
static subpicture_t *spu_new_buffer( filter_t * ); static subpicture_t *spu_new_buffer( filter_t * );
static void spu_del_buffer( filter_t *, subpicture_t * ); static void spu_del_buffer( filter_t *, subpicture_t * );
static picture_t *spu_new_video_buffer( filter_t * ); static picture_t *spu_new_video_buffer( filter_t * );
static void spu_del_video_buffer( filter_t *, picture_t * ); static void spu_del_video_buffer( filter_t *, picture_t * );
static int spu_ParseChain( spu_t * ); static int spu_ParseChain( spu_t * );
/* Buffer aloccation fir SUB filter */
static int SubFilterCallback( vlc_object_t *, char const *, static int SubFilterCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * ); vlc_value_t, vlc_value_t, void * );
static int SubFilterAllocationInit( filter_t *, void * ); static int SubFilterAllocationInit( filter_t *, void * );
static void SubFilterAllocationClean( filter_t * ); static void SubFilterAllocationClean( filter_t * );
struct filter_owner_sys_t
{
spu_t *p_spu;
int i_channel;
};
#define SCALE_UNIT (1000) #define SCALE_UNIT (1000)
#define VLC_FOURCC_YUVP VLC_FOURCC('Y','U','V','P') /* */
#define VLC_FOURCC_YUVA VLC_FOURCC('Y','U','V','A') subpicture_region_t *subpicture_region_New( const video_format_t *p_fmt )
#define VLC_FOURCC_RGBA VLC_FOURCC('R','G','B','A') {
#define VLC_FOURCC_TEXT VLC_FOURCC('T','E','X','T') subpicture_region_t *p_region = calloc( 1, sizeof(*p_region ) );
if( !p_region )
return NULL;
p_region->fmt = *p_fmt;
p_region->fmt.p_palette = NULL;
if( p_fmt->i_chroma == VLC_FOURCC_YUVP )
{
p_region->fmt.p_palette = calloc( 1, sizeof(*p_region->fmt.p_palette) );
if( p_fmt->p_palette )
*p_region->fmt.p_palette = *p_fmt->p_palette;
}
p_region->i_alpha = 0xff;
p_region->p_next = NULL;
p_region->p_private = NULL;
p_region->psz_text = NULL;
p_region->p_style = NULL;
p_region->p_picture = NULL;
if( p_fmt->i_chroma == VLC_FOURCC_TEXT )
return p_region;
p_region->p_picture = picture_New( p_fmt->i_chroma, p_fmt->i_width, p_fmt->i_height,
p_fmt->i_aspect );
if( !p_region->p_picture )
{
free( p_fmt->p_palette );
free( p_region );
return NULL;
}
return p_region;
}
/* */ /* */
struct subpicture_region_private_t void subpicture_region_Delete( subpicture_region_t *p_region )
{ {
video_format_t fmt; if( !p_region )
picture_t *p_picture; return;
};
if( p_region->p_private )
SpuRegionPrivateDestroy( p_region->p_private );
if( p_region->p_picture )
picture_Release( p_region->p_picture );
free( p_region->fmt.p_palette );
free( p_region->psz_text );
free( p_region->psz_html );
//free( p_region->p_style ); FIXME --fenrir plugin does not allocate the memory for it. I think it might lead to segfault, video renderer can live longer than the decoder
free( p_region );
}
/* */
void subpicture_region_ChainDelete( subpicture_region_t *p_head )
{
while( p_head )
{
subpicture_region_t *p_next = p_head->p_next;
subpicture_region_Delete( p_head );
p_head = p_next;
}
}
/**
* This function create a new empty subpicture.
*/
static subpicture_t *subpicture_New( void )
{
subpicture_t *p_subpic = calloc( 1, sizeof(*p_subpic) );
if( !p_subpic )
return NULL;
p_subpic->i_order = 0;
p_subpic->b_absolute = true;
p_subpic->b_fade = false;
p_subpic->b_subtitle = false;
p_subpic->i_alpha = 0xFF;
p_subpic->p_region = NULL;
p_subpic->pf_render = NULL;
p_subpic->pf_destroy = NULL;
p_subpic->p_sys = NULL;
return p_subpic;
}
static void subpicture_Delete( subpicture_t *p_subpic )
{
subpicture_region_ChainDelete( p_subpic->p_region );
p_subpic->p_region = NULL;
if( p_subpic->pf_destroy )
{
p_subpic->pf_destroy( p_subpic );
}
free( p_subpic );
}
static void SpuHeapInit( spu_heap_t *p_heap )
{
for( int i = 0; i < VOUT_MAX_SUBPICTURES; i++ )
{
spu_heap_entry_t *e = &p_heap->p_entry[i];
e->p_subpicture = NULL;
e->b_reject = false;
}
}
static int SpuHeapPush( spu_heap_t *p_heap, subpicture_t *p_subpic )
{
for( int i = 0; i < VOUT_MAX_SUBPICTURES; i++ )
{
spu_heap_entry_t *e = &p_heap->p_entry[i];
if( e->p_subpicture )
continue;
e->p_subpicture = p_subpic;
e->b_reject = false;
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
static void SpuHeapDeleteAt( spu_heap_t *p_heap, int i_index )
{
spu_heap_entry_t *e = &p_heap->p_entry[i_index];
if( e->p_subpicture )
subpicture_Delete( e->p_subpicture );
e->p_subpicture = NULL;
}
static int SpuHeapDeleteSubpicture( spu_heap_t *p_heap, subpicture_t *p_subpic )
{
for( int i = 0; i < VOUT_MAX_SUBPICTURES; i++ )
{
spu_heap_entry_t *e = &p_heap->p_entry[i];
if( e->p_subpicture != p_subpic )
continue;
SpuHeapDeleteAt( p_heap, i );
return VLC_SUCCESS;
}
return VLC_EGENERIC;
}
static void SpuHeapClean( spu_heap_t *p_heap )
{
for( int i = 0; i < VOUT_MAX_SUBPICTURES; i++ )
{
spu_heap_entry_t *e = &p_heap->p_entry[i];
if( e->p_subpicture )
subpicture_Delete( e->p_subpicture );
}
}
static subpicture_region_private_t *SpuRegionPrivateCreate( video_format_t *p_fmt ) static subpicture_region_private_t *SpuRegionPrivateCreate( video_format_t *p_fmt )
{ {
subpicture_region_private_t *p_private = malloc( sizeof(*p_private) ); subpicture_region_private_t *p_private = malloc( sizeof(*p_private) );
...@@ -142,8 +322,6 @@ static void FilterRelease( filter_t *p_filter ); ...@@ -142,8 +322,6 @@ static void FilterRelease( filter_t *p_filter );
*/ */
spu_t *__spu_Create( vlc_object_t *p_this ) spu_t *__spu_Create( vlc_object_t *p_this )
{ {
int i_index;
spu_t *p_spu; spu_t *p_spu;
spu_private_t *p_sys; spu_private_t *p_sys;
...@@ -158,11 +336,11 @@ spu_t *__spu_Create( vlc_object_t *p_this ) ...@@ -158,11 +336,11 @@ spu_t *__spu_Create( vlc_object_t *p_this )
p_spu->p = p_sys = (spu_private_t*)&p_spu[1]; p_spu->p = p_sys = (spu_private_t*)&p_spu[1];
/* Initialize private fields */ /* Initialize private fields */
vlc_mutex_init( &p_sys->lock );
SpuHeapInit( &p_sys->heap );
p_sys->i_subpicture_order = 1; p_sys->i_subpicture_order = 1;
for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++)
{
p_sys->p_subpicture[i_index].i_status = FREE_SUBPICTURE;
}
p_sys->p_blend = NULL; p_sys->p_blend = NULL;
p_sys->p_text = NULL; p_sys->p_text = NULL;
...@@ -172,8 +350,6 @@ spu_t *__spu_Create( vlc_object_t *p_this ) ...@@ -172,8 +350,6 @@ spu_t *__spu_Create( vlc_object_t *p_this )
/* Register the default subpicture channel */ /* Register the default subpicture channel */
p_sys->i_channel = 2; p_sys->i_channel = 2;
vlc_mutex_init( &p_sys->subpicture_lock );
vlc_object_attach( p_spu, p_this ); vlc_object_attach( p_spu, p_this );
p_sys->p_chain = filter_chain_New( p_spu, "sub filter", false, p_sys->p_chain = filter_chain_New( p_spu, "sub filter", false,
...@@ -231,16 +407,6 @@ int spu_ParseChain( spu_t *p_spu ) ...@@ -231,16 +407,6 @@ int spu_ParseChain( spu_t *p_spu )
void spu_Destroy( spu_t *p_spu ) void spu_Destroy( spu_t *p_spu )
{ {
spu_private_t *p_sys = p_spu->p; spu_private_t *p_sys = p_spu->p;
int i_index;
/* Destroy all remaining subpictures */
for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ )
{
if( p_sys->p_subpicture[i_index].i_status != FREE_SUBPICTURE )
{
spu_DestroySubpicture( p_spu, &p_sys->p_subpicture[i_index] );
}
}
if( p_sys->p_blend ) if( p_sys->p_blend )
FilterRelease( p_sys->p_blend ); FilterRelease( p_sys->p_blend );
...@@ -256,7 +422,10 @@ void spu_Destroy( spu_t *p_spu ) ...@@ -256,7 +422,10 @@ void spu_Destroy( spu_t *p_spu )
filter_chain_Delete( p_sys->p_chain ); filter_chain_Delete( p_sys->p_chain );
vlc_mutex_destroy( &p_sys->subpicture_lock ); /* Destroy all remaining subpictures */
SpuHeapClean( &p_sys->heap );
vlc_mutex_destroy( &p_sys->lock );
vlc_object_release( p_spu ); vlc_object_release( p_spu );
} }
...@@ -288,76 +457,6 @@ void spu_Attach( spu_t *p_spu, vlc_object_t *p_this, bool b_attach ) ...@@ -288,76 +457,6 @@ void spu_Attach( spu_t *p_spu, vlc_object_t *p_this, bool b_attach )
} }
} }
/* */
subpicture_region_t *subpicture_region_New( const video_format_t *p_fmt )
{
subpicture_region_t *p_region = calloc( 1, sizeof(*p_region ) );
if( !p_region )
return NULL;
p_region->fmt = *p_fmt;
p_region->fmt.p_palette = NULL;
if( p_fmt->i_chroma == VLC_FOURCC_YUVP )
{
p_region->fmt.p_palette = calloc( 1, sizeof(*p_region->fmt.p_palette) );
if( p_fmt->p_palette )
*p_region->fmt.p_palette = *p_fmt->p_palette;
}
p_region->i_alpha = 0xff;
p_region->p_next = NULL;
p_region->p_private = NULL;
p_region->psz_text = NULL;
p_region->p_style = NULL;
p_region->p_picture = NULL;
if( p_fmt->i_chroma == VLC_FOURCC_TEXT )
return p_region;
p_region->p_picture = picture_New( p_fmt->i_chroma, p_fmt->i_width, p_fmt->i_height,
p_fmt->i_aspect );
if( !p_region->p_picture )
{
free( p_fmt->p_palette );
free( p_region );
return NULL;
}
return p_region;
}
/* */
void subpicture_region_Delete( subpicture_region_t *p_region )
{
if( !p_region )
return;
if( p_region->p_private )
SpuRegionPrivateDestroy( p_region->p_private );
if( p_region->p_picture )
picture_Release( p_region->p_picture );
free( p_region->fmt.p_palette );
free( p_region->psz_text );
free( p_region->psz_html );
//free( p_region->p_style ); FIXME --fenrir plugin does not allocate the memory for it. I think it might lead to segfault, video renderer can live longer than the decoder
free( p_region );
}
/* */
void subpicture_region_ChainDelete( subpicture_region_t *p_head )
{
while( p_head )
{
subpicture_region_t *p_next = p_head->p_next;
subpicture_region_Delete( p_head );
p_head = p_next;
}
}
/** /**
* Display a subpicture * Display a subpicture
* *
...@@ -368,22 +467,26 @@ void subpicture_region_ChainDelete( subpicture_region_t *p_head ) ...@@ -368,22 +467,26 @@ void subpicture_region_ChainDelete( subpicture_region_t *p_head )
*/ */
void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic ) void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
{ {
/* Check if status is valid */ spu_private_t *p_sys = p_spu->p;
if( p_subpic->i_status != RESERVED_SUBPICTURE )
{
msg_Err( p_spu, "subpicture %p has invalid status #%d",
p_subpic, p_subpic->i_status );
}
/* DEFAULT_CHAN always reset itself */
if( p_subpic->i_channel == DEFAULT_CHAN ) if( p_subpic->i_channel == DEFAULT_CHAN )
SpuClearChannel( p_spu, DEFAULT_CHAN, false );
/* p_private is for spu only and cannot be non NULL here */
for( subpicture_region_t *r = p_subpic->p_region; r != NULL; r = r->p_next )
assert( r->p_private == NULL );
/* */
vlc_mutex_lock( &p_sys->lock );
if( SpuHeapPush( &p_sys->heap, p_subpic ) )
{ {
p_subpic->i_channel = 0xFFFF; vlc_mutex_unlock( &p_sys->lock );
spu_Control( p_spu, SPU_CHANNEL_CLEAR, DEFAULT_CHAN ); msg_Err( p_spu, "subpicture heap full" );
p_subpic->i_channel = DEFAULT_CHAN; subpicture_Delete( p_subpic );
return;
} }
vlc_mutex_unlock( &p_sys->lock );
/* Remove reservation flag */
p_subpic->i_status = READY_SUBPICTURE;
} }
/** /**
...@@ -398,51 +501,9 @@ void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic ) ...@@ -398,51 +501,9 @@ void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
*/ */
subpicture_t *spu_CreateSubpicture( spu_t *p_spu ) subpicture_t *spu_CreateSubpicture( spu_t *p_spu )
{ {
spu_private_t *p_sys = p_spu->p; VLC_UNUSED(p_spu);
int i_subpic; /* subpicture index */
subpicture_t * p_subpic = NULL; /* first free subpicture */
/* Get lock */ return subpicture_New();
vlc_mutex_lock( &p_sys->subpicture_lock );
/*
* Look for an empty place
*/
p_subpic = NULL;
for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
{
if( p_sys->p_subpicture[i_subpic].i_status == FREE_SUBPICTURE )
{
/* Subpicture is empty and ready for allocation */
p_subpic = &p_sys->p_subpicture[i_subpic];
p_sys->p_subpicture[i_subpic].i_status = RESERVED_SUBPICTURE;
break;
}
}
/* If no free subpicture could be found */
if( p_subpic == NULL )
{
msg_Err( p_spu, "subpicture heap is full" );
vlc_mutex_unlock( &p_sys->subpicture_lock );
return NULL;
}
/* Copy subpicture information, set some default values */
memset( p_subpic, 0, sizeof(subpicture_t) );
p_subpic->i_order = p_sys->i_subpicture_order++;
p_subpic->i_status = RESERVED_SUBPICTURE;
p_subpic->b_absolute = true;
p_subpic->b_fade = false;
p_subpic->b_subtitle = false;
p_subpic->i_alpha = 0xFF;
p_subpic->p_region = NULL;
p_subpic->pf_render = NULL;
p_subpic->pf_destroy = NULL;
p_subpic->p_sys = NULL;
vlc_mutex_unlock( &p_sys->subpicture_lock );
return p_subpic;
} }
/** /**
...@@ -455,37 +516,9 @@ subpicture_t *spu_CreateSubpicture( spu_t *p_spu ) ...@@ -455,37 +516,9 @@ subpicture_t *spu_CreateSubpicture( spu_t *p_spu )
*/ */
void spu_DestroySubpicture( spu_t *p_spu, subpicture_t *p_subpic ) void spu_DestroySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
{ {
spu_private_t *p_sys = p_spu->p; VLC_UNUSED(p_spu);
/* Get lock */ subpicture_Delete( p_subpic );
vlc_mutex_lock( &p_sys->subpicture_lock );
/* There can be race conditions so we need to check the status */
if( p_subpic->i_status == FREE_SUBPICTURE )
{
vlc_mutex_unlock( &p_sys->subpicture_lock );
return;
}
/* Check if status is valid */
if( ( p_subpic->i_status != RESERVED_SUBPICTURE )
&& ( p_subpic->i_status != READY_SUBPICTURE ) )
{
msg_Err( p_spu, "subpicture %p has invalid status %d",
p_subpic, p_subpic->i_status );
}
subpicture_region_ChainDelete( p_subpic->p_region );
p_subpic->p_region = NULL;
if( p_subpic->pf_destroy )
{
p_subpic->pf_destroy( p_subpic );
}
p_subpic->i_status = FREE_SUBPICTURE;
vlc_mutex_unlock( &p_sys->subpicture_lock );
} }
static void FilterRelease( filter_t *p_filter ) static void FilterRelease( filter_t *p_filter )
...@@ -590,6 +623,12 @@ static void SpuRenderCreateAndLoadText( spu_t *p_spu ) ...@@ -590,6 +623,12 @@ static void SpuRenderCreateAndLoadText( spu_t *p_spu )
if( !p_text->p_module ) if( !p_text->p_module )
p_text->p_module = module_need( p_text, "text renderer", NULL, false ); p_text->p_module = module_need( p_text, "text renderer", NULL, false );
/* Create a few variables used for enhanced text rendering */
var_Create( p_text, "spu-duration", VLC_VAR_TIME );
var_Create( p_text, "spu-elapsed", VLC_VAR_TIME );
var_Create( p_text, "text-rerender", VLC_VAR_BOOL );
var_Create( p_text, "scale", VLC_VAR_INTEGER );
} }
static filter_t *CreateAndLoadScale( vlc_object_t *p_obj, static filter_t *CreateAndLoadScale( vlc_object_t *p_obj,
...@@ -665,14 +704,6 @@ static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text, ...@@ -665,14 +704,6 @@ static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text,
* least show up on screen, but the effect won't change * least show up on screen, but the effect won't change
* the text over time. * the text over time.
*/ */
/* FIXME why these variables are recreated every time and not
* when text renderer module was created ? */
var_Create( p_text, "spu-duration", VLC_VAR_TIME );
var_Create( p_text, "spu-elapsed", VLC_VAR_TIME );
var_Create( p_text, "text-rerender", VLC_VAR_BOOL );
var_Create( p_text, "scale", VLC_VAR_INTEGER );
var_SetTime( p_text, "spu-duration", p_subpic->i_stop - p_subpic->i_start ); var_SetTime( p_text, "spu-duration", p_subpic->i_stop - p_subpic->i_start );
var_SetTime( p_text, "spu-elapsed", mdate() - p_subpic->i_start ); var_SetTime( p_text, "spu-elapsed", mdate() - p_subpic->i_start );
var_SetBool( p_text, "text-rerender", false ); var_SetBool( p_text, "text-rerender", false );
...@@ -688,11 +719,6 @@ static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text, ...@@ -688,11 +719,6 @@ static void SpuRenderText( spu_t *p_spu, bool *pb_rerender_text,
} }
*pb_rerender_text = var_GetBool( p_text, "text-rerender" ); *pb_rerender_text = var_GetBool( p_text, "text-rerender" );
var_Destroy( p_text, "spu-duration" );
var_Destroy( p_text, "spu-elapsed" );
var_Destroy( p_text, "text-rerender" );
var_Destroy( p_text, "scale" );
exit: exit:
p_region->i_align |= SUBPICTURE_RENDERED; p_region->i_align |= SUBPICTURE_RENDERED;
} }
...@@ -972,8 +998,6 @@ static void SpuRenderRegion( spu_t *p_spu, ...@@ -972,8 +998,6 @@ static void SpuRenderRegion( spu_t *p_spu,
video_format_t region_fmt; video_format_t region_fmt;
picture_t *p_region_picture; picture_t *p_region_picture;
vlc_assert_locked( &p_sys->subpicture_lock );
/* Invalidate area by default */ /* Invalidate area by default */
*p_area = spu_area_create( 0,0, 0,0, scale_size ); *p_area = spu_area_create( 0,0, 0,0, scale_size );
...@@ -1142,19 +1166,22 @@ static void SpuRenderRegion( spu_t *p_spu, ...@@ -1142,19 +1166,22 @@ static void SpuRenderRegion( spu_t *p_spu,
} }
/* */ /* */
p_region->p_private = SpuRegionPrivateCreate( &p_picture->format ); if( p_picture )
if( p_region->p_private )
{ {
p_region->p_private->p_picture = p_picture; p_region->p_private = SpuRegionPrivateCreate( &p_picture->format );
if( !p_region->p_private->p_picture ) if( p_region->p_private )
{ {
SpuRegionPrivateDestroy( p_region->p_private ); p_region->p_private->p_picture = p_picture;
p_region->p_private = NULL; if( !p_region->p_private->p_picture )
{
SpuRegionPrivateDestroy( p_region->p_private );
p_region->p_private = NULL;
}
}
else
{
picture_Release( p_picture );
} }
}
else
{
picture_Release( p_picture );
} }
} }
...@@ -1296,14 +1323,13 @@ void spu_RenderSubpictures( spu_t *p_spu, ...@@ -1296,14 +1323,13 @@ void spu_RenderSubpictures( spu_t *p_spu,
spu_area_t *p_subtitle_area; spu_area_t *p_subtitle_area;
int i_subtitle_area; int i_subtitle_area;
/* Get lock */ vlc_mutex_lock( &p_sys->lock );
vlc_mutex_lock( &p_sys->subpicture_lock );
/* Preprocess subpictures */ /* Preprocess subpictures */
i_subpicture = 0; i_subpicture = 0;
i_subtitle_region_count = 0; i_subtitle_region_count = 0;
for( subpicture_t * p_subpic = p_subpic_list; for( subpicture_t * p_subpic = p_subpic_list;
p_subpic != NULL && p_subpic->i_status != FREE_SUBPICTURE; /* Check again status (as we where unlocked) */ p_subpic != NULL;
p_subpic = p_subpic->p_next ) p_subpic = p_subpic->p_next )
{ {
/* */ /* */
...@@ -1335,7 +1361,7 @@ void spu_RenderSubpictures( spu_t *p_spu, ...@@ -1335,7 +1361,7 @@ void spu_RenderSubpictures( spu_t *p_spu,
/* Be sure we have at least 1 picture to process */ /* Be sure we have at least 1 picture to process */
if( i_subpicture <= 0 ) if( i_subpicture <= 0 )
{ {
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
return; return;
} }
...@@ -1458,20 +1484,26 @@ void spu_RenderSubpictures( spu_t *p_spu, ...@@ -1458,20 +1484,26 @@ void spu_RenderSubpictures( spu_t *p_spu,
if( p_subtitle_area != p_subtitle_area_buffer ) if( p_subtitle_area != p_subtitle_area_buffer )
free( p_subtitle_area ); free( p_subtitle_area );
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
} }
/***************************************************************************** /*****************************************************************************
* spu_SortSubpictures: find the subpictures to display * spu_SortSubpictures: find the subpictures to display
***************************************************************************** *****************************************************************************
* This function parses all subpictures and decides which ones need to be * This function parses all subpictures and decides which ones need to be
* displayed. This operation does not need lock, since only READY_SUBPICTURE * displayed. If no picture has been selected, display_date will depend on
* are handled. If no picture has been selected, display_date will depend on
* the subpicture. * the subpicture.
* We also check for ephemer DVD subpictures (subpictures that have * We also check for ephemer DVD subpictures (subpictures that have
* to be removed if a newer one is available), which makes it a lot * to be removed if a newer one is available), which makes it a lot
* more difficult to guess if a subpicture has to be rendered or not. * more difficult to guess if a subpicture has to be rendered or not.
*****************************************************************************/ *****************************************************************************/
static void SubpictureChain( subpicture_t **pp_head, subpicture_t *p_subpic )
{
p_subpic->p_next = *pp_head;
*pp_head = p_subpic;
}
subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date, subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
bool b_paused, bool b_subtitle_only ) bool b_paused, bool b_subtitle_only )
{ {
...@@ -1482,6 +1514,8 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date, ...@@ -1482,6 +1514,8 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
/* Run subpicture filters */ /* Run subpicture filters */
filter_chain_SubFilter( p_sys->p_chain, display_date ); filter_chain_SubFilter( p_sys->p_chain, display_date );
vlc_mutex_lock( &p_sys->lock );
/* We get an easily parsable chained list of subpictures which /* We get an easily parsable chained list of subpictures which
* ends with NULL since p_subpic was initialized to NULL. */ * ends with NULL since p_subpic was initialized to NULL. */
for( i_channel = 0; i_channel < p_sys->i_channel; i_channel++ ) for( i_channel = 0; i_channel < p_sys->i_channel; i_channel++ )
...@@ -1492,10 +1526,17 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date, ...@@ -1492,10 +1526,17 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ ) for( i_index = 0; i_index < VOUT_MAX_SUBPICTURES; i_index++ )
{ {
subpicture_t *p_current = &p_sys->p_subpicture[i_index]; spu_heap_entry_t *p_entry = &p_sys->heap.p_entry[i_index];
subpicture_t *p_current = p_entry->p_subpicture;
if( !p_current || p_entry->b_reject )
{
if( p_entry->b_reject )
SpuHeapDeleteAt( &p_sys->heap, i_index );
continue;
}
if( p_current->i_channel != i_channel || if( p_current->i_channel != i_channel ||
p_current->i_status != READY_SUBPICTURE ||
( b_subtitle_only && !p_current->b_subtitle ) ) ( b_subtitle_only && !p_current->b_subtitle ) )
{ {
continue; continue;
...@@ -1514,22 +1555,16 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date, ...@@ -1514,22 +1555,16 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
( !p_current->b_ephemer || p_current->i_stop > p_current->i_start ) && ( !p_current->b_ephemer || p_current->i_stop > p_current->i_start ) &&
!( p_current->b_subtitle && b_paused ) ) /* XXX Assume that subtitle are pausable */ !( p_current->b_subtitle && b_paused ) ) /* XXX Assume that subtitle are pausable */
{ {
/* Too late, destroy the subpic */ SpuHeapDeleteAt( &p_sys->heap, i_index );
spu_DestroySubpicture( p_spu, &p_sys->p_subpicture[i_index] );
continue;
} }
else if( p_current->b_ephemer )
/* If this is an ephemer subpic, add it to our list */
if( p_current->b_ephemer )
{ {
p_current->p_next = p_ephemer; SubpictureChain( &p_ephemer, p_current );
p_ephemer = p_current; }
else
continue; {
SubpictureChain( &p_subpic, p_current );
} }
p_current->p_next = p_subpic;
p_subpic = p_current;
} }
/* If we found ephemer subpictures, check if they have to be /* If we found ephemer subpictures, check if they have to be
...@@ -1541,17 +1576,15 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date, ...@@ -1541,17 +1576,15 @@ subpicture_t *spu_SortSubpictures( spu_t *p_spu, mtime_t display_date,
if( p_tmp->i_start < ephemer_date ) if( p_tmp->i_start < ephemer_date )
{ {
/* Ephemer subpicture has lived too long */ SpuHeapDeleteSubpicture( &p_sys->heap, p_tmp );
spu_DestroySubpicture( p_spu, p_tmp );
} }
else else
{ {
/* Ephemer subpicture can still live a bit */ SubpictureChain( &p_subpic, p_tmp );
p_tmp->p_next = p_subpic;
p_subpic = p_tmp;
} }
} }
} }
vlc_mutex_unlock( &p_sys->lock );
return p_subpic; return p_subpic;
} }
...@@ -1566,33 +1599,26 @@ static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked ) ...@@ -1566,33 +1599,26 @@ static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked )
{ {
spu_private_t *p_sys = p_spu->p; spu_private_t *p_sys = p_spu->p;
int i_subpic; /* subpicture index */ int i_subpic; /* subpicture index */
subpicture_t *p_subpic = NULL; /* first free subpicture */
if( !b_locked ) if( !b_locked )
vlc_mutex_lock( &p_sys->subpicture_lock ); vlc_mutex_lock( &p_sys->lock );
vlc_assert_locked( &p_sys->lock );
for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ ) for( i_subpic = 0; i_subpic < VOUT_MAX_SUBPICTURES; i_subpic++ )
{ {
p_subpic = &p_sys->p_subpicture[i_subpic]; spu_heap_entry_t *p_entry = &p_sys->heap.p_entry[i_subpic];
if( p_subpic->i_status == FREE_SUBPICTURE subpicture_t *p_subpic = p_entry->p_subpicture;
|| ( p_subpic->i_status != RESERVED_SUBPICTURE
&& p_subpic->i_status != READY_SUBPICTURE ) )
{
continue;
}
if( p_subpic->i_channel == i_channel ) if( !p_subpic || p_subpic->i_channel != i_channel )
{ continue;
subpicture_region_ChainDelete( p_subpic->p_region );
p_subpic->p_region = NULL;
if( p_subpic->pf_destroy ) p_subpic->pf_destroy( p_subpic ); /* You cannot delete subpicture outside of spu_SortSubpictures */
p_subpic->i_status = FREE_SUBPICTURE; p_entry->b_reject = true;
}
} }
if( !b_locked ) if( !b_locked )
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
} }
/***************************************************************************** /*****************************************************************************
...@@ -1607,10 +1633,10 @@ static int SpuControl( spu_t *p_spu, int i_query, va_list args ) ...@@ -1607,10 +1633,10 @@ static int SpuControl( spu_t *p_spu, int i_query, va_list args )
{ {
case SPU_CHANNEL_REGISTER: case SPU_CHANNEL_REGISTER:
pi = (int *)va_arg( args, int * ); pi = (int *)va_arg( args, int * );
vlc_mutex_lock( &p_sys->subpicture_lock ); vlc_mutex_lock( &p_sys->lock );
if( pi ) if( pi )
*pi = p_sys->i_channel++; *pi = p_sys->i_channel++;
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
break; break;
case SPU_CHANNEL_CLEAR: case SPU_CHANNEL_CLEAR:
...@@ -1641,14 +1667,14 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object ) ...@@ -1641,14 +1667,14 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object )
spu_private_t *p_sys = p_spu->p; spu_private_t *p_sys = p_spu->p;
vlc_value_t val; vlc_value_t val;
vlc_mutex_lock( &p_sys->subpicture_lock ); vlc_mutex_lock( &p_sys->lock );
p_sys->b_force_palette = false; p_sys->b_force_palette = false;
p_sys->b_force_crop = false; p_sys->b_force_crop = false;
if( var_Get( p_object, "highlight", &val ) || !val.b_bool ) if( var_Get( p_object, "highlight", &val ) || !val.b_bool )
{ {
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
return; return;
} }
...@@ -1663,7 +1689,7 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object ) ...@@ -1663,7 +1689,7 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object )
memcpy( p_sys->palette, val.p_address, 16 ); memcpy( p_sys->palette, val.p_address, 16 );
p_sys->b_force_palette = true; p_sys->b_force_palette = true;
} }
vlc_mutex_unlock( &p_sys->subpicture_lock ); vlc_mutex_unlock( &p_sys->lock );
msg_Dbg( p_object, "crop: %i,%i,%i,%i, palette forced: %i", msg_Dbg( p_object, "crop: %i,%i,%i,%i, palette forced: %i",
p_sys->i_crop_x, p_sys->i_crop_y, p_sys->i_crop_x, p_sys->i_crop_y,
...@@ -1679,7 +1705,8 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object ) ...@@ -1679,7 +1705,8 @@ static void UpdateSPU( spu_t *p_spu, vlc_object_t *p_object )
static int CropCallback( vlc_object_t *p_object, char const *psz_var, static int CropCallback( vlc_object_t *p_object, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data ) vlc_value_t oldval, vlc_value_t newval, void *p_data )
{ {
(void)psz_var; (void)oldval; (void)newval; VLC_UNUSED(oldval); VLC_UNUSED(newval); VLC_UNUSED(psz_var);
UpdateSPU( (spu_t *)p_data, p_object ); UpdateSPU( (spu_t *)p_data, p_object );
return VLC_SUCCESS; return VLC_SUCCESS;
} }
...@@ -1687,39 +1714,36 @@ static int CropCallback( vlc_object_t *p_object, char const *psz_var, ...@@ -1687,39 +1714,36 @@ static int CropCallback( vlc_object_t *p_object, char const *psz_var,
/***************************************************************************** /*****************************************************************************
* Buffers allocation callbacks for the filters * Buffers allocation callbacks for the filters
*****************************************************************************/ *****************************************************************************/
struct filter_owner_sys_t
{
spu_t *p_spu;
int i_channel;
};
static subpicture_t *sub_new_buffer( filter_t *p_filter ) static subpicture_t *sub_new_buffer( filter_t *p_filter )
{ {
filter_owner_sys_t *p_sys = p_filter->p_owner; filter_owner_sys_t *p_sys = p_filter->p_owner;
subpicture_t *p_subpicture = spu_CreateSubpicture( p_sys->p_spu );
if( p_subpicture ) p_subpicture->i_channel = p_sys->i_channel; subpicture_t *p_subpicture = subpicture_New();
if( p_subpicture )
p_subpicture->i_channel = p_sys->i_channel;
return p_subpicture; return p_subpicture;
} }
static void sub_del_buffer( filter_t *p_filter, subpicture_t *p_subpic ) static void sub_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
{ {
filter_owner_sys_t *p_sys = p_filter->p_owner; VLC_UNUSED( p_filter );
spu_DestroySubpicture( p_sys->p_spu, p_subpic ); subpicture_Delete( p_subpic );
} }
static subpicture_t *spu_new_buffer( filter_t *p_filter ) static subpicture_t *spu_new_buffer( filter_t *p_filter )
{ {
subpicture_t *p_subpic = calloc( 1, sizeof(subpicture_t) );
if( !p_subpic )
return NULL;
p_subpic->b_absolute = true;
p_subpic->i_alpha = 0xFF;
VLC_UNUSED(p_filter); VLC_UNUSED(p_filter);
return p_subpic; return subpicture_New();
} }
static void spu_del_buffer( filter_t *p_filter, subpicture_t *p_subpic ) static void spu_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
{ {
subpicture_region_ChainDelete( p_subpic->p_region );
VLC_UNUSED(p_filter); VLC_UNUSED(p_filter);
free( p_subpic ); subpicture_Delete( p_subpic );
} }
static picture_t *spu_new_video_buffer( filter_t *p_filter ) static picture_t *spu_new_video_buffer( filter_t *p_filter )
...@@ -1730,29 +1754,12 @@ static picture_t *spu_new_video_buffer( filter_t *p_filter ) ...@@ -1730,29 +1754,12 @@ static picture_t *spu_new_video_buffer( filter_t *p_filter )
return picture_New( p_fmt->i_chroma, return picture_New( p_fmt->i_chroma,
p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect ); p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect );
} }
static void spu_del_video_buffer( filter_t *p_filter, picture_t *p_picture ) static void spu_del_video_buffer( filter_t *p_filter, picture_t *p_picture )
{ {
VLC_UNUSED(p_filter); VLC_UNUSED(p_filter);
picture_Release( p_picture ); picture_Release( p_picture );
} }
static int SubFilterCallback( vlc_object_t *p_object, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
spu_t *p_spu = p_data;
spu_private_t *p_sys = p_spu->p;
VLC_UNUSED(p_object); VLC_UNUSED(oldval);
VLC_UNUSED(newval); VLC_UNUSED(psz_var);
vlc_mutex_lock( &p_sys->subpicture_lock );
filter_chain_Reset( p_sys->p_chain, NULL, NULL );
spu_ParseChain( p_spu );
vlc_mutex_unlock( &p_sys->subpicture_lock );
return VLC_SUCCESS;
}
static int SubFilterAllocationInit( filter_t *p_filter, void *p_data ) static int SubFilterAllocationInit( filter_t *p_filter, void *p_data )
{ {
spu_t *p_spu = p_data; spu_t *p_spu = p_data;
...@@ -1779,3 +1786,19 @@ static void SubFilterAllocationClean( filter_t *p_filter ) ...@@ -1779,3 +1786,19 @@ static void SubFilterAllocationClean( filter_t *p_filter )
free( p_filter->p_owner ); free( p_filter->p_owner );
} }
static int SubFilterCallback( vlc_object_t *p_object, char const *psz_var,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
spu_t *p_spu = p_data;
spu_private_t *p_sys = p_spu->p;
VLC_UNUSED(p_object); VLC_UNUSED(oldval);
VLC_UNUSED(newval); VLC_UNUSED(psz_var);
vlc_mutex_lock( &p_sys->lock );
filter_chain_Reset( p_sys->p_chain, NULL, NULL );
spu_ParseChain( p_spu );
vlc_mutex_unlock( &p_sys->lock );
return VLC_SUCCESS;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment