/*****************************************************************************
* 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
{
- vlc_mutex_t subpicture_lock; /**< subpicture heap lock */
- subpicture_t p_subpicture[VOUT_MAX_SUBPICTURES]; /**< subpictures */
+ vlc_mutex_t lock; /* lock to protect all followings fields */
+
+ spu_heap_t heap;
+
int i_channel; /**< number of subpicture channels registered */
int64_t i_subpicture_order; /**< number of created subpicture since spu creation */
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 int CropCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static int SpuControl( spu_t *, int, va_list );
-static subpicture_t *sub_new_buffer( filter_t * );
-static void sub_del_buffer( filter_t *, subpicture_t * );
+static void SpuClearChannel( spu_t *p_spu, int i_channel, bool b_locked );
+
+/* Buffer allocation for SPU filter (blend, scale, ...) */
static subpicture_t *spu_new_buffer( filter_t * );
static void spu_del_buffer( filter_t *, subpicture_t * );
static picture_t *spu_new_video_buffer( filter_t * );
static void spu_del_video_buffer( filter_t *, picture_t * );
static int spu_ParseChain( spu_t * );
+
+/* Buffer aloccation fir SUB filter */
static int SubFilterCallback( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static int SubFilterAllocationInit( filter_t *, void * );
static void SubFilterAllocationClean( filter_t * );
-struct filter_owner_sys_t
-{
- spu_t *p_spu;
- int i_channel;
-};
#define SCALE_UNIT (1000)
-#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')
+/* */
+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;
+}
/* */
-struct subpicture_region_private_t
+void subpicture_region_Delete( subpicture_region_t *p_region )
{
- video_format_t fmt;
- picture_t *p_picture;
-};
+ 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;
+ }
+}
+
+/**
+ * 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 )
{
subpicture_region_private_t *p_private = malloc( sizeof(*p_private) );
*/
spu_t *__spu_Create( vlc_object_t *p_this )
{
- int i_index;
-
spu_t *p_spu;
spu_private_t *p_sys;
p_spu->p = p_sys = (spu_private_t*)&p_spu[1];
/* Initialize private fields */
+ vlc_mutex_init( &p_sys->lock );
+
+ SpuHeapInit( &p_sys->heap );
+
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_text = NULL;
/* Register the default subpicture channel */
p_sys->i_channel = 2;
- vlc_mutex_init( &p_sys->subpicture_lock );
-
vlc_object_attach( p_spu, p_this );
p_sys->p_chain = filter_chain_New( p_spu, "sub filter", false,
void spu_Destroy( spu_t *p_spu )
{
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 )
FilterRelease( p_sys->p_blend );
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 );
}
}
}
-/* */
-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
*
*/
void spu_DisplaySubpicture( spu_t *p_spu, subpicture_t *p_subpic )
{
- /* Check if status is valid */
- if( p_subpic->i_status != RESERVED_SUBPICTURE )
- {
- msg_Err( p_spu, "subpicture %p has invalid status #%d",
- p_subpic, p_subpic->i_status );
- }
+ spu_private_t *p_sys = p_spu->p;
+ /* DEFAULT_CHAN always reset itself */
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;
- spu_Control( p_spu, SPU_CHANNEL_CLEAR, DEFAULT_CHAN );
- p_subpic->i_channel = DEFAULT_CHAN;
+ vlc_mutex_unlock( &p_sys->lock );
+ msg_Err( p_spu, "subpicture heap full" );
+ subpicture_Delete( p_subpic );
+ return;
}
-
- /* Remove reservation flag */
- p_subpic->i_status = READY_SUBPICTURE;
+ vlc_mutex_unlock( &p_sys->lock );
}
/**
*/
subpicture_t *spu_CreateSubpicture( spu_t *p_spu )
{
- spu_private_t *p_sys = p_spu->p;
- int i_subpic; /* subpicture index */
- subpicture_t * p_subpic = NULL; /* first free subpicture */
+ VLC_UNUSED(p_spu);
- /* Get lock */
- 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;
+ return subpicture_New();
}
/**
*/
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 */
- 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 );
+ subpicture_Delete( p_subpic );
}
static void FilterRelease( filter_t *p_filter )
if( !p_text->p_module )
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,
* least show up on screen, but the effect won't change
* 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-elapsed", mdate() - p_subpic->i_start );
var_SetBool( p_text, "text-rerender", false );
}
*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:
p_region->i_align |= SUBPICTURE_RENDERED;
}
video_format_t region_fmt;
picture_t *p_region_picture;
- vlc_assert_locked( &p_sys->subpicture_lock );
-
/* Invalidate area by default */
*p_area = spu_area_create( 0,0, 0,0, scale_size );
}
/* */
- p_region->p_private = SpuRegionPrivateCreate( &p_picture->format );
- if( p_region->p_private )
+ if( p_picture )
{
- p_region->p_private->p_picture = p_picture;
- if( !p_region->p_private->p_picture )
+ p_region->p_private = SpuRegionPrivateCreate( &p_picture->format );
+ if( p_region->p_private )
{
- SpuRegionPrivateDestroy( p_region->p_private );
- p_region->p_private = NULL;
+ p_region->p_private->p_picture = p_picture;
+ 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 );
}
}
spu_area_t *p_subtitle_area;
int i_subtitle_area;
- /* Get lock */
- vlc_mutex_lock( &p_sys->subpicture_lock );
+ vlc_mutex_lock( &p_sys->lock );
/* Preprocess subpictures */
i_subpicture = 0;
i_subtitle_region_count = 0;
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 )
{
/* */
/* Be sure we have at least 1 picture to process */
if( i_subpicture <= 0 )
{
- vlc_mutex_unlock( &p_sys->subpicture_lock );
+ vlc_mutex_unlock( &p_sys->lock );
return;
}
if( p_subtitle_area != p_subtitle_area_buffer )
free( p_subtitle_area );
- vlc_mutex_unlock( &p_sys->subpicture_lock );
+ vlc_mutex_unlock( &p_sys->lock );
}
/*****************************************************************************
* spu_SortSubpictures: find the subpictures to display
*****************************************************************************
* This function parses all subpictures and decides which ones need to be
- * displayed. This operation does not need lock, since only READY_SUBPICTURE
- * are handled. If no picture has been selected, display_date will depend on
+ * displayed. If no picture has been selected, display_date will depend on
* the subpicture.
* We also check for ephemer DVD subpictures (subpictures that have
* 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.
*****************************************************************************/
+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,
bool b_paused, bool b_subtitle_only )
{
/* Run subpicture filters */
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
* ends with NULL since p_subpic was initialized to NULL. */
for( i_channel = 0; i_channel < p_sys->i_channel; i_channel++ )
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 ||
- p_current->i_status != READY_SUBPICTURE ||
( b_subtitle_only && !p_current->b_subtitle ) )
{
continue;
( !p_current->b_ephemer || p_current->i_stop > p_current->i_start ) &&
!( p_current->b_subtitle && b_paused ) ) /* XXX Assume that subtitle are pausable */
{
- /* Too late, destroy the subpic */
- spu_DestroySubpicture( p_spu, &p_sys->p_subpicture[i_index] );
- continue;
+ SpuHeapDeleteAt( &p_sys->heap, i_index );
}
-
- /* If this is an ephemer subpic, add it to our list */
- if( p_current->b_ephemer )
+ else if( p_current->b_ephemer )
{
- p_current->p_next = p_ephemer;
- p_ephemer = p_current;
-
- continue;
+ SubpictureChain( &p_ephemer, p_current );
+ }
+ else
+ {
+ 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( p_tmp->i_start < ephemer_date )
{
- /* Ephemer subpicture has lived too long */
- spu_DestroySubpicture( p_spu, p_tmp );
+ SpuHeapDeleteSubpicture( &p_sys->heap, p_tmp );
}
else
{
- /* Ephemer subpicture can still live a bit */
- p_tmp->p_next = p_subpic;
- p_subpic = p_tmp;
+ SubpictureChain( &p_subpic, p_tmp );
}
}
}
+ vlc_mutex_unlock( &p_sys->lock );
return p_subpic;
}
{
spu_private_t *p_sys = p_spu->p;
int i_subpic; /* subpicture index */
- subpicture_t *p_subpic = NULL; /* first free subpicture */
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++ )
{
- p_subpic = &p_sys->p_subpicture[i_subpic];
- if( p_subpic->i_status == FREE_SUBPICTURE
- || ( p_subpic->i_status != RESERVED_SUBPICTURE
- && p_subpic->i_status != READY_SUBPICTURE ) )
- {
- continue;
- }
+ spu_heap_entry_t *p_entry = &p_sys->heap.p_entry[i_subpic];
+ subpicture_t *p_subpic = p_entry->p_subpicture;
- if( p_subpic->i_channel == i_channel )
- {
- subpicture_region_ChainDelete( p_subpic->p_region );
- p_subpic->p_region = NULL;
+ if( !p_subpic || p_subpic->i_channel != i_channel )
+ continue;
- if( p_subpic->pf_destroy ) p_subpic->pf_destroy( p_subpic );
- p_subpic->i_status = FREE_SUBPICTURE;
- }
+ /* You cannot delete subpicture outside of spu_SortSubpictures */
+ p_entry->b_reject = true;
}
if( !b_locked )
- vlc_mutex_unlock( &p_sys->subpicture_lock );
+ vlc_mutex_unlock( &p_sys->lock );
}
/*****************************************************************************
{
case SPU_CHANNEL_REGISTER:
pi = (int *)va_arg( args, int * );
- vlc_mutex_lock( &p_sys->subpicture_lock );
+ vlc_mutex_lock( &p_sys->lock );
if( pi )
*pi = p_sys->i_channel++;
- vlc_mutex_unlock( &p_sys->subpicture_lock );
+ vlc_mutex_unlock( &p_sys->lock );
break;
case SPU_CHANNEL_CLEAR:
spu_private_t *p_sys = p_spu->p;
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_crop = false;
if( var_Get( p_object, "highlight", &val ) || !val.b_bool )
{
- vlc_mutex_unlock( &p_sys->subpicture_lock );
+ vlc_mutex_unlock( &p_sys->lock );
return;
}
memcpy( p_sys->palette, val.p_address, 16 );
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",
p_sys->i_crop_x, p_sys->i_crop_y,
static int CropCallback( vlc_object_t *p_object, char const *psz_var,
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 );
return VLC_SUCCESS;
}
/*****************************************************************************
* 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 )
{
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;
}
-
static void sub_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
{
- filter_owner_sys_t *p_sys = p_filter->p_owner;
- spu_DestroySubpicture( p_sys->p_spu, p_subpic );
+ VLC_UNUSED( p_filter );
+ subpicture_Delete( p_subpic );
}
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);
- return p_subpic;
+ return subpicture_New();
}
-
static void spu_del_buffer( filter_t *p_filter, subpicture_t *p_subpic )
{
- subpicture_region_ChainDelete( p_subpic->p_region );
-
VLC_UNUSED(p_filter);
- free( p_subpic );
+ subpicture_Delete( p_subpic );
}
static picture_t *spu_new_video_buffer( filter_t *p_filter )
return picture_New( p_fmt->i_chroma,
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 )
{
VLC_UNUSED(p_filter);
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 )
{
spu_t *p_spu = p_data;
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;
+}
+
projects / vlc / commitdiff