* used exactly like a video buffer. The video output thread then manages
* how it gets displayed.
*/
-static int AllocatePicture( picture_t *p_pic,
- vlc_fourcc_t i_chroma,
- int i_width, int i_height,
- int i_sar_num, int i_sar_den )
+static int AllocatePicture( picture_t *p_pic )
{
- /* Make sure the real dimensions are a multiple of 16 */
- if( picture_Setup( p_pic, i_chroma, i_width, i_height,
- i_sar_num, i_sar_den ) != VLC_SUCCESS )
- return VLC_EGENERIC;
-
/* Calculate how big the new image should be */
size_t i_bytes = 0;
for( int i = 0; i < p_pic->i_planes; i++ )
{
const plane_t *p = &p_pic->p[i];
- if( p->i_pitch <= 0 || p->i_lines <= 0 ||
+ if( p->i_pitch < 0 || p->i_lines <= 0 ||
(size_t)p->i_pitch > (SIZE_MAX - i_bytes)/p->i_lines )
{
p_pic->i_planes = 0;
}
uint8_t *p_data = vlc_memalign( 16, i_bytes );
- if( !p_data )
+ if( i_bytes > 0 && p_data == NULL )
{
p_pic->i_planes = 0;
return VLC_EGENERIC;
}
- p_pic->p_data_orig = p_data; /* TODO: get rid of this */
+ p_pic->gc.p_sys = (void *)p_data;
/* Fill the p_pixels field for each plane */
p_pic->p[0].p_pixels = p_data;
/*****************************************************************************
*
*****************************************************************************/
-static void PictureReleaseCallback( picture_t *p_picture )
+
+static void PictureDestroyContext( picture_t *p_picture )
{
- if( --p_picture->i_refcount > 0 )
- return;
- picture_Delete( p_picture );
+ void (**context)( void * ) = p_picture->context;
+ if( context != NULL )
+ {
+ void (*context_destroy)( void * ) = *context;
+ context_destroy( context );
+ p_picture->context = NULL;
+ }
+}
+
+static void PictureDestroy( picture_t *p_picture )
+{
+ assert( p_picture &&
+ atomic_load( &p_picture->gc.refcount ) == 0 );
+
+ vlc_free( p_picture->gc.p_sys );
+ free( p_picture->p_sys );
+ free( p_picture );
}
/*****************************************************************************
p_picture->b_progressive = false;
p_picture->i_nb_fields = 2;
p_picture->b_top_field_first = false;
-
- free( p_picture->p_q );
- p_picture->p_q = NULL;
- p_picture->i_qstride = 0;
- p_picture->i_qtype = 0;
+ PictureDestroyContext( p_picture );
}
/*****************************************************************************
return a * b / GCD( a, b );
}
-int picture_Setup( picture_t *p_picture, vlc_fourcc_t i_chroma,
- int i_width, int i_height, int i_sar_num, int i_sar_den )
+int picture_Setup( picture_t *p_picture, const video_format_t *restrict fmt )
{
/* Store default values */
p_picture->i_planes = 0;
p->i_pixel_pitch = 0;
}
- p_picture->pf_release = NULL;
- p_picture->p_release_sys = NULL;
- p_picture->i_refcount = 0;
+ atomic_init( &p_picture->gc.refcount, 0 );
+ p_picture->gc.pf_destroy = NULL;
+ p_picture->gc.p_sys = NULL;
p_picture->i_nb_fields = 2;
- p_picture->i_qtype = QTYPE_NONE;
- p_picture->i_qstride = 0;
- p_picture->p_q = NULL;
-
- video_format_Setup( &p_picture->format, i_chroma, i_width, i_height,
- i_sar_num, i_sar_den );
+ video_format_Setup( &p_picture->format, fmt->i_chroma, fmt->i_width, fmt->i_height,
+ fmt->i_visible_width, fmt->i_visible_height,
+ fmt->i_sar_num, fmt->i_sar_den );
const vlc_chroma_description_t *p_dsc =
vlc_fourcc_GetChromaDescription( p_picture->format.i_chroma );
}
i_modulo_h = LCM( i_modulo_h, 32 );
- const int i_width_aligned = ( i_width + i_modulo_w - 1 ) / i_modulo_w * i_modulo_w;
- const int i_height_aligned = ( i_height + i_modulo_h - 1 ) / i_modulo_h * i_modulo_h;
+ const int i_width_aligned = ( fmt->i_width + i_modulo_w - 1 ) / i_modulo_w * i_modulo_w;
+ const int i_height_aligned = ( fmt->i_height + i_modulo_h - 1 ) / i_modulo_h * i_modulo_h;
const int i_height_extra = 2 * i_ratio_h; /* This one is a hack for some ASM functions */
for( unsigned i = 0; i < p_dsc->plane_count; i++ )
{
plane_t *p = &p_picture->p[i];
p->i_lines = (i_height_aligned + i_height_extra ) * p_dsc->p[i].h.num / p_dsc->p[i].h.den;
- p->i_visible_lines = i_height * p_dsc->p[i].h.num / p_dsc->p[i].h.den;
+ p->i_visible_lines = fmt->i_visible_height * p_dsc->p[i].h.num / p_dsc->p[i].h.den;
p->i_pitch = i_width_aligned * p_dsc->p[i].w.num / p_dsc->p[i].w.den * p_dsc->pixel_size;
- p->i_visible_pitch = i_width * p_dsc->p[i].w.num / p_dsc->p[i].w.den * p_dsc->pixel_size;
+ p->i_visible_pitch = fmt->i_visible_width * p_dsc->p[i].w.num / p_dsc->p[i].w.den * p_dsc->pixel_size;
p->i_pixel_pitch = p_dsc->pixel_size;
assert( (p->i_pitch % 16) == 0 );
/* It is needed to be sure all information are filled */
video_format_Setup( &fmt, p_fmt->i_chroma,
p_fmt->i_width, p_fmt->i_height,
+ p_fmt->i_visible_width, p_fmt->i_visible_height,
p_fmt->i_sar_num, p_fmt->i_sar_den );
if( p_fmt->i_x_offset < p_fmt->i_width &&
p_fmt->i_y_offset < p_fmt->i_height &&
if( !p_picture )
return NULL;
+ /* Make sure the real dimensions are a multiple of 16 */
+ if( picture_Setup( p_picture, &fmt ) )
+ {
+ free( p_picture );
+ return NULL;
+ }
+
if( p_resource )
{
- if( picture_Setup( p_picture, fmt.i_chroma, fmt.i_width, fmt.i_height,
- fmt.i_sar_num, fmt.i_sar_den ) )
- {
- free( p_picture );
- return NULL;
- }
p_picture->p_sys = p_resource->p_sys;
+ p_picture->gc.pf_destroy = p_resource->pf_destroy;
+ assert( p_picture->gc.p_sys == NULL );
for( int i = 0; i < p_picture->i_planes; i++ )
{
}
else
{
- if( AllocatePicture( p_picture,
- fmt.i_chroma, fmt.i_width, fmt.i_height,
- fmt.i_sar_num, fmt.i_sar_den ) )
+ if( AllocatePicture( p_picture ) )
{
free( p_picture );
return NULL;
}
}
+
/* */
p_picture->format = fmt;
- p_picture->i_refcount = 1;
- p_picture->pf_release = PictureReleaseCallback;
+
+ atomic_init( &p_picture->gc.refcount, 1 );
+ if( p_picture->gc.pf_destroy == NULL )
+ p_picture->gc.pf_destroy = PictureDestroy;
return p_picture;
}
+
picture_t *picture_NewFromFormat( const video_format_t *p_fmt )
{
return picture_NewFromResource( p_fmt, NULL );
}
+
picture_t *picture_New( vlc_fourcc_t i_chroma, int i_width, int i_height, int i_sar_num, int i_sar_den )
{
video_format_t fmt;
memset( &fmt, 0, sizeof(fmt) );
video_format_Setup( &fmt, i_chroma, i_width, i_height,
- i_sar_num, i_sar_den );
+ i_width, i_height, i_sar_num, i_sar_den );
return picture_NewFromFormat( &fmt );
}
/*****************************************************************************
*
*****************************************************************************/
-void picture_Delete( picture_t *p_picture )
-{
- assert( p_picture && p_picture->i_refcount == 0 );
- assert( p_picture->p_release_sys == NULL );
-
- free( p_picture->p_q );
- vlc_free( p_picture->p_data_orig );
- free( p_picture->p_sys );
- free( p_picture );
-}
picture_t *picture_Hold( picture_t *p_picture )
{
- if( p_picture->pf_release )
- p_picture->i_refcount++;
+ atomic_fetch_add( &p_picture->gc.refcount, 1 );
return p_picture;
}
void picture_Release( picture_t *p_picture )
{
- /* FIXME why do we let pf_release handle the i_refcount ? */
- if( p_picture->pf_release )
- p_picture->pf_release( p_picture );
+ uintptr_t refs = atomic_fetch_sub( &p_picture->gc.refcount, 1 );
+ assert( refs != 0 );
+ if( refs > 1 )
+ return;
+
+ PictureDestroyContext( p_picture );
+ assert( p_picture->gc.pf_destroy != NULL );
+ p_picture->gc.pf_destroy( p_picture );
}
bool picture_IsReferenced( picture_t *p_picture )
{
- return p_picture->i_refcount > 1;
+ return atomic_load( &p_picture->gc.refcount ) > 1;
}
/*****************************************************************************
p_src->i_pitch < 2*p_src->i_visible_pitch )
{
/* There are margins, but with the same width : perfect ! */
- vlc_memcpy( p_dst->p_pixels, p_src->p_pixels,
+ memcpy( p_dst->p_pixels, p_src->p_pixels,
p_src->i_pitch * i_height );
}
else
for( i_line = i_height; i_line--; )
{
- vlc_memcpy( p_out, p_in, i_width );
+ memcpy( p_out, p_in, i_width );
p_in += p_src->i_pitch;
p_out += p_dst->i_pitch;
}
p_dst->b_progressive = p_src->b_progressive;
p_dst->i_nb_fields = p_src->i_nb_fields;
p_dst->b_top_field_first = p_src->b_top_field_first;
-
- /* FIXME: copy ->p_q and ->p_qstride */
}
void picture_CopyPixels( picture_t *p_dst, const picture_t *p_src )
return VLC_SUCCESS;
}
-void picture_BlendSubpicture(picture_t *dst,
- filter_t *blend, subpicture_t *src)
+unsigned picture_BlendSubpicture(picture_t *dst,
+ filter_t *blend, subpicture_t *src)
{
+ unsigned done = 0;
+
assert(src && !src->b_fade && src->b_absolute);
for (subpicture_region_t *r = src->p_region; r != NULL; r = r->p_next) {
assert(r->p_picture && r->i_align == 0);
- if (filter_ConfigureBlend(blend, dst->format.i_width, dst->format.i_height,
- &r->fmt) ||
- filter_Blend(blend, dst,
- r->i_x, r->i_y, r->p_picture,
- src->i_alpha * r->i_alpha / 255)) {
+ if (filter_ConfigureBlend(blend, dst->format.i_width,
+ dst->format.i_height, &r->fmt)
+ || filter_Blend(blend, dst, r->i_x, r->i_y, r->p_picture,
+ src->i_alpha * r->i_alpha / 255))
msg_Err(blend, "blending %4.4s to %4.4s failed",
(char *)&blend->fmt_in.video.i_chroma,
(char *)&blend->fmt_out.video.i_chroma );
- }
+ else
+ done++;
}
+ return done;
}
projects / vlc / blobdiff