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 =
 439             f_aspect * id->p_encoder->fmt_out.video.i_height + 0.5;
 440         id->p_encoder->fmt_out.video.i_sar_num =
 441             VOUT_ASPECT_FACTOR * id->p_encoder->fmt_out.video.i_width;
 442     }
 443     id->p_encoder->fmt_in.video.i_sar_num =
 444         id->p_encoder->fmt_out.video.i_sar_num;
 445     id->p_encoder->fmt_in.video.i_sar_den =
 446         id->p_encoder->fmt_out.video.i_sar_den;
 447
 448     msg_Dbg( p_stream, "encoder aspect is %i:%i",
 449              id->p_encoder->fmt_out.video.i_sar_num * id->p_encoder->fmt_out.video.i_width,
 450              id->p_encoder->fmt_out.video.i_sar_den * id->p_encoder->fmt_out.video.i_height );
 451
 452     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 453 }
 454
 455 static int transcode_video_encoder_open( sout_stream_t *p_stream,
 456                                          sout_stream_id_t *id )
 457 {
 458     sout_stream_sys_t *p_sys = p_stream->p_sys;
 459
 460
 461     msg_Dbg( p_stream, "destination (after video filters) %ix%i",
 462              id->p_encoder->fmt_in.video.i_width,
 463              id->p_encoder->fmt_in.video.i_height );
 464
 465     id->p_encoder->p_module =
 466         module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
 467     if( !id->p_encoder->p_module )
 468     {
 469         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
 470                  p_sys->psz_venc ? p_sys->psz_venc : "any",
 471                  (char *)&p_sys->i_vcodec );
 472         return VLC_EGENERIC;
 473     }
 474
 475     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 476
 477     /*  */
 478     id->p_encoder->fmt_out.i_codec =
 479         vlc_fourcc_GetCodec( VIDEO_ES, id->p_encoder->fmt_out.i_codec );
 480
 481     id->id = sout_StreamIdAdd( p_stream->p_sys->p_out,
 482                                &id->p_encoder->fmt_out );
 483     if( !id->id )
 484     {
 485         msg_Err( p_stream, "cannot add this stream" );
 486         return VLC_EGENERIC;
 487     }
 488
 489     return VLC_SUCCESS;
 490 }
 491
 492 void transcode_video_close( sout_stream_t *p_stream,
 493                                    sout_stream_id_t *id )
 494 {
 495     if( p_stream->p_sys->i_threads >= 1 )
 496     {
 497         vlc_mutex_lock( &p_stream->p_sys->lock_out );
 498         vlc_object_kill( p_stream->p_sys );
 499         vlc_cond_signal( &p_stream->p_sys->cond );
 500         vlc_mutex_unlock( &p_stream->p_sys->lock_out );
 501         vlc_thread_join( p_stream->p_sys );
 502         vlc_mutex_destroy( &p_stream->p_sys->lock_out );
 503         vlc_cond_destroy( &p_stream->p_sys->cond );
 504     }
 505
 506     video_timer_close( id->p_encoder );
 507
 508     /* Close decoder */
 509     if( id->p_decoder->p_module )
 510         module_unneed( id->p_decoder, id->p_decoder->p_module );
 511     if( id->p_decoder->p_description )
 512         vlc_meta_Delete( id->p_decoder->p_description );
 513
 514     free( id->p_decoder->p_owner );
 515
 516     /* Close encoder */
 517     if( id->p_encoder->p_module )
 518         module_unneed( id->p_encoder, id->p_encoder->p_module );
 519
 520     /* Close filters */
 521     if( id->p_f_chain )
 522         filter_chain_Delete( id->p_f_chain );
 523     if( id->p_uf_chain )
 524         filter_chain_Delete( id->p_uf_chain );
 525 }
 526
 527 int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
 528                                     block_t *in, block_t **out )
 529 {
 530     sout_stream_sys_t *p_sys = p_stream->p_sys;
 531     int i_duplicate = 1;
 532     picture_t *p_pic, *p_pic2 = NULL;
 533     *out = NULL;
 534
 535     while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
 536     {
 537         subpicture_t *p_subpic = NULL;
 538
 539         sout_UpdateStatistic( p_stream->p_sout, SOUT_STATISTIC_DECODED_VIDEO, 1 );
 540
 541         if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
 542         {
 543             mtime_t current_date = mdate();
 544             if( current_date + 50000 > p_pic->date )
 545             {
 546                 msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
 547                          current_date + 50000 - p_pic->date );
 548                 picture_Release( p_pic );
 549                 continue;
 550             }
 551         }
 552
 553         if( p_sys->b_master_sync )
 554         {
 555             mtime_t i_video_drift;
 556             mtime_t i_master_drift = p_sys->i_master_drift;
 557             mtime_t i_pts;
 558
 559             i_pts = date_Get( &id->interpolated_pts ) + 1;
 560             if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
 561                   || p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
 562             {
 563                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 564                 date_Set( &id->interpolated_pts, p_pic->date );
 565                 i_pts = p_pic->date + 1;
 566             }
 567             i_video_drift = p_pic->date - i_pts;
 568             i_duplicate = 1;
 569
 570             /* Set the pts of the frame being encoded */
 571             p_pic->date = i_pts;
 572
 573             if( i_video_drift < (i_master_drift - 50000) )
 574             {
 575 #if 0
 576                 msg_Dbg( p_stream, "dropping frame (%i)",
 577                          (int)(i_video_drift - i_master_drift) );
 578 #endif
 579                 picture_Release( p_pic );
 580                 continue;
 581             }
 582             else if( i_video_drift > (i_master_drift + 50000) )
 583             {
 584 #if 0
 585                 msg_Dbg( p_stream, "adding frame (%i)",
 586                          (int)(i_video_drift - i_master_drift) );
 587 #endif
 588                 i_duplicate = 2;
 589             }
 590         }
 591
 592         if( !id->p_encoder->p_module )
 593         {
 594             transcode_video_encoder_init( p_stream, id );
 595
 596             id->p_f_chain = filter_chain_New( p_stream, "video filter2",
 597                                               false,
 598                                transcode_video_filter_allocation_init,
 599                                transcode_video_filter_allocation_clear,
 600                                p_stream->p_sys );
 601
 602             /* Deinterlace */
 603             if( p_stream->p_sys->b_deinterlace )
 604             {
 605                 filter_chain_AppendFilter( id->p_f_chain,
 606                                            p_sys->psz_deinterlace,
 607                                            p_sys->p_deinterlace_cfg,
 608                                            &id->p_decoder->fmt_out,
 609                                            &id->p_decoder->fmt_out );
 610             }
 611             /* Take care of the scaling and chroma conversions */
 612             if( ( id->p_decoder->fmt_out.video.i_chroma !=
 613                   id->p_encoder->fmt_in.video.i_chroma ) ||
 614                 ( id->p_decoder->fmt_out.video.i_width !=
 615                   id->p_encoder->fmt_in.video.i_width ) ||
 616                 ( id->p_decoder->fmt_out.video.i_height !=
 617                   id->p_encoder->fmt_in.video.i_height ) )
 618             {
 619                 filter_chain_AppendFilter( id->p_f_chain,
 620                                            NULL, NULL,
 621                                            &id->p_decoder->fmt_out,
 622                                            &id->p_encoder->fmt_in );
 623             }
 624
 625             if( p_sys->psz_vf2 )
 626             {
 627                 const es_format_t *p_fmt_out;
 628                 id->p_uf_chain = filter_chain_New( p_stream, "video filter2",
 629                                                    true,
 630                                    transcode_video_filter_allocation_init,
 631                                    transcode_video_filter_allocation_clear,
 632                                    p_stream->p_sys );
 633                 filter_chain_Reset( id->p_uf_chain, &id->p_encoder->fmt_in,
 634                                     &id->p_encoder->fmt_in );
 635                 filter_chain_AppendFromString( id->p_uf_chain, p_sys->psz_vf2 );
 636                 p_fmt_out = filter_chain_GetFmtOut( id->p_uf_chain );
 637                 es_format_Copy( &id->p_encoder->fmt_in, p_fmt_out );
 638                 id->p_encoder->fmt_out.video.i_width =
 639                     id->p_encoder->fmt_in.video.i_width;
 640                 id->p_encoder->fmt_out.video.i_height =
 641                     id->p_encoder->fmt_in.video.i_height;
 642                 id->p_encoder->fmt_out.video.i_sar_num =
 643                     id->p_encoder->fmt_in.video.i_sar_num;
 644                 id->p_encoder->fmt_out.video.i_sar_den =
 645                     id->p_encoder->fmt_in.video.i_sar_den;
 646             }
 647
 648             if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
 649             {
 650                 picture_Release( p_pic );
 651                 transcode_video_close( p_stream, id );
 652                 id->b_transcode = false;
 653                 return VLC_EGENERIC;
 654             }
 655         }
 656
 657         /* Run filter chain */
 658         if( id->p_f_chain )
 659             p_pic = filter_chain_VideoFilter( id->p_f_chain, p_pic );
 660
 661         /*
 662          * Encoding
 663          */
 664
 665         /* Check if we have a subpicture to overlay */
 666         if( p_sys->p_spu )
 667         {
 668             p_subpic = spu_SortSubpictures( p_sys->p_spu, p_pic->date, false );
 669             /* TODO: get another pic */
 670         }
 671
 672         /* Overlay subpicture */
 673         if( p_subpic )
 674         {
 675             video_format_t fmt;
 676
 677             if( picture_IsReferenced( p_pic ) && !filter_chain_GetLength( id->p_f_chain ) )
 678             {
 679                 /* We can't modify the picture, we need to duplicate it */
 680                 picture_t *p_tmp = video_new_buffer_decoder( id->p_decoder );
 681                 if( p_tmp )
 682                 {
 683                     picture_Copy( p_tmp, p_pic );
 684                     picture_Release( p_pic );
 685                     p_pic = p_tmp;
 686                 }
 687             }
 688
 689             if( filter_chain_GetLength( id->p_f_chain ) > 0 )
 690                 fmt = filter_chain_GetFmtOut( id->p_f_chain )->video;
 691             else
 692                 fmt = id->p_decoder->fmt_out.video;
 693
 694             /* FIXME the mdate() seems highly suspicious */
 695             spu_RenderSubpictures( p_sys->p_spu, p_pic, &fmt,
 696                                    p_subpic, &id->p_decoder->fmt_out.video, mdate() );
 697         }
 698
 699         /* Run user specified filter chain */
 700         if( id->p_uf_chain )
 701             p_pic = filter_chain_VideoFilter( id->p_uf_chain, p_pic );
 702
 703         if( p_sys->i_threads == 0 )
 704         {
 705             block_t *p_block;
 706
 707             video_timer_start( id->p_encoder );
 708             p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
 709             video_timer_stop( id->p_encoder );
 710
 711             block_ChainAppend( out, p_block );
 712         }
 713
 714         if( p_sys->b_master_sync )
 715         {
 716             mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 717             if ( p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT
 718                   || p_pic->date - i_pts < -MASTER_SYNC_MAX_DRIFT )
 719             {
 720                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 721                 date_Set( &id->interpolated_pts, p_pic->date );
 722                 i_pts = p_pic->date + 1;
 723             }
 724             date_Increment( &id->interpolated_pts, 1 );
 725         }
 726
 727         if( p_sys->b_master_sync && i_duplicate > 1 )
 728         {
 729             mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 730             if( (p_pic->date - i_pts > MASTER_SYNC_MAX_DRIFT)
 731                  || ((p_pic->date - i_pts) < -MASTER_SYNC_MAX_DRIFT) )
 732             {
 733                 msg_Dbg( p_stream, "drift is too high, resetting master sync" );
 734                 date_Set( &id->interpolated_pts, p_pic->date );
 735                 i_pts = p_pic->date + 1;
 736             }
 737             date_Increment( &id->interpolated_pts, 1 );
 738
 739             if( p_sys->i_threads >= 1 )
 740             {
 741                 /* We can't modify the picture, we need to duplicate it */
 742                 p_pic2 = video_new_buffer_decoder( id->p_decoder );
 743                 if( p_pic2 != NULL )
 744                 {
 745                     picture_Copy( p_pic2, p_pic );
 746                     p_pic2->date = i_pts;
 747                 }
 748             }
 749             else
 750             {
 751                 block_t *p_block;
 752                 p_pic->date = i_pts;
 753                 video_timer_start( id->p_encoder );
 754                 p_block = id->p_encoder->pf_encode_video(id->p_encoder, p_pic);
 755                 video_timer_stop( id->p_encoder );
 756                 block_ChainAppend( out, p_block );
 757             }
 758         }
 759
 760         if( p_sys->i_threads == 0 )
 761         {
 762             picture_Release( p_pic );
 763         }
 764         else
 765         {
 766             vlc_mutex_lock( &p_sys->lock_out );
 767             p_sys->pp_pics[p_sys->i_last_pic++] = p_pic;
 768             p_sys->i_last_pic %= PICTURE_RING_SIZE;
 769             *out = p_sys->p_buffers;
 770             p_sys->p_buffers = NULL;
 771             if( p_pic2 != NULL )
 772             {
 773                 p_sys->pp_pics[p_sys->i_last_pic++] = p_pic2;
 774                 p_sys->i_last_pic %= PICTURE_RING_SIZE;
 775             }
 776             vlc_cond_signal( &p_sys->cond );
 777             vlc_mutex_unlock( &p_sys->lock_out );
 778         }
 779     }
 780
 781     return VLC_SUCCESS;
 782 }
 783
 784 bool transcode_video_add( sout_stream_t *p_stream, es_format_t *p_fmt,
 785                                 sout_stream_id_t *id )
 786 {
 787     sout_stream_sys_t *p_sys = p_stream->p_sys;
 788
 789     msg_Dbg( p_stream,
 790              "creating video transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
 791              (char*)&p_fmt->i_codec, (char*)&p_sys->i_vcodec );
 792
 793     /* Complete destination format */
 794     id->p_encoder->fmt_out.i_codec = p_sys->i_vcodec;
 795     id->p_encoder->fmt_out.video.i_width  = p_sys->i_width & ~1;
 796     id->p_encoder->fmt_out.video.i_height = p_sys->i_height & ~1;
 797     id->p_encoder->fmt_out.i_bitrate = p_sys->i_vbitrate;
 798
 799     /* Build decoder -> filter -> encoder chain */
 800     if( transcode_video_new( p_stream, id ) )
 801     {
 802         msg_Err( p_stream, "cannot create video chain" );
 803         return false;
 804     }
 805
 806     /* Stream will be added later on because we don't know
 807      * all the characteristics of the decoded stream yet */
 808     id->b_transcode = true;
 809
 810     if( p_sys->f_fps > 0 )
 811     {
 812         id->p_encoder->fmt_out.video.i_frame_rate = (p_sys->f_fps * 1000) + 0.5;
 813         id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 814     }
 815
 816     return true;
 817 }
 818