git.sesse.net Git - vlc/blob - include/video_fifo.h

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