videolan/vlc
1
Fork 0
mirror of https://code.videolan.org/videolan/vlc synced 2024-09-04 09:11:33 +02:00
Code Releases Activity

Changed subpicture_region_t->picture into a picture_t *

Browse Source 
It will avoid useless picture copy.
This commit is contained in:
Laurent Aimar 2008-09-20 00:09:37 +02:00
parent 692cad3b3e
commit 8f83ef4b74
24 changed files with 225 additions and 229 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/vlc_vout.h
View File

@ -289,6 +289,11 @@ struct picture_heap_t
* @{
*/
/**
* Video subtitle region spu core private
*/
typedef struct subpicture_region_private_t subpicture_region_private_t;
/**
* Video subtitle region
*
@ -299,7 +304,7 @@ struct picture_heap_t
struct subpicture_region_t
{
video_format_t fmt; /**< format of the picture */
picture_t picture; /**< picture comprising this region */
picture_t *p_picture; /**< picture comprising this region */
int i_x; /**< position of region */
int i_y; /**< position of region */
@ -311,7 +316,7 @@ struct subpicture_region_t
text_style_t *p_style; /**< a description of the text style formatting */
subpicture_region_t *p_next; /**< next region in the list */
subpicture_region_t *p_cache; /**< modified version of this region */
subpicture_region_private_t *p_private; /**< modified version of this region */
};
/**

6
modules/codec/csri.c
View File

@ -305,14 +305,14 @@ static void UpdateRegions( spu_t *p_spu, subpicture_t *p_subpic,
/* */
p_spu_region->i_align = SUBPICTURE_ALIGN_TOP | SUBPICTURE_ALIGN_LEFT;
memset( p_spu_region->picture.Y_PIXELS, 0x00, p_spu_region->picture.Y_PITCH * p_sys->fmt_cached.i_height );
memset( p_spu_region->p_picture->Y_PIXELS, 0x00, p_spu_region->p_picture->Y_PITCH * p_sys->fmt_cached.i_height );
/* */
//msg_Dbg( p_dec, "TS %lf", ts * 0.000001 );
memset( &csri_frame, 0, sizeof(csri_frame) );
csri_frame.pixfmt = CSRI_F_BGRA;
csri_frame.planes[0] = (unsigned char*)p_spu_region->picture.Y_PIXELS;
csri_frame.strides[0] = p_spu_region->picture.Y_PITCH;
csri_frame.planes[0] = (unsigned char*)p_spu_region->p_picture->Y_PIXELS;
csri_frame.strides[0] = p_spu_region->p_picture->Y_PITCH;
csri_render( p_sys->p_instance, &csri_frame, ts * 0.000001 );
}
}

6
modules/codec/cvdsub.c
View File

