#include <vlc_picture.h>
#include <vlc_image.h>
#include <vlc_block.h>
+#include <vlc_atomic.h>
/**
* Allocate a new picture in the heap.
* used exactly like a video buffer. The video output thread then manages
* how it gets displayed.
*/
-static int vout_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,
+ vlc_fourcc_t i_chroma,
+ int i_width, int i_height,
+ int i_sar_num, int i_sar_den )
{
/* Make sure the real dimensions are a multiple of 16 */
if( picture_Setup( p_pic, i_chroma, i_width, i_height,
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 PictureDestroy( picture_t *p_picture )
{
- if( --p_picture->i_refcount > 0 )
- return;
- picture_Delete( p_picture );
+ assert( p_picture &&
+ vlc_atomic_get( &p_picture->gc.refcount ) == 0 );
+
+ free( p_picture->p_q );
+ 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;
- picture_CleanupQuant( p_picture );
+
+ free( p_picture->p_q );
+ p_picture->p_q = NULL;
+ p_picture->i_qstride = 0;
+ p_picture->i_qtype = 0;
}
/*****************************************************************************
p->i_pixel_pitch = 0;
}
- p_picture->pf_release = NULL;
- p_picture->p_release_sys = NULL;
- p_picture->i_refcount = 0;
+ vlc_atomic_set( &p_picture->gc.refcount, 0 );
+ p_picture->gc.pf_destroy = NULL;
+ p_picture->gc.p_sys = NULL;
p_picture->i_nb_fields = 2;
if( i_ratio_h < p_dsc->p[i].h.den )
i_ratio_h = p_dsc->p[i].h.den;
}
+ 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;
return NULL;
}
p_picture->p_sys = p_resource->p_sys;
+ assert( p_picture->gc.p_sys == NULL );
for( int i = 0; i < p_picture->i_planes; i++ )
{
}
else
{
- if( vout_AllocatePicture( p_picture,
- fmt.i_chroma, fmt.i_width, fmt.i_height,
- fmt.i_sar_num, fmt.i_sar_den ) )
+ if( AllocatePicture( p_picture,
+ fmt.i_chroma, fmt.i_width, fmt.i_height,
+ fmt.i_sar_num, fmt.i_sar_den ) )
{
free( p_picture );
return NULL;
}
+ assert( p_picture->gc.p_sys != NULL );
}
/* */
p_picture->format = fmt;
- p_picture->i_refcount = 1;
- p_picture->pf_release = PictureReleaseCallback;
+
+ vlc_atomic_set( &p_picture->gc.refcount, 1 );
+ p_picture->gc.pf_destroy = PictureDestroy;
return p_picture;
}
/*****************************************************************************
*
*****************************************************************************/
-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 )
+{
+ vlc_atomic_inc( &p_picture->gc.refcount );
+ return p_picture;
}
-/*****************************************************************************
- *
- *****************************************************************************/
-void picture_CopyPixels( picture_t *p_dst, const picture_t *p_src )
+void picture_Release( picture_t *p_picture )
{
- int i;
+ if( vlc_atomic_dec( &p_picture->gc.refcount ) == 0 &&
+ p_picture->gc.pf_destroy )
+ p_picture->gc.pf_destroy( p_picture );
+}
- for( i = 0; i < p_src->i_planes ; i++ )
- plane_CopyPixels( p_dst->p+i, p_src->p+i );
+bool picture_IsReferenced( picture_t *p_picture )
+{
+ return vlc_atomic_get( &p_picture->gc.refcount ) > 1;
}
+/*****************************************************************************
+ *
+ *****************************************************************************/
void plane_CopyPixels( plane_t *p_dst, const plane_t *p_src )
{
const unsigned i_width = __MIN( p_dst->i_visible_pitch,
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;
}
}
}
+void picture_CopyProperties( picture_t *p_dst, const picture_t *p_src )
+{
+ p_dst->date = p_src->date;
+ p_dst->b_force = p_src->b_force;
+
+ 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 )
+{
+ int i;
+
+ for( i = 0; i < p_src->i_planes ; i++ )
+ plane_CopyPixels( p_dst->p+i, p_src->p+i );
+}
+
+void picture_Copy( picture_t *p_dst, const picture_t *p_src )
+{
+ picture_CopyPixels( p_dst, p_src );
+ picture_CopyProperties( p_dst, p_src );
+}
+
+
/*****************************************************************************
*
*****************************************************************************/
void picture_BlendSubpicture(picture_t *dst,
filter_t *blend, subpicture_t *src)
{
- assert(blend && dst && blend->fmt_out.video.i_chroma == dst->format.i_chroma);
assert(src && !src->b_fade && src->b_absolute);
for (subpicture_region_t *r = src->p_region; r != NULL; r = r->p_next) {
projects / vlc / blobdiff