git.sesse.net Git - vlc/blob - src/video_decoder/video_fifo.h

   1 /*****************************************************************************
   2  * video_fifo.h : FIFO for the pool of video_decoders
   3  *****************************************************************************
   4  * Copyright (C) 1999, 2000 VideoLAN
   5  * $Id: video_fifo.h,v 1.4 2001/02/23 14:07:25 massiot Exp $
   6  *
   7  * Authors: Christophe Massiot <massiot@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Requires:
  26  *  "config.h"
  27  *  "common.h"
  28  *  "threads.h"
  29  *  "video_parser.h"
  30  *  "undec_picture.h"
  31  *****************************************************************************/
  32
  33 /*****************************************************************************
  34  * Macros
  35  *****************************************************************************/
  36
  37 #ifdef VDEC_SMP
  38 /* FIXME: move to inline functions ??*/
  39 #define VIDEO_FIFO_ISEMPTY( fifo )    ( (fifo).i_start == (fifo).i_end )
  40 #define VIDEO_FIFO_ISFULL( fifo )     ( ( ( (fifo).i_end + 1 - (fifo).i_start )\
  41                                           & VFIFO_SIZE ) == 0 )
  42 #define VIDEO_FIFO_START( fifo )      ( (fifo).buffer[ (fifo).i_start ] )
  43 #define VIDEO_FIFO_INCSTART( fifo )   ( (fifo).i_start = ((fifo).i_start + 1) \
  44                                                            & VFIFO_SIZE )
  45 #define VIDEO_FIFO_END( fifo )        ( (fifo).buffer[ (fifo).i_end ] )
  46 #define VIDEO_FIFO_INCEND( fifo )     ( (fifo).i_end = ((fifo).i_end + 1) \
  47                                                          & VFIFO_SIZE )
  48 #endif
  49
  50 /*****************************************************************************
  51  * vpar_GetMacroblock : return a macroblock to be decoded
  52  *****************************************************************************/
  53 static __inline__ macroblock_t * vpar_GetMacroblock( video_fifo_t * p_fifo )
  54 {
  55 #ifdef VDEC_SMP
  56     macroblock_t *      p_mb;
  57
  58     vlc_mutex_lock( &p_fifo->lock );
  59     while( VIDEO_FIFO_ISEMPTY( *p_fifo ) )
  60     {
  61         vlc_cond_wait( &p_fifo->wait, &p_fifo->lock );
  62         if( p_fifo->p_vpar->p_fifo->b_die )
  63         {
  64             vlc_mutex_unlock( &p_fifo->lock );
  65             return( NULL );
  66         }
  67     }
  68
  69     p_mb = VIDEO_FIFO_START( *p_fifo );
  70     VIDEO_FIFO_INCSTART( *p_fifo );
  71
  72     vlc_mutex_unlock( &p_fifo->lock );
  73
  74     return( p_mb );
  75 #else
  76     /* Shouldn't normally be used without SMP. */
  77     return NULL;
  78 #endif
  79 }
  80
  81 /*****************************************************************************
  82  * vpar_NewMacroblock : return a buffer for the parser
  83  *****************************************************************************/
  84 static __inline__ macroblock_t * vpar_NewMacroblock( video_fifo_t * p_fifo )
  85 {
  86 #ifdef VDEC_SMP
  87     macroblock_t *      p_mb;
  88
  89 #define P_buffer p_fifo->p_vpar->vbuffer
  90     vlc_mutex_lock( &P_buffer.lock );
  91     while( P_buffer.i_index == -1 )
  92     {
  93         /* No more structures available. This should not happen ! */
  94         intf_DbgMsg("vpar debug: macroblock list is empty, delaying");
  95         vlc_mutex_unlock( &P_buffer.lock );
  96         if( p_fifo->p_vpar->p_fifo->b_die )
  97         {
  98             return( NULL );
  99         }
 100         msleep(VPAR_OUTMEM_SLEEP);
 101         vlc_mutex_lock( &P_buffer.lock );
 102     }
 103
 104     p_mb = P_buffer.pp_mb_free[ P_buffer.i_index-- ];
 105
 106     vlc_mutex_unlock( &P_buffer.lock );
 107 #undef P_buffer
 108     return( p_mb );
 109 #else
 110     return( &p_fifo->buffer );
 111 #endif
 112 }
 113
 114 /*****************************************************************************
 115  * vpar_DecodeMacroblock : put a macroblock in the video fifo
 116  *****************************************************************************/
 117 static __inline__ void vpar_DecodeMacroblock( video_fifo_t * p_fifo,
 118                                               macroblock_t * p_mb )
 119 {
 120 #ifdef VDEC_SMP
 121     /* Place picture in the video FIFO */
 122     vlc_mutex_lock( &p_fifo->lock );
 123
 124     /* By construction, the video FIFO cannot be full */
 125     VIDEO_FIFO_END( *p_fifo ) = p_mb;
 126     VIDEO_FIFO_INCEND( *p_fifo );
 127
 128     vlc_mutex_unlock( &p_fifo->lock );
 129 #else
 130     vdec_DecodeMacroblockC( p_fifo->p_vpar->pp_vdec[0], p_mb );
 131 #endif
 132 }
 133
 134 /*****************************************************************************
 135  * vpar_ReleaseMacroblock : release a macroblock and put the picture in the
 136  *                          video output heap, if it is finished
 137  *****************************************************************************/
 138 static __inline__ void vpar_ReleaseMacroblock( video_fifo_t * p_fifo,
 139                                                macroblock_t * p_mb )
 140 {
 141 #ifdef VDEC_SMP
 142     boolean_t      b_finished;
 143
 144     /* Unlink picture buffer */
 145     vlc_mutex_lock( &p_mb->p_picture->lock_deccount );
 146     p_mb->p_picture->i_deccount--;
 147     b_finished = (p_mb->p_picture->i_deccount == 1);
 148     vlc_mutex_unlock( &p_mb->p_picture->lock_deccount );
 149 //intf_DbgMsg( "%d ", p_mb->p_picture->i_deccount );
 150     /* Test if it was the last block of the picture */
 151     if( b_finished )
 152     {
 153 //intf_DbgMsg( "Image decodee" );
 154         /* Mark the picture to be displayed */
 155         vout_DisplayPicture( p_fifo->p_vpar->p_vout, p_mb->p_picture );
 156
 157         /* Warn Synchro for its records. */
 158         vpar_SynchroEnd( p_fifo->p_vpar, 0 );
 159
 160         /* Unlink referenced pictures */
 161         if( p_mb->p_forward != NULL )
 162         {
 163             vout_UnlinkPicture( p_fifo->p_vpar->p_vout, p_mb->p_forward );
 164         }
 165         if( p_mb->p_backward != NULL )
 166         {
 167             vout_UnlinkPicture( p_fifo->p_vpar->p_vout, p_mb->p_backward );
 168         }
 169     }
 170
 171     /* Release the macroblock_t structure */
 172 #define P_buffer p_fifo->p_vpar->vbuffer
 173     vlc_mutex_lock( &P_buffer.lock );
 174     P_buffer.pp_mb_free[ ++P_buffer.i_index ] = p_mb;
 175     vlc_mutex_unlock( &P_buffer.lock );
 176 #undef P_buffer
 177
 178 #else
 179     p_mb->p_picture->i_deccount--;
 180     if( p_mb->p_picture->i_deccount == 1 )
 181     {
 182         /* Mark the picture to be displayed */
 183         vout_DisplayPicture( p_fifo->p_vpar->p_vout, p_mb->p_picture );
 184
 185         /* Warn Synchro for its records. */
 186         vpar_SynchroEnd( p_fifo->p_vpar, 0 );
 187     }
 188 #endif
 189 }
 190
 191 /*****************************************************************************
 192  * vpar_DestroyMacroblock : destroy a macroblock in case of error
 193  *****************************************************************************/
 194 static __inline__ void vpar_DestroyMacroblock( video_fifo_t * p_fifo,
 195                                                macroblock_t * p_mb )
 196 {
 197 #ifdef VDEC_SMP
 198     boolean_t       b_finished;
 199
 200     /* Unlink picture buffer */
 201     vlc_mutex_lock( &p_mb->p_picture->lock_deccount );
 202     p_mb->p_picture->i_deccount--;
 203     b_finished = (p_mb->p_picture->i_deccount == 1);
 204     vlc_mutex_unlock( &p_mb->p_picture->lock_deccount );
 205
 206     /* Test if it was the last block of the picture */
 207     if( b_finished )
 208     {
 209         intf_DbgMsg( "Image trashee" );
 210         /* Mark the picture to be trashed */
 211         vout_DestroyPicture( p_fifo->p_vpar->p_vout, p_mb->p_picture );
 212
 213         /* Warn Synchro for its records. */
 214         vpar_SynchroEnd( p_fifo->p_vpar, 1 );
 215
 216         /* Unlink referenced pictures */
 217         if( p_mb->p_forward != NULL )
 218         {
 219             vout_UnlinkPicture( p_fifo->p_vpar->p_vout, p_mb->p_forward );
 220         }
 221         if( p_mb->p_backward != NULL )
 222         {
 223             vout_UnlinkPicture( p_fifo->p_vpar->p_vout, p_mb->p_backward );
 224         }
 225     }
 226
 227     /* Release the macroblock_t structure */
 228 #define P_buffer p_fifo->p_vpar->vbuffer
 229     vlc_mutex_lock( &P_buffer.lock );
 230     P_buffer.pp_mb_free[ ++P_buffer.i_index ] = p_mb;
 231     vlc_mutex_unlock( &P_buffer.lock );
 232 #undef P_buffer
 233
 234 #else
 235     p_mb->p_picture->i_deccount--;
 236     if( p_mb->p_picture->i_deccount == 1 )
 237     {
 238         /* Mark the picture to be trashed */
 239         vout_DestroyPicture( p_fifo->p_vpar->p_vout, p_mb->p_picture );
 240
 241         /* Warn Synchro for its records. */
 242         vpar_SynchroEnd( p_fifo->p_vpar, 1 );
 243     }
 244 #endif
 245 }
 246
 247 /*****************************************************************************
 248  * vpar_FreeMacroblock : destroy a macroblock in case of error, without
 249  * updating the macroblock counters
 250  *****************************************************************************/
 251 static __inline__ void vpar_FreeMacroblock( video_fifo_t * p_fifo,
 252                                             macroblock_t * p_mb )
 253 {
 254 #ifdef VDEC_SMP
 255     /* Release the macroblock_t structure */
 256 #define P_buffer p_fifo->p_vpar->vbuffer
 257     vlc_mutex_lock( &P_buffer.lock );
 258     P_buffer.pp_mb_free[ ++P_buffer.i_index ] = p_mb;
 259     vlc_mutex_unlock( &P_buffer.lock );
 260 #undef P_buffer
 261
 262 #else
 263     ;
 264 #endif
 265 }
 266 /*****************************************************************************
 267  * Prototypes
 268  *****************************************************************************/
 269 void vpar_InitFIFO( struct vpar_thread_s * p_vpar );