@ -569,7 +569,7 @@ static void RenderImage( decoder_t *p_dec, block_t *p_data,
subpicture_region_t *p_region )
{
decoder_sys_t *p_sys = p_dec->p_sys;
uint8_t *p_dest = p_region->picture.Y_PIXELS;
uint8_t *p_dest = p_region->p_picture->Y_PIXELS;
int i_field; /* The subtitles are interlaced */
int i_row, i_column; /* scanline row/column number */
uint8_t i_color, i_count;
@ -591,7 +591,7 @@ static void RenderImage( decoder_t *p_dec, block_t *p_data,
/* Fill the rest of the line with next color */
i_color = bs_read( &bs, 4 );
memset( &p_dest[i_row * p_region->picture.Y_PITCH +
memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
i_column], i_color,
p_sys->i_width - i_column );
i_column = p_sys->i_width;
@ -605,7 +605,7 @@ static void RenderImage( decoder_t *p_dec, block_t *p_data,
i_count = __MIN( i_count, p_sys->i_width - i_column );
memset( &p_dest[i_row * p_region->picture.Y_PITCH +
memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
i_column], i_color, i_count );
i_column += i_count - 1;
continue;

54
modules/codec/dvbsub.c
View File

@ -1571,8 +1571,8 @@ static subpicture_t *render( decoder_t *p_dec )
}
p_src = p_region->p_pixbuf;
p_dst = p_spu_region->picture.Y_PIXELS;
i_pitch = p_spu_region->picture.Y_PITCH;
p_dst = p_spu_region->p_picture->Y_PIXELS;
i_pitch = p_spu_region->p_picture->Y_PITCH;
/* Copy pixel buffer */
for( j = 0; j < p_region->i_height; j++ )
@ -1710,11 +1710,11 @@ static subpicture_t *YuvaYuvp( subpicture_t *p_subpic )
#else
int *pi_delta;
#endif
int i_pixels = p_region->picture.p[0].i_visible_lines
* p_region->picture.p[0].i_pitch;
int i_iterator = p_region->picture.p[0].i_visible_lines * 3 / 4
* p_region->picture.p[0].i_pitch
+ p_region->picture.p[0].i_pitch * 1 / 3;
int i_pixels = p_region->p_picture->p[0].i_visible_lines
* p_region->p_picture->p[0].i_pitch;
int i_iterator = p_region->p_picture->p[0].i_visible_lines * 3 / 4
* p_region->p_picture->p[0].i_pitch
+ p_region->p_picture->p[0].i_pitch * 1 / 3;
int i_tolerance = 0;
#ifdef DEBUG_DVBSUB
@ -1754,10 +1754,10 @@ static subpicture_t *YuvaYuvp( subpicture_t *p_subpic )
for( i = 0; i < i_pixels ; )
{
uint8_t y, u, v, a;
y = p_region->picture.p[0].p_pixels[i];
u = p_region->picture.p[1].p_pixels[i];
v = p_region->picture.p[2].p_pixels[i];
a = p_region->picture.p[3].p_pixels[i];
y = p_region->p_picture->p[0].p_pixels[i];
u = p_region->p_picture->p[1].p_pixels[i];
v = p_region->p_picture->p[2].p_pixels[i];
a = p_region->p_picture->p[3].p_pixels[i];
for( j = 0; j < p_fmt->p_palette->i_entries; j++ )
{
if( abs((int)p_fmt->p_palette->palette[j][0] - (int)y) <= i_tolerance &&
@ -1799,29 +1799,29 @@ static subpicture_t *YuvaYuvp( subpicture_t *p_subpic )
#endif
#ifndef RANDOM_DITHERING
pi_delta = malloc( ( p_region->picture.p[0].i_pitch + 1 )
pi_delta = malloc( ( p_region->p_picture->p[0].i_pitch + 1 )
* sizeof(int) * 4 );
for( i = 0; i < (p_region->picture.p[0].i_pitch + 1) * 4 ; i++ )
for( i = 0; i < (p_region->p_picture->p[0].i_pitch + 1) * 4 ; i++ )
{
pi_delta[ i ] = 0;
}
#endif
/* Fill image with our new colours */
for( p = 0; p < p_region->picture.p[0].i_visible_lines ; p++ )
for( p = 0; p < p_region->p_picture->p[0].i_visible_lines ; p++ )
{
int i_ydelta = 0, i_udelta = 0, i_vdelta = 0, i_adelta = 0;
for( n = 0; n < p_region->picture.p[0].i_pitch ; n++ )
for( n = 0; n < p_region->p_picture->p[0].i_pitch ; n++ )
{
int i_offset = p * p_region->picture.p[0].i_pitch + n;
int i_offset = p * p_region->p_picture->p[0].i_pitch + n;
int y, u, v, a;
int i_mindist, i_best;
y = (int)p_region->picture.p[0].p_pixels[i_offset];
u = (int)p_region->picture.p[1].p_pixels[i_offset];
v = (int)p_region->picture.p[2].p_pixels[i_offset];
a = (int)p_region->picture.p[3].p_pixels[i_offset];
y = (int)p_region->p_picture->p[0].p_pixels[i_offset];
u = (int)p_region->p_picture->p[1].p_pixels[i_offset];
v = (int)p_region->p_picture->p[2].p_pixels[i_offset];
a = (int)p_region->p_picture->p[3].p_pixels[i_offset];
/* Add dithering compensation */
#ifdef RANDOM_DITHERING
@ -1854,7 +1854,7 @@ static subpicture_t *YuvaYuvp( subpicture_t *p_subpic )
}
/* Set pixel to best color */
p_region->picture.p[0].p_pixels[i_offset] = i_best;
p_region->p_picture->p[0].p_pixels[i_offset] = i_best;
/* Update dithering state */
#ifdef RANDOM_DITHERING
@ -2364,8 +2364,8 @@ static void encode_pixel_line_2bp( bs_t *s, subpicture_region_t *p_region,
int i_line )
{
unsigned int i, i_length = 0;
int i_pitch = p_region->picture.p->i_pitch;
uint8_t *p_data = &p_region->picture.p->p_pixels[ i_pitch * i_line ];
int i_pitch = p_region->p_picture->p->i_pitch;
uint8_t *p_data = &p_region->p_picture->p->p_pixels[ i_pitch * i_line ];
int i_last_pixel = p_data[0];
for( i = 0; i <= p_region->fmt.i_visible_width; i++ )
@ -2455,8 +2455,8 @@ static void encode_pixel_line_4bp( bs_t *s, subpicture_region_t *p_region,
int i_line )
{
unsigned int i, i_length = 0;
int i_pitch = p_region->picture.p->i_pitch;
uint8_t *p_data = &p_region->picture.p->p_pixels[ i_pitch * i_line ];
int i_pitch = p_region->p_picture->p->i_pitch;
uint8_t *p_data = &p_region->p_picture->p->p_pixels[ i_pitch * i_line ];
int i_last_pixel = p_data[0];
for( i = 0; i <= p_region->fmt.i_visible_width; i++ )
@ -2553,8 +2553,8 @@ static void encode_pixel_line_8bp( bs_t *s, subpicture_region_t *p_region,
int i_line )
{
unsigned int i, i_length = 0;
int i_pitch = p_region->picture.p->i_pitch;
uint8_t *p_data = &p_region->picture.p->p_pixels[ i_pitch * i_line ];
int i_pitch = p_region->p_picture->p->i_pitch;
uint8_t *p_data = &p_region->p_picture->p->p_pixels[ i_pitch * i_line ];
int i_last_pixel = p_data[0];
for( i = 0; i <= p_region->fmt.i_visible_width; i++ )

2
modules/codec/kate.c
View File

@ -640,7 +640,7 @@ static subpicture_t *DecodePacket( decoder_t *p_dec, kate_packet *p_kp, block_t
CreateKatePalette( fmt.p_palette, ev->palette );
/* create the bitmap */
CreateKateBitmap( &p_bitmap_region->picture, ev->bitmap );
CreateKateBitmap( p_bitmap_region->p_picture, ev->bitmap );
msg_Dbg(p_dec, "Created bitmap, %zux%zu, %zu colors\n", ev->bitmap->width, ev->bitmap->height, ev->palette->ncolors);
}

2
modules/codec/libass.c
View File

@ -569,7 +569,7 @@ static int BuildRegions( spu_t *p_spu, rectangle_t *p_region, int i_max_region,
static void RegionDraw( subpicture_region_t *p_region, ass_image_t *p_img )
{
const plane_t *p = &p_region->picture.p[0];
const plane_t *p = &p_region->p_picture->p[0];
const int i_x = p_region->i_x;
const int i_y = p_region->i_y;
const int i_width = p_region->fmt.i_width;

4
modules/codec/spudec/parse.c
View File

@ -676,8 +676,8 @@ static void Render( decoder_t *p_dec, subpicture_t *p_spu,
p_spu->p_region->i_x = p_spu_properties->i_x;
p_spu->p_region->i_y = p_spu_properties->i_y + p_spu_data->i_y_top_offset;
p_p = p_spu->p_region->picture.p->p_pixels;
i_pitch = p_spu->p_region->picture.p->i_pitch;
p_p = p_spu->p_region->p_picture->p->p_pixels;
i_pitch = p_spu->p_region->p_picture->p->i_pitch;
/* Build palette */
fmt.p_palette->i_entries = 4;

11
modules/codec/subtitles/subsusf.c
View File

@ -1208,7 +1208,8 @@ static subpicture_region_t *LoadEmbeddedImage( decoder_t *p_dec,
return NULL;
}
assert( p_pic->format.i_chroma == VLC_FOURCC('Y','U','V','A') );
picture_CopyPixels( &p_region->picture, p_pic );
/* FIXME the copy is probably not needed anymore */
picture_CopyPixels( p_region->p_picture, p_pic );
/* This isn't the best way to do this - if you really want transparency, then
* you're much better off using an image type that supports it like PNG. The
@ -1231,11 +1232,11 @@ static subpicture_region_t *LoadEmbeddedImage( decoder_t *p_dec,
{
for( unsigned int x = 0; x < p_region->fmt.i_width; x++ )
{
if( p_region->picture.Y_PIXELS[y*p_region->picture.Y_PITCH + x] != i_y ||
p_region->picture.U_PIXELS[y*p_region->picture.U_PITCH + x] != i_u ||
p_region->picture.V_PIXELS[y*p_region->picture.V_PITCH + x] != i_v )
if( p_region->p_picture->Y_PIXELS[y*p_region->p_picture->Y_PITCH + x] != i_y ||
p_region->p_picture->U_PIXELS[y*p_region->p_picture->U_PITCH + x] != i_u ||
p_region->p_picture->V_PIXELS[y*p_region->p_picture->V_PITCH + x] != i_v )
continue;
p_region->picture.A_PIXELS[y*p_region->picture.A_PITCH + x] = 0;
p_region->p_picture->A_PIXELS[y*p_region->p_picture->A_PITCH + x] = 0;
}
}

6
modules/codec/svcdsub.c
View File

@ -544,7 +544,7 @@ static void SVCDSubRenderImage( decoder_t *p_dec, block_t *p_data,
subpicture_region_t *p_region )
{
decoder_sys_t *p_sys = p_dec->p_sys;
uint8_t *p_dest = p_region->picture.Y_PIXELS;
uint8_t *p_dest = p_region->p_picture->Y_PIXELS;
int i_field; /* The subtitles are interlaced */
int i_row, i_column; /* scanline row/column number */
uint8_t i_color, i_count;
@ -563,13 +563,13 @@ static void SVCDSubRenderImage( decoder_t *p_dec, block_t *p_data,
if( i_color == 0 && (i_count = bs_read( &bs, 2 )) )
{
i_count = __MIN( i_count, p_sys->i_width - i_column );
memset( &p_dest[i_row * p_region->picture.Y_PITCH +
memset( &p_dest[i_row * p_region->p_picture->Y_PITCH +
i_column], 0, i_count + 1 );
i_column += i_count;
continue;
}
p_dest[i_row * p_region->picture.Y_PITCH + i_column] = i_color;
p_dest[i_row * p_region->p_picture->Y_PITCH + i_column] = i_color;
}
bs_align( &bs );

4
modules/codec/zvbi.c
View File

@ -418,12 +418,12 @@ static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
}
else
{
picture_t *p_pic = &p_spu->p_region->picture;
picture_t *p_pic = p_spu->p_region->p_picture;
/* ZVBI is stupid enough to assume pitch == width */
p_pic->p->i_pitch = 4 * fmt.i_width;
vbi_draw_vt_page( &p_page, ZVBI_PIXFMT_RGBA32,
p_spu->p_region->picture.p->p_pixels, 1, 1 );
p_spu->p_region->p_picture->p->p_pixels, 1, 1 );
vlc_mutex_lock( &p_sys->lock );
memcpy( p_sys->nav_link, &p_page.nav_link, sizeof( p_sys->nav_link )) ;

11
modules/gui/fbosd.c
View File

@ -883,23 +883,22 @@ static picture_t *RenderText( intf_thread_t *p_intf, const char *psz_string,
fmt_out.i_bits_per_pixel = 32;
vlc_memcpy( p_fmt, &fmt_out, sizeof(video_format_t) );
/* FIXME not needed to copy the picture anymore no ? */
p_dest = AllocatePicture( VLC_OBJECT(p_intf), &fmt_out );
if( !p_dest )
{
if( p_region->picture.pf_release )
p_region->picture.pf_release( &p_region->picture );
picture_Release( p_region->p_picture );
free( p_region->psz_text );
free( p_region );
return NULL;
}
vout_CopyPicture( VLC_OBJECT(p_intf), p_dest, &p_region->picture );
vout_CopyPicture( VLC_OBJECT(p_intf), p_dest, p_region->p_picture );
#else
fmt_out.i_chroma = p_fmt->i_chroma;
p_dest = ConvertImage( p_intf, &p_region->picture,
p_dest = ConvertImage( p_intf, &p_region->p_picture,
&p_region->fmt, &fmt_out );
#endif
if( p_region->picture.pf_release )
p_region->picture.pf_release( &p_region->picture );
picture_Release( p_region->p_picture );
free( p_region->psz_text );
free( p_region );
return p_dest;

63
modules/misc/freetype.c
View File

@ -662,7 +662,6 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
int i, x, y, i_pitch;
uint8_t i_y; /* YUV values, derived from incoming RGB */
int8_t i_u, i_v;
subpicture_region_t *p_region_tmp;
/* Create a new subpicture region */
memset( &fmt, 0, sizeof(video_format_t) );
@ -675,16 +674,12 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
if( p_region->fmt.i_visible_height > 0 )
fmt.i_visible_height = p_region->fmt.i_visible_height;
fmt.i_x_offset = fmt.i_y_offset = 0;
p_region_tmp = spu_CreateRegion( p_filter, &fmt );
if( !p_region_tmp )
{
msg_Err( p_filter, "cannot allocate SPU region" );
return VLC_EGENERIC;
}
p_region->fmt = p_region_tmp->fmt;
p_region->picture = p_region_tmp->picture;
free( p_region_tmp );
assert( !p_region->p_picture );
p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
if( !p_region->p_picture )
return VLC_EGENERIC;
p_region->fmt = fmt;
/* Calculate text color components */
i_y = (uint8_t)(( 66 * p_line->i_red + 129 * p_line->i_green +
@ -715,8 +710,8 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
(int)fmt.p_palette->palette[i][3] * (255 - p_line->i_alpha) / 255;
}
p_dst = p_region->picture.Y_PIXELS;
i_pitch = p_region->picture.Y_PITCH;
p_dst = p_region->p_picture->Y_PIXELS;
i_pitch = p_region->p_picture->Y_PITCH;
/* Initialize the region pixels */
memset( p_dst, 0, i_pitch * p_region->fmt.i_height );
@ -768,21 +763,21 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
/* Outlining (find something better than nearest neighbour filtering ?) */
if( 1 )
{
uint8_t *p_dst = p_region->picture.Y_PIXELS;
uint8_t *p_dst = p_region->p_picture->Y_PIXELS;
uint8_t *p_top = p_dst; /* Use 1st line as a cache */
uint8_t left, current;
for( y = 1; y < (int)fmt.i_height - 1; y++ )
{
if( y > 1 ) memcpy( p_top, p_dst, fmt.i_width );
p_dst += p_region->picture.Y_PITCH;
p_dst += p_region->p_picture->Y_PITCH;
left = 0;
for( x = 1; x < (int)fmt.i_width - 1; x++ )
{
current = p_dst[x];
p_dst[x] = ( 8 * (int)p_dst[x] + left + p_dst[x+1] + p_top[x -1]+ p_top[x] + p_top[x+1] +
p_dst[x -1 + p_region->picture.Y_PITCH ] + p_dst[x + p_region->picture.Y_PITCH] + p_dst[x + 1 + p_region->picture.Y_PITCH]) / 16;
p_dst[x -1 + p_region->p_picture->Y_PITCH ] + p_dst[x + p_region->p_picture->Y_PITCH] + p_dst[x + 1 + p_region->p_picture->Y_PITCH]) / 16;
left = current;
}
}
@ -803,11 +798,11 @@ static void UnderlineGlyphYUVA( int i_line_thickness, int i_line_offset, bool b_
int i_pitch;
uint8_t *p_dst_y,*p_dst_u,*p_dst_v,*p_dst_a;
p_dst_y = p_region->picture.Y_PIXELS;
p_dst_u = p_region->picture.U_PIXELS;
p_dst_v = p_region->picture.V_PIXELS;
p_dst_a = p_region->picture.A_PIXELS;
i_pitch = p_region->picture.A_PITCH;
p_dst_y = p_region->p_picture->Y_PIXELS;
p_dst_u = p_region->p_picture->U_PIXELS;
p_dst_v = p_region->p_picture->V_PIXELS;
p_dst_a = p_region->p_picture->A_PIXELS;
i_pitch = p_region->p_picture->A_PITCH;
int i_offset = ( p_this_glyph_pos->y + i_glyph_tmax + i_line_offset + 3 ) * i_pitch +
p_this_glyph_pos->x + p_this_glyph->left + 3 + i_align_offset;
@ -866,8 +861,8 @@ static void UnderlineGlyphYUVA( int i_line_thickness, int i_line_offset, bool b_
static void DrawBlack( line_desc_t *p_line, int i_width, subpicture_region_t *p_region, int xoffset, int yoffset )
{
uint8_t *p_dst = p_region->picture.A_PIXELS;
int i_pitch = p_region->picture.A_PITCH;
uint8_t *p_dst = p_region->p_picture->A_PIXELS;
int i_pitch = p_region->p_picture->A_PITCH;
int x,y;
for( ; p_line != NULL; p_line = p_line->p_next )
@ -930,7 +925,6 @@ static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
video_format_t fmt;
int i, x, y, i_pitch, i_alpha;
uint8_t i_y, i_u, i_v; /* YUV values, derived from incoming RGB */
subpicture_region_t *p_region_tmp;
if( i_width == 0 || i_height == 0 )
return VLC_SUCCESS;
@ -946,16 +940,11 @@ static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
if( p_region->fmt.i_visible_height > 0 )
fmt.i_visible_height = p_region->fmt.i_visible_height;
fmt.i_x_offset = fmt.i_y_offset = 0;
p_region_tmp = spu_CreateRegion( p_filter, &fmt );
if( !p_region_tmp )
{
msg_Err( p_filter, "cannot allocate SPU region" );
return VLC_EGENERIC;
}
p_region->fmt = p_region_tmp->fmt;
p_region->picture = p_region_tmp->picture;
free( p_region_tmp );
p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
if( !p_region->p_picture )
return VLC_EGENERIC;
p_region->fmt = fmt;
/* Calculate text color components */
YUVFromRGB( (p_line->i_red << 16) |
@ -964,11 +953,11 @@ static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region,
&i_y, &i_u, &i_v);
i_alpha = p_line->i_alpha;
p_dst_y = p_region->picture.Y_PIXELS;
p_dst_u = p_region->picture.U_PIXELS;
p_dst_v = p_region->picture.V_PIXELS;
p_dst_a = p_region->picture.A_PIXELS;
i_pitch = p_region->picture.A_PITCH;
p_dst_y = p_region->p_picture->Y_PIXELS;
p_dst_u = p_region->p_picture->U_PIXELS;
p_dst_v = p_region->p_picture->V_PIXELS;
p_dst_a = p_region->p_picture->A_PIXELS;
i_pitch = p_region->p_picture->A_PITCH;
/* Initialize the region pixels */
if( p_filter->p_sys->i_effect != EFFECT_BACKGROUND )

25
modules/misc/quartztext.c
View File

@ -1321,7 +1321,6 @@ static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region, UniCha
video_format_t fmt;
int x, y, i_offset, i_pitch;
uint8_t i_y, i_u, i_v; // YUV values, derived from incoming RGB
subpicture_region_t *p_region_tmp;
// Create a new subpicture region
memset( &fmt, 0, sizeof(video_format_t) );
@ -1330,21 +1329,17 @@ static int RenderYUVA( filter_t *p_filter, subpicture_region_t *p_region, UniCha
fmt.i_width = fmt.i_visible_width = i_width;
fmt.i_height = fmt.i_visible_height = i_textblock_height + VERTICAL_MARGIN * 2;
fmt.i_x_offset = fmt.i_y_offset = 0;
p_region_tmp = spu_CreateRegion( p_filter, &fmt );
if( !p_region_tmp )
{
msg_Err( p_filter, "cannot allocate SPU region" );
return VLC_EGENERIC;
}
p_region->fmt = p_region_tmp->fmt;
p_region->picture = p_region_tmp->picture;
free( p_region_tmp );
p_dst_y = p_region->picture.Y_PIXELS;
p_dst_u = p_region->picture.U_PIXELS;
p_dst_v = p_region->picture.V_PIXELS;
p_dst_a = p_region->picture.A_PIXELS;
i_pitch = p_region->picture.A_PITCH;
p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
if( !p_region->p_picture )
return VLC_EGENERIC;
p_region->fmt = fmt;
p_dst_y = p_region->p_picture->Y_PIXELS;
p_dst_u = p_region->p_picture->U_PIXELS;
p_dst_v = p_region->p_picture->V_PIXELS;
p_dst_a = p_region->p_picture->A_PIXELS;
i_pitch = p_region->p_picture->A_PITCH;
i_offset = VERTICAL_MARGIN *i_pitch;
for( y=0; y<i_textblock_height; y++)

27
modules/misc/svg.c
View File

@ -257,7 +257,6 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
int channels_in;
int alpha;
picture_t *p_pic;
subpicture_region_t *p_region_tmp;
if ( p_filter->p_sys->i_width != i_width ||
p_filter->p_sys->i_height != i_height )
@ -284,31 +283,27 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
fmt.i_width = fmt.i_visible_width = i_width;
fmt.i_height = fmt.i_visible_height = i_height;
fmt.i_x_offset = fmt.i_y_offset = 0;
p_region_tmp = spu_CreateRegion( p_filter, &fmt );
if( !p_region_tmp )
{
msg_Err( p_filter, "cannot allocate SPU region" );
p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
if( !p_region->p_picture )
return VLC_EGENERIC;
}
p_region->fmt = p_region_tmp->fmt;
p_region->picture = p_region_tmp->picture;
free( p_region_tmp );
p_region->fmt = fmt;
p_region->i_x = p_region->i_y = 0;
p_y = p_region->picture.Y_PIXELS;
p_u = p_region->picture.U_PIXELS;
p_v = p_region->picture.V_PIXELS;
p_a = p_region->picture.A_PIXELS;
p_y = p_region->p_picture->Y_PIXELS;
p_u = p_region->p_picture->U_PIXELS;
p_v = p_region->p_picture->V_PIXELS;
p_a = p_region->p_picture->A_PIXELS;
i_pitch = p_region->picture.Y_PITCH;
i_u_pitch = p_region->picture.U_PITCH;
i_pitch = p_region->p_picture->Y_PITCH;
i_u_pitch = p_region->p_picture->U_PITCH;
/* Initialize the region pixels (only the alpha will be changed later) */
memset( p_y, 0x00, i_pitch * p_region->fmt.i_height );
memset( p_u, 0x80, i_u_pitch * p_region->fmt.i_height );
memset( p_v, 0x80, i_u_pitch * p_region->fmt.i_height );
p_pic = &p_region->picture;
p_pic = p_region->p_picture;
/* Copy the data */

22
modules/misc/win32text.c
View File

@ -217,7 +217,6 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
uint8_t *p_dst;
video_format_t fmt;
int i, i_pitch;
subpicture_region_t *p_region_tmp;
bool b_outline = true;
/* Create a new subpicture region */
@ -226,12 +225,6 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
fmt.i_width = fmt.i_visible_width = i_width + (b_outline ? 4 : 0);
fmt.i_height = fmt.i_visible_height = i_height + (b_outline ? 4 : 0);
fmt.i_x_offset = fmt.i_y_offset = 0;
p_region_tmp = spu_CreateRegion( p_filter, &fmt );
if( !p_region_tmp )
{
msg_Err( p_filter, "cannot allocate SPU region" );
return VLC_EGENERIC;
}
/* Build palette */
fmt.p_palette->i_entries = 16;
@ -243,17 +236,18 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
fmt.p_palette->palette[i][3] = pi_gamma[i];
}
p_region->fmt = p_region_tmp->fmt;
p_region->picture = p_region_tmp->picture;
free( p_region_tmp );
p_region->p_picture = picture_New( fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect );
if( !p_region->p_picture )
return VLC_EGENERIC;
p_region->fmt = fmt;
p_dst = p_region->picture.Y_PIXELS;
i_pitch = p_region->picture.Y_PITCH;
p_dst = p_region->p_picture->Y_PIXELS;
i_pitch = p_region->p_picture->Y_PITCH;
if( b_outline )
{
memset( p_dst, 0, i_pitch * fmt.i_height );
p_dst += p_region->picture.Y_PITCH * 2 + 2;
p_dst += p_region->p_picture->Y_PITCH * 2 + 2;
}
for( i = 0; i < i_height; i++ )
@ -270,7 +264,7 @@ static int Render( filter_t *p_filter, subpicture_region_t *p_region,
uint8_t left, current;
int x, y;
p_dst = p_region->picture.Y_PIXELS;
p_dst = p_region->p_picture->Y_PIXELS;
for( y = 1; y < (int)fmt.i_height - 1; y++ )
{

3
modules/video_filter/dynamicoverlay/dynamicoverlay.c
View File

@ -365,7 +365,8 @@ static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
}
else
{
vout_CopyPicture( p_filter, &p_region->picture, p_overlay->data.p_pic );
/* FIXME the copy is probably not needed anymore */
vout_CopyPicture( p_filter, p_region->p_picture, p_overlay->data.p_pic );
}
p_region->i_x = p_overlay->i_x;
p_region->i_y = p_overlay->i_y;

3
modules/video_filter/logo.c
View File

@ -873,7 +873,8 @@ static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
return NULL;
}
vout_CopyPicture( p_filter, &p_region->picture, p_pic );
/* FIXME the copy is probably not needed anymore */
vout_CopyPicture( p_filter, &p_region->p_picture, p_pic );
vlc_mutex_unlock( &p_logo_list->lock );
/* where to locate the logo: */

4
modules/video_filter/mosaic.c
View File

@ -642,9 +642,9 @@ static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
}
p_region = p_spu->pf_create_region( VLC_OBJECT(p_filter), &fmt_out );
/* XXX That's a pity to do a copy, but it is needed for now */
/* FIXME the copy is probably not needed anymore */
if( p_region )
picture_Copy( &p_region->picture, p_converted );
picture_Copy( &p_region->p_picture, p_converted );
if( !p_sys->b_keep )
picture_Release( p_converted );

3
modules/video_filter/osdmenu.c
View File

@ -426,8 +426,9 @@ static subpicture_region_t *create_picture_region( filter_t *p_filter, subpictur
p_region->fmt.i_width = p_region->fmt.i_visible_width = 0;
p_region->fmt.i_height = p_region->fmt.i_visible_height = 0;
}
/* FIXME the copy is probably not needed anymore */
if( p_pic )
vout_CopyPicture( p_filter, &p_region->picture, p_pic );
vout_CopyPicture( p_filter, p_region->p_picture, p_pic );
p_region->i_x = 0;
p_region->i_y = 0;

3
modules/video_filter/remoteosd.c
View File

@ -1171,7 +1171,8 @@ static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
return NULL;
}
vout_CopyPicture( p_filter, &p_region->picture, p_pic );
/* FIXME the copy is probably not needed anymore */
vout_CopyPicture( p_filter, p_region->p_picture, p_pic );
p_sys->b_need_update = false;

3
modules/video_filter/rss.c
View File

@ -557,7 +557,8 @@ static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
p_region->i_x = p_sys->i_xoff;
p_region->i_y = p_sys->i_yoff;
vout_CopyPicture( p_filter, &p_region->picture, p_pic );
/* FIXME the copy is probably not needed anymore */
vout_CopyPicture( p_filter, p_region->p_picture, p_pic );
p_spu->p_region->p_next = p_region;
}

22
src/osd/osd_widgets.c
View File

@ -52,8 +52,8 @@ static void DrawRect( subpicture_t *p_subpic, int i_x1, int i_y1,
int i_x2, int i_y2, short fill )
{
int x, y;
uint8_t *p_a = p_subpic->p_region->picture.A_PIXELS;
int i_pitch = p_subpic->p_region->picture.Y_PITCH;
uint8_t *p_a = p_subpic->p_region->p_picture->A_PIXELS;
int i_pitch = p_subpic->p_region->p_picture->Y_PITCH;
if( fill == STYLE_FILLED )
{
@ -88,8 +88,8 @@ static void DrawTriangle( subpicture_t *p_subpic, int i_x1, int i_y1,
int i_x2, int i_y2, short fill )
{
int x, y, i_mid, h;
uint8_t *p_a = p_subpic->p_region->picture.A_PIXELS;
int i_pitch = p_subpic->p_region->picture.Y_PITCH;
uint8_t *p_a = p_subpic->p_region->p_picture->A_PIXELS;
int i_pitch = p_subpic->p_region->p_picture->Y_PITCH;
i_mid = i_y1 + ( ( i_y2 - i_y1 ) >> 1 );
@ -173,11 +173,11 @@ static int CreatePicture( spu_t *p_spu, subpicture_t *p_subpic,
p_subpic->p_region->i_x = i_x;
p_subpic->p_region->i_y = i_y;
p_y = p_subpic->p_region->picture.Y_PIXELS;
p_u = p_subpic->p_region->picture.U_PIXELS;
p_v = p_subpic->p_region->picture.V_PIXELS;
p_a = p_subpic->p_region->picture.A_PIXELS;
i_pitch = p_subpic->p_region->picture.Y_PITCH;
p_y = p_subpic->p_region->p_picture->Y_PIXELS;
p_u = p_subpic->p_region->p_picture->U_PIXELS;
p_v = p_subpic->p_region->p_picture->V_PIXELS;
p_a = p_subpic->p_region->p_picture->A_PIXELS;
i_pitch = p_subpic->p_region->p_picture->Y_PITCH;
/* Initialize the region pixels (only the alpha will be changed later) */
memset( p_y, 0xff, i_pitch * p_subpic->p_region->fmt.i_height );
@ -328,8 +328,8 @@ int osd_Icon( vlc_object_t *p_this, spu_t *p_spu,
STYLE_FILLED );
if( i_type == OSD_MUTE_ICON )
{
uint8_t *p_a = p_subpic->p_region->picture.A_PIXELS;
int i_pitch = p_subpic->p_region->picture.Y_PITCH;
uint8_t *p_a = p_subpic->p_region->p_picture->A_PIXELS;
int i_pitch = p_subpic->p_region->p_picture->Y_PITCH;
int i;
for( i = 1; i < i_pitch; i++ )
{

10
src/video_output/vout_intf.c
View File

@ -477,8 +477,14 @@ static int VoutSnapshotPip( vout_thread_t *p_vout, image_handler_t *p_image, pic
p_subpic->p_region = spu_CreateRegion( p_vout->p_spu, &fmt_out );
if( p_subpic->p_region )
vout_CopyPicture( p_image->p_parent, &p_subpic->p_region->picture, p_pip );
picture_Release( p_pip );
{
picture_Release( p_subpic->p_region->p_picture );
p_subpic->p_region->p_picture = p_pip;
}
else
{
picture_Release( p_pip );
}
spu_DisplaySubpicture( p_vout->p_spu, p_subpic );
return VLC_SUCCESS;

151
src/video_output/vout_subpictures.c
View File

@ -70,6 +70,39 @@ struct filter_owner_sys_t
#define SCALE_UNIT (1000)
/* */
struct subpicture_region_private_t
{
video_format_t fmt;
picture_t *p_picture;
};
static subpicture_region_private_t *SpuRegionPrivateCreate( video_format_t *p_fmt )
{
subpicture_region_private_t *p_private = malloc( sizeof(*p_private) );
if( !p_private )
return NULL;
p_private->fmt = *p_fmt;
if( p_fmt->p_palette )
{
p_private->fmt.p_palette = malloc( sizeof(*p_private->fmt.p_palette) );
if( p_private->fmt.p_palette )
*p_private->fmt.p_palette = *p_fmt->p_palette;
}
p_private->p_picture = NULL;
return p_private;
}
static void SpuRegionPrivateDestroy( subpicture_region_private_t *p_private )
{
if( p_private->p_picture )
picture_Release( p_private->p_picture );
free( p_private->fmt.p_palette );
free( p_private );
}
/* */
static void SpuRenderCreateAndLoadText( spu_t *p_spu );
static void SpuRenderCreateAndLoadScale( spu_t *p_spu );
@ -215,19 +248,6 @@ void spu_Attach( spu_t *p_spu, vlc_object_t *p_this, bool b_attach )
}
}
/* */
static void RegionPictureRelease( picture_t *p_picture )
{
if( --p_picture->i_refcount > 0 )
return;
assert( p_picture->i_refcount == 0 );
free( p_picture->p_q );
free( p_picture->p_data_orig );
free( p_picture->p_sys );
}
/**
* Create a subpicture region
*
@ -250,26 +270,23 @@ subpicture_region_t *__spu_CreateRegion( vlc_object_t *p_this,
p_region->fmt = *p_fmt;
p_region->i_alpha = 0xff;
p_region->p_next = NULL;
p_region->p_cache = 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('T','E','X','T') )
return p_region;
vout_AllocatePicture( p_this, &p_region->picture, p_fmt->i_chroma,
p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect );
if( !p_region->picture.i_planes )
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;
}
p_region->picture.i_refcount = 1;
p_region->picture.pf_release = RegionPictureRelease;
return p_region;
}
@ -284,11 +301,13 @@ void __spu_DestroyRegion( vlc_object_t *p_this, subpicture_region_t *p_region )
if( !p_region )
return;
picture_Release( &p_region->picture );
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 );
if( p_region->p_cache )
__spu_DestroyRegion( p_this, p_region->p_cache );
free( p_region->psz_text );
free( p_region->psz_html );
@ -902,6 +921,9 @@ static void SpuRenderRegion( spu_t *p_spu,
int i_y_offset;
filter_t *p_scale;
video_format_t *p_region_fmt;
picture_t *p_region_picture;
vlc_assert_locked( &p_spu->subpicture_lock );
/* Invalidate area by default */
@ -958,6 +980,7 @@ static void SpuRenderRegion( spu_t *p_spu,
i_x_offset = spu_scale_w( p_area->i_x, p_area->scale );
i_y_offset = spu_scale_h( p_area->i_y, p_area->scale );
/* */
if( b_force_palette )
{
/* It looks so wrong I won't comment
@ -968,12 +991,14 @@ static void SpuRenderRegion( spu_t *p_spu,
memcpy( p_region->fmt.p_palette->palette, p_spu->palette, 4*sizeof(uint32_t) );
}
if( b_using_palette )
p_scale = p_spu->p_scale_yuvp;
else
p_scale = p_spu->p_scale;
/* */
p_region_fmt = &p_region->fmt;
p_region_picture = p_region->p_picture;
/* Scale from rendered size to destination size */
p_scale = b_using_palette ? p_spu->p_scale_yuvp : p_spu->p_scale;
if( p_scale &&
( scale_size.w != SCALE_UNIT || scale_size.h != SCALE_UNIT || b_force_palette ) )
{
@ -983,21 +1008,17 @@ static void SpuRenderRegion( spu_t *p_spu,
/* TODO when b_using_palette is true, we should first convert it to YUVA to allow
* a proper rescaling */
/* Destroy if cache is unusable */
if( p_region->p_cache )
/* Destroy if cache is unusable
* FIXME do not always destroy the region it can sometimes be reused
* if same size and same palette if present */
if( p_region->p_private )
{
if( p_region->p_cache->fmt.i_width != i_dst_width ||
p_region->p_cache->fmt.i_height != i_dst_height ||
b_force_palette )
{
p_subpic->pf_destroy_region( VLC_OBJECT(p_spu),
p_region->p_cache );
p_region->p_cache = NULL;
}
SpuRegionPrivateDestroy( p_region->p_private );
p_region->p_private = NULL;
}
/* Scale if needed into cache */
if( !p_region->p_cache )
if( !p_region->p_private )
{
picture_t *p_pic;
@ -1012,52 +1033,33 @@ static void SpuRenderRegion( spu_t *p_spu,
p_scale->fmt_out.video.i_visible_height =
spu_scale_h( p_region->fmt.i_visible_height, scale_size );
p_region->p_cache =
p_subpic->pf_create_region( VLC_OBJECT(p_spu),
&p_scale->fmt_out.video );
p_region->p_private = SpuRegionPrivateCreate( &p_scale->fmt_out.video );
p_pic = NULL;
if( p_scale->p_module )
{
picture_Yield( &p_region->picture );
p_pic = p_scale->pf_video_filter( p_scale, &p_region->picture );
picture_Yield( p_region->p_picture );
p_region->p_private->p_picture = p_scale->pf_video_filter( p_scale, p_region->p_picture );
}
if( p_pic )
{
picture_CopyPixels( &p_region->p_cache->picture, p_pic );
picture_Release( p_pic );
if( p_region->p_cache->fmt.p_palette )
*p_region->p_cache->fmt.p_palette = *p_region->fmt.p_palette;
/* i_x/i_y of cached region should NOT be used. I set them to
* an invalid value to catch it (assert) */
p_region->p_cache->i_x = INT_MAX;
p_region->p_cache->i_y = INT_MAX;
p_region->p_cache->i_align = p_region->i_align;
p_region->p_cache->i_alpha = p_region->i_alpha;
}
else
if( !p_region->p_private->p_picture )
{
msg_Err( p_spu, "scaling failed (module not loaded)" );
p_subpic->pf_destroy_region( VLC_OBJECT(p_spu),
p_region->p_cache );
p_region->p_cache = NULL;
SpuRegionPrivateDestroy( p_region->p_private );
p_region->p_private = NULL;
}
}
/* And use the scaled picture */
if( p_region->p_cache )
if( p_region->p_private )
{
p_region = p_region->p_cache;
fmt_original = p_region->fmt;
p_region_fmt = &p_region->p_private->fmt;
p_region_picture = p_region->p_private->p_picture;
}
}
/* Force cropping if requested */
if( b_force_crop )
{
video_format_t *p_fmt = &p_region->fmt;
video_format_t *p_fmt = p_region_fmt;
int i_crop_x = spu_scale_w( p_spu->i_crop_x, scale_size );
int i_crop_y = spu_scale_h( p_spu->i_crop_y, scale_size );
int i_crop_width = spu_scale_w( p_spu->i_crop_width, scale_size );
@ -1094,14 +1096,14 @@ static void SpuRenderRegion( spu_t *p_spu,
}
/* Update the blender */
SpuRenderUpdateBlend( p_spu, p_fmt->i_width, p_fmt->i_height, &p_region->fmt );
SpuRenderUpdateBlend( p_spu, p_fmt->i_width, p_fmt->i_height, p_region_fmt );
if( p_spu->p_blend->p_module )
{
const int i_alpha = SpuRegionAlpha( p_subpic, p_region );
p_spu->p_blend->pf_video_blend( p_spu->p_blend, p_pic_dst,
&p_region->picture, i_x_offset, i_y_offset, i_alpha );
p_region_picture, i_x_offset, i_y_offset, i_alpha );
}
else
{
@ -1118,8 +1120,13 @@ exit:
* pre-rendered state, so the next time through everything is
* calculated again.
*/
p_region->picture.pf_release( &p_region->picture );
memset( &p_region->picture, 0, sizeof( picture_t ) );
picture_Release( p_region->p_picture );
p_region->p_picture = NULL;
if( p_region->p_private )
{
SpuRegionPrivateDestroy( p_region->p_private );
p_region->p_private = NULL;
}
p_region->i_align &= ~SUBPICTURE_RENDERED;
}
if( b_restore_format )