git.sesse.net Git - vlc/blob - modules/stream_out/transcode/video.c

   1 /*****************************************************************************
   2  * video.c: transcoding stream output module (video)
   3  *****************************************************************************
   4  * Copyright (C) 2003-2009 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@videolan.org>
   9  *          Jean-Paul Saman <jpsaman #_at_# m2x dot nl>
  10  *          Antoine Cellerier <dionoea at videolan dot org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #include "transcode.h"
  32
  33 #include <vlc_meta.h>
  34 #include <vlc_osd.h>
  35
  36 #define ENC_FRAMERATE (25 * 1000 + .5)
  37 #define ENC_FRAMERATE_BASE 1000
  38
  39 struct decoder_owner_sys_t
  40 {
  41     sout_stream_sys_t *p_sys;
  42 };
  43
  44 static inline void video_timer_start( encoder_t * p_encoder )
  45 {
  46     stats_TimerStart( p_encoder, "encoding video frame",
  47                       STATS_TIMER_VIDEO_FRAME_ENCODING );
  48 }
  49
  50 static inline void video_timer_stop( encoder_t * p_encoder )
  51 {
  52     stats_TimerStop( p_encoder, STATS_TIMER_VIDEO_FRAME_ENCODING );
  53 }
  54
  55 static inline void video_timer_close( encoder_t * p_encoder )
  56 {
  57     stats_TimerDump(  p_encoder, STATS_TIMER_VIDEO_FRAME_ENCODING );
  58     stats_TimerClean( p_encoder, STATS_TIMER_VIDEO_FRAME_ENCODING );
  59 }
  60
  61 static void video_del_buffer_decoder( decoder_t *p_decoder, picture_t *p_pic )
  62 {
  63     VLC_UNUSED(p_decoder);
  64     picture_Release( p_pic );
  65 }
  66
  67 static void video_link_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
  68 {
  69     VLC_UNUSED(p_dec);
  70     picture_Hold( p_pic );
  71 }
  72
  73 static void video_unlink_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
  74 {
  75     VLC_UNUSED(p_dec);
  76     picture_Release( p_pic );
  77 }
  78
  79 static picture_t *video_new_buffer_decoder( decoder_t *p_dec )
  80 {
  81     sout_stream_sys_t *p_ssys = p_dec->p_owner->p_sys;
  82     if( p_ssys->i_threads >= 1 )
  83     {
  84         int i_first_pic = p_ssys->i_first_pic;
  85
  86         if( p_ssys->i_first_pic != p_ssys->i_last_pic )
  87         {
  88             /* Encoder still has stuff to encode, wait to clear-up the list */
  89             while( p_ssys->i_first_pic == i_first_pic )
  90             {
  91 #warning THERE IS DEFINITELY A BUG! LOCKING IS INSUFFICIENT!
  92                 msleep( 10000 );
  93                 barrier ();
  94             }
  95         }
  96     }
  97
  98     p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
  99     return picture_NewFromFormat( &p_dec->fmt_out.video );
 100 }
 101
 102 static picture_t *transcode_video_filter_buffer_new( filter_t *p_filter )
 103 {
 104     p_filter->fmt_out.video.i_chroma = p_filter->fmt_out.i_codec;
 105     return picture_NewFromFormat( &p_filter->fmt_out.video );
 106 }
 107 static void transcode_video_filter_buffer_del( filter_t *p_filter, picture_t *p_pic )
 108 {
 109     VLC_UNUSED(p_filter);
 110     picture_Release( p_pic );
 111 }
 112
 113 static int transcode_video_filter_allocation_init( filter_t *p_filter,
 114                                                    void *p_data )
 115 {
 116     VLC_UNUSED(p_data);
 117     p_filter->pf_vout_buffer_new = transcode_video_filter_buffer_new;
 118     p_filter->pf_vout_buffer_del = transcode_video_filter_buffer_del;
 119     return VLC_SUCCESS;
 120 }
 121
 122 static void transcode_video_filter_allocation_clear( filter_t *p_filter )
 123 {
 124     VLC_UNUSED(p_filter);
 125 }
 126
 127 static void* EncoderThread( vlc_object_t* p_this )
 128 {
 129     sout_stream_sys_t *p_sys = (sout_stream_sys_t*)p_this;
 130     sout_stream_id_t *id = p_sys->id_video;
 131     picture_t *p_pic;
 132     int canc = vlc_savecancel ();
 133
 134     while( vlc_object_alive (p_sys) && !p_sys->b_error )
 135     {
 136         block_t *p_block;
 137
 138         vlc_mutex_lock( &p_sys->lock_out );
 139         while( p_sys->i_last_pic == p_sys->i_first_pic )
 140         {
 141             vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );
 142             if( !vlc_object_alive (p_sys) || p_sys->b_error ) break;
 143         }
 144         if( !vlc_object_alive (p_sys) || p_sys->b_error )
 145         {
 146             vlc_mutex_unlock( &p_sys->lock_out );
 147             break;
 148         }
 149
 150         p_pic = p_sys->pp_pics[p_sys->i_first_pic++];
 151         p_sys->i_first_pic %= PICTURE_RING_SIZE;
 152         vlc_mutex_unlock( &p_sys->lock_out );
 153
 154         video_timer_start( id->p_encoder );
 155         p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
 156         video_timer_stop( id->p_encoder );
 157
 158         vlc_mutex_lock( &p_sys->lock_out );
 159         block_ChainAppend( &p_sys->p_buffers, p_block );
 160
 161         vlc_mutex_unlock( &p_sys->lock_out );
 162         picture_Release( p_pic );
 163     }
 164
 165     while( p_sys->i_last_pic != p_sys->i_first_pic )
 166     {
 167         p_pic = p_sys->pp_pics[p_sys->i_first_pic++];
 168         p_sys->i_first_pic %= PICTURE_RING_SIZE;
 169         picture_Release( p_pic );
 170     }
 171     block_ChainRelease( p_sys->p_buffers );
 172
 173     vlc_restorecancel (canc);
 174     return NULL;
 175 }
 176
 177 int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
 178 {
 179     sout_stream_sys_t *p_sys = p_stream->p_sys;
 180
 181     /* Open decoder
 182      * Initialization of decoder structures
 183      */
 184     id->p_decoder->fmt_out = id->p_decoder->fmt_in;
 185     id->p_decoder->fmt_out.i_extra = 0;
 186     id->p_decoder->fmt_out.p_extra = 0;
 187     id->p_decoder->pf_decode_video = NULL;
 188     id->p_decoder->pf_get_cc = NULL;
 189     id->p_decoder->pf_get_cc = 0;
 190     id->p_decoder->pf_vout_buffer_new = video_new_buffer_decoder;
 191     id->p_decoder->pf_vout_buffer_del = video_del_buffer_decoder;
 192     id->p_decoder->pf_picture_link    = video_link_picture_decoder;
 193     id->p_decoder->pf_picture_unlink  = video_unlink_picture_decoder;
 194     id->p_decoder->p_owner = malloc( sizeof(decoder_owner_sys_t) );
 195     if( !id->p_decoder->p_owner )
 196         return VLC_EGENERIC;
 197
 198     id->p_decoder->p_owner->p_sys = p_sys;
 199     /* id->p_decoder->p_cfg = p_sys->p_video_cfg; */
 200
 201     id->p_decoder->p_module =
 202         module_need( id->p_decoder, "decoder", "$codec", false );
 203
 204     if( !id->p_decoder->p_module )
 205     {
 206         msg_Err( p_stream, "cannot find video decoder" );
 207         free( id->p_decoder->p_owner );
 208         return VLC_EGENERIC;
 209     }
 210
 211     /*
 212      * Open encoder.
 213      * Because some info about the decoded input will only be available
 214      * once the first frame is decoded, we actually only test the availability
 215      * of the encoder here.
 216      */
 217
 218     /* Initialization of encoder format structures */
 219     es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
 220                     id->p_decoder->fmt_out.i_codec );
 221     id->p_encoder->fmt_in.video.i_chroma = id->p_decoder->fmt_out.i_codec;
 222
 223     /* The dimensions will be set properly later on.
 224      * Just put sensible values so we can test an encoder is available. */
 225     id->p_encoder->fmt_in.video.i_width =
 226         id->p_encoder->fmt_out.video.i_width
 227           ? id->p_encoder->fmt_out.video.i_width
 228           : id->p_decoder->fmt_in.video.i_width
 229             ? id->p_decoder->fmt_in.video.i_width : 16;
 230     id->p_encoder->fmt_in.video.i_height =
 231         id->p_encoder->fmt_out.video.i_height
 232           ? id->p_encoder->fmt_out.video.i_height
 233           : id->p_decoder->fmt_in.video.i_height
 234             ? id->p_decoder->fmt_in.video.i_height : 16;
 235     id->p_encoder->fmt_in.video.i_frame_rate = ENC_FRAMERATE;
 236     id->p_encoder->fmt_in.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 237
 238     id->p_encoder->i_threads = p_sys->i_threads;
 239     id->p_encoder->p_cfg = p_sys->p_video_cfg;
 240
 241     id->p_encoder->p_module =
 242         module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
 243     if( !id->p_encoder->p_module )
 244     {
 245         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
 246                  p_sys->psz_venc ? p_sys->psz_venc : "any",
 247                  (char *)&p_sys->i_vcodec );
 248         module_unneed( id->p_decoder, id->p_decoder->p_module );
 249         id->p_decoder->p_module = 0;
 250         free( id->p_decoder->p_owner );
 251         return VLC_EGENERIC;
 252     }
 253
 254     /* Close the encoder.
 255      * We'll open it only when we have the first frame. */
 256     module_unneed( id->p_encoder, id->p_encoder->p_module );
 257     if( id->p_encoder->fmt_out.p_extra )
 258     {
 259         free( id->p_encoder->fmt_out.p_extra );
 260         id->p_encoder->fmt_out.p_extra = NULL;
 261         id->p_encoder->fmt_out.i_extra = 0;
 262     }
 263     id->p_encoder->p_module = NULL;
 264
 265     if( p_sys->i_threads >= 1 )
 266     {
 267         int i_priority = p_sys->b_high_priority ? VLC_THREAD_PRIORITY_OUTPUT :
 268                            VLC_THREAD_PRIORITY_VIDEO;
 269         p_sys->id_video = id;
 270         vlc_mutex_init( &p_sys->lock_out );
 271         vlc_cond_init( &p_sys->cond );
 272         memset( p_sys->pp_pics, 0, sizeof(p_sys->pp_pics) );
 273         p_sys->i_first_pic = 0;
 274         p_sys->i_last_pic = 0;
 275         p_sys->p_buffers = NULL;
 276         p_sys->b_die = p_sys->b_error = 0;
 277         if( vlc_thread_create( p_sys, "encoder", EncoderThread, i_priority ) )
 278         {
 279             msg_Err( p_stream, "cannot spawn encoder thread" );
 280             module_unneed( id->p_decoder, id->p_decoder->p_module );
 281             id->p_decoder->p_module = 0;
 282             free( id->p_decoder->p_owner );
 283             return VLC_EGENERIC;
 284         }
 285     }
 286     return VLC_SUCCESS;
 287 }
 288 static void transcode_video_encoder_init( sout_stream_t *p_stream,
 289                                           sout_stream_id_t *id )
 290 {
 291     sout_stream_sys_t *p_sys = p_stream->p_sys;
 292
 293     /* Calculate scaling
 294      * width/height of source */
 295     int i_src_width = id->p_decoder->fmt_out.video.i_width;
 296     int i_src_height = id->p_decoder->fmt_out.video.i_height;
 297
 298     /* with/height scaling */
 299     float f_scale_width = 1;
 300     float f_scale_height = 1;
 301
 302     /* width/height of output stream */
 303     int i_dst_width;
 304     int i_dst_height;
 305
 306     /* aspect ratio */
 307     float f_aspect = (double)id->p_decoder->fmt_out.video.i_sar_num *
 308                      id->p_decoder->fmt_out.video.i_width /
 309                      id->p_decoder->fmt_out.video.i_sar_den /
 310                      id->p_decoder->fmt_out.video.i_height;
 311
 312     msg_Dbg( p_stream, "decoder aspect is %f:1", f_aspect );
 313
 314     /* Change f_aspect from source frame to source pixel */
 315     f_aspect = f_aspect * i_src_height / i_src_width;
 316     msg_Dbg( p_stream, "source pixel aspect is %f:1", f_aspect );
 317
 318     /* Calculate scaling factor for specified parameters */
 319     if( id->p_encoder->fmt_out.video.i_width <= 0 &&
 320         id->p_encoder->fmt_out.video.i_height <= 0 && p_sys->f_scale )
 321     {
 322         /* Global scaling. Make sure width will remain a factor of 16 */
 323         float f_real_scale;
 324         int  i_new_height;
 325         int i_new_width = i_src_width * p_sys->f_scale;
 326
 327         if( i_new_width % 16 <= 7 && i_new_width >= 16 )
 328             i_new_width -= i_new_width % 16;
 329         else
 330             i_new_width += 16 - i_new_width % 16;
 331
 332         f_real_scale = (float)( i_new_width ) / (float) i_src_width;
 333
 334         i_new_height = __MAX( 16, i_src_height * (float)f_real_scale );
 335
 336         f_scale_width = f_real_scale;
 337         f_scale_height = (float) i_new_height / (float) i_src_height;
 338     }
 339     else if( id->p_encoder->fmt_out.video.i_width > 0 &&
 340              id->p_encoder->fmt_out.video.i_height <= 0 )
 341     {
 342         /* Only width specified */
 343         f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width;
 344         f_scale_height = f_scale_width;
 345     }
 346     else if( id->p_encoder->fmt_out.video.i_width <= 0 &&
 347              id->p_encoder->fmt_out.video.i_height > 0 )
 348     {
 349          /* Only height specified */
 350          f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height;
 351          f_scale_width = f_scale_height;
 352      }
 353      else if( id->p_encoder->fmt_out.video.i_width > 0 &&
 354               id->p_encoder->fmt_out.video.i_height > 0 )
 355      {
 356          /* Width and height specified */
 357          f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width;
 358          f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height;
 359      }
 360
 361      /* check maxwidth and maxheight */
 362      if( p_sys->i_maxwidth && f_scale_width > (float)p_sys->i_maxwidth /
 363                                                      i_src_width )
 364      {
 365          f_scale_width = (float)p_sys->i_maxwidth / i_src_width;
 366      }
 367
 368      if( p_sys->i_maxheight && f_scale_height > (float)p_sys->i_maxheight /
 369                                                        i_src_height )
 370      {
 371          f_scale_height = (float)p_sys->i_maxheight / i_src_height;
 372      }
 373
 374
 375      /* Change aspect ratio from source pixel to scaled pixel */
 376      f_aspect = f_aspect * f_scale_height / f_scale_width;
 377      msg_Dbg( p_stream, "scaled pixel aspect is %f:1", f_aspect );
 378
 379      /* f_scale_width and f_scale_height are now final */
 380      /* Calculate width, height from scaling
 381       * Make sure its multiple of 2
 382       */
 383      i_dst_width =  2 * (int)(f_scale_width*i_src_width/2+0.5);
 384      i_dst_height = 2 * (int)(f_scale_height*i_src_height/2+0.5);
 385
 386      /* Change aspect ratio from scaled pixel to output frame */
 387      f_aspect = f_aspect * i_dst_width / i_dst_height;
 388
 389      /* Store calculated values */
 390      id->p_encoder->fmt_out.video.i_width =
 391      id->p_encoder->fmt_out.video.i_visible_width = i_dst_width;
 392      id->p_encoder->fmt_out.video.i_height =
 393      id->p_encoder->fmt_out.video.i_visible_height = i_dst_height;
 394
 395      id->p_encoder->fmt_in.video.i_width =
 396      id->p_encoder->fmt_in.video.i_visible_width = i_dst_width;
 397      id->p_encoder->fmt_in.video.i_height =
 398      id->p_encoder->fmt_in.video.i_visible_height = i_dst_height;
 399
 400      msg_Dbg( p_stream, "source %ix%i, destination %ix%i",
 401          i_src_width, i_src_height,
 402          i_dst_width, i_dst_height
 403      );
 404
 405     /* Handle frame rate conversion */
 406     if( !id->p_encoder->fmt_out.video.i_frame_rate ||
 407         !id->p_encoder->fmt_out.video.i_frame_rate_base )
 408     {
 409         if( id->p_decoder->fmt_out.video.i_frame_rate &&
 410             id->p_decoder->fmt_out.video.i_frame_rate_base )
 411         {
 412             id->p_encoder->fmt_out.video.i_frame_rate =
 413                 id->p_decoder->fmt_out.video.i_frame_rate;
 414             id->p_encoder->fmt_out.video.i_frame_rate_base =
 415                 id->p_decoder->fmt_out.video.i_frame_rate_base;
 416         }
 417         else
 418         {
 419             /* Pick a sensible default value */
 420             id->p_encoder->fmt_out.video.i_frame_rate = ENC_FRAMERATE;
 421             id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 422         }
 423     }
 424
 425     id->p_encoder->fmt_in.video.i_frame_rate =
 426         id->p_encoder->fmt_out.video.i_frame_rate;
 427     id->p_encoder->fmt_in.video.i_frame_rate_base =
 428         id->p_encoder->fmt_out.video.i_frame_rate_base;
 429
 430     date_Init( &id->interpolated_pts,
 431                id->p_encoder->fmt_out.video.i_frame_rate,
 432                id->p_encoder->fmt_out.video.i_frame_rate_base );
 433
 434     /* Check whether a particular aspect ratio was requested */
 435     if( id->p_encoder->fmt_out.video.i_sar_num <= 0 ||
 436         id->p_encoder->fmt_out.video.i_sar_den <= 0 )
 437     {
 438         id->p_encoder->fmt_out.video.i_sar_num = id->p_decoder->fmt_out.video.i_sar_num * i_src_width / i_dst_width;
 439         id->p_encoder->fmt_out.video.i_sar_den = id->p_decoder->fmt_out.video.i_sar_den * i_src_height / i_dst_height;
 440     }
 441     vlc_ureduce( &id->p_encoder->fmt_out.video.i_sar_num,
 442                  &id->p_encoder->fmt_out.video.i_sar_den,
 443                  id->p_encoder->fmt_out.video.i_sar_num,
 444                  id->p_encoder->fmt_out.video.i_sar_den,
 445                  0 );
 446
 447     id->p_encoder->fmt_in.video.i_sar_num =
 448         id->p_encoder->fmt_out.video.i_sar_num;
 449     id->p_encoder->fmt_in.video.i_sar_den =
 450         id->p_encoder->fmt_out.video.i_sar_den;
 451
 452     msg_Dbg( p_stream, "encoder aspect is %i:%i",
 453              id->p_encoder->fmt_out.video.i_sar_num * id->p_encoder->fmt_out.video.i_width,
 454              id->p_encoder->fmt_out.video.i_sar_den * id->p_encoder->fmt_out.video.i_height );
 455
 456     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 457 }
 458
 459 static int transcode_video_encoder_open( sout_stream_t *p_stream,
 460                                          sout_stream_id_t *id )
 461 {
 462     sout_stream_sys_t *p_sys = p_stream->p_sys;
 463
 464
 465     msg_Dbg( p_stream, "destination (after video filters) %ix%i",
 466              id->p_encoder->fmt_in.video.i_width,
 467              id->p_encoder->fmt_in.video.i_height );
 468
 469     id->p_encoder->p_module =
 470         module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
 471     if( !id->p_encoder->p_module )
 472     {
 473         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
 474                  p_sys->psz_venc ? p_sys->psz_venc : "any",
 475                  (char *)&p_sys->i_vcodec );
 476         return VLC_EGENERIC;
 477     }
 478
 479     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 480
 481     /*  */
 482     id->p_encoder->fmt_out.i_codec =
 483         vlc_fourcc_GetCodec( VIDEO_ES, id->p_encoder->fmt_out.i_codec );
 484
 485     id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_encoder->fmt_out );
 486     if( !id->id )
 487     {
 488         msg_Err( p_stream, "cannot add this stream" );
 489         return VLC_EGENERIC;
 490     }
 491
 492     return VLC_SUCCESS;
 493 }
 494
 495 void transcode_video_close( sout_stream_t *p_stream,
 496                                    sout_stream_id_t *id )
 497 {
 498     if( p_stream->p_sys->i_threads >= 1 )
 499     {
 500         vlc_mutex_lock( &p_stream->p_sys->lock_out );
 501         vlc_object_kill( p_stream->p_sys );
 502         vlc_cond_signal( &p_stream->p_sys->cond );
 503         vlc_mutex_unlock( &p_stream->p_sys->lock_out );
 504         vlc_thread_join( p_stream->p_sys );
 505         vlc_mutex_destroy( &p_stream->p_sys->lock_out );
 506         vlc_cond_destroy( &p_stream->p_sys->cond );
 507     }
 508
 509     video_timer_close( id->p_encoder );
 510
 511     /* Close decoder */
 512     if( id->p_decoder->p_module )
 513         module_unneed( id->p_decoder, id->p_decoder->p_module );
 514     if( id->p_decoder->p_description )
 515         vlc_meta_Delete( id->p_decoder->p_description );
 516
 517     free( id->p_decoder->p_owner );
 518
 519     /* Close encoder */
 520     if( id->p_encoder->p_module )
 521         module_unneed( id->p_encoder, id->p_encoder->p_module );
 522
 523     /* Close filters */
 524     if( id->p_f_chain )
 525         filter_chain_Delete( id->p_f_chain );
 526     if( id->p_uf_chain )
 527         filter_chain_Delete( id->p_uf_chain );
 528 }
 529
 530 int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
 531                                     block_t *in, block_t **out )
 532 {
 533     sout_stream_sys_t *p_sys = p_stream->p_sys;
 534     int i_duplicate = 1;
 535     picture_t *p_pic, *p_pic2 = NULL;
 536     *out = NULL;
 537
 538     while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
 539     {
 540         subpicture_t *p_subpic = NULL;
 541
 542         sout_UpdateStatistic( p_stream->p_sout, SOUT_STATISTIC_DECODED_VIDEO, 1 );
 543
 544         if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
 545         {
 546             mtime_t current_date = mdate();
 547             if( current_date + 50000 > p_pic->date )
 548             {
 549                 msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
 550                          current_date + 50000 - p_pic->date );
 551                 picture_Release( p_pic );
 552                 continue;
 553             }
 554         }
 555
 556         if( p_sys->b_master_sync )
 557         {
 558             mtime_t i_video_drift;
 559             mtime_t i_master_drift = p_sys->i_master_drift;
 560             mtime_t i_pts;
 561
 562             i_pts = date_Get( &id->interpolated_pts ) + 1;
 563             if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
 564                   || p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
 565             {
 566                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 567                 date_Set( &id->interpolated_pts, p_pic->date );
 568                 i_pts = p_pic->date + 1;
 569             }
 570             i_video_drift = p_pic->date - i_pts;
 571             i_duplicate = 1;
 572
 573             /* Set the pts of the frame being encoded */
 574             p_pic->date = i_pts;
 575
 576             if( i_video_drift < (i_master_drift - 50000) )
 577             {
 578 #if 0
 579                 msg_Dbg( p_stream, "dropping frame (%i)",
 580                          (int)(i_video_drift - i_master_drift) );
 581 #endif
 582                 picture_Release( p_pic );
 583                 continue;
 584             }
 585             else if( i_video_drift > (i_master_drift + 50000) )
 586             {
 587 #if 0
 588                 msg_Dbg( p_stream, "adding frame (%i)",
 589                          (int)(i_video_drift - i_master_drift) );
 590 #endif
 591                 i_duplicate = 2;
 592             }
 593         }
 594
 595         if( !id->p_encoder->p_module )
 596         {
 597             transcode_video_encoder_init( p_stream, id );
 598
 599             id->p_f_chain = filter_chain_New( p_stream, "video filter2",
 600                                               false,
 601                                transcode_video_filter_allocation_init,
 602                                transcode_video_filter_allocation_clear,
 603                                p_stream->p_sys );
 604
 605             /* Deinterlace */
 606             if( p_stream->p_sys->b_deinterlace )
 607             {
 608                 filter_chain_AppendFilter( id->p_f_chain,
 609                                            p_sys->psz_deinterlace,
 610                                            p_sys->p_deinterlace_cfg,
 611                                            &id->p_decoder->fmt_out,
 612                                            &id->p_decoder->fmt_out );
 613             }
 614             /* Take care of the scaling and chroma conversions */
 615             if( ( id->p_decoder->fmt_out.video.i_chroma !=
 616                   id->p_encoder->fmt_in.video.i_chroma ) ||
 617                 ( id->p_decoder->fmt_out.video.i_width !=
 618                   id->p_encoder->fmt_in.video.i_width ) ||
 619                 ( id->p_decoder->fmt_out.video.i_height !=
 620                   id->p_encoder->fmt_in.video.i_height ) )
 621             {
 622                 filter_chain_AppendFilter( id->p_f_chain,
 623                                            NULL, NULL,
 624                                            &id->p_decoder->fmt_out,
 625                                            &id->p_encoder->fmt_in );
 626             }
 627
 628             if( p_sys->psz_vf2 )
 629             {
 630                 const es_format_t *p_fmt_out;
 631                 id->p_uf_chain = filter_chain_New( p_stream, "video filter2",
 632                                                    true,
 633                                    transcode_video_filter_allocation_init,
 634                                    transcode_video_filter_allocation_clear,
 635                                    p_stream->p_sys );
 636                 filter_chain_Reset( id->p_uf_chain, &id->p_encoder->fmt_in,
 637                                     &id->p_encoder->fmt_in );
 638                 filter_chain_AppendFromString( id->p_uf_chain, p_sys->psz_vf2 );
 639                 p_fmt_out = filter_chain_GetFmtOut( id->p_uf_chain );
 640                 es_format_Copy( &id->p_encoder->fmt_in, p_fmt_out );
 641                 id->p_encoder->fmt_out.video.i_width =
 642                     id->p_encoder->fmt_in.video.i_width;
 643                 id->p_encoder->fmt_out.video.i_height =
 644                     id->p_encoder->fmt_in.video.i_height;
 645                 id->p_encoder->fmt_out.video.i_sar_num =
 646                     id->p_encoder->fmt_in.video.i_sar_num;
 647                 id->p_encoder->fmt_out.video.i_sar_den =
 648                     id->p_encoder->fmt_in.video.i_sar_den;
 649             }
 650
 651             if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
 652             {
 653                 picture_Release( p_pic );
 654                 transcode_video_close( p_stream, id );
 655                 id->b_transcode = false;
 656                 return VLC_EGENERIC;
 657             }
 658         }
 659
 660         /* Run filter chain */
 661         if( id->p_f_chain )
 662             p_pic = filter_chain_VideoFilter( id->p_f_chain, p_pic );
 663
 664         /*
 665          * Encoding
 666          */
 667
 668         /* Check if we have a subpicture to overlay */
 669         if( p_sys->p_spu )
 670         {
 671             p_subpic = spu_SortSubpictures( p_sys->p_spu, p_pic->date, false );
 672             /* TODO: get another pic */
 673         }
 674
 675         /* Overlay subpicture */
 676         if( p_subpic )
 677         {
 678             video_format_t fmt;
 679
 680             if( picture_IsReferenced( p_pic ) && !filter_chain_GetLength( id->p_f_chain ) )
 681             {
 682                 /* We can't modify the picture, we need to duplicate it */
 683                 picture_t *p_tmp = video_new_buffer_decoder( id->p_decoder );
 684                 if( p_tmp )
 685                 {
 686                     picture_Copy( p_tmp, p_pic );
 687                     picture_Release( p_pic );
 688                     p_pic = p_tmp;
 689                 }
 690             }
 691
 692             if( filter_chain_GetLength( id->p_f_chain ) > 0 )
 693                 fmt = filter_chain_GetFmtOut( id->p_f_chain )->video;
 694             else
 695                 fmt = id->p_decoder->fmt_out.video;
 696
 697             /* FIXME the mdate() seems highly suspicious */
 698             spu_RenderSubpictures( p_sys->p_spu, p_pic, &fmt,
 699                                    p_subpic, &id->p_decoder->fmt_out.video, mdate() );
 700         }
 701
 702         /* Run user specified filter chain */
 703         if( id->p_uf_chain )
 704             p_pic = filter_chain_VideoFilter( id->p_uf_chain, p_pic );
 705
 706         if( p_sys->i_threads == 0 )
 707         {
 708             block_t *p_block;
 709
 710             video_timer_start( id->p_encoder );
 711             p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
 712             video_timer_stop( id->p_encoder );
 713
 714             block_ChainAppend( out, p_block );
 715         }
 716
 717         if( p_sys->b_master_sync )
 718         {
 719             mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 720             if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
 721                   || p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
 722             {
 723                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 724                 date_Set( &id->interpolated_pts, p_pic->date );
 725                 i_pts = p_pic->date + 1;
 726             }
 727             date_Increment( &id->interpolated_pts, 1 );
 728         }
 729
 730         if( p_sys->b_master_sync && i_duplicate > 1 )
 731         {
 732             mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 733             if( (p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT)
 734                  || ((p_pic->date - i_pts) < -MASTER_SYNC_MAX_DRIFT) )
 735             {
 736                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 737                 date_Set( &id->interpolated_pts, p_pic->date );
 738                 i_pts = p_pic->date + 1;
 739             }
 740             date_Increment( &id->interpolated_pts, 1 );
 741
 742             if( p_sys->i_threads >= 1 )
 743             {
 744                 /* We can't modify the picture, we need to duplicate it */
 745                 p_pic2 = video_new_buffer_decoder( id->p_decoder );
 746                 if( p_pic2 != NULL )
 747                 {
 748                     picture_Copy( p_pic2, p_pic );
 749                     p_pic2->date = i_pts;
 750                 }
 751             }
 752             else
 753             {
 754                 block_t *p_block;
 755                 p_pic->date = i_pts;
 756                 video_timer_start( id->p_encoder );
 757                 p_block = id->p_encoder->pf_encode_video(id->p_encoder, p_pic);
 758                 video_timer_stop( id->p_encoder );
 759                 block_ChainAppend( out, p_block );
 760             }
 761         }
 762
 763         if( p_sys->i_threads == 0 )
 764         {
 765             picture_Release( p_pic );
 766         }
 767         else
 768         {
 769             vlc_mutex_lock( &p_sys->lock_out );
 770             p_sys->pp_pics[p_sys->i_last_pic++] = p_pic;
 771             p_sys->i_last_pic %= PICTURE_RING_SIZE;
 772             *out = p_sys->p_buffers;
 773             p_sys->p_buffers = NULL;
 774             if( p_pic2 != NULL )
 775             {
 776                 p_sys->pp_pics[p_sys->i_last_pic++] = p_pic2;
 777                 p_sys->i_last_pic %= PICTURE_RING_SIZE;
 778             }
 779             vlc_cond_signal( &p_sys->cond );
 780             vlc_mutex_unlock( &p_sys->lock_out );
 781         }
 782     }
 783
 784     return VLC_SUCCESS;
 785 }
 786
 787 bool transcode_video_add( sout_stream_t *p_stream, es_format_t *p_fmt,
 788                                 sout_stream_id_t *id )
 789 {
 790     sout_stream_sys_t *p_sys = p_stream->p_sys;
 791
 792     msg_Dbg( p_stream,
 793              "creating video transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
 794              (char*)&p_fmt->i_codec, (char*)&p_sys->i_vcodec );
 795
 796     /* Complete destination format */
 797     id->p_encoder->fmt_out.i_codec = p_sys->i_vcodec;
 798     id->p_encoder->fmt_out.video.i_width  = p_sys->i_width & ~1;
 799     id->p_encoder->fmt_out.video.i_height = p_sys->i_height & ~1;
 800     id->p_encoder->fmt_out.i_bitrate = p_sys->i_vbitrate;
 801
 802     /* Build decoder -> filter -> encoder chain */
 803     if( transcode_video_new( p_stream, id ) )
 804     {
 805         msg_Err( p_stream, "cannot create video chain" );
 806         return false;
 807     }
 808
 809     /* Stream will be added later on because we don't know
 810      * all the characteristics of the decoded stream yet */
 811     id->b_transcode = true;
 812
 813     if( p_sys->f_fps > 0 )
 814     {
 815         id->p_encoder->fmt_out.video.i_frame_rate = (p_sys->f_fps * 1000) + 0.5;
 816         id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 817     }
 818
 819     return true;
 820 }
 821