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: Christophe Massiot <massiot@via.ecp.fr>
   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 #else
 129     p_fifo->p_vpar->p_vout->vdec_DecodeMacroblock(
 130             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\n" );
 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\n" );
 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  * Prototypes
 249  *****************************************************************************/
 250 void vpar_InitFIFO( struct vpar_thread_s * p_vpar );