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_spu.h>
  35 #include <vlc_modules.h>
  36
  37 #define ENC_FRAMERATE (25 * 1000)
  38 #define ENC_FRAMERATE_BASE 1000
  39
  40 struct decoder_owner_sys_t
  41 {
  42     sout_stream_sys_t *p_sys;
  43 };
  44
  45 static void video_del_buffer_decoder( decoder_t *p_decoder, picture_t *p_pic )
  46 {
  47     VLC_UNUSED(p_decoder);
  48     picture_Release( p_pic );
  49 }
  50
  51 static void video_link_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
  52 {
  53     VLC_UNUSED(p_dec);
  54     picture_Hold( p_pic );
  55 }
  56
  57 static void video_unlink_picture_decoder( decoder_t *p_dec, picture_t *p_pic )
  58 {
  59     VLC_UNUSED(p_dec);
  60     picture_Release( p_pic );
  61 }
  62
  63 static picture_t *video_new_buffer_decoder( decoder_t *p_dec )
  64 {
  65     p_dec->fmt_out.video.i_chroma = p_dec->fmt_out.i_codec;
  66     return picture_NewFromFormat( &p_dec->fmt_out.video );
  67 }
  68
  69 static picture_t *video_new_buffer_encoder( encoder_t *p_enc )
  70 {
  71     p_enc->fmt_in.video.i_chroma = p_enc->fmt_in.i_codec;
  72     return picture_NewFromFormat( &p_enc->fmt_in.video );
  73 }
  74
  75 static picture_t *transcode_video_filter_buffer_new( filter_t *p_filter )
  76 {
  77     p_filter->fmt_out.video.i_chroma = p_filter->fmt_out.i_codec;
  78     return picture_NewFromFormat( &p_filter->fmt_out.video );
  79 }
  80 static void transcode_video_filter_buffer_del( filter_t *p_filter, picture_t *p_pic )
  81 {
  82     VLC_UNUSED(p_filter);
  83     picture_Release( p_pic );
  84 }
  85
  86 static int transcode_video_filter_allocation_init( filter_t *p_filter,
  87                                                    void *p_data )
  88 {
  89     VLC_UNUSED(p_data);
  90     p_filter->pf_video_buffer_new = transcode_video_filter_buffer_new;
  91     p_filter->pf_video_buffer_del = transcode_video_filter_buffer_del;
  92     return VLC_SUCCESS;
  93 }
  94
  95 static void transcode_video_filter_allocation_clear( filter_t *p_filter )
  96 {
  97     VLC_UNUSED(p_filter);
  98 }
  99
 100 static void* EncoderThread( void *obj )
 101 {
 102     sout_stream_sys_t *p_sys = (sout_stream_sys_t*)obj;
 103     sout_stream_id_t *id = p_sys->id_video;
 104     picture_t *p_pic;
 105     int canc = vlc_savecancel ();
 106
 107     for( ;; )
 108     {
 109         block_t *p_block;
 110
 111         vlc_mutex_lock( &p_sys->lock_out );
 112         while( !p_sys->b_abort &&
 113                (p_pic = picture_fifo_Pop( p_sys->pp_pics )) == NULL )
 114             vlc_cond_wait( &p_sys->cond, &p_sys->lock_out );
 115
 116         if( p_sys->b_abort )
 117         {
 118             vlc_mutex_unlock( &p_sys->lock_out );
 119             break;
 120         }
 121         vlc_mutex_unlock( &p_sys->lock_out );
 122
 123         p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
 124
 125         vlc_mutex_lock( &p_sys->lock_out );
 126         block_ChainAppend( &p_sys->p_buffers, p_block );
 127
 128         vlc_mutex_unlock( &p_sys->lock_out );
 129         picture_Release( p_pic );
 130     }
 131
 132     block_ChainRelease( p_sys->p_buffers );
 133
 134     vlc_restorecancel (canc);
 135     return NULL;
 136 }
 137
 138 int transcode_video_new( sout_stream_t *p_stream, sout_stream_id_t *id )
 139 {
 140     sout_stream_sys_t *p_sys = p_stream->p_sys;
 141
 142     /* Open decoder
 143      * Initialization of decoder structures
 144      */
 145     id->p_decoder->fmt_out = id->p_decoder->fmt_in;
 146     id->p_decoder->fmt_out.i_extra = 0;
 147     id->p_decoder->fmt_out.p_extra = 0;
 148     id->p_decoder->pf_decode_video = NULL;
 149     id->p_decoder->pf_get_cc = NULL;
 150     id->p_decoder->pf_get_cc = 0;
 151     id->p_decoder->pf_vout_buffer_new = video_new_buffer_decoder;
 152     id->p_decoder->pf_vout_buffer_del = video_del_buffer_decoder;
 153     id->p_decoder->pf_picture_link    = video_link_picture_decoder;
 154     id->p_decoder->pf_picture_unlink  = video_unlink_picture_decoder;
 155     id->p_decoder->p_owner = malloc( sizeof(decoder_owner_sys_t) );
 156     if( !id->p_decoder->p_owner )
 157         return VLC_EGENERIC;
 158
 159     id->p_decoder->p_owner->p_sys = p_sys;
 160     /* id->p_decoder->p_cfg = p_sys->p_video_cfg; */
 161
 162     id->p_decoder->p_module =
 163         module_need( id->p_decoder, "decoder", "$codec", false );
 164
 165     if( !id->p_decoder->p_module )
 166     {
 167         msg_Err( p_stream, "cannot find video decoder" );
 168         free( id->p_decoder->p_owner );
 169         return VLC_EGENERIC;
 170     }
 171
 172     /*
 173      * Open encoder.
 174      * Because some info about the decoded input will only be available
 175      * once the first frame is decoded, we actually only test the availability
 176      * of the encoder here.
 177      */
 178
 179     /* Initialization of encoder format structures */
 180     es_format_Init( &id->p_encoder->fmt_in, id->p_decoder->fmt_in.i_cat,
 181                     id->p_decoder->fmt_out.i_codec );
 182     id->p_encoder->fmt_in.video.i_chroma = id->p_decoder->fmt_out.i_codec;
 183
 184     /* The dimensions will be set properly later on.
 185      * Just put sensible values so we can test an encoder is available. */
 186     id->p_encoder->fmt_in.video.i_width =
 187         id->p_encoder->fmt_out.video.i_width
 188           ? id->p_encoder->fmt_out.video.i_width
 189           : id->p_decoder->fmt_in.video.i_width
 190             ? id->p_decoder->fmt_in.video.i_width : 16;
 191     id->p_encoder->fmt_in.video.i_height =
 192         id->p_encoder->fmt_out.video.i_height
 193           ? id->p_encoder->fmt_out.video.i_height
 194           : id->p_decoder->fmt_in.video.i_height
 195             ? id->p_decoder->fmt_in.video.i_height : 16;
 196     id->p_encoder->fmt_in.video.i_frame_rate = ENC_FRAMERATE;
 197     id->p_encoder->fmt_in.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 198
 199     id->p_encoder->i_threads = p_sys->i_threads;
 200     id->p_encoder->p_cfg = p_sys->p_video_cfg;
 201
 202     id->p_encoder->p_module =
 203         module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
 204     if( !id->p_encoder->p_module )
 205     {
 206         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s). Take a look few lines earlier to see possible reason.",
 207                  p_sys->psz_venc ? p_sys->psz_venc : "any",
 208                  (char *)&p_sys->i_vcodec );
 209         module_unneed( id->p_decoder, id->p_decoder->p_module );
 210         id->p_decoder->p_module = 0;
 211         free( id->p_decoder->p_owner );
 212         return VLC_EGENERIC;
 213     }
 214
 215     /* Close the encoder.
 216      * We'll open it only when we have the first frame. */
 217     module_unneed( id->p_encoder, id->p_encoder->p_module );
 218     if( id->p_encoder->fmt_out.p_extra )
 219     {
 220         free( id->p_encoder->fmt_out.p_extra );
 221         id->p_encoder->fmt_out.p_extra = NULL;
 222         id->p_encoder->fmt_out.i_extra = 0;
 223     }
 224     id->p_encoder->p_module = NULL;
 225
 226     if( p_sys->i_threads >= 1 )
 227     {
 228         int i_priority = p_sys->b_high_priority ? VLC_THREAD_PRIORITY_OUTPUT :
 229                            VLC_THREAD_PRIORITY_VIDEO;
 230         p_sys->id_video = id;
 231         vlc_mutex_init( &p_sys->lock_out );
 232         vlc_cond_init( &p_sys->cond );
 233         p_sys->pp_pics = picture_fifo_New();
 234         if( p_sys->pp_pics == NULL )
 235         {
 236             msg_Err( p_stream, "cannot create picture fifo" );
 237             vlc_mutex_destroy( &p_sys->lock_out );
 238             vlc_cond_destroy( &p_sys->cond );
 239             module_unneed( id->p_decoder, id->p_decoder->p_module );
 240             id->p_decoder->p_module = NULL;
 241             free( id->p_decoder->p_owner );
 242             return VLC_ENOMEM;
 243         }
 244         p_sys->p_buffers = NULL;
 245         p_sys->b_abort = false;
 246         if( vlc_clone( &p_sys->thread, EncoderThread, p_sys, i_priority ) )
 247         {
 248             msg_Err( p_stream, "cannot spawn encoder thread" );
 249             vlc_mutex_destroy( &p_sys->lock_out );
 250             vlc_cond_destroy( &p_sys->cond );
 251             picture_fifo_Delete( p_sys->pp_pics );
 252             module_unneed( id->p_decoder, id->p_decoder->p_module );
 253             id->p_decoder->p_module = NULL;
 254             free( id->p_decoder->p_owner );
 255             return VLC_EGENERIC;
 256         }
 257     }
 258     return VLC_SUCCESS;
 259 }
 260
 261 static filter_t *AppendDeinterlaceFilter( sout_stream_t *p_stream,
 262                                           filter_chain_t *p_chain,
 263                                           const char *psz_name,
 264                                           config_chain_t *p_cfg,
 265                                           const es_format_t *p_fmt_in,
 266                                           const es_format_t *p_fmt_out )
 267 {
 268     filter_t *p_filter =
 269         filter_chain_AppendFilter( p_chain, psz_name, p_cfg, p_fmt_in, p_fmt_out );
 270     if( p_filter )
 271         return p_filter;
 272
 273     msg_Dbg( p_stream, "deinterlace init failed, trying colorspace conversion" );
 274
 275     /* Most likely the filter failed due to wrong (e.g. non-planar) input format.
 276      * Try converting to a different color space and try again.
 277      *
 278      * We use the recommended fallback formats in order, to get a conversion that's
 279      * as cheap (both CPU-wise and quality-wise) as possible.
 280      */
 281     for( const vlc_fourcc_t *fourcc = vlc_fourcc_GetYUVFallback( p_fmt_out->video.i_chroma );
 282          *fourcc != 0;
 283          ++fourcc )
 284     {
 285         msg_Dbg( p_stream, "trying deinterlace through colorspace conversion to %4.4s", (char *)fourcc );
 286
 287         es_format_t p_new_fmt;
 288         es_format_Copy( &p_new_fmt, p_fmt_in );
 289         p_new_fmt.video.i_chroma = *fourcc;  // XXX: is this enough?
 290
 291         filter_chain_Reset( p_chain, NULL, NULL );
 292
 293         p_filter = filter_chain_AppendFilter( p_chain,
 294                                               NULL, NULL,
 295                                               p_fmt_in,
 296                                               &p_new_fmt );
 297         if( !p_filter )
 298             continue;
 299
 300         p_filter = filter_chain_AppendFilter( p_chain,
 301                                               psz_name,
 302                                               p_cfg,
 303                                               &p_new_fmt,
 304                                               &p_new_fmt );
 305         if( p_filter )
 306         {
 307             msg_Dbg( p_stream, "deinterlace through colorspace conversion to %4.4s succeeded", (char *)fourcc );
 308             return p_filter;
 309         }
 310     }
 311
 312     msg_Err( p_stream, "deinterlace init failed, even with colorspace conversion" );
 313     return NULL;
 314 }
 315
 316 static void transcode_video_filter_init( sout_stream_t *p_stream,
 317                                          sout_stream_id_t *id )
 318 {
 319     const es_format_t *p_fmt_out = &id->p_decoder->fmt_out;
 320
 321     id->p_f_chain = filter_chain_New( p_stream, "video filter2",
 322                                       false,
 323                                       transcode_video_filter_allocation_init,
 324                                       transcode_video_filter_allocation_clear,
 325                                       p_stream->p_sys );
 326     filter_chain_Reset( id->p_f_chain, p_fmt_out, p_fmt_out );
 327
 328     /* Deinterlace */
 329     if( p_stream->p_sys->b_deinterlace )
 330     {
 331         filter_t *p_filter =
 332             AppendDeinterlaceFilter( p_stream,
 333                                      id->p_f_chain,
 334                                      p_stream->p_sys->psz_deinterlace,
 335                                      p_stream->p_sys->p_deinterlace_cfg,
 336                                      p_fmt_out,
 337                                      p_fmt_out );
 338         if( !p_filter )
 339         {
 340             msg_Err( p_stream, "deinterlace init failed, even with colorspace conversion" );
 341             return;
 342         }
 343
 344         p_fmt_out = filter_chain_GetFmtOut( id->p_f_chain );
 345     }
 346
 347     if( p_stream->p_sys->psz_vf2 )
 348     {
 349         const es_format_t *p_fmt_out;
 350         id->p_uf_chain = filter_chain_New( p_stream, "video filter2",
 351                                           true,
 352                            transcode_video_filter_allocation_init,
 353                            transcode_video_filter_allocation_clear,
 354                            p_stream->p_sys );
 355         filter_chain_Reset( id->p_uf_chain, &id->p_encoder->fmt_in,
 356                             &id->p_encoder->fmt_in );
 357         filter_chain_AppendFromString( id->p_uf_chain, p_stream->p_sys->psz_vf2 );
 358         p_fmt_out = filter_chain_GetFmtOut( id->p_uf_chain );
 359         es_format_Copy( &id->p_encoder->fmt_in, p_fmt_out );
 360         id->p_encoder->fmt_out.video.i_width =
 361             id->p_encoder->fmt_in.video.i_width;
 362         id->p_encoder->fmt_out.video.i_height =
 363             id->p_encoder->fmt_in.video.i_height;
 364         id->p_encoder->fmt_out.video.i_sar_num =
 365             id->p_encoder->fmt_in.video.i_sar_num;
 366         id->p_encoder->fmt_out.video.i_sar_den =
 367             id->p_encoder->fmt_in.video.i_sar_den;
 368     }
 369
 370 }
 371
 372 /* Take care of the scaling and chroma conversions.
 373  *
 374  * XXX: Shouldn't this really be after p_uf_chain, not p_f_chain,
 375  * in case p_uf_chain changes the format?
 376  */
 377 static void conversion_video_filter_append( sout_stream_id_t *id )
 378 {
 379     const es_format_t *p_fmt_out = &id->p_decoder->fmt_out;
 380     if( id->p_f_chain )
 381         p_fmt_out = filter_chain_GetFmtOut( id->p_f_chain );
 382
 383     if( ( p_fmt_out->video.i_chroma != id->p_encoder->fmt_in.video.i_chroma ) ||
 384         ( p_fmt_out->video.i_width != id->p_encoder->fmt_in.video.i_width ) ||
 385         ( p_fmt_out->video.i_height != id->p_encoder->fmt_in.video.i_height ) )
 386     {
 387         filter_chain_AppendFilter( id->p_f_chain,
 388                                    NULL, NULL,
 389                                    p_fmt_out,
 390                                    &id->p_encoder->fmt_in );
 391     }
 392 }
 393
 394 static void transcode_video_encoder_init( sout_stream_t *p_stream,
 395                                           sout_stream_id_t *id )
 396 {
 397     sout_stream_sys_t *p_sys = p_stream->p_sys;
 398
 399     const es_format_t *p_fmt_out = &id->p_decoder->fmt_out;
 400     if( id->p_f_chain ) {
 401         p_fmt_out = filter_chain_GetFmtOut( id->p_f_chain );
 402     }
 403     if( id->p_uf_chain ) {
 404         p_fmt_out = filter_chain_GetFmtOut( id->p_uf_chain );
 405     }
 406
 407     /* Calculate scaling
 408      * width/height of source */
 409     int i_src_width = p_fmt_out->video.i_width;
 410     int i_src_height = p_fmt_out->video.i_height;
 411
 412     /* with/height scaling */
 413     float f_scale_width = 1;
 414     float f_scale_height = 1;
 415
 416     /* width/height of output stream */
 417     int i_dst_width;
 418     int i_dst_height;
 419
 420     /* aspect ratio */
 421     float f_aspect = (double)p_fmt_out->video.i_sar_num *
 422                      p_fmt_out->video.i_width /
 423                      p_fmt_out->video.i_sar_den /
 424                      p_fmt_out->video.i_height;
 425
 426     msg_Dbg( p_stream, "decoder aspect is %f:1", f_aspect );
 427
 428     /* Change f_aspect from source frame to source pixel */
 429     f_aspect = f_aspect * i_src_height / i_src_width;
 430     msg_Dbg( p_stream, "source pixel aspect is %f:1", f_aspect );
 431
 432     /* Calculate scaling factor for specified parameters */
 433     if( id->p_encoder->fmt_out.video.i_width <= 0 &&
 434         id->p_encoder->fmt_out.video.i_height <= 0 && p_sys->f_scale )
 435     {
 436         /* Global scaling. Make sure width will remain a factor of 16 */
 437         float f_real_scale;
 438         int  i_new_height;
 439         int i_new_width = i_src_width * p_sys->f_scale;
 440
 441         if( i_new_width % 16 <= 7 && i_new_width >= 16 )
 442             i_new_width -= i_new_width % 16;
 443         else
 444             i_new_width += 16 - i_new_width % 16;
 445
 446         f_real_scale = (float)( i_new_width ) / (float) i_src_width;
 447
 448         i_new_height = __MAX( 16, i_src_height * (float)f_real_scale );
 449
 450         f_scale_width = f_real_scale;
 451         f_scale_height = (float) i_new_height / (float) i_src_height;
 452     }
 453     else if( id->p_encoder->fmt_out.video.i_width > 0 &&
 454              id->p_encoder->fmt_out.video.i_height <= 0 )
 455     {
 456         /* Only width specified */
 457         f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width;
 458         f_scale_height = f_scale_width;
 459     }
 460     else if( id->p_encoder->fmt_out.video.i_width <= 0 &&
 461              id->p_encoder->fmt_out.video.i_height > 0 )
 462     {
 463          /* Only height specified */
 464          f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height;
 465          f_scale_width = f_scale_height;
 466      }
 467      else if( id->p_encoder->fmt_out.video.i_width > 0 &&
 468               id->p_encoder->fmt_out.video.i_height > 0 )
 469      {
 470          /* Width and height specified */
 471          f_scale_width = (float)id->p_encoder->fmt_out.video.i_width/i_src_width;
 472          f_scale_height = (float)id->p_encoder->fmt_out.video.i_height/i_src_height;
 473      }
 474
 475      /* check maxwidth and maxheight */
 476      if( p_sys->i_maxwidth && f_scale_width > (float)p_sys->i_maxwidth /
 477                                                      i_src_width )
 478      {
 479          f_scale_width = (float)p_sys->i_maxwidth / i_src_width;
 480      }
 481
 482      if( p_sys->i_maxheight && f_scale_height > (float)p_sys->i_maxheight /
 483                                                        i_src_height )
 484      {
 485          f_scale_height = (float)p_sys->i_maxheight / i_src_height;
 486      }
 487
 488
 489      /* Change aspect ratio from source pixel to scaled pixel */
 490      f_aspect = f_aspect * f_scale_height / f_scale_width;
 491      msg_Dbg( p_stream, "scaled pixel aspect is %f:1", f_aspect );
 492
 493      /* f_scale_width and f_scale_height are now final */
 494      /* Calculate width, height from scaling
 495       * Make sure its multiple of 2
 496       */
 497      i_dst_width =  2 * (int)(f_scale_width*i_src_width/2+0.5);
 498      i_dst_height = 2 * (int)(f_scale_height*i_src_height/2+0.5);
 499
 500      /* Change aspect ratio from scaled pixel to output frame */
 501      f_aspect = f_aspect * i_dst_width / i_dst_height;
 502
 503      /* Store calculated values */
 504      id->p_encoder->fmt_out.video.i_width =
 505      id->p_encoder->fmt_out.video.i_visible_width = i_dst_width;
 506      id->p_encoder->fmt_out.video.i_height =
 507      id->p_encoder->fmt_out.video.i_visible_height = i_dst_height;
 508
 509      id->p_encoder->fmt_in.video.i_width =
 510      id->p_encoder->fmt_in.video.i_visible_width = i_dst_width;
 511      id->p_encoder->fmt_in.video.i_height =
 512      id->p_encoder->fmt_in.video.i_visible_height = i_dst_height;
 513
 514      msg_Dbg( p_stream, "source %ix%i, destination %ix%i",
 515          i_src_width, i_src_height,
 516          i_dst_width, i_dst_height
 517      );
 518
 519     /* Handle frame rate conversion */
 520     if( !id->p_encoder->fmt_out.video.i_frame_rate ||
 521         !id->p_encoder->fmt_out.video.i_frame_rate_base )
 522     {
 523         if( p_fmt_out->video.i_frame_rate &&
 524             p_fmt_out->video.i_frame_rate_base )
 525         {
 526             id->p_encoder->fmt_out.video.i_frame_rate =
 527                 p_fmt_out->video.i_frame_rate;
 528             id->p_encoder->fmt_out.video.i_frame_rate_base =
 529                 p_fmt_out->video.i_frame_rate_base;
 530         }
 531         else
 532         {
 533             /* Pick a sensible default value */
 534             id->p_encoder->fmt_out.video.i_frame_rate = ENC_FRAMERATE;
 535             id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 536         }
 537     }
 538
 539     id->p_encoder->fmt_in.video.i_frame_rate =
 540         id->p_encoder->fmt_out.video.i_frame_rate;
 541     id->p_encoder->fmt_in.video.i_frame_rate_base =
 542         id->p_encoder->fmt_out.video.i_frame_rate_base;
 543
 544     date_Init( &id->interpolated_pts,
 545                id->p_encoder->fmt_out.video.i_frame_rate,
 546                id->p_encoder->fmt_out.video.i_frame_rate_base );
 547
 548     /* Check whether a particular aspect ratio was requested */
 549     if( id->p_encoder->fmt_out.video.i_sar_num <= 0 ||
 550         id->p_encoder->fmt_out.video.i_sar_den <= 0 )
 551     {
 552         vlc_ureduce( &id->p_encoder->fmt_out.video.i_sar_num,
 553                      &id->p_encoder->fmt_out.video.i_sar_den,
 554                      (uint64_t)p_fmt_out->video.i_sar_num * i_src_width  * i_dst_height,
 555                      (uint64_t)p_fmt_out->video.i_sar_den * i_src_height * i_dst_width,
 556                      0 );
 557     }
 558     else
 559     {
 560         vlc_ureduce( &id->p_encoder->fmt_out.video.i_sar_num,
 561                      &id->p_encoder->fmt_out.video.i_sar_den,
 562                      id->p_encoder->fmt_out.video.i_sar_num,
 563                      id->p_encoder->fmt_out.video.i_sar_den,
 564                      0 );
 565     }
 566
 567     id->p_encoder->fmt_in.video.i_sar_num =
 568         id->p_encoder->fmt_out.video.i_sar_num;
 569     id->p_encoder->fmt_in.video.i_sar_den =
 570         id->p_encoder->fmt_out.video.i_sar_den;
 571
 572     msg_Dbg( p_stream, "encoder aspect is %i:%i",
 573              id->p_encoder->fmt_out.video.i_sar_num * id->p_encoder->fmt_out.video.i_width,
 574              id->p_encoder->fmt_out.video.i_sar_den * id->p_encoder->fmt_out.video.i_height );
 575
 576     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 577 }
 578
 579 static int transcode_video_encoder_open( sout_stream_t *p_stream,
 580                                          sout_stream_id_t *id )
 581 {
 582     sout_stream_sys_t *p_sys = p_stream->p_sys;
 583
 584
 585     msg_Dbg( p_stream, "destination (after video filters) %ix%i",
 586              id->p_encoder->fmt_in.video.i_width,
 587              id->p_encoder->fmt_in.video.i_height );
 588
 589     id->p_encoder->p_module =
 590         module_need( id->p_encoder, "encoder", p_sys->psz_venc, true );
 591     if( !id->p_encoder->p_module )
 592     {
 593         msg_Err( p_stream, "cannot find video encoder (module:%s fourcc:%4.4s)",
 594                  p_sys->psz_venc ? p_sys->psz_venc : "any",
 595                  (char *)&p_sys->i_vcodec );
 596         return VLC_EGENERIC;
 597     }
 598
 599     id->p_encoder->fmt_in.video.i_chroma = id->p_encoder->fmt_in.i_codec;
 600
 601     /*  */
 602     id->p_encoder->fmt_out.i_codec =
 603         vlc_fourcc_GetCodec( VIDEO_ES, id->p_encoder->fmt_out.i_codec );
 604
 605     id->id = sout_StreamIdAdd( p_stream->p_next, &id->p_encoder->fmt_out );
 606     if( !id->id )
 607     {
 608         msg_Err( p_stream, "cannot add this stream" );
 609         return VLC_EGENERIC;
 610     }
 611
 612     return VLC_SUCCESS;
 613 }
 614
 615 void transcode_video_close( sout_stream_t *p_stream,
 616                                    sout_stream_id_t *id )
 617 {
 618     if( p_stream->p_sys->i_threads >= 1 )
 619     {
 620         vlc_mutex_lock( &p_stream->p_sys->lock_out );
 621         p_stream->p_sys->b_abort = true;
 622         vlc_cond_signal( &p_stream->p_sys->cond );
 623         vlc_mutex_unlock( &p_stream->p_sys->lock_out );
 624
 625         vlc_join( p_stream->p_sys->thread, NULL );
 626         vlc_mutex_destroy( &p_stream->p_sys->lock_out );
 627         vlc_cond_destroy( &p_stream->p_sys->cond );
 628
 629         picture_fifo_Delete( p_stream->p_sys->pp_pics );
 630         p_stream->p_sys->pp_pics = NULL;
 631     }
 632
 633     /* Close decoder */
 634     if( id->p_decoder->p_module )
 635         module_unneed( id->p_decoder, id->p_decoder->p_module );
 636     if( id->p_decoder->p_description )
 637         vlc_meta_Delete( id->p_decoder->p_description );
 638
 639     free( id->p_decoder->p_owner );
 640
 641     /* Close encoder */
 642     if( id->p_encoder->p_module )
 643         module_unneed( id->p_encoder, id->p_encoder->p_module );
 644
 645     /* Close filters */
 646     if( id->p_f_chain )
 647         filter_chain_Delete( id->p_f_chain );
 648     if( id->p_uf_chain )
 649         filter_chain_Delete( id->p_uf_chain );
 650 }
 651
 652 static void OutputFrame( sout_stream_sys_t *p_sys, picture_t *p_pic, bool b_need_duplicate, sout_stream_t *p_stream, sout_stream_id_t *id, block_t **out )
 653 {
 654     picture_t *p_pic2 = NULL;
 655
 656     /*
 657      * Encoding
 658      */
 659
 660     /* Check if we have a subpicture to overlay */
 661     if( p_sys->p_spu )
 662     {
 663         video_format_t fmt = id->p_encoder->fmt_in.video;
 664         if( fmt.i_visible_width <= 0 || fmt.i_visible_height <= 0 )
 665         {
 666             fmt.i_visible_width  = fmt.i_width;
 667             fmt.i_visible_height = fmt.i_height;
 668             fmt.i_x_offset       = 0;
 669             fmt.i_y_offset       = 0;
 670         }
 671
 672         subpicture_t *p_subpic = spu_Render( p_sys->p_spu, NULL, &fmt, &fmt,
 673                                              p_pic->date, p_pic->date, false );
 674
 675         /* Overlay subpicture */
 676         if( p_subpic )
 677         {
 678             if( picture_IsReferenced( p_pic ) && !filter_chain_GetLength( id->p_f_chain ) )
 679             {
 680                 /* We can't modify the picture, we need to duplicate it,
 681                  * in this point the picture is already p_encoder->fmt.in format*/
 682                 picture_t *p_tmp = video_new_buffer_encoder( id->p_encoder );
 683                 if( likely( p_tmp ) )
 684                 {
 685                     picture_Copy( p_tmp, p_pic );
 686                     picture_Release( p_pic );
 687                     p_pic = p_tmp;
 688                 }
 689             }
 690             if( unlikely( !p_sys->p_spu_blend ) )
 691                 p_sys->p_spu_blend = filter_NewBlend( VLC_OBJECT( p_sys->p_spu ), &fmt );
 692             if( likely( p_sys->p_spu_blend ) )
 693                 picture_BlendSubpicture( p_pic, p_sys->p_spu_blend, p_subpic );
 694             subpicture_Delete( p_subpic );
 695         }
 696     }
 697
 698     if( p_sys->i_threads == 0 )
 699     {
 700         block_t *p_block;
 701
 702         p_block = id->p_encoder->pf_encode_video( id->p_encoder, p_pic );
 703         block_ChainAppend( out, p_block );
 704     }
 705
 706     if( p_sys->b_master_sync )
 707     {
 708         mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 709         mtime_t i_video_drift = p_pic->date - i_pts;
 710         if (unlikely ( i_video_drift  > MASTER_SYNC_MAX_DRIFT
 711               || i_video_drift < -MASTER_SYNC_MAX_DRIFT ) )
 712         {
 713             msg_Dbg( p_stream,
 714                 "drift is too high (%"PRId64"), resetting master sync",
 715                 i_video_drift );
 716             date_Set( &id->interpolated_pts, p_pic->date );
 717             i_pts = p_pic->date + 1;
 718         }
 719         date_Increment( &id->interpolated_pts, 1 );
 720
 721         if( unlikely( b_need_duplicate ) )
 722         {
 723
 724            if( p_sys->i_threads >= 1 )
 725            {
 726                /* We can't modify the picture, we need to duplicate it */
 727                p_pic2 = video_new_buffer_encoder( id->p_encoder );
 728                if( likely( p_pic2 != NULL ) )
 729                {
 730                    picture_Copy( p_pic2, p_pic );
 731                    p_pic2->date = i_pts;
 732                }
 733            }
 734            else
 735            {
 736                block_t *p_block;
 737                p_pic->date = i_pts;
 738                p_block = id->p_encoder->pf_encode_video(id->p_encoder, p_pic);
 739                block_ChainAppend( out, p_block );
 740            }
 741        }
 742     }
 743
 744     if( p_sys->i_threads == 0 )
 745     {
 746         picture_Release( p_pic );
 747     }
 748     else
 749     {
 750         vlc_mutex_lock( &p_sys->lock_out );
 751         picture_fifo_Push( p_sys->pp_pics, p_pic );
 752         if( p_pic2 != NULL )
 753         {
 754             picture_fifo_Push( p_sys->pp_pics, p_pic2 );
 755         }
 756         vlc_cond_signal( &p_sys->cond );
 757         vlc_mutex_unlock( &p_sys->lock_out );
 758     }
 759 }
 760
 761 int transcode_video_process( sout_stream_t *p_stream, sout_stream_id_t *id,
 762                                     block_t *in, block_t **out )
 763 {
 764     sout_stream_sys_t *p_sys = p_stream->p_sys;
 765     bool b_need_duplicate = false;
 766     picture_t *p_pic;
 767     *out = NULL;
 768
 769     if( unlikely( in == NULL ) )
 770     {
 771         if( p_sys->i_threads == 0 )
 772         {
 773             block_t *p_block;
 774             do {
 775                 p_block = id->p_encoder->pf_encode_video(id->p_encoder, NULL );
 776                 block_ChainAppend( out, p_block );
 777             } while( p_block );
 778         }
 779         else
 780         {
 781             /*
 782              * FIXME: we need EncoderThread() to flush buffers and signal us
 783              * when it's done so we can send the last frames to the chain
 784              */
 785         }
 786         return VLC_SUCCESS;
 787     }
 788
 789
 790     while( (p_pic = id->p_decoder->pf_decode_video( id->p_decoder, &in )) )
 791     {
 792
 793         if( p_stream->p_sout->i_out_pace_nocontrol && p_sys->b_hurry_up )
 794         {
 795             mtime_t current_date = mdate();
 796             if( unlikely( current_date + 50000 > p_pic->date ) )
 797             {
 798                 msg_Dbg( p_stream, "late picture skipped (%"PRId64")",
 799                          current_date + 50000 - p_pic->date );
 800                 picture_Release( p_pic );
 801                 continue;
 802             }
 803         }
 804
 805         if( p_sys->b_master_sync )
 806         {
 807             mtime_t i_master_drift = p_sys->i_master_drift;
 808             mtime_t i_pts = date_Get( &id->interpolated_pts ) + 1;
 809             mtime_t i_video_drift = p_pic->date - i_pts;
 810
 811             if ( unlikely( i_video_drift > MASTER_SYNC_MAX_DRIFT
 812                   || i_video_drift < -MASTER_SYNC_MAX_DRIFT ) )
 813             {
 814                 msg_Dbg( p_stream,
 815                     "drift is too high (%"PRId64", resetting master sync",
 816                     i_video_drift );
 817                 date_Set( &id->interpolated_pts, p_pic->date );
 818                 i_pts = p_pic->date + 1;
 819             }
 820             i_video_drift = p_pic->date - i_pts;
 821             b_need_duplicate = false;
 822
 823             /* Set the pts of the frame being encoded */
 824             p_pic->date = i_pts;
 825
 826             if( unlikely( i_video_drift < (i_master_drift - 50000) ) )
 827             {
 828 #if 0
 829                 msg_Dbg( p_stream, "dropping frame (%i)",
 830                          (int)(i_video_drift - i_master_drift) );
 831 #endif
 832                 picture_Release( p_pic );
 833                 continue;
 834             }
 835             else if( unlikely( i_video_drift > (i_master_drift + 50000) ) )
 836             {
 837 #if 0
 838                 msg_Dbg( p_stream, "adding frame (%i)",
 839                          (int)(i_video_drift - i_master_drift) );
 840 #endif
 841                 b_need_duplicate = true;
 842             }
 843         }
 844         if( unlikely (
 845              id->p_encoder->p_module &&
 846              !video_format_IsSimilar( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video )
 847             )
 848           )
 849         {
 850             msg_Info( p_stream, "aspect-ratio changed, reiniting. %i -> %i : %i -> %i.",
 851                         p_sys->fmt_input_video.i_sar_num, id->p_decoder->fmt_out.video.i_sar_num,
 852                         p_sys->fmt_input_video.i_sar_den, id->p_decoder->fmt_out.video.i_sar_den
 853                     );
 854             /* Close filters */
 855             if( id->p_f_chain )
 856                 filter_chain_Delete( id->p_f_chain );
 857             id->p_f_chain = NULL;
 858             if( id->p_uf_chain )
 859                 filter_chain_Delete( id->p_uf_chain );
 860             id->p_uf_chain = NULL;
 861
 862             /* Reinitialize filters */
 863             id->p_encoder->fmt_out.video.i_width  = p_sys->i_width & ~1;
 864             id->p_encoder->fmt_out.video.i_height = p_sys->i_height & ~1;
 865             id->p_encoder->fmt_out.video.i_sar_num = id->p_encoder->fmt_out.video.i_sar_den = 0;
 866
 867             transcode_video_filter_init( p_stream, id );
 868             transcode_video_encoder_init( p_stream, id );
 869             conversion_video_filter_append( id );
 870             memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
 871         }
 872
 873
 874         if( unlikely( !id->p_encoder->p_module ) )
 875         {
 876             if( id->p_f_chain )
 877                 filter_chain_Delete( id->p_f_chain );
 878             if( id->p_uf_chain )
 879                 filter_chain_Delete( id->p_uf_chain );
 880             id->p_f_chain = id->p_uf_chain = NULL;
 881
 882             transcode_video_filter_init( p_stream, id );
 883             transcode_video_encoder_init( p_stream, id );
 884             conversion_video_filter_append( id );
 885             memcpy( &p_sys->fmt_input_video, &id->p_decoder->fmt_out.video, sizeof(video_format_t));
 886
 887             if( transcode_video_encoder_open( p_stream, id ) != VLC_SUCCESS )
 888             {
 889                 picture_Release( p_pic );
 890                 transcode_video_close( p_stream, id );
 891                 id->b_transcode = false;
 892                 return VLC_EGENERIC;
 893             }
 894         }
 895
 896         /* Run the filter and output chains; first with the picture,
 897          * and then with NULL as many times as we need until they
 898          * stop outputting frames.
 899          */
 900         for ( ;; ) {
 901             picture_t *p_filtered_pic = p_pic;
 902
 903             /* Run filter chain */
 904             if( id->p_f_chain )
 905                 p_filtered_pic = filter_chain_VideoFilter( id->p_f_chain, p_filtered_pic );
 906             if( !p_filtered_pic )
 907                 break;
 908
 909             for ( ;; ) {
 910                 picture_t *p_user_filtered_pic = p_filtered_pic;
 911
 912                 /* Run user specified filter chain */
 913                 if( id->p_uf_chain )
 914                     p_user_filtered_pic = filter_chain_VideoFilter( id->p_uf_chain, p_user_filtered_pic );
 915                 if( !p_user_filtered_pic )
 916                     break;
 917
 918                 OutputFrame( p_sys, p_user_filtered_pic, b_need_duplicate, p_stream, id, out );
 919                 b_need_duplicate = false;
 920
 921                 p_filtered_pic = NULL;
 922             }
 923
 924             p_pic = NULL;
 925         }
 926     }
 927
 928     if( p_sys->i_threads >= 1 )
 929     {
 930         /* Pick up any return data the encoder thread wants to output. */
 931         vlc_mutex_lock( &p_sys->lock_out );
 932         *out = p_sys->p_buffers;
 933         p_sys->p_buffers = NULL;
 934         vlc_mutex_unlock( &p_sys->lock_out );
 935     }
 936
 937     return VLC_SUCCESS;
 938 }
 939
 940 bool transcode_video_add( sout_stream_t *p_stream, es_format_t *p_fmt,
 941                                 sout_stream_id_t *id )
 942 {
 943     sout_stream_sys_t *p_sys = p_stream->p_sys;
 944
 945     msg_Dbg( p_stream,
 946              "creating video transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
 947              (char*)&p_fmt->i_codec, (char*)&p_sys->i_vcodec );
 948
 949     /* Complete destination format */
 950     id->p_encoder->fmt_out.i_codec = p_sys->i_vcodec;
 951     id->p_encoder->fmt_out.video.i_width  = p_sys->i_width & ~1;
 952     id->p_encoder->fmt_out.video.i_height = p_sys->i_height & ~1;
 953     id->p_encoder->fmt_out.i_bitrate = p_sys->i_vbitrate;
 954
 955     /* Build decoder -> filter -> encoder chain */
 956     if( transcode_video_new( p_stream, id ) )
 957     {
 958         msg_Err( p_stream, "cannot create video chain" );
 959         return false;
 960     }
 961
 962     /* Stream will be added later on because we don't know
 963      * all the characteristics of the decoded stream yet */
 964     id->b_transcode = true;
 965
 966     if( p_sys->f_fps > 0 )
 967     {
 968         id->p_encoder->fmt_out.video.i_frame_rate = (p_sys->f_fps * ENC_FRAMERATE_BASE);
 969         id->p_encoder->fmt_out.video.i_frame_rate_base = ENC_FRAMERATE_BASE;
 970     }
 971
 972     return true;
 973 }
 974