X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fvideo_output%2Fvout_pictures.c;h=83bfb59651df88267d19c0eabcae30295da83834;hb=13268071115898a03f9b1d3c470a72de82eabf0c;hp=22fc9139f1663dfe8fedf4e5ac1c75be353966c3;hpb=5b55ee1bb0a0212b967f8f4a33824ffc6b7c7f09;p=vlc diff --git a/src/video_output/vout_pictures.c b/src/video_output/vout_pictures.c index 22fc9139f1..83bfb59651 100644 --- a/src/video_output/vout_pictures.c +++ b/src/video_output/vout_pictures.c @@ -29,67 +29,42 @@ #ifdef HAVE_CONFIG_H # include "config.h" #endif +#include -#include +#include +#include #include #include +#include +#include +#include +#include +#include + #include "vout_pictures.h" +#include "vout_internal.h" /** * Display a picture * * Remove the reservation flag of a picture, which will cause it to be ready - * for display. The picture won't be displayed until vout_DatePicture has been - * called. + * for display. */ void vout_DisplayPicture( vout_thread_t *p_vout, picture_t *p_pic ) { vlc_mutex_lock( &p_vout->picture_lock ); - switch( p_pic->i_status ) + + if( p_pic->i_status == RESERVED_PICTURE ) { - case RESERVED_PICTURE: - p_pic->i_status = RESERVED_DISP_PICTURE; - break; - case RESERVED_DATED_PICTURE: p_pic->i_status = READY_PICTURE; - break; - default: - msg_Err( p_vout, "picture to display %p has invalid status %d", - p_pic, p_pic->i_status ); - break; + vlc_cond_signal( &p_vout->p->picture_wait ); } - - vlc_mutex_unlock( &p_vout->picture_lock ); -} - -/** - * Date a picture - * - * Remove the reservation flag of a picture, which will cause it to be ready - * for display. The picture won't be displayed until vout_DisplayPicture has - * been called. - * \param p_vout The vout in question - * \param p_pic The picture to date - * \param date The date to display the picture - */ -void vout_DatePicture( vout_thread_t *p_vout, - picture_t *p_pic, mtime_t date ) -{ - vlc_mutex_lock( &p_vout->picture_lock ); - p_pic->date = date; - switch( p_pic->i_status ) + else { - case RESERVED_PICTURE: - p_pic->i_status = RESERVED_DATED_PICTURE; - break; - case RESERVED_DISP_PICTURE: - p_pic->i_status = READY_PICTURE; - break; - default: - msg_Err( p_vout, "picture to date %p has invalid status %d", + msg_Err( p_vout, "picture to display %p has invalid status %d", p_pic, p_pic->i_status ); - break; } + p_vout->p->i_picture_qtype = p_pic->i_qtype; vlc_mutex_unlock( &p_vout->picture_lock ); } @@ -103,6 +78,35 @@ void vout_DatePicture( vout_thread_t *p_vout, * It needs locking since several pictures can be created by several producers * threads. */ +int vout_CountPictureAvailable( vout_thread_t *p_vout ) +{ + int i_free = 0; + int i_pic; + + vlc_mutex_lock( &p_vout->picture_lock ); + for( i_pic = 0; i_pic < I_RENDERPICTURES; i_pic++ ) + { + picture_t *p_pic = PP_RENDERPICTURE[(p_vout->render.i_last_used_pic + i_pic + 1) % I_RENDERPICTURES]; + + switch( p_pic->i_status ) + { + case DESTROYED_PICTURE: + i_free++; + break; + + case FREE_PICTURE: + i_free++; + break; + + default: + break; + } + } + vlc_mutex_unlock( &p_vout->picture_lock ); + + return i_free; +} + picture_t *vout_CreatePicture( vout_thread_t *p_vout, bool b_progressive, bool b_top_field_first, @@ -181,8 +185,6 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, p_freepic->i_nb_fields = i_nb_fields; p_freepic->b_top_field_first = b_top_field_first; - p_freepic->i_matrix_coefficients = 1; - p_vout->i_heap_size++; } else @@ -206,30 +208,75 @@ picture_t *vout_CreatePicture( vout_thread_t *p_vout, return( NULL ); } +/* */ +static void DestroyPicture( vout_thread_t *p_vout, picture_t *p_picture ) +{ + vlc_assert_locked( &p_vout->picture_lock ); + + p_picture->i_status = DESTROYED_PICTURE; + p_vout->i_heap_size--; + picture_CleanupQuant( p_picture ); + + vlc_cond_signal( &p_vout->p->picture_wait ); +} + /** * Remove a permanent or reserved picture from the heap * * This function frees a previously reserved picture or a permanent * picture. It is meant to be used when the construction of a picture aborted. * Note that the picture will be destroyed even if it is linked ! + * + * TODO remove it, vout_DropPicture should be used instead */ void vout_DestroyPicture( vout_thread_t *p_vout, picture_t *p_pic ) { - vlc_mutex_lock( &p_vout->picture_lock ); - #ifndef NDEBUG /* Check if picture status is valid */ - if( (p_pic->i_status != RESERVED_PICTURE) && - (p_pic->i_status != RESERVED_DATED_PICTURE) && - (p_pic->i_status != RESERVED_DISP_PICTURE) ) + vlc_mutex_lock( &p_vout->picture_lock ); + if( p_pic->i_status != RESERVED_PICTURE ) { msg_Err( p_vout, "picture to destroy %p has invalid status %d", p_pic, p_pic->i_status ); } + vlc_mutex_unlock( &p_vout->picture_lock ); #endif - p_pic->i_status = DESTROYED_PICTURE; - p_vout->i_heap_size--; + vout_DropPicture( p_vout, p_pic ); +} + +/* */ +void vout_UsePictureLocked( vout_thread_t *p_vout, picture_t *p_picture ) +{ + vlc_assert_locked( &p_vout->picture_lock ); + if( p_picture->i_refcount > 0 ) + { + /* Pretend we displayed the picture, but don't destroy + * it since the decoder might still need it. */ + p_picture->i_status = DISPLAYED_PICTURE; + } + else + { + /* Destroy the picture without displaying it */ + DestroyPicture( p_vout, p_picture ); + } +} + +/* */ +void vout_DropPicture( vout_thread_t *p_vout, picture_t *p_pic ) +{ + vlc_mutex_lock( &p_vout->picture_lock ); + + if( p_pic->i_status == READY_PICTURE ) + { + /* Grr cannot destroy ready picture by myself so be sure vout won't like it */ + p_pic->date = 1; + vlc_cond_signal( &p_vout->p->picture_wait ); + } + else + { + vout_UsePictureLocked( p_vout, p_pic ); + } vlc_mutex_unlock( &p_vout->picture_lock ); } @@ -255,18 +302,31 @@ void vout_LinkPicture( vout_thread_t *p_vout, picture_t *p_pic ) void vout_UnlinkPicture( vout_thread_t *p_vout, picture_t *p_pic ) { vlc_mutex_lock( &p_vout->picture_lock ); - p_pic->i_refcount--; - if( ( p_pic->i_refcount == 0 ) && - ( p_pic->i_status == DISPLAYED_PICTURE ) ) - { - p_pic->i_status = DESTROYED_PICTURE; - p_vout->i_heap_size--; - } + if( p_pic->i_refcount > 0 ) + p_pic->i_refcount--; + else + msg_Err( p_vout, "Invalid picture reference count (%p, %d)", + p_pic, p_pic->i_refcount ); + + if( p_pic->i_refcount == 0 && p_pic->i_status == DISPLAYED_PICTURE ) + DestroyPicture( p_vout, p_pic ); vlc_mutex_unlock( &p_vout->picture_lock ); } +static int vout_LockPicture( vout_thread_t *p_vout, picture_t *p_picture ) +{ + if( p_picture->pf_lock ) + return p_picture->pf_lock( p_vout, p_picture ); + return VLC_SUCCESS; +} +static void vout_UnlockPicture( vout_thread_t *p_vout, picture_t *p_picture ) +{ + if( p_picture->pf_unlock ) + p_picture->pf_unlock( p_vout, p_picture ); +} + /** * Render a picture * @@ -274,78 +334,58 @@ void vout_UnlinkPicture( vout_thread_t *p_vout, picture_t *p_pic ) * before rendering, does the subpicture magic, and tells the video output * thread which direct buffer needs to be displayed. */ -picture_t * vout_RenderPicture( vout_thread_t *p_vout, picture_t *p_pic, - subpicture_t *p_subpic ) +picture_t *vout_RenderPicture( vout_thread_t *p_vout, picture_t *p_pic, + subpicture_t *p_subpic, mtime_t render_date ) { - int i_scale_width, i_scale_height; - if( p_pic == NULL ) - { - /* XXX: subtitles */ return NULL; - } - - i_scale_width = p_vout->fmt_out.i_visible_width * 1000 / - p_vout->fmt_in.i_visible_width; - i_scale_height = p_vout->fmt_out.i_visible_height * 1000 / - p_vout->fmt_in.i_visible_height; if( p_pic->i_type == DIRECT_PICTURE ) { - if( !p_vout->render.b_allow_modify_pics || p_pic->i_refcount || - p_pic->b_force ) + /* Picture is in a direct buffer. */ + + if( p_subpic != NULL ) { - /* Picture is in a direct buffer and is still in use, - * we need to copy it to another direct buffer before - * displaying it if there are subtitles. */ - if( p_subpic != NULL ) - { - /* We have subtitles. First copy the picture to - * the spare direct buffer, then render the - * subtitles. */ - vout_CopyPicture( p_vout, PP_OUTPUTPICTURE[0], p_pic ); - - spu_RenderSubpictures( p_vout->p_spu, &p_vout->fmt_out, - PP_OUTPUTPICTURE[0], p_pic, p_subpic, - i_scale_width, i_scale_height ); - - return PP_OUTPUTPICTURE[0]; - } - - /* No subtitles, picture is in a directbuffer so - * we can display it directly even if it is still - * in use. */ - return p_pic; - } + /* We have subtitles. First copy the picture to + * the spare direct buffer, then render the + * subtitles. */ + if( vout_LockPicture( p_vout, PP_OUTPUTPICTURE[0] ) ) + return NULL; + + picture_Copy( PP_OUTPUTPICTURE[0], p_pic ); - /* Picture is in a direct buffer but isn't used by the - * decoder. We can safely render subtitles on it and - * display it. */ - spu_RenderSubpictures( p_vout->p_spu, &p_vout->fmt_out, p_pic, p_pic, - p_subpic, i_scale_width, i_scale_height ); + spu_RenderSubpictures( p_vout->p_spu, + PP_OUTPUTPICTURE[0], &p_vout->fmt_out, + p_subpic, &p_vout->fmt_in, render_date ); + vout_UnlockPicture( p_vout, PP_OUTPUTPICTURE[0] ); + + return PP_OUTPUTPICTURE[0]; + } + + /* No subtitles, picture is in a directbuffer so + * we can display it directly (even if it is still + * in use or not). */ return p_pic; } /* Not a direct buffer. We either need to copy it to a direct buffer, * or render it if the chroma isn't the same. */ - if( p_vout->b_direct ) + if( p_vout->p->b_direct ) { /* Picture is not in a direct buffer, but is exactly the * same size as the direct buffers. A memcpy() is enough, * then render the subtitles. */ - if( PP_OUTPUTPICTURE[0]->pf_lock ) - if( PP_OUTPUTPICTURE[0]->pf_lock( p_vout, PP_OUTPUTPICTURE[0] ) ) - return NULL; + if( vout_LockPicture( p_vout, PP_OUTPUTPICTURE[0] ) ) + return NULL; - vout_CopyPicture( p_vout, PP_OUTPUTPICTURE[0], p_pic ); - spu_RenderSubpictures( p_vout->p_spu, &p_vout->fmt_out, - PP_OUTPUTPICTURE[0], p_pic, - p_subpic, i_scale_width, i_scale_height ); + picture_Copy( PP_OUTPUTPICTURE[0], p_pic ); + spu_RenderSubpictures( p_vout->p_spu, + PP_OUTPUTPICTURE[0], &p_vout->fmt_out, + p_subpic, &p_vout->fmt_in, render_date ); - if( PP_OUTPUTPICTURE[0]->pf_unlock ) - PP_OUTPUTPICTURE[0]->pf_unlock( p_vout, PP_OUTPUTPICTURE[0] ); + vout_UnlockPicture( p_vout, PP_OUTPUTPICTURE[0] ); return PP_OUTPUTPICTURE[0]; } @@ -370,41 +410,38 @@ picture_t * vout_RenderPicture( vout_thread_t *p_vout, picture_t *p_pic, p_vout->fmt_out.i_aspect ); p_tmp_pic->i_type = MEMORY_PICTURE; p_tmp_pic->i_status = RESERVED_PICTURE; - /* some modules (such as blend) needs to know the extra information in picture heap */ - p_tmp_pic->p_heap = &p_vout->output; } /* Convert image to the first direct buffer */ - p_vout->chroma.pf_convert( p_vout, p_pic, p_tmp_pic ); + p_vout->p->p_chroma->p_owner = (filter_owner_sys_t *)p_tmp_pic; + p_vout->p->p_chroma->pf_video_filter( p_vout->p->p_chroma, p_pic ); /* Render subpictures on the first direct buffer */ - spu_RenderSubpictures( p_vout->p_spu, &p_vout->fmt_out, p_tmp_pic, - p_tmp_pic, p_subpic, - i_scale_width, i_scale_height ); + spu_RenderSubpictures( p_vout->p_spu, + p_tmp_pic, &p_vout->fmt_out, + p_subpic, &p_vout->fmt_in, render_date ); - if( p_vout->p_picture[0].pf_lock ) - if( p_vout->p_picture[0].pf_lock( p_vout, &p_vout->p_picture[0] ) ) - return NULL; + if( vout_LockPicture( p_vout, &p_vout->p_picture[0] ) ) + return NULL; - vout_CopyPicture( p_vout, &p_vout->p_picture[0], p_tmp_pic ); + picture_Copy( &p_vout->p_picture[0], p_tmp_pic ); } else { - if( p_vout->p_picture[0].pf_lock ) - if( p_vout->p_picture[0].pf_lock( p_vout, &p_vout->p_picture[0] ) ) - return NULL; + if( vout_LockPicture( p_vout, &p_vout->p_picture[0] ) ) + return NULL; /* Convert image to the first direct buffer */ - p_vout->chroma.pf_convert( p_vout, p_pic, &p_vout->p_picture[0] ); + p_vout->p->p_chroma->p_owner = (filter_owner_sys_t *)&p_vout->p_picture[0]; + p_vout->p->p_chroma->pf_video_filter( p_vout->p->p_chroma, p_pic ); /* Render subpictures on the first direct buffer */ - spu_RenderSubpictures( p_vout->p_spu, &p_vout->fmt_out, - &p_vout->p_picture[0], &p_vout->p_picture[0], - p_subpic, i_scale_width, i_scale_height ); + spu_RenderSubpictures( p_vout->p_spu, + &p_vout->p_picture[0], &p_vout->fmt_out, + p_subpic, &p_vout->fmt_in, render_date ); } - if( p_vout->p_picture[0].pf_unlock ) - p_vout->p_picture[0].pf_unlock( p_vout, &p_vout->p_picture[0] ); + vout_UnlockPicture( p_vout, &p_vout->p_picture[0] ); return &p_vout->p_picture[0]; } @@ -415,42 +452,71 @@ picture_t * vout_RenderPicture( vout_thread_t *p_vout, picture_t *p_pic, * This function will be accessed by plugins. It calculates the relative * position of the output window and the image window. */ -void vout_PlacePicture( vout_thread_t *p_vout, +void vout_PlacePicture( const vout_thread_t *p_vout, unsigned int i_width, unsigned int i_height, - unsigned int *pi_x, unsigned int *pi_y, - unsigned int *pi_width, unsigned int *pi_height ) + unsigned int *restrict pi_x, + unsigned int *restrict pi_y, + unsigned int *restrict pi_width, + unsigned int *restrict pi_height ) { - if( (i_width <= 0) || (i_height <=0) ) + if( i_width <= 0 || i_height <= 0 ) { *pi_width = *pi_height = *pi_x = *pi_y = 0; return; } - if( p_vout->b_scale ) + if( p_vout->b_autoscale ) { *pi_width = i_width; *pi_height = i_height; } else { - *pi_width = __MIN( i_width, p_vout->fmt_in.i_visible_width ); - *pi_height = __MIN( i_height, p_vout->fmt_in.i_visible_height ); + int i_zoom = p_vout->i_zoom; + /* be realistic, scaling factor confined between .2 and 10. */ + if( i_zoom > 10 * ZOOM_FP_FACTOR ) i_zoom = 10 * ZOOM_FP_FACTOR; + else if( i_zoom < ZOOM_FP_FACTOR / 5 ) i_zoom = ZOOM_FP_FACTOR / 5; + + unsigned int i_original_width, i_original_height; + + if( p_vout->fmt_in.i_sar_num >= p_vout->fmt_in.i_sar_den ) + { + i_original_width = p_vout->fmt_in.i_visible_width * + p_vout->fmt_in.i_sar_num / p_vout->fmt_in.i_sar_den; + i_original_height = p_vout->fmt_in.i_visible_height; + } + else + { + i_original_width = p_vout->fmt_in.i_visible_width; + i_original_height = p_vout->fmt_in.i_visible_height * + p_vout->fmt_in.i_sar_den / p_vout->fmt_in.i_sar_num; + } +#ifdef WIN32 + /* On windows, inner video window exceeding container leads to black screen */ + *pi_width = __MIN( i_width, i_original_width * i_zoom / ZOOM_FP_FACTOR ); + *pi_height = __MIN( i_height, i_original_height * i_zoom / ZOOM_FP_FACTOR ); +#else + *pi_width = i_original_width * i_zoom / ZOOM_FP_FACTOR ; + *pi_height = i_original_height * i_zoom / ZOOM_FP_FACTOR ; +#endif } - if( p_vout->fmt_in.i_visible_width * (int64_t)p_vout->fmt_in.i_sar_num * - *pi_height / p_vout->fmt_in.i_visible_height / - p_vout->fmt_in.i_sar_den > *pi_width ) + int64_t i_scaled_width = p_vout->fmt_in.i_visible_width * (int64_t)p_vout->fmt_in.i_sar_num * + *pi_height / p_vout->fmt_in.i_visible_height / p_vout->fmt_in.i_sar_den; + int64_t i_scaled_height = p_vout->fmt_in.i_visible_height * (int64_t)p_vout->fmt_in.i_sar_den * + *pi_width / p_vout->fmt_in.i_visible_width / p_vout->fmt_in.i_sar_num; + + if( i_scaled_width <= 0 || i_scaled_height <= 0 ) { - *pi_height = p_vout->fmt_in.i_visible_height * - (int64_t)p_vout->fmt_in.i_sar_den * *pi_width / - p_vout->fmt_in.i_visible_width / p_vout->fmt_in.i_sar_num; + msg_Warn( p_vout, "ignoring broken aspect ratio" ); + i_scaled_width = *pi_width; + i_scaled_height = *pi_height; } + + if( i_scaled_width > *pi_width ) + *pi_height = i_scaled_height; else - { - *pi_width = p_vout->fmt_in.i_visible_width * - (int64_t)p_vout->fmt_in.i_sar_num * *pi_height / - p_vout->fmt_in.i_visible_height / p_vout->fmt_in.i_sar_den; - } + *pi_width = i_scaled_width; switch( p_vout->i_alignment & VOUT_ALIGN_HMASK ) { @@ -488,14 +554,15 @@ int __vout_AllocatePicture( vlc_object_t *p_this, picture_t *p_pic, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_aspect ) { + VLC_UNUSED(p_this); int i_bytes, i_index, i_width_aligned, i_height_aligned; /* Make sure the real dimensions are a multiple of 16 */ i_width_aligned = (i_width + 15) >> 4 << 4; i_height_aligned = (i_height + 15) >> 4 << 4; - if( vout_InitPicture( p_this, p_pic, i_chroma, - i_width, i_height, i_aspect ) != VLC_SUCCESS ) + if( picture_Setup( p_pic, i_chroma, + i_width, i_height, i_aspect ) != VLC_SUCCESS ) { p_pic->i_planes = 0; return VLC_EGENERIC; @@ -526,432 +593,787 @@ int __vout_AllocatePicture( vlc_object_t *p_this, picture_t *p_pic, } /** - * Initialise the video format fields given chroma/size. + * Compare two chroma values * - * This function initializes all the video_frame_format_t fields given the - * static properties of a picture (chroma and size). - * \param p_format Pointer to the format structure to initialize - * \param i_chroma Chroma to set - * \param i_width Width to set - * \param i_height Height to set - * \param i_aspect Aspect ratio + * This function returns 1 if the two fourcc values given as argument are + * the same format (eg. UYVY/UYNV) or almost the same format (eg. I420/YV12) */ -void vout_InitFormat( video_frame_format_t *p_format, vlc_fourcc_t i_chroma, - int i_width, int i_height, int i_aspect ) -{ - p_format->i_chroma = i_chroma; - p_format->i_width = p_format->i_visible_width = i_width; - p_format->i_height = p_format->i_visible_height = i_height; - p_format->i_x_offset = p_format->i_y_offset = 0; - p_format->i_aspect = i_aspect; - -#if 0 - /* Assume we have square pixels */ - if( i_width && i_height ) - p_format->i_aspect = i_width * VOUT_ASPECT_FACTOR / i_height; - else - p_format->i_aspect = 0; -#endif +int vout_ChromaCmp( vlc_fourcc_t i_chroma, vlc_fourcc_t i_amorhc ) +{ + static const vlc_fourcc_t p_I420[] = { + VLC_CODEC_I420, VLC_CODEC_YV12, VLC_CODEC_J420, 0 + }; + static const vlc_fourcc_t p_I422[] = { + VLC_CODEC_I422, VLC_CODEC_J422, 0 + }; + static const vlc_fourcc_t p_I440[] = { + VLC_CODEC_I440, VLC_CODEC_J440, 0 + }; + static const vlc_fourcc_t p_I444[] = { + VLC_CODEC_I444, VLC_CODEC_J444, 0 + }; + static const vlc_fourcc_t *pp_fcc[] = { + p_I420, p_I422, p_I440, p_I444, NULL + }; + + /* */ + i_chroma = vlc_fourcc_GetCodec( VIDEO_ES, i_chroma ); + i_amorhc = vlc_fourcc_GetCodec( VIDEO_ES, i_amorhc ); - switch( i_chroma ) - { - case FOURCC_YUVA: - p_format->i_bits_per_pixel = 32; - break; - case FOURCC_I444: - case FOURCC_J444: - p_format->i_bits_per_pixel = 24; - break; - case FOURCC_I422: - case FOURCC_YUY2: - case FOURCC_UYVY: - case FOURCC_J422: - p_format->i_bits_per_pixel = 16; - break; - case FOURCC_I411: - case FOURCC_YV12: - case FOURCC_I420: - case FOURCC_J420: - case FOURCC_IYUV: - p_format->i_bits_per_pixel = 12; - break; - case FOURCC_I410: - case FOURCC_YVU9: - p_format->i_bits_per_pixel = 9; - break; - case FOURCC_Y211: - p_format->i_bits_per_pixel = 8; - break; - case FOURCC_YUVP: - p_format->i_bits_per_pixel = 8; - break; + /* If they are the same, they are the same ! */ + if( i_chroma == i_amorhc ) + return 1; - case FOURCC_RV32: - case FOURCC_RGBA: - p_format->i_bits_per_pixel = 32; - break; - case FOURCC_RV24: - p_format->i_bits_per_pixel = 24; - break; - case FOURCC_RV15: - case FOURCC_RV16: - p_format->i_bits_per_pixel = 16; - break; - case FOURCC_RGB2: - p_format->i_bits_per_pixel = 8; - break; + /* Check for equivalence classes */ + for( int i = 0; pp_fcc[i] != NULL; i++ ) + { + bool b_fcc1 = false; + bool b_fcc2 = false; + for( int j = 0; pp_fcc[i][j] != 0; j++ ) + { + if( i_chroma == pp_fcc[i][j] ) + b_fcc1 = true; + if( i_amorhc == pp_fcc[i][j] ) + b_fcc2 = true; + } + if( b_fcc1 && b_fcc2 ) + return 1; + } + return 0; +} - case FOURCC_GREY: - p_format->i_bits_per_pixel = 8; - break; +/***************************************************************************** + * + *****************************************************************************/ +static void PictureReleaseCallback( picture_t *p_picture ) +{ + if( --p_picture->i_refcount > 0 ) + return; + picture_Delete( p_picture ); +} - default: - p_format->i_bits_per_pixel = 0; - break; - } +/***************************************************************************** + * + *****************************************************************************/ +void picture_Reset( picture_t *p_picture ) +{ + /* */ + p_picture->date = VLC_TS_INVALID; + p_picture->b_force = false; + p_picture->b_progressive = false; + p_picture->i_nb_fields = 0; + p_picture->b_top_field_first = false; + picture_CleanupQuant( p_picture ); } -/** - * Initialise the picture_t fields given chroma/size. +/***************************************************************************** * - * This function initializes most of the picture_t fields given a chroma and - * size. It makes the assumption that stride == width. - * \param p_this The calling object - * \param p_pic Pointer to the picture to initialize - * \param i_chroma The chroma fourcc to set - * \param i_width The width of the picture - * \param i_height The height of the picture - * \param i_aspect The aspect ratio of the picture - */ -int __vout_InitPicture( vlc_object_t *p_this, picture_t *p_pic, - vlc_fourcc_t i_chroma, - int i_width, int i_height, int i_aspect ) + *****************************************************************************/ +int picture_Setup( picture_t *p_picture, vlc_fourcc_t i_chroma, int i_width, int i_height, int i_aspect ) { int i_index, i_width_aligned, i_height_aligned; /* Store default values */ for( i_index = 0; i_index < VOUT_MAX_PLANES; i_index++ ) { - p_pic->p[i_index].p_pixels = NULL; - p_pic->p[i_index].i_pixel_pitch = 1; + p_picture->p[i_index].p_pixels = NULL; + p_picture->p[i_index].i_pixel_pitch = 1; } - p_pic->pf_release = 0; - p_pic->pf_lock = 0; - p_pic->pf_unlock = 0; - p_pic->i_refcount = 0; + p_picture->pf_release = NULL; + p_picture->p_release_sys = NULL; + p_picture->pf_lock = NULL; + p_picture->pf_unlock = NULL; + p_picture->i_refcount = 0; - vout_InitFormat( &p_pic->format, i_chroma, i_width, i_height, i_aspect ); + 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_aspect ); /* Make sure the real dimensions are a multiple of 16 */ i_width_aligned = (i_width + 15) >> 4 << 4; i_height_aligned = (i_height + 15) >> 4 << 4; /* Calculate coordinates */ - switch( i_chroma ) - { - case FOURCC_I411: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned; - p_pic->p[ U_PLANE ].i_visible_lines = i_height; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 4; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 4; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned; - p_pic->p[ V_PLANE ].i_visible_lines = i_height; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 4; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 4; - p_pic->i_planes = 3; - break; + switch( vlc_fourcc_GetCodec( VIDEO_ES, i_chroma ) ) + { + case VLC_CODEC_I411: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned; + p_picture->p[ U_PLANE ].i_visible_lines = i_height; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned / 4; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width / 4; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned; + p_picture->p[ V_PLANE ].i_visible_lines = i_height; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned / 4; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width / 4; + p_picture->i_planes = 3; + break; - case FOURCC_I410: - case FOURCC_YVU9: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned / 4; - p_pic->p[ U_PLANE ].i_visible_lines = i_height / 4; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 4; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 4; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned / 4; - p_pic->p[ V_PLANE ].i_visible_lines = i_height / 4; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 4; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 4; - p_pic->i_planes = 3; - break; + case VLC_CODEC_I410: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned / 4; + p_picture->p[ U_PLANE ].i_visible_lines = i_height / 4; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned / 4; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width / 4; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned / 4; + p_picture->p[ V_PLANE ].i_visible_lines = i_height / 4; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned / 4; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width / 4; + p_picture->i_planes = 3; + break; - case FOURCC_YV12: - case FOURCC_I420: - case FOURCC_IYUV: - case FOURCC_J420: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned / 2; - p_pic->p[ U_PLANE ].i_visible_lines = i_height / 2; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 2; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 2; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned / 2; - p_pic->p[ V_PLANE ].i_visible_lines = i_height / 2; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 2; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 2; - p_pic->i_planes = 3; - break; + case VLC_CODEC_YV12: + case VLC_CODEC_I420: + case VLC_CODEC_J420: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned / 2; + p_picture->p[ U_PLANE ].i_visible_lines = i_height / 2; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned / 2; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width / 2; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned / 2; + p_picture->p[ V_PLANE ].i_visible_lines = i_height / 2; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned / 2; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width / 2; + p_picture->i_planes = 3; + break; - case FOURCC_I422: - case FOURCC_J422: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned; - p_pic->p[ U_PLANE ].i_visible_lines = i_height; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned / 2; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width / 2; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned; - p_pic->p[ V_PLANE ].i_visible_lines = i_height; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned / 2; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width / 2; - p_pic->i_planes = 3; - break; + case VLC_CODEC_I422: + case VLC_CODEC_J422: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned; + p_picture->p[ U_PLANE ].i_visible_lines = i_height; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned / 2; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width / 2; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned; + p_picture->p[ V_PLANE ].i_visible_lines = i_height; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned / 2; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width / 2; + p_picture->i_planes = 3; + break; - case FOURCC_I444: - case FOURCC_J444: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned; - p_pic->p[ U_PLANE ].i_visible_lines = i_height; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned; - p_pic->p[ V_PLANE ].i_visible_lines = i_height; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width; - p_pic->i_planes = 3; - break; + case VLC_CODEC_I440: + case VLC_CODEC_J440: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned / 2; + p_picture->p[ U_PLANE ].i_visible_lines = i_height / 2; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned / 2; + p_picture->p[ V_PLANE ].i_visible_lines = i_height / 2; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width; + p_picture->i_planes = 3; + break; - case FOURCC_YUVA: - p_pic->p[ Y_PLANE ].i_lines = i_height_aligned; - p_pic->p[ Y_PLANE ].i_visible_lines = i_height; - p_pic->p[ Y_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ Y_PLANE ].i_visible_pitch = i_width; - p_pic->p[ U_PLANE ].i_lines = i_height_aligned; - p_pic->p[ U_PLANE ].i_visible_lines = i_height; - p_pic->p[ U_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ U_PLANE ].i_visible_pitch = i_width; - p_pic->p[ V_PLANE ].i_lines = i_height_aligned; - p_pic->p[ V_PLANE ].i_visible_lines = i_height; - p_pic->p[ V_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ V_PLANE ].i_visible_pitch = i_width; - p_pic->p[ A_PLANE ].i_lines = i_height_aligned; - p_pic->p[ A_PLANE ].i_visible_lines = i_height; - p_pic->p[ A_PLANE ].i_pitch = i_width_aligned; - p_pic->p[ A_PLANE ].i_visible_pitch = i_width; - p_pic->i_planes = 4; - break; + case VLC_CODEC_I444: + case VLC_CODEC_J444: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned; + p_picture->p[ U_PLANE ].i_visible_lines = i_height; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned; + p_picture->p[ V_PLANE ].i_visible_lines = i_height; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width; + p_picture->i_planes = 3; + break; - case FOURCC_YUVP: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned; - p_pic->p->i_visible_pitch = i_width; - p_pic->p->i_pixel_pitch = 8; - p_pic->i_planes = 1; - break; + case VLC_CODEC_YUVA: + p_picture->p[ Y_PLANE ].i_lines = i_height_aligned; + p_picture->p[ Y_PLANE ].i_visible_lines = i_height; + p_picture->p[ Y_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ Y_PLANE ].i_visible_pitch = i_width; + p_picture->p[ U_PLANE ].i_lines = i_height_aligned; + p_picture->p[ U_PLANE ].i_visible_lines = i_height; + p_picture->p[ U_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ U_PLANE ].i_visible_pitch = i_width; + p_picture->p[ V_PLANE ].i_lines = i_height_aligned; + p_picture->p[ V_PLANE ].i_visible_lines = i_height; + p_picture->p[ V_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ V_PLANE ].i_visible_pitch = i_width; + p_picture->p[ A_PLANE ].i_lines = i_height_aligned; + p_picture->p[ A_PLANE ].i_visible_lines = i_height; + p_picture->p[ A_PLANE ].i_pitch = i_width_aligned; + p_picture->p[ A_PLANE ].i_visible_pitch = i_width; + p_picture->i_planes = 4; + break; - case FOURCC_Y211: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned; - p_pic->p->i_visible_pitch = i_width; - p_pic->p->i_pixel_pitch = 4; - p_pic->i_planes = 1; - break; + case VLC_CODEC_YUVP: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned; + p_picture->p->i_visible_pitch = i_width; + p_picture->p->i_pixel_pitch = 8; + p_picture->i_planes = 1; + break; - case FOURCC_UYVY: - case FOURCC_YUY2: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned * 2; - p_pic->p->i_visible_pitch = i_width * 2; - p_pic->p->i_pixel_pitch = 4; - p_pic->i_planes = 1; - break; + case VLC_CODEC_Y211: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned; + p_picture->p->i_visible_pitch = i_width; + p_picture->p->i_pixel_pitch = 4; + p_picture->i_planes = 1; + break; - case FOURCC_RGB2: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned; - p_pic->p->i_visible_pitch = i_width; - p_pic->p->i_pixel_pitch = 1; - p_pic->i_planes = 1; - break; + case VLC_CODEC_UYVY: + case VLC_CODEC_VYUY: + case VLC_CODEC_YUYV: + case VLC_CODEC_YVYU: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned * 2; + p_picture->p->i_visible_pitch = i_width * 2; + p_picture->p->i_pixel_pitch = 4; + p_picture->i_planes = 1; + break; - case FOURCC_RV15: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned * 2; - p_pic->p->i_visible_pitch = i_width * 2; - p_pic->p->i_pixel_pitch = 2; - p_pic->i_planes = 1; - break; + case VLC_CODEC_RGB8: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned; + p_picture->p->i_visible_pitch = i_width; + p_picture->p->i_pixel_pitch = 1; + p_picture->i_planes = 1; + break; - case FOURCC_RV16: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned * 2; - p_pic->p->i_visible_pitch = i_width * 2; - p_pic->p->i_pixel_pitch = 2; - p_pic->i_planes = 1; - break; + case VLC_CODEC_RGB15: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned * 2; + p_picture->p->i_visible_pitch = i_width * 2; + p_picture->p->i_pixel_pitch = 2; + p_picture->i_planes = 1; + break; - case FOURCC_RV24: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned * 3; - p_pic->p->i_visible_pitch = i_width * 3; - p_pic->p->i_pixel_pitch = 3; - p_pic->i_planes = 1; - break; + case VLC_CODEC_RGB16: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned * 2; + p_picture->p->i_visible_pitch = i_width * 2; + p_picture->p->i_pixel_pitch = 2; + p_picture->i_planes = 1; + break; - case FOURCC_RV32: - case FOURCC_RGBA: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned * 4; - p_pic->p->i_visible_pitch = i_width * 4; - p_pic->p->i_pixel_pitch = 4; - p_pic->i_planes = 1; - break; + case VLC_CODEC_RGB24: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned * 3; + p_picture->p->i_visible_pitch = i_width * 3; + p_picture->p->i_pixel_pitch = 3; + p_picture->i_planes = 1; + break; - case FOURCC_GREY: - p_pic->p->i_lines = i_height_aligned; - p_pic->p->i_visible_lines = i_height; - p_pic->p->i_pitch = i_width_aligned; - p_pic->p->i_visible_pitch = i_width; - p_pic->p->i_pixel_pitch = 1; - p_pic->i_planes = 1; - break; + case VLC_CODEC_RGB32: + case VLC_CODEC_RGBA: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned * 4; + p_picture->p->i_visible_pitch = i_width * 4; + p_picture->p->i_pixel_pitch = 4; + p_picture->i_planes = 1; + break; - default: - msg_Err( p_this, "unknown chroma type 0x%.8x (%4.4s)", - i_chroma, (char*)&i_chroma ); - p_pic->i_planes = 0; - return VLC_EGENERIC; + case VLC_CODEC_GREY: + case VLC_CODEC_RGBP: + p_picture->p->i_lines = i_height_aligned; + p_picture->p->i_visible_lines = i_height; + p_picture->p->i_pitch = i_width_aligned; + p_picture->p->i_visible_pitch = i_width; + p_picture->p->i_pixel_pitch = 1; + p_picture->i_planes = 1; + break; + + default: + p_picture->i_planes = 0; + return VLC_EGENERIC; } return VLC_SUCCESS; } -/** - * Compare two chroma values +/***************************************************************************** * - * This function returns 1 if the two fourcc values given as argument are - * the same format (eg. UYVY/UYNV) or almost the same format (eg. I420/YV12) - */ -int vout_ChromaCmp( vlc_fourcc_t i_chroma, vlc_fourcc_t i_amorhc ) + *****************************************************************************/ +picture_t *picture_NewFromResource( const video_format_t *p_fmt, const picture_resource_t *p_resource ) { - /* If they are the same, they are the same ! */ - if( i_chroma == i_amorhc ) + video_format_t fmt = *p_fmt; + + /* It is needed to be sure all informations are filled */ + video_format_Setup( &fmt, p_fmt->i_chroma, + p_fmt->i_width, p_fmt->i_height, p_fmt->i_aspect ); + + /* */ + picture_t *p_picture = calloc( 1, sizeof(*p_picture) ); + if( !p_picture ) + return NULL; + + if( p_resource ) { - return 1; - } + if( picture_Setup( p_picture, fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect ) ) + { + free( p_picture ); + return NULL; + } + p_picture->p_sys = p_resource->p_sys; - /* Check for equivalence classes */ - switch( i_chroma ) - { - case FOURCC_I420: - case FOURCC_IYUV: - case FOURCC_YV12: - switch( i_amorhc ) - { - case FOURCC_I420: - case FOURCC_IYUV: - case FOURCC_YV12: - return 1; - - default: - return 0; - } - - case FOURCC_UYVY: - case FOURCC_UYNV: - case FOURCC_Y422: - switch( i_amorhc ) - { - case FOURCC_UYVY: - case FOURCC_UYNV: - case FOURCC_Y422: - return 1; - - default: - return 0; - } - - case FOURCC_YUY2: - case FOURCC_YUNV: - switch( i_amorhc ) - { - case FOURCC_YUY2: - case FOURCC_YUNV: - return 1; - - default: - return 0; - } - - default: - return 0; + for( int i = 0; i < p_picture->i_planes; i++ ) + { + p_picture->p[i].p_pixels = p_resource->p[i].p_pixels; + p_picture->p[i].i_lines = p_resource->p[i].i_lines; + p_picture->p[i].i_pitch = p_resource->p[i].i_pitch; + } } + else + { + if( __vout_AllocatePicture( NULL, p_picture, + fmt.i_chroma, fmt.i_width, fmt.i_height, fmt.i_aspect ) ) + { + free( p_picture ); + return NULL; + } + } + /* */ + p_picture->format = fmt; + p_picture->i_refcount = 1; + p_picture->pf_release = PictureReleaseCallback; + p_picture->i_status = RESERVED_PICTURE; + + 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_aspect ) +{ + video_format_t fmt; + + memset( &fmt, 0, sizeof(fmt) ); + video_format_Setup( &fmt, i_chroma, i_width, i_height, i_aspect ); + + return picture_NewFromFormat( &fmt ); } /***************************************************************************** - * vout_CopyPicture: copy a picture to another one - ***************************************************************************** - * This function takes advantage of the image format, and reduces the - * number of calls to memcpy() to the minimum. Source and destination - * images must have same width (hence i_visible_pitch), height, and chroma. + * + *****************************************************************************/ +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 ); + free( p_picture->p_data_orig ); + free( p_picture->p_sys ); + free( p_picture ); +} + +/***************************************************************************** + * *****************************************************************************/ -void __vout_CopyPicture( vlc_object_t *p_this, - picture_t *p_dest, picture_t *p_src ) +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 plane_CopyPixels( plane_t *p_dst, const plane_t *p_src ) +{ + const unsigned i_width = __MIN( p_dst->i_visible_pitch, + p_src->i_visible_pitch ); + const unsigned i_height = __MIN( p_dst->i_visible_lines, + p_src->i_visible_lines ); + + if( p_src->i_pitch == p_dst->i_pitch ) + { + /* There are margins, but with the same width : perfect ! */ + vlc_memcpy( p_dst->p_pixels, p_src->p_pixels, + p_src->i_pitch * i_height ); + } + else { - if( p_src->p[i].i_pitch == p_dest->p[i].i_pitch ) + /* We need to proceed line by line */ + uint8_t *p_in = p_src->p_pixels; + uint8_t *p_out = p_dst->p_pixels; + int i_line; + + assert( p_in ); + assert( p_out ); + + for( i_line = i_height; i_line--; ) { - /* There are margins, but with the same width : perfect ! */ - vlc_memcpy( p_dest->p[i].p_pixels, p_src->p[i].p_pixels, - p_src->p[i].i_pitch * p_src->p[i].i_visible_lines ); + vlc_memcpy( p_out, p_in, i_width ); + p_in += p_src->i_pitch; + p_out += p_dst->i_pitch; } + } +} + +/***************************************************************************** + * + *****************************************************************************/ +int picture_Export( vlc_object_t *p_obj, + block_t **pp_image, + video_format_t *p_fmt, + picture_t *p_picture, + vlc_fourcc_t i_format, + unsigned i_override_width, unsigned i_override_height ) +{ + /* */ + video_format_t fmt_in = p_picture->format; + if( fmt_in.i_sar_num <= 0 || fmt_in.i_sar_den <= 0 ) + { + fmt_in.i_sar_num = + fmt_in.i_sar_den = 1; + } + + /* */ + video_format_t fmt_out; + memset( &fmt_out, 0, sizeof(fmt_out) ); + fmt_out.i_sar_num = + fmt_out.i_sar_den = 1; + fmt_out.i_chroma = i_format; + + /* compute original width/height */ + unsigned int i_original_width; + unsigned int i_original_height; + if( fmt_in.i_sar_num >= fmt_in.i_sar_den ) + { + i_original_width = fmt_in.i_width * fmt_in.i_sar_num / fmt_in.i_sar_den; + i_original_height = fmt_in.i_height; + } + else + { + i_original_width = fmt_in.i_width; + i_original_height = fmt_in.i_height * fmt_in.i_sar_den / fmt_in.i_sar_num; + } + + /* */ + fmt_out.i_width = i_override_width > 0 ? i_override_width : i_original_width; + fmt_out.i_height = i_override_height > 0 ? i_override_height : i_original_height; + + /* scale if only one direction is provided */ + if( fmt_out.i_height == 0 && fmt_out.i_width > 0 ) + { + fmt_out.i_height = fmt_in.i_height * fmt_out.i_width + * fmt_in.i_sar_den / fmt_in.i_width / fmt_in.i_sar_num; + } + else if( fmt_out.i_width == 0 && fmt_out.i_height > 0 ) + { + fmt_out.i_width = fmt_in.i_width * fmt_out.i_height + * fmt_in.i_sar_num / fmt_in.i_height / fmt_in.i_sar_den; + } + + image_handler_t *p_image = image_HandlerCreate( p_obj ); + + block_t *p_block = image_Write( p_image, p_picture, &fmt_in, &fmt_out ); + + image_HandlerDelete( p_image ); + + if( !p_block ) + return VLC_EGENERIC; + + p_block->i_pts = + p_block->i_dts = p_picture->date; + + if( p_fmt ) + *p_fmt = fmt_out; + *pp_image = p_block; + + return VLC_SUCCESS; +} + +/***************************************************************************** + * + *****************************************************************************/ +struct picture_fifo_t +{ + vlc_mutex_t lock; + picture_t *p_first; + picture_t **pp_last; +}; + +static void PictureFifoReset( picture_fifo_t *p_fifo ) +{ + p_fifo->p_first = NULL; + p_fifo->pp_last = &p_fifo->p_first; +} +static void PictureFifoPush( picture_fifo_t *p_fifo, picture_t *p_picture ) +{ + assert( !p_picture->p_next ); + *p_fifo->pp_last = p_picture; + p_fifo->pp_last = &p_picture->p_next; +} +static picture_t *PictureFifoPop( picture_fifo_t *p_fifo ) +{ + picture_t *p_picture = p_fifo->p_first; + + if( p_picture ) + { + p_fifo->p_first = p_picture->p_next; + if( !p_fifo->p_first ) + p_fifo->pp_last = &p_fifo->p_first; + } + return p_picture; +} + +picture_fifo_t *picture_fifo_New(void) +{ + picture_fifo_t *p_fifo = malloc( sizeof(*p_fifo) ); + if( !p_fifo ) + return NULL; + + vlc_mutex_init( &p_fifo->lock ); + PictureFifoReset( p_fifo ); + return p_fifo; +} + +void picture_fifo_Push( picture_fifo_t *p_fifo, picture_t *p_picture ) +{ + vlc_mutex_lock( &p_fifo->lock ); + PictureFifoPush( p_fifo, p_picture ); + vlc_mutex_unlock( &p_fifo->lock ); +} +picture_t *picture_fifo_Pop( picture_fifo_t *p_fifo ) +{ + vlc_mutex_lock( &p_fifo->lock ); + picture_t *p_picture = PictureFifoPop( p_fifo ); + vlc_mutex_unlock( &p_fifo->lock ); + + return p_picture; +} +picture_t *picture_fifo_Peek( picture_fifo_t *p_fifo ) +{ + vlc_mutex_lock( &p_fifo->lock ); + picture_t *p_picture = p_fifo->p_first; + if( p_picture ) + picture_Hold( p_picture ); + vlc_mutex_unlock( &p_fifo->lock ); + + return p_picture; +} +void picture_fifo_Flush( picture_fifo_t *p_fifo, mtime_t i_date, bool b_below ) +{ + picture_t *p_picture; + + vlc_mutex_lock( &p_fifo->lock ); + + p_picture = p_fifo->p_first; + PictureFifoReset( p_fifo ); + + picture_fifo_t tmp; + PictureFifoReset( &tmp ); + + while( p_picture ) + { + picture_t *p_next = p_picture->p_next; + + p_picture->p_next = NULL; + if( ( b_below && p_picture->date <= i_date ) || + ( !b_below && p_picture->date >= i_date ) ) + PictureFifoPush( &tmp, p_picture ); else + PictureFifoPush( p_fifo, p_picture ); + p_picture = p_next; + } + vlc_mutex_unlock( &p_fifo->lock ); + + for( ;; ) + { + picture_t *p_picture = PictureFifoPop( &tmp ); + if( !p_picture ) + break; + picture_Release( p_picture ); + } +} +void picture_fifo_OffsetDate( picture_fifo_t *p_fifo, mtime_t i_delta ) +{ + vlc_mutex_lock( &p_fifo->lock ); + for( picture_t *p_picture = p_fifo->p_first; p_picture != NULL; ) + { + p_picture->date += i_delta; + p_picture = p_picture->p_next; + } + vlc_mutex_unlock( &p_fifo->lock ); +} +void picture_fifo_Delete( picture_fifo_t *p_fifo ) +{ + picture_fifo_Flush( p_fifo, INT64_MAX, true ); + vlc_mutex_destroy( &p_fifo->lock ); +} + +/***************************************************************************** + * + *****************************************************************************/ +struct picture_release_sys_t +{ + /* Saved release */ + void (*pf_release)( picture_t * ); + picture_release_sys_t *p_release_sys; + + /* */ + int64_t i_tick; +}; + +struct picture_pool_t +{ + int64_t i_tick; + + int i_picture; + picture_t **pp_picture; +}; + +static void PicturePoolPictureRelease( picture_t * ); + +picture_pool_t *picture_pool_New( int i_picture, picture_t *pp_picture[] ) +{ + picture_pool_t *p_pool = calloc( 1, sizeof(*p_pool) ); + if( !p_pool ) + return NULL; + + p_pool->i_tick = 1; + p_pool->i_picture = i_picture; + p_pool->pp_picture = calloc( p_pool->i_picture, sizeof(*p_pool->pp_picture) ); + + for( int i = 0; i < i_picture; i++ ) + { + picture_t *p_picture = pp_picture[i]; + + /* The pool must be the only owner of the picture */ + assert( p_picture->i_refcount == 1 ); + + /* Install the new release callback */ + picture_release_sys_t *p_release_sys = malloc( sizeof(*p_release_sys) ); + p_release_sys->pf_release = p_picture->pf_release; + p_release_sys->p_release_sys = p_picture->p_release_sys; + p_release_sys->i_tick = 0; + + p_picture->i_refcount = 0; + p_picture->pf_release = PicturePoolPictureRelease; + p_picture->p_release_sys = p_release_sys; + + /* */ + p_pool->pp_picture[i] = p_picture; + } + return p_pool; +} + +picture_pool_t *picture_pool_NewFromFormat( const video_format_t *p_fmt, int i_picture ) +{ + picture_t *pp_picture[i_picture]; + + for( int i = 0; i < i_picture; i++ ) + { + pp_picture[i] = picture_New( p_fmt->i_chroma, + p_fmt->i_width, p_fmt->i_height, + p_fmt->i_aspect ); + if( !pp_picture[i] ) + goto error; + } + picture_pool_t *p_pool = picture_pool_New( i_picture, pp_picture ); + if( !p_pool ) + goto error; + + return p_pool; + +error: + for( int i = 0; i < i_picture; i++ ) + { + if( !pp_picture[i] ) + break; + picture_Release( pp_picture[i] ); + } + return NULL; +} + +void picture_pool_Delete( picture_pool_t *p_pool ) +{ + for( int i = 0; i < p_pool->i_picture; i++ ) + { + picture_t *p_picture = p_pool->pp_picture[i]; + picture_release_sys_t *p_release_sys = p_picture->p_release_sys; + + assert( p_picture->i_refcount == 0 ); + + /* Restore old release callback */ + p_picture->i_refcount = 1; + p_picture->pf_release = p_release_sys->pf_release; + p_picture->p_release_sys = p_release_sys->p_release_sys; + + picture_Release( p_picture ); + + free( p_release_sys ); + } + free( p_pool ); +} + +picture_t *picture_pool_Get( picture_pool_t *p_pool ) +{ + for( int i = 0; i < p_pool->i_picture; i++ ) + { + picture_t *p_picture = p_pool->pp_picture[i]; + + if( p_picture->i_refcount <= 0 ) { - /* We need to proceed line by line */ - uint8_t *p_in = p_src->p[i].p_pixels; - assert( p_in ); - uint8_t *p_out = p_dest->p[i].p_pixels; - assert( p_out ); - int i_line; - - for( i_line = p_src->p[i].i_visible_lines; i_line--; ) - { - vlc_memcpy( p_out, p_in, p_src->p[i].i_visible_pitch ); - p_in += p_src->p[i].i_pitch; - p_out += p_dest->p[i].i_pitch; - } + p_picture->p_release_sys->i_tick = p_pool->i_tick++; + picture_Hold( p_picture ); + return p_picture; } } + return NULL; +} - p_dest->date = p_src->date; - p_dest->b_force = p_src->b_force; - p_dest->i_nb_fields = p_src->i_nb_fields; - p_dest->b_progressive = p_src->b_progressive; - p_dest->b_top_field_first = p_src->b_top_field_first; +void picture_pool_NonEmpty( picture_pool_t *p_pool, bool b_reset ) +{ + picture_t *p_old = NULL; + + for( int i = 0; i < p_pool->i_picture; i++ ) + { + picture_t *p_picture = p_pool->pp_picture[i]; + + if( b_reset ) + p_picture->i_refcount = 0; + else if( p_picture->i_refcount == 0 ) + return; + else if( !p_old || p_picture->p_release_sys->i_tick < p_old->p_release_sys->i_tick ) + p_old = p_picture; + } + if( !b_reset && p_old ) + p_old->i_refcount = 0; } + +static void PicturePoolPictureRelease( picture_t *p_picture ) +{ + assert( p_picture->i_refcount > 0 ); + + if( --p_picture->i_refcount > 0 ) + return; + + /* Nothing to do for the moment */ +} +