git.sesse.net Git - vlc/blob - modules/codec/mpeg_video/pool.c

   1 /*****************************************************************************
   2  * vpar_pool.c : management of the pool of decoder threads
   3  *****************************************************************************
   4  * Copyright (C) 2001 VideoLAN
   5  * $Id: pool.c,v 1.1 2002/08/04 17:23:42 sam 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  * Preamble
  26  *****************************************************************************/
  27 #include <string.h>                                    /* memcpy(), memset() */
  28 #include <stdlib.h>                                             /* realloc() */
  29
  30 #include <vlc/vlc.h>
  31 #include <vlc/vout.h>
  32 #include <vlc/decoder.h>
  33
  34 #include "vdec_ext-plugins.h"
  35
  36 #include "decoder.h"
  37 #include "pool.h"
  38 #include "parser.h"
  39
  40 /*
  41  * Local prototypes
  42  */
  43 static void WaitDummy( vdec_pool_t * p_pool );
  44 static void WaitPool( vdec_pool_t * p_pool );
  45 static void FreeMacroblockDummy( vdec_pool_t * p_pool, macroblock_t * p_mb );
  46 static void FreeMacroblockPool( vdec_pool_t * p_pool, macroblock_t * p_mb );
  47 static macroblock_t * NewMacroblockDummy( vdec_pool_t * p_pool );
  48 static macroblock_t * NewMacroblockPool( vdec_pool_t * p_pool );
  49 static void DecodeMacroblockDummy( vdec_pool_t * p_pool, macroblock_t * p_mb );
  50 static void DecodeMacroblockPool( vdec_pool_t * p_pool, macroblock_t * p_mb );
  51
  52 /*****************************************************************************
  53  * vpar_InitPool: Initializes the pool structure
  54  *****************************************************************************/
  55 void vpar_InitPool( vpar_thread_t * p_vpar )
  56 {
  57     int j;
  58
  59     /* Initialize mutex and cond. */
  60     vlc_mutex_init( p_vpar->p_fifo, &p_vpar->pool.lock );
  61     vlc_cond_init( p_vpar->p_fifo, &p_vpar->pool.wait_empty );
  62     vlc_cond_init( p_vpar->p_fifo, &p_vpar->pool.wait_undecoded );
  63
  64     /* Spawn optional video decoder threads. */
  65     p_vpar->pool.i_smp = 0;
  66     p_vpar->pool.pp_vdec = NULL;
  67     p_vpar->pool.p_macroblocks = NULL;
  68     p_vpar->pool.pp_empty_macroblocks = NULL;
  69     p_vpar->pool.pp_new_macroblocks = NULL;
  70     p_vpar->pool.p_vpar = p_vpar;
  71     vpar_SpawnPool( p_vpar );
  72
  73     /* Initialize fake video decoder structure (used when
  74      * decoder == parser). */
  75     p_vpar->pool.p_vdec = vlc_object_create( p_vpar->p_fifo,
  76                                              sizeof(vdec_thread_t) );
  77     if ( p_vpar->pool.p_vdec == NULL )
  78     {
  79         msg_Err( p_vpar->p_fifo, "out of memory" );
  80         p_vpar->p_fifo->b_error = 1;
  81         return;
  82     }
  83     p_vpar->pool.p_vdec->p_pool = &p_vpar->pool;
  84     vdec_InitThread( p_vpar->pool.p_vdec );
  85
  86     vlc_object_attach( p_vpar->pool.p_vdec, p_vpar->p_fifo );
  87
  88     for( j = 0; j < 12; j++ )
  89     {
  90         p_vpar->pool.mb.p_idcts[j].pi_block =
  91             vlc_memalign( &p_vpar->pool.mb.p_idcts[j].pi_block_orig,
  92                           16, 64 * sizeof(dctelem_t) );
  93     }
  94 }
  95
  96 /*****************************************************************************
  97  * vpar_SpawnPool: Create and cancel video decoder threads at any time
  98  *****************************************************************************
  99  * This function is called on startup, and everytime the user changes the
 100  * number of threads to launch. Please note that *all* decoder threads must
 101  * be idle during this operation, which only happens at the end of
 102  * PictureHeader().
 103  *****************************************************************************/
 104 void vpar_SpawnPool( vpar_thread_t * p_vpar )
 105 {
 106     int                 i_new_smp;
 107     stream_ctrl_t *     p_control;
 108
 109     p_control = p_vpar->p_fifo->p_stream_ctrl;
 110     vlc_mutex_lock( &p_control->control_lock );
 111     i_new_smp = config_GetInt( p_vpar->p_fifo, "vdec-smp" );
 112     vlc_mutex_unlock( &p_control->control_lock );
 113
 114     /* FIXME: No error check because I'm tired. Come back later... */
 115
 116     /* No need to lock p_vpar->pool, since decoders MUST be idle here. */
 117     if( p_vpar->pool.i_smp != i_new_smp )
 118     {
 119         int i;
 120
 121         if( p_vpar->pool.i_smp > i_new_smp )
 122         {
 123             /* The user reduces the number of threads. */
 124
 125             for( i = p_vpar->pool.i_smp - 1; i >= i_new_smp; i-- )
 126             {
 127                 int j;
 128
 129                 vlc_object_detach_all( p_vpar->pool.pp_vdec[i] );
 130                 vdec_DestroyThread( p_vpar->pool.pp_vdec[i] );
 131
 132                 for( j = 0; j < 12; j++ )
 133                 {
 134                     free( p_vpar->pool.p_macroblocks[i].p_idcts[j].pi_block_orig );
 135                 }
 136             }
 137
 138             p_vpar->pool.pp_vdec = realloc( p_vpar->pool.pp_vdec,
 139                                             i_new_smp * sizeof(vdec_thread_t *) );
 140             p_vpar->pool.p_macroblocks = realloc( p_vpar->pool.p_macroblocks,
 141                                             i_new_smp * sizeof(macroblock_t) );
 142             p_vpar->pool.pp_empty_macroblocks = realloc( p_vpar->pool.pp_empty_macroblocks,
 143                                             i_new_smp * sizeof(macroblock_t *) );
 144             p_vpar->pool.i_index_empty = i_new_smp;
 145             p_vpar->pool.pp_new_macroblocks = realloc( p_vpar->pool.pp_new_macroblocks,
 146                                             i_new_smp * sizeof(macroblock_t *) );
 147             p_vpar->pool.i_index_new = 0;
 148         }
 149         else
 150         {
 151             /* The user raises the number of threads. */
 152
 153             p_vpar->pool.pp_vdec = realloc( p_vpar->pool.pp_vdec,
 154                                             i_new_smp * sizeof(vdec_thread_t *) );
 155             p_vpar->pool.p_macroblocks = realloc( p_vpar->pool.p_macroblocks,
 156                                             i_new_smp * sizeof(macroblock_t) );
 157             p_vpar->pool.pp_empty_macroblocks = realloc( p_vpar->pool.pp_empty_macroblocks,
 158                                             i_new_smp * sizeof(macroblock_t *) );
 159             p_vpar->pool.i_index_empty = i_new_smp;
 160             p_vpar->pool.pp_new_macroblocks = realloc( p_vpar->pool.pp_new_macroblocks,
 161                                             i_new_smp * sizeof(macroblock_t *) );
 162             p_vpar->pool.i_index_new = 0;
 163
 164             for( i = p_vpar->pool.i_smp; i < i_new_smp ; i++ )
 165             {
 166                 int j;
 167
 168                 for( j = 0; j < 12; j++ )
 169                 {
 170                     p_vpar->pool.p_macroblocks[i].p_idcts[j].pi_block =
 171                         vlc_memalign( &p_vpar->pool.p_macroblocks[i].p_idcts[j].pi_block_orig,
 172                                       16, 64 * sizeof(dctelem_t) );
 173                 }
 174
 175                 p_vpar->pool.pp_vdec[i] = vdec_CreateThread( &p_vpar->pool );
 176                 vlc_object_attach( p_vpar->pool.pp_vdec[i], p_vpar->p_fifo );
 177             }
 178
 179         }
 180         for( i = 0; i < i_new_smp; i++ )
 181         {
 182             p_vpar->pool.pp_empty_macroblocks[i] =
 183                                     &p_vpar->pool.p_macroblocks[i];
 184         }
 185         p_vpar->pool.i_smp = i_new_smp;
 186     }
 187
 188     if( i_new_smp )
 189     {
 190         /* We have at least one decoder thread. */
 191         p_vpar->pool.pf_wait_pool = WaitPool;
 192         p_vpar->pool.pf_new_mb = NewMacroblockPool;
 193         p_vpar->pool.pf_free_mb = FreeMacroblockPool;
 194         p_vpar->pool.pf_decode_mb = DecodeMacroblockPool;
 195     }
 196     else
 197     {
 198         /* No decoder pool. */
 199         p_vpar->pool.pf_wait_pool = WaitDummy;
 200         p_vpar->pool.pf_new_mb = NewMacroblockDummy;
 201         p_vpar->pool.pf_free_mb = FreeMacroblockDummy;
 202         p_vpar->pool.pf_decode_mb = DecodeMacroblockDummy;
 203     }
 204 }
 205
 206 /*****************************************************************************
 207  * vpar_EndPool: Releases the pool structure
 208  *****************************************************************************/
 209 void vpar_EndPool( vpar_thread_t * p_vpar )
 210 {
 211     int i;
 212
 213     for( i = 0; i < 12; i++ )
 214     {
 215         free( p_vpar->pool.mb.p_idcts[i].pi_block_orig );
 216     }
 217
 218     for( i = 0; i < p_vpar->pool.i_smp; i++ )
 219     {
 220         int j;
 221
 222         vlc_object_detach_all( p_vpar->pool.pp_vdec[i] );
 223         vdec_DestroyThread( p_vpar->pool.pp_vdec[i] );
 224
 225         for( j = 0; j < 12; j++ )
 226         {
 227             free( p_vpar->pool.p_macroblocks[i].p_idcts[j].pi_block_orig );
 228         }
 229     }
 230
 231     if( p_vpar->pool.i_smp )
 232     {
 233         free( p_vpar->pool.pp_vdec );
 234         free( p_vpar->pool.p_macroblocks );
 235         free( p_vpar->pool.pp_new_macroblocks );
 236     }
 237
 238     /* Free fake video decoder (used when parser == decoder). */
 239     vlc_object_detach_all( p_vpar->pool.p_vdec );
 240     vdec_EndThread( p_vpar->pool.p_vdec );
 241     vlc_object_destroy( p_vpar->pool.p_vdec );
 242
 243     /* Destroy lock and cond. */
 244     vlc_mutex_destroy( &p_vpar->pool.lock );
 245     vlc_cond_destroy( &p_vpar->pool.wait_empty );
 246     vlc_cond_destroy( &p_vpar->pool.wait_undecoded );
 247 }
 248
 249 /*****************************************************************************
 250  * WaitPool: Wait until all decoders are idle
 251  *****************************************************************************/
 252 static void WaitPool( vdec_pool_t * p_pool )
 253 {
 254     vlc_mutex_lock( &p_pool->lock );
 255     while( p_pool->i_index_empty != p_pool->i_smp )
 256     {
 257         vlc_cond_wait( &p_pool->wait_empty, &p_pool->lock );
 258     }
 259     vlc_mutex_unlock( &p_pool->lock );
 260 }
 261
 262 /*****************************************************************************
 263  * WaitDummy: Placeholder used when parser == decoder
 264  *****************************************************************************/
 265 static void WaitDummy( vdec_pool_t * p_pool )
 266 {
 267 }
 268
 269 /*****************************************************************************
 270  * NewMacroblockPool: Get an empty macroblock from the decoder pool
 271  *****************************************************************************/
 272 static macroblock_t * NewMacroblockPool( vdec_pool_t * p_pool )
 273 {
 274     macroblock_t *  p_mb;
 275
 276     vlc_mutex_lock( &p_pool->lock );
 277     while( p_pool->i_index_empty == 0 )
 278     {
 279         vlc_cond_wait( &p_pool->wait_empty, &p_pool->lock );
 280     }
 281     p_mb = p_pool->pp_empty_macroblocks[ --p_pool->i_index_empty ];
 282     vlc_mutex_unlock( &p_pool->lock );
 283     return( p_mb );
 284 }
 285
 286 /*****************************************************************************
 287  * NewMacroblockDummy: Placeholder used when parser == decoder
 288  *****************************************************************************/
 289 static macroblock_t * NewMacroblockDummy( vdec_pool_t * p_pool )
 290 {
 291     return( &p_pool->mb );
 292 }
 293
 294 /*****************************************************************************
 295  * FreeMacroblockPool: Free a macroblock
 296  *****************************************************************************/
 297 static void FreeMacroblockPool( vdec_pool_t * p_pool, macroblock_t * p_mb )
 298 {
 299     vlc_mutex_lock( &p_pool->lock );
 300     p_pool->pp_empty_macroblocks[ p_pool->i_index_empty++ ] = p_mb;
 301     vlc_cond_signal( &p_pool->wait_empty );
 302     vlc_mutex_unlock( &p_pool->lock );
 303 }
 304
 305 /*****************************************************************************
 306  * FreeMacroblockDummy: Placeholder used when parser == decoder
 307  *****************************************************************************/
 308 static void FreeMacroblockDummy( vdec_pool_t * p_pool, macroblock_t * p_mb )
 309 {
 310 }
 311
 312 /*****************************************************************************
 313  * DecodeMacroblockPool: Send a macroblock to a vdec thread
 314  *****************************************************************************/
 315 static void DecodeMacroblockPool( vdec_pool_t * p_pool, macroblock_t * p_mb )
 316 {
 317     vlc_mutex_lock( &p_pool->lock );
 318     /* The undecoded macroblock LIFO cannot be full, because
 319      * #macroblocks == size of the LIFO */
 320     p_pool->pp_new_macroblocks[ p_pool->i_index_new++ ] = p_mb;
 321     vlc_cond_signal( &p_pool->wait_undecoded );
 322     vlc_mutex_unlock( &p_pool->lock );
 323 }
 324
 325 /*****************************************************************************
 326  * DecodeMacroblockDummy: Placeholder used when parser == decoder
 327  *****************************************************************************/
 328 static void DecodeMacroblockDummy( vdec_pool_t * p_pool, macroblock_t * p_mb )
 329 {
 330     p_pool->pf_vdec_decode( p_pool->p_vdec, p_mb );
 331 }
 332