1 /*****************************************************************************
2 * picture.c : picture management functions
3 *****************************************************************************
4 * Copyright (C) 2000-2010 VLC authors and VideoLAN
5 * Copyright (C) 2009-2010 Laurent Aimar
8 * Authors: Vincent Seguin <seguin@via.ecp.fr>
9 * Samuel Hocevar <sam@zoy.org>
10 * Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU Lesser General Public License as published by
14 * the Free Software Foundation; either version 2.1 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public License
23 * along with this program; if not, write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 *****************************************************************************/
27 /*****************************************************************************
29 *****************************************************************************/
36 #include <vlc_common.h>
38 #include <vlc_image.h>
39 #include <vlc_block.h>
42 * Allocate a new picture in the heap.
44 * This function allocates a fake direct buffer in memory, which can be
45 * used exactly like a video buffer. The video output thread then manages
46 * how it gets displayed.
48 static int AllocatePicture( picture_t
*p_pic
)
50 /* Calculate how big the new image should be */
52 for( int i
= 0; i
< p_pic
->i_planes
; i
++ )
54 const plane_t
*p
= &p_pic
->p
[i
];
56 if( p
->i_pitch
< 0 || p
->i_lines
<= 0 ||
57 (size_t)p
->i_pitch
> (SIZE_MAX
- i_bytes
)/p
->i_lines
)
62 i_bytes
+= p
->i_pitch
* p
->i_lines
;
65 uint8_t *p_data
= aligned_alloc( 16, i_bytes
);
66 if( i_bytes
> 0 && p_data
== NULL
)
72 /* Fill the p_pixels field for each plane */
73 p_pic
->p
[0].p_pixels
= p_data
;
74 for( int i
= 1; i
< p_pic
->i_planes
; i
++ )
76 p_pic
->p
[i
].p_pixels
= &p_pic
->p
[i
-1].p_pixels
[ p_pic
->p
[i
-1].i_lines
*
77 p_pic
->p
[i
-1].i_pitch
];
83 /*****************************************************************************
85 *****************************************************************************/
87 static void PictureDestroyContext( picture_t
*p_picture
)
89 picture_context_t
*ctx
= p_picture
->context
;
93 p_picture
->context
= NULL
;
98 * Destroys a picture allocated by picture_NewFromResource() but without
99 * a custom destruction callback.
101 static void picture_DestroyFromResource( picture_t
*p_picture
)
103 free( p_picture
->p_sys
);
108 * Destroys a picture allocated with picture_NewFromFormat()
109 * (and thus AllocatePicture()).
111 static void picture_Destroy( picture_t
*p_picture
)
113 aligned_free( p_picture
->p
[0].p_pixels
);
117 /*****************************************************************************
119 *****************************************************************************/
120 void picture_Reset( picture_t
*p_picture
)
123 p_picture
->date
= VLC_TS_INVALID
;
124 p_picture
->b_force
= false;
125 p_picture
->b_progressive
= false;
126 p_picture
->i_nb_fields
= 2;
127 p_picture
->b_top_field_first
= false;
128 PictureDestroyContext( p_picture
);
131 /*****************************************************************************
133 *****************************************************************************/
134 static int LCM( int a
, int b
)
136 return a
* b
/ GCD( a
, b
);
139 int picture_Setup( picture_t
*p_picture
, const video_format_t
*restrict fmt
)
141 /* Store default values */
142 p_picture
->i_planes
= 0;
143 for( unsigned i
= 0; i
< VOUT_MAX_PLANES
; i
++ )
145 plane_t
*p
= &p_picture
->p
[i
];
147 p
->i_pixel_pitch
= 0;
150 p_picture
->i_nb_fields
= 2;
152 video_format_Setup( &p_picture
->format
, fmt
->i_chroma
, fmt
->i_width
, fmt
->i_height
,
153 fmt
->i_visible_width
, fmt
->i_visible_height
,
154 fmt
->i_sar_num
, fmt
->i_sar_den
);
156 const vlc_chroma_description_t
*p_dsc
=
157 vlc_fourcc_GetChromaDescription( p_picture
->format
.i_chroma
);
161 /* We want V (width/height) to respect:
162 (V * p_dsc->p[i].w.i_num) % p_dsc->p[i].w.i_den == 0
163 (V * p_dsc->p[i].w.i_num/p_dsc->p[i].w.i_den * p_dsc->i_pixel_size) % 16 == 0
164 Which is respected if you have
165 V % lcm( p_dsc->p[0..planes].w.i_den * 16) == 0
169 unsigned int i_ratio_h
= 1;
170 for( unsigned i
= 0; i
< p_dsc
->plane_count
; i
++ )
172 i_modulo_w
= LCM( i_modulo_w
, 16 * p_dsc
->p
[i
].w
.den
);
173 i_modulo_h
= LCM( i_modulo_h
, 16 * p_dsc
->p
[i
].h
.den
);
174 if( i_ratio_h
< p_dsc
->p
[i
].h
.den
)
175 i_ratio_h
= p_dsc
->p
[i
].h
.den
;
177 i_modulo_h
= LCM( i_modulo_h
, 32 );
179 const int i_width_aligned
= ( fmt
->i_width
+ i_modulo_w
- 1 ) / i_modulo_w
* i_modulo_w
;
180 const int i_height_aligned
= ( fmt
->i_height
+ i_modulo_h
- 1 ) / i_modulo_h
* i_modulo_h
;
181 const int i_height_extra
= 2 * i_ratio_h
; /* This one is a hack for some ASM functions */
182 for( unsigned i
= 0; i
< p_dsc
->plane_count
; i
++ )
184 plane_t
*p
= &p_picture
->p
[i
];
186 p
->i_lines
= (i_height_aligned
+ i_height_extra
) * p_dsc
->p
[i
].h
.num
/ p_dsc
->p
[i
].h
.den
;
187 p
->i_visible_lines
= fmt
->i_visible_height
* p_dsc
->p
[i
].h
.num
/ p_dsc
->p
[i
].h
.den
;
188 p
->i_pitch
= i_width_aligned
* p_dsc
->p
[i
].w
.num
/ p_dsc
->p
[i
].w
.den
* p_dsc
->pixel_size
;
189 p
->i_visible_pitch
= fmt
->i_visible_width
* p_dsc
->p
[i
].w
.num
/ p_dsc
->p
[i
].w
.den
* p_dsc
->pixel_size
;
190 p
->i_pixel_pitch
= p_dsc
->pixel_size
;
192 assert( (p
->i_pitch
% 16) == 0 );
194 p_picture
->i_planes
= p_dsc
->plane_count
;
199 /*****************************************************************************
201 *****************************************************************************/
202 picture_t
*picture_NewFromResource( const video_format_t
*p_fmt
, const picture_resource_t
*p_resource
)
204 video_format_t fmt
= *p_fmt
;
206 /* It is needed to be sure all information are filled */
207 video_format_Setup( &fmt
, p_fmt
->i_chroma
,
208 p_fmt
->i_width
, p_fmt
->i_height
,
209 p_fmt
->i_visible_width
, p_fmt
->i_visible_height
,
210 p_fmt
->i_sar_num
, p_fmt
->i_sar_den
);
211 if( p_fmt
->i_x_offset
< p_fmt
->i_width
&&
212 p_fmt
->i_y_offset
< p_fmt
->i_height
&&
213 p_fmt
->i_visible_width
> 0 && p_fmt
->i_x_offset
+ p_fmt
->i_visible_width
<= p_fmt
->i_width
&&
214 p_fmt
->i_visible_height
> 0 && p_fmt
->i_y_offset
+ p_fmt
->i_visible_height
<= p_fmt
->i_height
)
215 video_format_CopyCrop( &fmt
, p_fmt
);
218 picture_priv_t
*priv
= malloc( sizeof (*priv
) );
219 if( unlikely(priv
== NULL
) )
222 picture_t
*p_picture
= &priv
->picture
;
224 memset( p_picture
, 0, sizeof( *p_picture
) );
225 p_picture
->format
= fmt
;
227 /* Make sure the real dimensions are a multiple of 16 */
228 if( picture_Setup( p_picture
, &fmt
) )
234 atomic_init( &priv
->gc
.refs
, 1 );
235 priv
->gc
.opaque
= NULL
;
239 p_picture
->p_sys
= p_resource
->p_sys
;
241 if( p_resource
->pf_destroy
!= NULL
)
242 priv
->gc
.destroy
= p_resource
->pf_destroy
;
244 priv
->gc
.destroy
= picture_DestroyFromResource
;
246 for( int i
= 0; i
< p_picture
->i_planes
; i
++ )
248 p_picture
->p
[i
].p_pixels
= p_resource
->p
[i
].p_pixels
;
249 p_picture
->p
[i
].i_lines
= p_resource
->p
[i
].i_lines
;
250 p_picture
->p
[i
].i_pitch
= p_resource
->p
[i
].i_pitch
;
255 if( AllocatePicture( p_picture
) )
260 priv
->gc
.destroy
= picture_Destroy
;
266 picture_t
*picture_NewFromFormat( const video_format_t
*p_fmt
)
268 return picture_NewFromResource( p_fmt
, NULL
);
271 picture_t
*picture_New( vlc_fourcc_t i_chroma
, int i_width
, int i_height
, int i_sar_num
, int i_sar_den
)
275 memset( &fmt
, 0, sizeof(fmt
) );
276 video_format_Setup( &fmt
, i_chroma
, i_width
, i_height
,
277 i_width
, i_height
, i_sar_num
, i_sar_den
);
279 return picture_NewFromFormat( &fmt
);
282 /*****************************************************************************
284 *****************************************************************************/
286 picture_t
*picture_Hold( picture_t
*p_picture
)
288 assert( p_picture
!= NULL
);
290 picture_priv_t
*priv
= (picture_priv_t
*)p_picture
;
291 uintptr_t refs
= atomic_fetch_add( &priv
->gc
.refs
, 1 );
296 void picture_Release( picture_t
*p_picture
)
298 assert( p_picture
!= NULL
);
300 picture_priv_t
*priv
= (picture_priv_t
*)p_picture
;
301 uintptr_t refs
= atomic_fetch_sub( &priv
->gc
.refs
, 1 );
306 PictureDestroyContext( p_picture
);
307 assert( priv
->gc
.destroy
!= NULL
);
308 priv
->gc
.destroy( p_picture
);
311 bool picture_IsReferenced( picture_t
*p_picture
)
313 picture_priv_t
*priv
= (picture_priv_t
*)p_picture
;
315 return atomic_load( &priv
->gc
.refs
) > 1;
318 /*****************************************************************************
320 *****************************************************************************/
321 void plane_CopyPixels( plane_t
*p_dst
, const plane_t
*p_src
)
323 const unsigned i_width
= __MIN( p_dst
->i_visible_pitch
,
324 p_src
->i_visible_pitch
);
325 const unsigned i_height
= __MIN( p_dst
->i_visible_lines
,
326 p_src
->i_visible_lines
);
328 /* The 2x visible pitch check does two things:
329 1) Makes field plane_t's work correctly (see the deinterlacer module)
330 2) Moves less data if the pitch and visible pitch differ much.
332 if( p_src
->i_pitch
== p_dst
->i_pitch
&&
333 p_src
->i_pitch
< 2*p_src
->i_visible_pitch
)
335 /* There are margins, but with the same width : perfect ! */
336 memcpy( p_dst
->p_pixels
, p_src
->p_pixels
,
337 p_src
->i_pitch
* i_height
);
341 /* We need to proceed line by line */
342 uint8_t *p_in
= p_src
->p_pixels
;
343 uint8_t *p_out
= p_dst
->p_pixels
;
348 for( int i_line
= i_height
; i_line
--; )
350 memcpy( p_out
, p_in
, i_width
);
351 p_in
+= p_src
->i_pitch
;
352 p_out
+= p_dst
->i_pitch
;
357 void picture_CopyProperties( picture_t
*p_dst
, const picture_t
*p_src
)
359 p_dst
->date
= p_src
->date
;
360 p_dst
->b_force
= p_src
->b_force
;
362 p_dst
->b_progressive
= p_src
->b_progressive
;
363 p_dst
->i_nb_fields
= p_src
->i_nb_fields
;
364 p_dst
->b_top_field_first
= p_src
->b_top_field_first
;
367 void picture_CopyPixels( picture_t
*p_dst
, const picture_t
*p_src
)
369 for( int i
= 0; i
< p_src
->i_planes
; i
++ )
370 plane_CopyPixels( p_dst
->p
+i
, p_src
->p
+i
);
372 assert( p_dst
->context
== NULL
);
374 if( p_src
->context
!= NULL
)
375 p_dst
->context
= p_src
->context
->copy( p_src
->context
);
378 void picture_Copy( picture_t
*p_dst
, const picture_t
*p_src
)
380 picture_CopyPixels( p_dst
, p_src
);
381 picture_CopyProperties( p_dst
, p_src
);
385 /*****************************************************************************
387 *****************************************************************************/
388 int picture_Export( vlc_object_t
*p_obj
,
390 video_format_t
*p_fmt
,
391 picture_t
*p_picture
,
392 vlc_fourcc_t i_format
,
393 int i_override_width
, int i_override_height
)
396 video_format_t fmt_in
= p_picture
->format
;
397 if( fmt_in
.i_sar_num
<= 0 || fmt_in
.i_sar_den
<= 0 )
400 fmt_in
.i_sar_den
= 1;
404 video_format_t fmt_out
;
405 memset( &fmt_out
, 0, sizeof(fmt_out
) );
407 fmt_out
.i_sar_den
= 1;
408 fmt_out
.i_chroma
= i_format
;
410 /* compute original width/height */
411 unsigned int i_width
, i_height
, i_original_width
, i_original_height
;
412 if( fmt_in
.i_visible_width
> 0 && fmt_in
.i_visible_height
> 0 )
414 i_width
= fmt_in
.i_visible_width
;
415 i_height
= fmt_in
.i_visible_height
;
419 i_width
= fmt_in
.i_width
;
420 i_height
= fmt_in
.i_height
;
422 if( fmt_in
.i_sar_num
>= fmt_in
.i_sar_den
)
424 i_original_width
= (int64_t)i_width
* fmt_in
.i_sar_num
/ fmt_in
.i_sar_den
;
425 i_original_height
= i_height
;
429 i_original_width
= i_width
;
430 i_original_height
= i_height
* fmt_in
.i_sar_den
/ fmt_in
.i_sar_num
;
434 fmt_out
.i_width
= ( i_override_width
< 0 ) ?
435 i_original_width
: (unsigned)i_override_width
;
436 fmt_out
.i_height
= ( i_override_height
< 0 ) ?
437 i_original_height
: (unsigned)i_override_height
;
439 /* scale if only one direction is provided */
440 if( fmt_out
.i_height
== 0 && fmt_out
.i_width
> 0 )
442 fmt_out
.i_height
= i_height
* fmt_out
.i_width
443 * fmt_in
.i_sar_den
/ fmt_in
.i_width
/ fmt_in
.i_sar_num
;
445 else if( fmt_out
.i_width
== 0 && fmt_out
.i_height
> 0 )
447 fmt_out
.i_width
= i_width
* fmt_out
.i_height
448 * fmt_in
.i_sar_num
/ fmt_in
.i_height
/ fmt_in
.i_sar_den
;
451 image_handler_t
*p_image
= image_HandlerCreate( p_obj
);
455 block_t
*p_block
= image_Write( p_image
, p_picture
, &fmt_in
, &fmt_out
);
457 image_HandlerDelete( p_image
);
463 p_block
->i_dts
= p_picture
->date
;