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

   1 /*****************************************************************************
   2  * transcode.c: transcoding stream output module
   3  *****************************************************************************
   4  * Copyright (C) 2003-2004 VideoLAN
   5  * $Id: transcode.c,v 1.74 2004/02/12 23:51:15 gbazin Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Gildas Bazin <gbazin@netcourrier.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include <vlc/vlc.h>
  32 #include <vlc/input.h>
  33 #include <vlc/sout.h>
  34 #include <vlc/vout.h>
  35 #include <vlc/decoder.h>
  36
  37 /* ffmpeg header */
  38 #ifdef HAVE_FFMPEG_AVCODEC_H
  39 #   include <ffmpeg/avcodec.h>
  40 #else
  41 #   include <avcodec.h>
  42 #endif
  43
  44 /*****************************************************************************
  45  * Exported prototypes
  46  *****************************************************************************/
  47 static int      Open    ( vlc_object_t * );
  48 static void     Close   ( vlc_object_t * );
  49
  50 static sout_stream_id_t *Add ( sout_stream_t *, es_format_t * );
  51 static int               Del ( sout_stream_t *, sout_stream_id_t * );
  52 static int               Send( sout_stream_t *, sout_stream_id_t *, sout_buffer_t* );
  53
  54 static int  transcode_audio_ffmpeg_new    ( sout_stream_t *, sout_stream_id_t * );
  55 static void transcode_audio_ffmpeg_close  ( sout_stream_t *, sout_stream_id_t * );
  56 static int  transcode_audio_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, sout_buffer_t *, sout_buffer_t ** );
  57
  58 static int  transcode_video_ffmpeg_new    ( sout_stream_t *, sout_stream_id_t * );
  59 static void transcode_video_ffmpeg_close  ( sout_stream_t *, sout_stream_id_t * );
  60 static int  transcode_video_ffmpeg_process( sout_stream_t *, sout_stream_id_t *, sout_buffer_t *, sout_buffer_t ** );
  61
  62 static int  transcode_video_ffmpeg_getframebuf( struct AVCodecContext *, AVFrame *);
  63
  64 static int pi_channels_maps[6] =
  65 {
  66     0,
  67     AOUT_CHAN_CENTER,   AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  68     AOUT_CHAN_CENTER | AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT,
  69     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_REARLEFT
  70      | AOUT_CHAN_REARRIGHT,
  71     AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
  72      | AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
  73 };
  74
  75 /*****************************************************************************
  76  * Module descriptor
  77  *****************************************************************************/
  78 vlc_module_begin();
  79     set_description( _("Transcode stream output") );
  80     set_capability( "sout stream", 50 );
  81     add_shortcut( "transcode" );
  82     set_callbacks( Open, Close );
  83 vlc_module_end();
  84
  85 struct sout_stream_sys_t
  86 {
  87     sout_stream_t   *p_out;
  88
  89     vlc_fourcc_t    i_acodec;   /* codec audio (0 if not transcode) */
  90     int             i_sample_rate;
  91     int             i_channels;
  92     int             i_abitrate;
  93
  94     vlc_fourcc_t    i_vcodec;   /*    "   video  " "   "      " */
  95     int             i_vbitrate;
  96     int             i_vtolerance;
  97     double          f_scale;
  98     int             i_width;
  99     int             i_height;
 100     int             i_b_frames;
 101     int             i_key_int;
 102     int             i_qmin;
 103     int             i_qmax;
 104     vlc_bool_t      i_hq;
 105     vlc_bool_t      b_deinterlace;
 106     vlc_bool_t      b_strict_rc;
 107     vlc_bool_t      b_pre_me;
 108     vlc_bool_t      b_hurry_up;
 109
 110     int             i_crop_top;
 111     int             i_crop_bottom;
 112     int             i_crop_right;
 113     int             i_crop_left;
 114
 115     mtime_t         i_input_pts;
 116     mtime_t         i_output_pts;
 117 };
 118
 119 /*****************************************************************************
 120  * Open:
 121  *****************************************************************************/
 122 static int Open( vlc_object_t *p_this )
 123 {
 124     sout_stream_t     *p_stream = (sout_stream_t*)p_this;
 125     sout_stream_sys_t *p_sys;
 126     char *codec;
 127
 128     p_sys = malloc( sizeof( sout_stream_sys_t ) );
 129     memset( p_sys, 0, sizeof(struct sout_stream_sys_t) );
 130     p_sys->p_out = sout_stream_new( p_stream->p_sout, p_stream->psz_next );
 131
 132     p_sys->f_scale      = 1;
 133     p_sys->i_vtolerance = -1;
 134     p_sys->i_key_int    = -1;
 135     p_sys->i_qmin       = 2;
 136     p_sys->i_qmax       = 31;
 137 #if LIBAVCODEC_BUILD >= 4673
 138     p_sys->i_hq         = FF_MB_DECISION_SIMPLE;
 139 #else
 140     p_sys->i_hq         = VLC_FALSE;
 141 #endif
 142
 143     if( ( codec = sout_cfg_find_value( p_stream->p_cfg, "acodec" ) ) )
 144     {
 145         char fcc[4] = "    ";
 146         char *val;
 147
 148         memcpy( fcc, codec, __MIN( strlen( codec ), 4 ) );
 149
 150         p_sys->i_acodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
 151
 152         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "samplerate" ) ) )
 153         {
 154             p_sys->i_sample_rate = atoi( val );
 155         }
 156         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "channels" ) ) )
 157         {
 158             p_sys->i_channels = atoi( val );
 159         }
 160         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "ab" ) ) )
 161         {
 162             p_sys->i_abitrate = atoi( val );
 163             if( p_sys->i_abitrate < 4000 )
 164             {
 165                 p_sys->i_abitrate *= 1000;
 166             }
 167         }
 168
 169         msg_Dbg( p_stream, "codec audio=%4.4s %dHz %d channels %dKb/s", fcc,
 170                  p_sys->i_sample_rate, p_sys->i_channels,
 171                  p_sys->i_abitrate / 1024 );
 172     }
 173
 174     if( ( codec = sout_cfg_find_value( p_stream->p_cfg, "vcodec" ) ) )
 175     {
 176         char fcc[4] = "    ";
 177         char *val;
 178
 179         memcpy( fcc, codec, __MIN( strlen( codec ), 4 ) );
 180
 181         p_sys->i_vcodec = VLC_FOURCC( fcc[0], fcc[1], fcc[2], fcc[3] );
 182
 183         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "scale" ) ) )
 184         {
 185             p_sys->f_scale = atof( val );
 186         }
 187         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "width" ) ) )
 188         {
 189             p_sys->i_width = atoi( val );
 190         }
 191         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "height" ) ) )
 192         {
 193             p_sys->i_height = atoi( val );
 194         }
 195         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "vb" ) ) )
 196         {
 197             p_sys->i_vbitrate = atoi( val );
 198             if( p_sys->i_vbitrate < 16000 )
 199             {
 200                 p_sys->i_vbitrate *= 1000;
 201             }
 202         }
 203         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "vt" ) ) )
 204         {
 205             p_sys->i_vtolerance = atoi( val );
 206         }
 207         if( sout_cfg_find( p_stream->p_cfg, "deinterlace" ) )
 208         {
 209             p_sys->b_deinterlace = VLC_TRUE;
 210         }
 211         if( sout_cfg_find( p_stream->p_cfg, "strict_rc" ) )
 212         {
 213             p_sys->b_strict_rc = VLC_TRUE;
 214         }
 215         if( sout_cfg_find( p_stream->p_cfg, "pre_me" ) )
 216         {
 217             p_sys->b_pre_me = VLC_TRUE;
 218         }
 219         if( sout_cfg_find( p_stream->p_cfg, "hurry_up" ) )
 220         {
 221             p_sys->b_hurry_up = VLC_TRUE;
 222         }
 223         /* crop */
 224         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "croptop" ) ) )
 225         {
 226             p_sys->i_crop_top = atoi( val );
 227         }
 228         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropbottom" ) ) )
 229         {
 230             p_sys->i_crop_bottom = atoi( val );
 231         }
 232         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropleft" ) ) )
 233         {
 234             p_sys->i_crop_left = atoi( val );
 235         }
 236         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "cropright" ) ) )
 237         {
 238             p_sys->i_crop_right = atoi( val );
 239         }
 240         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "keyint" ) ) )
 241         {
 242             p_sys->i_key_int    = atoi( val );
 243         }
 244         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "bframes" ) ) )
 245         {
 246             p_sys->i_b_frames   = atoi( val );
 247         }
 248 #if LIBAVCODEC_BUILD >= 4673
 249         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "hq" ) ) )
 250         {
 251             if( !strcmp( val, "rd" ) )
 252             {
 253                 p_sys->i_hq = FF_MB_DECISION_RD;
 254             }
 255             else if( !strcmp( val, "bits" ) )
 256             {
 257                 p_sys->i_hq = FF_MB_DECISION_BITS;
 258             }
 259             else if( !strcmp( val, "simple" ) )
 260             {
 261                 p_sys->i_hq = FF_MB_DECISION_SIMPLE;
 262             }
 263             else
 264             {
 265                 p_sys->i_hq = FF_MB_DECISION_RD;
 266             }
 267         }
 268 #else
 269         if( sout_cfg_find( p_stream->p_cfg, "hq" ) )
 270         {
 271             p_sys->i_hq = VLC_TRUE;
 272         }
 273 #endif
 274         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "qmin" ) ) )
 275         {
 276             p_sys->i_qmin   = atoi( val );
 277         }
 278         if( ( val = sout_cfg_find_value( p_stream->p_cfg, "qmax" ) ) )
 279         {
 280             p_sys->i_qmax   = atoi( val );
 281         }
 282
 283         msg_Dbg( p_stream, "codec video=%4.4s %dx%d scaling: %f %dkb/s",
 284                  fcc, p_sys->i_width, p_sys->i_height, p_sys->f_scale,
 285                  p_sys->i_vbitrate / 1024 );
 286     }
 287
 288     if( !p_sys->p_out )
 289     {
 290         msg_Err( p_stream, "cannot create chain" );
 291         free( p_sys );
 292         return VLC_EGENERIC;
 293     }
 294
 295     p_stream->pf_add    = Add;
 296     p_stream->pf_del    = Del;
 297     p_stream->pf_send   = Send;
 298     p_stream->p_sys     = p_sys;
 299
 300     avcodec_init();
 301     avcodec_register_all();
 302
 303     /* ffmpeg needs some padding at the end of each buffer */
 304     p_stream->p_sout->i_padding += FF_INPUT_BUFFER_PADDING_SIZE;
 305
 306     return VLC_SUCCESS;
 307 }
 308
 309 /*****************************************************************************
 310  * Close:
 311  *****************************************************************************/
 312 static void Close( vlc_object_t * p_this )
 313 {
 314     sout_stream_t       *p_stream = (sout_stream_t*)p_this;
 315     sout_stream_sys_t   *p_sys = p_stream->p_sys;
 316
 317     sout_stream_delete( p_sys->p_out );
 318     free( p_sys );
 319 }
 320
 321 struct sout_stream_id_t
 322 {
 323     vlc_fourcc_t  b_transcode;
 324     es_format_t f_src;        /* only if transcoding */
 325     es_format_t f_dst;        /*  "   "      " */
 326     unsigned int  i_inter_pixfmt; /* intermediary format when transcoding */
 327
 328     /* id of the out stream */
 329     void *id;
 330
 331     /* Encoder */
 332     encoder_t       *p_encoder;
 333     vlc_fourcc_t    b_enc_inited;
 334
 335     /* ffmpeg part */
 336     AVCodec         *ff_dec;
 337     AVCodecContext  *ff_dec_c;
 338
 339     mtime_t         i_dts;
 340     mtime_t         i_length;
 341
 342     int             i_buffer;
 343     int             i_buffer_pos;
 344     uint8_t         *p_buffer;
 345
 346     AVFrame         *p_ff_pic;
 347     AVFrame         *p_ff_pic_tmp0; /* to do deinterlace */
 348     AVFrame         *p_ff_pic_tmp1; /* to do pix conversion */
 349     AVFrame         *p_ff_pic_tmp2; /* to do resample */
 350
 351     ImgReSampleContext *p_vresample;
 352 };
 353
 354
 355 static sout_stream_id_t * Add( sout_stream_t *p_stream, es_format_t *p_fmt )
 356 {
 357     sout_stream_sys_t   *p_sys = p_stream->p_sys;
 358     sout_stream_id_t    *id;
 359
 360     id = malloc( sizeof( sout_stream_id_t ) );
 361     id->i_dts = 0;
 362     id->id = NULL;
 363     id->p_encoder = NULL;
 364
 365     if( p_fmt->i_cat == AUDIO_ES && p_sys->i_acodec != 0 )
 366     {
 367         msg_Dbg( p_stream,
 368                  "creating audio transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
 369                  (char*)&p_fmt->i_codec,
 370                  (char*)&p_sys->i_acodec );
 371
 372         /* src format */
 373         memcpy( &id->f_src, p_fmt, sizeof( es_format_t ) );
 374
 375         /* create dst format */
 376         es_format_Init( &id->f_dst, AUDIO_ES, p_sys->i_acodec );
 377         id->f_dst.i_id    = id->f_src.i_id;
 378         id->f_dst.i_group = id->f_src.i_group;
 379         if( id->f_src.psz_language ) id->f_dst.psz_language = strdup( id->f_src.psz_language );
 380         id->f_dst.audio.i_rate = p_sys->i_sample_rate  > 0 ? p_sys->i_sample_rate : id->f_src.audio.i_rate;
 381         id->f_dst.audio.i_channels    = p_sys->i_channels > 0 ? p_sys->i_channels : id->f_src.audio.i_channels;
 382         id->f_dst.i_bitrate     = p_sys->i_abitrate > 0 ? p_sys->i_abitrate : 64000;
 383         id->f_dst.audio.i_blockalign = 0;
 384         id->f_dst.i_extra  = 0;
 385         id->f_dst.p_extra  = NULL;
 386
 387         /* build decoder -> filter -> encoder */
 388         if( transcode_audio_ffmpeg_new( p_stream, id ) )
 389         {
 390             msg_Err( p_stream, "cannot create audio chain" );
 391             free( id );
 392             return NULL;
 393         }
 394
 395         /* open output stream */
 396         id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
 397         id->b_transcode = VLC_TRUE;
 398
 399         if( id->id == NULL )
 400         {
 401             free( id );
 402             return NULL;
 403         }
 404     }
 405     else if( p_fmt->i_cat == VIDEO_ES && p_sys->i_vcodec != 0 )
 406     {
 407         msg_Dbg( p_stream,
 408                  "creating video transcoding from fcc=`%4.4s' to fcc=`%4.4s'",
 409                  (char*)&p_fmt->i_codec,
 410                  (char*)&p_sys->i_vcodec );
 411
 412         memcpy( &id->f_src, p_fmt, sizeof( es_format_t ) );
 413
 414         /* create dst format */
 415         es_format_Init( &id->f_dst, VIDEO_ES, p_sys->i_vcodec );
 416         id->f_dst.i_id    = id->f_src.i_id;
 417         id->f_dst.i_group = id->f_src.i_group;
 418         if( id->f_src.psz_language ) id->f_dst.psz_language = strdup( id->f_src.psz_language );
 419         id->f_dst.video.i_width = p_sys->i_width;
 420         id->f_dst.video.i_height= p_sys->i_height;
 421         id->f_dst.i_bitrate     = p_sys->i_vbitrate > 0 ? p_sys->i_vbitrate : 800*1000;
 422         id->f_dst.i_extra       = 0;
 423         id->f_dst.p_extra       = NULL;
 424
 425         /* build decoder -> filter -> encoder */
 426         if( transcode_video_ffmpeg_new( p_stream, id ) )
 427         {
 428             msg_Err( p_stream, "cannot create video chain" );
 429             free( id );
 430             return NULL;
 431         }
 432 #if 0
 433         /* open output stream */
 434         id->id = p_sys->p_out->pf_add( p_sys->p_out, &id->f_dst );
 435 #endif
 436         id->b_transcode = VLC_TRUE;
 437     }
 438     else
 439     {
 440         msg_Dbg( p_stream, "not transcoding a stream (fcc=`%4.4s')", (char*)&p_fmt->i_codec );
 441         id->id = p_sys->p_out->pf_add( p_sys->p_out, p_fmt );
 442         id->b_transcode = VLC_FALSE;
 443
 444         if( id->id == NULL )
 445         {
 446             free( id );
 447             return NULL;
 448         }
 449     }
 450
 451     return id;
 452 }
 453
 454 static int     Del      ( sout_stream_t *p_stream, sout_stream_id_t *id )
 455 {
 456     sout_stream_sys_t   *p_sys = p_stream->p_sys;
 457
 458     if( id->b_transcode )
 459     {
 460         if( id->f_src.i_cat == AUDIO_ES )
 461         {
 462             transcode_audio_ffmpeg_close( p_stream, id );
 463         }
 464         else if( id->f_src.i_cat == VIDEO_ES )
 465         {
 466             transcode_video_ffmpeg_close( p_stream, id );
 467         }
 468     }
 469
 470     if( id->id ) p_sys->p_out->pf_del( p_sys->p_out, id->id );
 471     free( id );
 472
 473     return VLC_SUCCESS;
 474 }
 475
 476 static int Send( sout_stream_t *p_stream, sout_stream_id_t *id,
 477                  sout_buffer_t *p_buffer )
 478 {
 479     sout_stream_sys_t   *p_sys = p_stream->p_sys;
 480
 481     if( id->b_transcode )
 482     {
 483         sout_buffer_t *p_buffer_out;
 484         if( id->f_src.i_cat == AUDIO_ES )
 485         {
 486             transcode_audio_ffmpeg_process( p_stream, id, p_buffer,
 487                                             &p_buffer_out );
 488         }
 489         else if( id->f_src.i_cat == VIDEO_ES )
 490         {
 491             if( transcode_video_ffmpeg_process( p_stream, id, p_buffer,
 492                 &p_buffer_out ) != VLC_SUCCESS )
 493             {
 494                 sout_BufferDelete( p_stream->p_sout, p_buffer );
 495                 return VLC_EGENERIC;
 496             }
 497         }
 498         sout_BufferDelete( p_stream->p_sout, p_buffer );
 499
 500         if( p_buffer_out )
 501         {
 502             return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer_out );
 503         }
 504         return VLC_SUCCESS;
 505     }
 506     else if( id->id != NULL )
 507     {
 508         return p_sys->p_out->pf_send( p_sys->p_out, id->id, p_buffer );
 509     }
 510     else
 511     {
 512         sout_BufferDelete( p_stream->p_sout, p_buffer );
 513         return VLC_EGENERIC;
 514     }
 515 }
 516
 517 /****************************************************************************
 518  * ffmpeg decoder reencocdr part
 519  ****************************************************************************/
 520
 521 static struct
 522 {
 523     vlc_fourcc_t i_fcc;
 524     int          i_ff_codec;
 525 } fourcc_to_ff_code[] =
 526 {
 527     /* audio */
 528     { VLC_FOURCC( 'm', 'p', 'g', 'a' ), CODEC_ID_MP2 },
 529     { VLC_FOURCC( 'm', 'p', '3', ' ' ), CODEC_ID_MP3LAME },
 530     { VLC_FOURCC( 'm', 'p', '4', 'a' ), CODEC_ID_AAC },
 531     { VLC_FOURCC( 'a', '5', '2', ' ' ), CODEC_ID_AC3 },
 532     { VLC_FOURCC( 'a', 'c', '3', ' ' ), CODEC_ID_AC3 },
 533     { VLC_FOURCC( 'w', 'm', 'a', '1' ), CODEC_ID_WMAV1 },
 534     { VLC_FOURCC( 'w', 'm', 'a', '2' ), CODEC_ID_WMAV2 },
 535     { VLC_FOURCC( 'v', 'o', 'r', 'b' ), CODEC_ID_VORBIS },
 536     { VLC_FOURCC( 'a', 'l', 'a', 'w' ), CODEC_ID_PCM_ALAW },
 537
 538     /* video */
 539     { VLC_FOURCC( 'm', 'p', 'g', 'v' ), CODEC_ID_MPEG1VIDEO },
 540     { VLC_FOURCC( 'm', 'p', '1', 'v' ), CODEC_ID_MPEG1VIDEO },
 541 #if LIBAVCODEC_BUILD >= 4676
 542     { VLC_FOURCC( 'm', 'p', '2', 'v' ), CODEC_ID_MPEG2VIDEO },
 543 #endif
 544     { VLC_FOURCC( 'm', 'p', '4', 'v'),  CODEC_ID_MPEG4 },
 545     { VLC_FOURCC( 'D', 'I', 'V', '1' ), CODEC_ID_MSMPEG4V1 },
 546     { VLC_FOURCC( 'D', 'I', 'V', '2' ), CODEC_ID_MSMPEG4V2 },
 547     { VLC_FOURCC( 'D', 'I', 'V', '3' ), CODEC_ID_MSMPEG4V3 },
 548     { VLC_FOURCC( 'H', '2', '6', '3' ), CODEC_ID_H263 },
 549     { VLC_FOURCC( 'I', '2', '6', '3' ), CODEC_ID_H263I },
 550     { VLC_FOURCC( 'h', 'u', 'f', 'f' ), CODEC_ID_HUFFYUV },
 551     { VLC_FOURCC( 'W', 'M', 'V', '1' ), CODEC_ID_WMV1 },
 552     { VLC_FOURCC( 'W', 'M', 'V', '2' ), CODEC_ID_WMV2 },
 553     { VLC_FOURCC( 'M', 'J', 'P', 'G' ), CODEC_ID_MJPEG },
 554     { VLC_FOURCC( 'm', 'j', 'p', 'b' ), CODEC_ID_MJPEGB },
 555     { VLC_FOURCC( 'd', 'v', 's', 'l' ), CODEC_ID_DVVIDEO },
 556     { VLC_FOURCC( 'S', 'V', 'Q', '1' ), CODEC_ID_SVQ1 },
 557 #if LIBAVCODEC_BUILD >= 4666
 558     { VLC_FOURCC( 'S', 'V', 'Q', '3' ), CODEC_ID_SVQ3 },
 559 #endif
 560
 561     /* raw video code, only used for 'encoding' */
 562     { VLC_FOURCC( 'I', '4', '2', '0' ), CODEC_ID_RAWVIDEO },
 563     { VLC_FOURCC( 'I', '4', '2', '2' ), CODEC_ID_RAWVIDEO },
 564     { VLC_FOURCC( 'I', '4', '4', '4' ), CODEC_ID_RAWVIDEO },
 565     { VLC_FOURCC( 'R', 'V', '1', '5' ), CODEC_ID_RAWVIDEO },
 566     { VLC_FOURCC( 'R', 'V', '1', '6' ), CODEC_ID_RAWVIDEO },
 567     { VLC_FOURCC( 'R', 'V', '2', '4' ), CODEC_ID_RAWVIDEO },
 568     { VLC_FOURCC( 'R', 'V', '3', '2' ), CODEC_ID_RAWVIDEO },
 569     { VLC_FOURCC( 'Y', 'U', 'Y', '2' ), CODEC_ID_RAWVIDEO },
 570     { VLC_FOURCC( 'Y', 'V', '1', '2' ), CODEC_ID_RAWVIDEO },
 571     { VLC_FOURCC( 'I', 'Y', 'U', 'V' ), CODEC_ID_RAWVIDEO },
 572
 573     { VLC_FOURCC(   0,   0,   0,   0 ), 0 }
 574 };
 575
 576 static inline int get_ff_codec( vlc_fourcc_t i_fcc )
 577 {
 578     int i;
 579
 580     for( i = 0; fourcc_to_ff_code[i].i_fcc != 0; i++ )
 581     {
 582         if( fourcc_to_ff_code[i].i_fcc == i_fcc )
 583         {
 584             return fourcc_to_ff_code[i].i_ff_codec;
 585         }
 586     }
 587
 588     return 0;
 589 }
 590
 591 static inline int get_ff_chroma( vlc_fourcc_t i_chroma )
 592 {
 593     switch( i_chroma )
 594     {
 595         case VLC_FOURCC( 'Y', 'V', '1', '2' ):
 596         case VLC_FOURCC( 'I', 'Y', 'U', 'V' ):
 597         case VLC_FOURCC( 'I', '4', '2', '0' ):
 598             return PIX_FMT_YUV420P;
 599         case VLC_FOURCC( 'I', '4', '2', '2' ):
 600             return PIX_FMT_YUV422P;
 601         case VLC_FOURCC( 'I', '4', '4', '4' ):
 602             return PIX_FMT_YUV444P;
 603         case VLC_FOURCC( 'R', 'V', '1', '5' ):
 604             return PIX_FMT_RGB555;
 605         case VLC_FOURCC( 'R', 'V', '1', '6' ):
 606             return PIX_FMT_RGB565;
 607         case VLC_FOURCC( 'R', 'V', '2', '4' ):
 608             return PIX_FMT_BGR24;
 609         case VLC_FOURCC( 'R', 'V', '3', '2' ):
 610             return PIX_FMT_RGBA32;
 611         case VLC_FOURCC( 'G', 'R', 'E', 'Y' ):
 612             return PIX_FMT_GRAY8;
 613         case VLC_FOURCC( 'Y', 'U', 'Y', '2' ):
 614             return PIX_FMT_YUV422;
 615         default:
 616             return 0;
 617     }
 618 }
 619
 620 static inline vlc_fourcc_t get_vlc_chroma( int i_pix_fmt )
 621 {
 622     switch( i_pix_fmt )
 623     {
 624     case PIX_FMT_YUV420P:
 625         return VLC_FOURCC('I','4','2','0');
 626     case PIX_FMT_YUV422P:
 627         return VLC_FOURCC('I','4','2','2');
 628     case PIX_FMT_YUV444P:
 629         return VLC_FOURCC('I','4','4','4');
 630
 631     case PIX_FMT_YUV422:
 632         return VLC_FOURCC('Y','U','Y','2');
 633
 634     case PIX_FMT_RGB555:
 635         return VLC_FOURCC('R','V','1','5');
 636     case PIX_FMT_RGB565:
 637         return VLC_FOURCC('R','V','1','6');
 638     case PIX_FMT_RGB24:
 639         return VLC_FOURCC('R','V','2','4');
 640     case PIX_FMT_RGBA32:
 641         return VLC_FOURCC('R','V','3','2');
 642     case PIX_FMT_GRAY8:
 643         return VLC_FOURCC('G','R','E','Y');
 644
 645     case PIX_FMT_YUV410P:
 646     case PIX_FMT_YUV411P:
 647     case PIX_FMT_BGR24:
 648     default:
 649         return 0;
 650     }
 651 }
 652
 653 static int transcode_audio_ffmpeg_new( sout_stream_t *p_stream,
 654                                        sout_stream_id_t *id )
 655 {
 656     int i_ff_codec;
 657
 658     if( id->f_src.i_codec == VLC_FOURCC('s','1','6','l') ||
 659         id->f_src.i_codec == VLC_FOURCC('s','1','6','b') ||
 660         id->f_src.i_codec == VLC_FOURCC('s','8',' ',' ') ||
 661         id->f_src.i_codec == VLC_FOURCC('u','8',' ',' ') )
 662     {
 663         id->ff_dec = NULL;
 664
 665         id->ff_dec_c = avcodec_alloc_context();
 666         id->ff_dec_c->sample_rate = id->f_src.audio.i_rate;
 667         id->ff_dec_c->channels    = id->f_src.audio.i_channels;
 668         id->ff_dec_c->block_align = id->f_src.audio.i_blockalign;
 669         id->ff_dec_c->bit_rate    = id->f_src.i_bitrate;
 670     }
 671     else
 672     {
 673         /* find decoder */
 674         i_ff_codec = get_ff_codec( id->f_src.i_codec );
 675         if( i_ff_codec == 0 )
 676         {
 677             msg_Err( p_stream, "cannot find decoder id" );
 678             return VLC_EGENERIC;
 679         }
 680
 681         id->ff_dec = avcodec_find_decoder( i_ff_codec );
 682         if( !id->ff_dec )
 683         {
 684             msg_Err( p_stream, "cannot find decoder (avcodec)" );
 685             return VLC_EGENERIC;
 686         }
 687
 688         id->ff_dec_c = avcodec_alloc_context();
 689         id->ff_dec_c->sample_rate = id->f_src.audio.i_rate;
 690         id->ff_dec_c->channels    = id->f_src.audio.i_channels;
 691         id->ff_dec_c->block_align = id->f_src.audio.i_blockalign;
 692         id->ff_dec_c->bit_rate    = id->f_src.i_bitrate;
 693
 694         id->ff_dec_c->extradata_size = id->f_src.i_extra;
 695         id->ff_dec_c->extradata      = id->f_src.p_extra;
 696         if( avcodec_open( id->ff_dec_c, id->ff_dec ) )
 697         {
 698             msg_Err( p_stream, "cannot open decoder" );
 699             return VLC_EGENERIC;
 700         }
 701     }
 702
 703     id->i_buffer     = 2 * AVCODEC_MAX_AUDIO_FRAME_SIZE;
 704     id->i_buffer_pos = 0;
 705     id->p_buffer     = malloc( id->i_buffer );
 706
 707     /* Sanity check for audio channels */
 708     id->f_dst.audio.i_channels = __MIN( id->f_dst.audio.i_channels, id->f_src.audio.i_channels );
 709
 710     /* find encoder */
 711     id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
 712
 713     /* Initialization of encoder format structures */
 714     es_format_Init( &id->p_encoder->fmt_in, AUDIO_ES, AOUT_FMT_S16_NE );
 715     id->p_encoder->fmt_in.audio.i_format = AOUT_FMT_S16_NE;
 716     id->p_encoder->fmt_in.audio.i_rate = id->f_dst.audio.i_rate;
 717     id->p_encoder->fmt_in.audio.i_physical_channels =
 718         id->p_encoder->fmt_in.audio.i_original_channels =
 719             pi_channels_maps[id->f_dst.audio.i_channels];
 720     id->p_encoder->fmt_in.audio.i_channels = id->f_dst.audio.i_channels;
 721
 722     id->p_encoder->fmt_out = id->p_encoder->fmt_in;
 723     id->p_encoder->fmt_out.i_codec = id->f_dst.i_codec;
 724     id->p_encoder->fmt_out.i_bitrate = id->f_dst.i_bitrate;
 725
 726     id->p_encoder->p_module =
 727         module_Need( id->p_encoder, "encoder", NULL );
 728     if( !id->p_encoder->p_module )
 729     {
 730         vlc_object_destroy( id->p_encoder );
 731         msg_Err( p_stream, "cannot open encoder" );
 732         return VLC_EGENERIC;
 733     }
 734
 735     id->b_enc_inited = VLC_FALSE;
 736
 737     id->f_dst.i_extra = id->p_encoder->fmt_out.i_extra;
 738     id->f_dst.p_extra = id->p_encoder->fmt_out.p_extra;
 739
 740     /* Hack for mp3 transcoding support */
 741     if( id->f_dst.i_codec == VLC_FOURCC( 'm','p','3',' ' ) )
 742     {
 743         id->f_dst.i_codec = VLC_FOURCC( 'm','p','g','a' );
 744     }
 745
 746     return VLC_SUCCESS;
 747 }
 748
 749 static void transcode_audio_ffmpeg_close( sout_stream_t *p_stream,
 750                                           sout_stream_id_t *id )
 751 {
 752     if( id->ff_dec )
 753     {
 754         avcodec_close( id->ff_dec_c );
 755         free( id->ff_dec_c );
 756     }
 757
 758     module_Unneed( id->p_encoder, id->p_encoder->p_module );
 759     vlc_object_destroy( id->p_encoder );
 760
 761     free( id->p_buffer );
 762 }
 763
 764 static int transcode_audio_ffmpeg_process( sout_stream_t *p_stream,
 765                                            sout_stream_id_t *id,
 766                                            sout_buffer_t *in,
 767                                            sout_buffer_t **out )
 768 {
 769     aout_buffer_t aout_buf;
 770     block_t *p_block;
 771     int i_buffer = in->i_size;
 772     char *p_buffer = in->p_buffer;
 773     id->i_dts = in->i_dts;
 774     *out = NULL;
 775
 776     while( i_buffer )
 777     {
 778         id->i_buffer_pos = 0;
 779
 780         /* decode as much data as possible */
 781         if( id->ff_dec )
 782         {
 783             int i_used;
 784
 785             i_used = avcodec_decode_audio( id->ff_dec_c,
 786                          (int16_t*)id->p_buffer, &id->i_buffer_pos,
 787                          p_buffer, i_buffer );
 788
 789 #if 0
 790             msg_Warn( p_stream, "avcodec_decode_audio: %d used on %d",
 791                       i_used, i_buffer );
 792 #endif
 793             if( i_used < 0 )
 794             {
 795                 msg_Warn( p_stream, "error audio decoding");
 796                 break;
 797             }
 798
 799             i_buffer -= i_used;
 800             p_buffer += i_used;
 801         }
 802         else
 803         {
 804             int16_t *sout = (int16_t*)id->p_buffer;
 805
 806             if( id->f_src.i_codec == VLC_FOURCC( 's', '8', ' ', ' ' ) ||
 807                 id->f_src.i_codec == VLC_FOURCC( 'u', '8', ' ', ' ' ) )
 808             {
 809                 int8_t *sin = (int8_t*)p_buffer;
 810                 int i_used = __MIN( id->i_buffer/2, i_buffer );
 811                 int i_samples = i_used;
 812
 813                 if( id->f_src.i_codec == VLC_FOURCC( 's', '8', ' ', ' ' ) )
 814                     while( i_samples > 0 )
 815                     {
 816                         *sout++ = ( *sin++ ) << 8;
 817                         i_samples--;
 818                     }
 819                 else
 820                     while( i_samples > 0 )
 821                     {
 822                         *sout++ = ( *sin++ - 128 ) << 8;
 823                         i_samples--;
 824                     }
 825
 826                 i_buffer -= i_used;
 827                 p_buffer += i_used;
 828                 id->i_buffer_pos = i_used * 2;
 829             }
 830             else if( id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'l' ) ||
 831                      id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'b' ) )
 832             {
 833                 int16_t *sin = (int16_t*)p_buffer;
 834                 int i_used = __MIN( id->i_buffer, i_buffer );
 835                 int i_samples = i_used / 2;
 836                 int b_invert_indianness;
 837
 838                 if( id->f_src.i_codec == VLC_FOURCC( 's', '1', '6', 'l' ) )
 839 #ifdef WORDS_BIGENDIAN
 840                     b_invert_indianness = 1;
 841 #else
 842                     b_invert_indianness = 0;
 843 #endif
 844                 else
 845 #ifdef WORDS_BIGENDIAN
 846                     b_invert_indianness = 0;
 847 #else
 848                     b_invert_indianness = 1;
 849 #endif
 850
 851                 if( b_invert_indianness )
 852                 {
 853                     while( i_samples > 0 )
 854                     {
 855                         uint8_t tmp[2];
 856
 857                         tmp[1] = *sin++;
 858                         tmp[0] = *sin++;
 859                         *sout++ = *(int16_t*)tmp;
 860                         i_samples--;
 861                     }
 862                 }
 863                 else
 864                 {
 865                     memcpy( sout, sin, i_used );
 866                     sout += i_samples;
 867                 }
 868
 869                 i_buffer -= i_used;
 870                 p_buffer += i_used;
 871                 id->i_buffer_pos = i_used;
 872             }
 873         }
 874
 875         if( id->i_buffer_pos == 0 ) continue;
 876
 877         /* Encode as much data as possible */
 878         if( !id->b_enc_inited && id->p_encoder->pf_header )
 879         {
 880             p_block = id->p_encoder->pf_header( id->p_encoder );
 881             while( p_block )
 882             {
 883                 sout_buffer_t *p_out;
 884                 block_t *p_prev_block = p_block;
 885
 886                 p_out = sout_BufferNew( p_stream->p_sout, p_block->i_buffer );
 887                 memcpy( p_out->p_buffer, p_block->p_buffer, p_block->i_buffer);
 888                 p_out->i_dts = p_out->i_pts = in->i_dts;
 889                 p_out->i_length = 0;
 890                 sout_BufferChain( out, p_out );
 891
 892                 p_block = p_block->p_next;
 893                 block_Release( p_prev_block );
 894             }
 895
 896             id->b_enc_inited = VLC_TRUE;
 897         }
 898
 899         aout_buf.p_buffer = id->p_buffer;
 900         aout_buf.i_nb_bytes = id->i_buffer_pos;
 901         aout_buf.i_nb_samples = id->i_buffer_pos / 2 / id->f_src.audio.i_channels;
 902         aout_buf.start_date = id->i_dts;
 903         aout_buf.end_date = id->i_dts;
 904
 905         id->i_dts += ( I64C(1000000) * id->i_buffer_pos / 2 /
 906             id->f_src.audio.i_channels / id->f_src.audio.i_rate );
 907
 908         if( id->f_src.audio.i_channels !=
 909             id->p_encoder->fmt_in.audio.i_channels )
 910         {
 911             unsigned int i;
 912             int j;
 913
 914             /* This is for liba52 which is what ffmpeg uses to decode ac3 */
 915             static const int translation[7][6] =
 916             {{ 0, 0, 0, 0, 0, 0 },      /* 0 channels (rarely used) */
 917              { 0, 0, 0, 0, 0, 0 },       /* 1 ch */
 918              { 0, 1, 0, 0, 0, 0 },       /* 2 */
 919              { 1, 2, 0, 0, 0, 0 },       /* 3 */
 920              { 1, 3, 2, 0, 0, 0 },       /* 4 */
 921              { 1, 3, 4, 2, 0, 0 },       /* 5 */
 922              { 1, 3, 4, 5, 2, 0 }};      /* 6 */
 923
 924             /* dumb downmixing */
 925             for( i = 0; i < aout_buf.i_nb_samples; i++ )
 926             {
 927                 uint16_t *p_buffer = (uint16_t *)aout_buf.p_buffer;
 928                 for( j = 0 ; j < id->p_encoder->fmt_in.audio.i_channels; j++ )
 929                 {
 930                     p_buffer[i*id->p_encoder->fmt_in.audio.i_channels+j] =
 931                         p_buffer[i*id->f_src.audio.i_channels+
 932                                  translation[id->f_src.audio.i_channels][j]];
 933                 }
 934             }
 935             aout_buf.i_nb_bytes = i*id->p_encoder->fmt_in.audio.i_channels * 2;
 936         }
 937
 938         p_block = id->p_encoder->pf_encode_audio( id->p_encoder, &aout_buf );
 939         while( p_block )
 940         {
 941             sout_buffer_t *p_out;
 942             block_t *p_prev_block = p_block;
 943
 944             p_out = sout_BufferNew( p_stream->p_sout, p_block->i_buffer );
 945             memcpy( p_out->p_buffer, p_block->p_buffer, p_block->i_buffer);
 946             p_out->i_dts = p_block->i_dts;
 947             p_out->i_pts = p_block->i_pts;
 948             p_out->i_length = p_block->i_length;
 949             sout_BufferChain( out, p_out );
 950
 951             p_block = p_block->p_next;
 952             block_Release( p_prev_block );
 953         }
 954     }
 955
 956     return VLC_SUCCESS;
 957 }
 958
 959
 960 /*
 961  * video
 962  */
 963 static int transcode_video_ffmpeg_new( sout_stream_t *p_stream,
 964                                        sout_stream_id_t *id )
 965 {
 966     sout_stream_sys_t   *p_sys = p_stream->p_sys;
 967
 968     int i_ff_codec;
 969
 970     /* Open decoder */
 971     if( id->f_src.i_codec == VLC_FOURCC( 'I', '4', '2', '0' ) ||
 972         id->f_src.i_codec == VLC_FOURCC( 'I', '4', '2', '2' ) ||
 973         id->f_src.i_codec == VLC_FOURCC( 'I', '4', '4', '4' ) ||
 974         id->f_src.i_codec == VLC_FOURCC( 'Y', 'V', '1', '2' ) ||
 975         id->f_src.i_codec == VLC_FOURCC( 'Y', 'U', 'Y', '2' ) ||
 976         id->f_src.i_codec == VLC_FOURCC( 'I', 'Y', 'U', 'V' ) ||
 977         id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '1', '5' ) ||
 978         id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '1', '6' ) ||
 979         id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '2', '4' ) ||
 980         id->f_src.i_codec == VLC_FOURCC( 'R', 'V', '3', '2' ) ||
 981         id->f_src.i_codec == VLC_FOURCC( 'G', 'R', 'E', 'Y' ) )
 982     {
 983         id->ff_dec              = NULL;
 984         id->ff_dec_c            = avcodec_alloc_context();
 985         id->ff_dec_c->width     = id->f_src.video.i_width;
 986         id->ff_dec_c->height    = id->f_src.video.i_height;
 987         id->ff_dec_c->pix_fmt   = get_ff_chroma( id->f_src.i_codec );
 988     }
 989     else
 990     {
 991         /* find decoder */
 992         i_ff_codec = get_ff_codec( id->f_src.i_codec );
 993         if( i_ff_codec == 0 )
 994         {
 995             msg_Err( p_stream, "cannot find decoder" );
 996             return VLC_EGENERIC;
 997         }
 998
 999         id->ff_dec = avcodec_find_decoder( i_ff_codec );
1000         if( !id->ff_dec )
1001         {
1002             msg_Err( p_stream, "cannot find decoder" );
1003             return VLC_EGENERIC;
1004         }
1005
1006         id->ff_dec_c = avcodec_alloc_context();
1007         id->ff_dec_c->width         = id->f_src.video.i_width;
1008         id->ff_dec_c->height        = id->f_src.video.i_height;
1009         /* id->ff_dec_c->bit_rate      = id->f_src.i_bitrate; */
1010         id->ff_dec_c->extradata_size= id->f_src.i_extra;
1011         id->ff_dec_c->extradata     = id->f_src.p_extra;
1012         id->ff_dec_c->workaround_bugs = FF_BUG_AUTODETECT;
1013         id->ff_dec_c->error_resilience= -1;
1014         id->ff_dec_c->get_buffer    = transcode_video_ffmpeg_getframebuf;
1015         id->ff_dec_c->opaque        = p_sys;
1016
1017         if( avcodec_open( id->ff_dec_c, id->ff_dec ) < 0 )
1018         {
1019             msg_Err( p_stream, "cannot open decoder" );
1020             return VLC_EGENERIC;
1021         }
1022
1023         if( i_ff_codec == CODEC_ID_MPEG4 && id->ff_dec_c->extradata_size > 0 )
1024         {
1025             int b_gotpicture;
1026             AVFrame frame;
1027             uint8_t *p_vol = malloc( id->ff_dec_c->extradata_size +
1028                                      FF_INPUT_BUFFER_PADDING_SIZE );
1029
1030             memcpy( p_vol, id->ff_dec_c->extradata,
1031                     id->ff_dec_c->extradata_size );
1032             memset( p_vol + id->ff_dec_c->extradata_size, 0,
1033                     FF_INPUT_BUFFER_PADDING_SIZE );
1034
1035             avcodec_decode_video( id->ff_dec_c, &frame, &b_gotpicture,
1036                                   id->ff_dec_c->extradata,
1037                                   id->ff_dec_c->extradata_size );
1038             free( p_vol );
1039         }
1040     }
1041
1042     /* Open encoder */
1043     id->p_encoder = vlc_object_create( p_stream, VLC_OBJECT_ENCODER );
1044
1045     /* Initialization of encoder format structures */
1046     es_format_Init( &id->p_encoder->fmt_in,
1047                     id->f_src.i_cat, get_vlc_chroma(id->ff_dec_c->pix_fmt) );
1048
1049     /* The dimensions will be set properly later on.
1050      * Just put sensible values so we can test if there is an encoder. */
1051     id->p_encoder->fmt_in.video.i_width = 16;
1052     id->p_encoder->fmt_in.video.i_height = 16;
1053
1054     id->p_encoder->fmt_in.video.i_frame_rate = 25; /* FIXME as it break mpeg */
1055     id->p_encoder->fmt_in.video.i_frame_rate_base= 1;
1056     if( id->ff_dec )
1057     {
1058         id->p_encoder->fmt_in.video.i_frame_rate = id->ff_dec_c->frame_rate;
1059 #if LIBAVCODEC_BUILD >= 4662
1060         id->p_encoder->fmt_in.video.i_frame_rate_base =
1061             id->ff_dec_c->frame_rate_base;
1062 #endif
1063
1064 #if LIBAVCODEC_BUILD >= 4687
1065         if( id->ff_dec_c->height )
1066         id->p_encoder->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR *
1067             ( av_q2d(id->ff_dec_c->sample_aspect_ratio) *
1068               id->ff_dec_c->width / id->ff_dec_c->height );
1069 #else
1070         id->p_encoder->fmt_in.video.i_aspect = VOUT_ASPECT_FACTOR *
1071             id->ff_dec_c->aspect_ratio;
1072 #endif
1073     }
1074
1075     /* Check whether a particular aspect ratio was requested */
1076     if( id->f_src.video.i_aspect )
1077     {
1078         id->p_encoder->fmt_in.video.i_aspect = id->f_src.video.i_aspect;
1079         id->f_dst.video.i_aspect = id->f_src.video.i_aspect;
1080     }
1081
1082     id->p_encoder->fmt_out = id->p_encoder->fmt_in;
1083     id->p_encoder->fmt_out.i_codec = id->f_dst.i_codec;
1084     id->p_encoder->fmt_out.i_bitrate = id->f_dst.i_bitrate;
1085
1086     id->p_encoder->i_vtolerance = p_sys->i_vtolerance;
1087     id->p_encoder->i_key_int = p_sys->i_key_int;
1088     id->p_encoder->i_b_frames = p_sys->i_b_frames;
1089     id->p_encoder->i_qmin = p_sys->i_qmin;
1090     id->p_encoder->i_qmax = p_sys->i_qmax;
1091     id->p_encoder->i_hq = p_sys->i_hq;
1092     id->p_encoder->b_strict_rc = p_sys->b_strict_rc;
1093     id->p_encoder->b_pre_me = p_sys->b_pre_me;
1094     id->p_encoder->b_hurry_up = p_sys->b_hurry_up;
1095
1096     id->p_ff_pic         = avcodec_alloc_frame();
1097     id->p_ff_pic_tmp0    = NULL;
1098     id->p_ff_pic_tmp1    = NULL;
1099     id->p_ff_pic_tmp2    = NULL;
1100     id->p_vresample      = NULL;
1101
1102     id->p_encoder->p_module =
1103         module_Need( id->p_encoder, "encoder", NULL );
1104
1105     if( !id->p_encoder->p_module )
1106     {
1107         vlc_object_destroy( id->p_encoder );
1108         msg_Err( p_stream, "cannot find encoder" );
1109         return VLC_EGENERIC;
1110     }
1111
1112     /* Close the encoder.
1113      * We'll open it only when we have the first frame */
1114     module_Unneed( id->p_encoder, id->p_encoder->p_module );
1115     id->p_encoder->p_module = NULL;
1116
1117     id->b_enc_inited = VLC_FALSE;
1118
1119     return VLC_SUCCESS;
1120 }
1121
1122 static void transcode_video_ffmpeg_close ( sout_stream_t *p_stream,
1123                                            sout_stream_id_t *id )
1124 {
1125     /* Close decoder */
1126     if( id->ff_dec )
1127     {
1128         avcodec_close( id->ff_dec_c );
1129         free( id->ff_dec_c );
1130     }
1131
1132     /* Close encoder */
1133     if( id->p_encoder->p_module )
1134         module_Unneed( id->p_encoder, id->p_encoder->p_module );
1135     vlc_object_destroy( id->p_encoder );
1136
1137     /* Misc cleanup */
1138     if( id->p_ff_pic)
1139     {
1140         free( id->p_ff_pic );
1141     }
1142
1143     if( id->p_ff_pic_tmp0 )
1144     {
1145         free( id->p_ff_pic_tmp0->data[0] );
1146         free( id->p_ff_pic_tmp0 );
1147     }
1148     if( id->p_ff_pic_tmp1)
1149     {
1150         free( id->p_ff_pic_tmp1->data[0] );
1151         free( id->p_ff_pic_tmp1 );
1152     }
1153     if( id->p_ff_pic_tmp2)
1154     {
1155         free( id->p_ff_pic_tmp2->data[0] );
1156         free( id->p_ff_pic_tmp2 );
1157     }
1158     if( id->p_vresample )
1159     {
1160         img_resample_close( id->p_vresample );
1161     }
1162 }
1163
1164 static int transcode_video_ffmpeg_process( sout_stream_t *p_stream,
1165                sout_stream_id_t *id, sout_buffer_t *in, sout_buffer_t **out )
1166 {
1167     sout_stream_sys_t   *p_sys = p_stream->p_sys;
1168     int     i_used;
1169     int     b_gotpicture;
1170     AVFrame *frame;
1171
1172     int     i_data;
1173     uint8_t *p_data;
1174
1175     *out = NULL;
1176
1177     i_data = in->i_size;
1178     p_data = in->p_buffer;
1179
1180     for( ;; )
1181     {
1182         block_t *p_block;
1183         picture_t pic;
1184         int i_plane;
1185
1186         /* decode frame */
1187         frame = id->p_ff_pic;
1188         p_sys->i_input_pts = in->i_pts;
1189         if( id->ff_dec )
1190         {
1191             i_used = avcodec_decode_video( id->ff_dec_c, frame,
1192                                            &b_gotpicture,
1193                                            p_data, i_data );
1194         }
1195         else
1196         {
1197             /* raw video */
1198             avpicture_fill( (AVPicture*)frame, p_data,
1199                             id->ff_dec_c->pix_fmt,
1200                             id->ff_dec_c->width, id->ff_dec_c->height );
1201             i_used = i_data;
1202             b_gotpicture = 1;
1203
1204             /* Set PTS */
1205             frame->pts = p_sys->i_input_pts;
1206         }
1207
1208         if( i_used < 0 )
1209         {
1210             msg_Warn( p_stream, "error");
1211             return VLC_EGENERIC;
1212         }
1213         i_data -= i_used;
1214         p_data += i_used;
1215
1216         if( !b_gotpicture )
1217         {
1218             return VLC_SUCCESS;
1219         }
1220
1221         /* Get the pts of the decoded frame if any, otherwise keep the
1222          * interpolated one */
1223         if( frame->pts > 0 )
1224         {
1225             p_sys->i_output_pts = frame->pts;
1226         }
1227
1228         if( !id->b_enc_inited )
1229         {
1230             /* Hack because of the copy packetizer which can fail to detect the
1231              * proper size (which forces us to wait until the 1st frame
1232              * is decoded) */
1233             int i_width = id->ff_dec_c->width - p_sys->i_crop_left -
1234                           p_sys->i_crop_right;
1235             int i_height = id->ff_dec_c->height - p_sys->i_crop_top -
1236                            p_sys->i_crop_bottom;
1237
1238             if( id->f_dst.video.i_width <= 0 && id->f_dst.video.i_height <= 0
1239                 && p_sys->f_scale )
1240             {
1241                 /* Apply the scaling */
1242                 id->f_dst.video.i_width = i_width * p_sys->f_scale;
1243                 id->f_dst.video.i_height = i_height * p_sys->f_scale;
1244             }
1245             else if( id->f_dst.video.i_width > 0 &&
1246                      id->f_dst.video.i_height <= 0 )
1247             {
1248                 id->f_dst.video.i_height =
1249                     id->f_dst.video.i_width / (double)i_width * i_height;
1250             }
1251             else if( id->f_dst.video.i_width <= 0 &&
1252                      id->f_dst.video.i_height > 0 )
1253             {
1254                 id->f_dst.video.i_width =
1255                     id->f_dst.video.i_height / (double)i_height * i_width;
1256             }
1257
1258             id->p_encoder->fmt_in.video.i_width =
1259               id->p_encoder->fmt_out.video.i_width =
1260                 id->f_dst.video.i_width;
1261             id->p_encoder->fmt_in.video.i_height =
1262               id->p_encoder->fmt_out.video.i_height =
1263                 id->f_dst.video.i_height;
1264
1265             id->p_encoder->fmt_out.i_extra = 0;
1266             id->p_encoder->fmt_out.p_extra = NULL;
1267
1268             id->p_encoder->p_module =
1269                 module_Need( id->p_encoder, "encoder", NULL );
1270             if( !id->p_encoder->p_module )
1271             {
1272                 vlc_object_destroy( id->p_encoder );
1273                 msg_Err( p_stream, "cannot find encoder" );
1274                 id->b_transcode = VLC_FALSE;
1275                 return VLC_EGENERIC;
1276             }
1277
1278             id->f_dst.i_extra = id->p_encoder->fmt_out.i_extra;
1279             id->f_dst.p_extra = id->p_encoder->fmt_out.p_extra;
1280
1281             /* Hack for mp2v/mp1v transcoding support */
1282             if( id->f_dst.i_codec == VLC_FOURCC( 'm','p','1','v' ) ||
1283                 id->f_dst.i_codec == VLC_FOURCC( 'm','p','2','v' ) )
1284             {
1285                 id->f_dst.i_codec = VLC_FOURCC( 'm','p','g','v' );
1286             }
1287
1288             if( !( id->id =
1289                      p_stream->p_sys->p_out->pf_add( p_stream->p_sys->p_out,
1290                                                      &id->f_dst ) ) )
1291             {
1292                 msg_Err( p_stream, "cannot add this stream" );
1293                 transcode_video_ffmpeg_close( p_stream, id );
1294                 id->b_transcode = VLC_FALSE;
1295                 return VLC_EGENERIC;
1296             }
1297
1298             if( id->p_encoder->pf_header )
1299             {
1300                 p_block = id->p_encoder->pf_header( id->p_encoder );
1301                 while( p_block )
1302                 {
1303                     sout_buffer_t *p_out;
1304                     block_t *p_prev_block = p_block;
1305
1306                     p_out = sout_BufferNew( p_stream->p_sout,
1307                                             p_block->i_buffer );
1308                     memcpy( p_out->p_buffer, p_block->p_buffer,
1309                             p_block->i_buffer);
1310                     p_out->i_dts = p_out->i_pts = in->i_dts;
1311                     p_out->i_length = 0;
1312                     sout_BufferChain( out, p_out );
1313
1314                     p_block = p_block->p_next;
1315                     block_Release( p_prev_block );
1316                 }
1317             }
1318
1319             id->i_inter_pixfmt =
1320                 get_ff_chroma( id->p_encoder->fmt_in.i_codec );
1321
1322             id->b_enc_inited = VLC_TRUE;
1323         }
1324
1325         /* deinterlace */
1326         if( p_stream->p_sys->b_deinterlace )
1327         {
1328             if( id->p_ff_pic_tmp0 == NULL )
1329             {
1330                 int     i_size;
1331                 uint8_t *buf;
1332                 id->p_ff_pic_tmp0 = avcodec_alloc_frame();
1333                 i_size = avpicture_get_size( id->ff_dec_c->pix_fmt,
1334                                              id->ff_dec_c->width, id->ff_dec_c->height );
1335
1336                 buf = malloc( i_size );
1337
1338                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp0, buf,
1339                                 id->i_inter_pixfmt,
1340                                 id->ff_dec_c->width, id->ff_dec_c->height );
1341             }
1342
1343             avpicture_deinterlace( (AVPicture*)id->p_ff_pic_tmp0, (AVPicture*)frame,
1344                                    id->ff_dec_c->pix_fmt,
1345                                    id->ff_dec_c->width, id->ff_dec_c->height );
1346
1347             frame = id->p_ff_pic_tmp0;
1348         }
1349
1350         /* convert pix format */
1351         if( id->ff_dec_c->pix_fmt != id->i_inter_pixfmt )
1352         {
1353             if( id->p_ff_pic_tmp1 == NULL )
1354             {
1355                 int     i_size;
1356                 uint8_t *buf;
1357                 id->p_ff_pic_tmp1 = avcodec_alloc_frame();
1358                 i_size = avpicture_get_size( id->i_inter_pixfmt,
1359                                              id->ff_dec_c->width,
1360                                              id->ff_dec_c->height );
1361
1362                 buf = malloc( i_size );
1363
1364                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp1, buf,
1365                                 id->i_inter_pixfmt,
1366                                 id->ff_dec_c->width, id->ff_dec_c->height );
1367             }
1368
1369             img_convert( (AVPicture*)id->p_ff_pic_tmp1, id->i_inter_pixfmt,
1370                          (AVPicture*)frame, id->ff_dec_c->pix_fmt,
1371                          id->ff_dec_c->width, id->ff_dec_c->height );
1372
1373             frame = id->p_ff_pic_tmp1;
1374         }
1375
1376         /* convert size and crop */
1377         if( id->ff_dec_c->width  != id->f_dst.video.i_width ||
1378             id->ff_dec_c->height != id->f_dst.video.i_height ||
1379             p_sys->i_crop_top > 0 || p_sys->i_crop_bottom > 0 ||
1380             p_sys->i_crop_left > 0 || p_sys->i_crop_right > 0 )
1381         {
1382             if( id->p_ff_pic_tmp2 == NULL )
1383             {
1384                 int     i_size;
1385                 uint8_t *buf;
1386                 id->p_ff_pic_tmp2 = avcodec_alloc_frame();
1387                 i_size = avpicture_get_size( id->i_inter_pixfmt,
1388                                              id->f_dst.video.i_width,
1389                                              id->f_dst.video.i_height );
1390
1391                 buf = malloc( i_size );
1392
1393                 avpicture_fill( (AVPicture*)id->p_ff_pic_tmp2, buf,
1394                                 id->i_inter_pixfmt,
1395                                 id->f_dst.video.i_width, id->f_dst.video.i_height );
1396
1397                 id->p_vresample =
1398                     img_resample_full_init( id->f_dst.video.i_width,
1399                                             id->f_dst.video.i_height,
1400                                             id->ff_dec_c->width, id->ff_dec_c->height,
1401                                             p_stream->p_sys->i_crop_top,
1402                                             p_stream->p_sys->i_crop_bottom,
1403                                             p_stream->p_sys->i_crop_left,
1404                                             p_stream->p_sys->i_crop_right );
1405             }
1406
1407             img_resample( id->p_vresample, (AVPicture*)id->p_ff_pic_tmp2,
1408                           (AVPicture*)frame );
1409
1410             frame = id->p_ff_pic_tmp2;
1411         }
1412
1413         /* Encoding */
1414         vout_InitPicture( VLC_OBJECT(p_stream), &pic,
1415                           id->p_encoder->fmt_in.i_codec,
1416                           id->f_dst.video.i_width, id->f_dst.video.i_height,
1417                           id->f_dst.video.i_width * VOUT_ASPECT_FACTOR /
1418                           id->f_dst.video.i_height );
1419
1420         for( i_plane = 0; i_plane < pic.i_planes; i_plane++ )
1421         {
1422             pic.p[i_plane].p_pixels = frame->data[i_plane];
1423             pic.p[i_plane].i_pitch = frame->linesize[i_plane];
1424         }
1425
1426         /* Set the pts of the frame being encoded */
1427         pic.date = p_sys->i_output_pts;
1428
1429         pic.b_progressive = 1; /* ffmpeg doesn't support interlaced encoding */
1430         pic.i_nb_fields = frame->repeat_pict;
1431 #if LIBAVCODEC_BUILD >= 4684
1432         pic.b_top_field_first = frame->top_field_first;
1433 #endif
1434
1435         /* Interpolate the next PTS
1436          * (needed by the mpeg video packetizer which can send pts <= 0 ) */
1437         if( id->ff_dec_c && id->ff_dec_c->frame_rate > 0 )
1438         {
1439             p_sys->i_output_pts += I64C(1000000) * (2 + frame->repeat_pict) *
1440               id->ff_dec_c->frame_rate_base / (2 * id->ff_dec_c->frame_rate);
1441         }
1442
1443         p_block = id->p_encoder->pf_encode_video( id->p_encoder, &pic );
1444         while( p_block )
1445         {
1446             sout_buffer_t *p_out;
1447             block_t *p_prev_block = p_block;
1448
1449             p_out = sout_BufferNew( p_stream->p_sout, p_block->i_buffer );
1450             memcpy( p_out->p_buffer, p_block->p_buffer, p_block->i_buffer);
1451             p_out->i_dts = p_block->i_dts;
1452             p_out->i_pts = p_block->i_pts;
1453             p_out->i_length = p_block->i_length;
1454             sout_BufferChain( out, p_out );
1455
1456             p_block = p_block->p_next;
1457             block_Release( p_prev_block );
1458         }
1459
1460         if( i_data <= 0 )
1461         {
1462             return VLC_SUCCESS;
1463         }
1464     }
1465
1466     return VLC_SUCCESS;
1467 }
1468
1469 /*****************************************************************************
1470  * transcode_video_ffmpeg_getframebuf:
1471  *
1472  * Callback used by ffmpeg to get a frame buffer.
1473  * We use it to get the right PTS for each decoded picture.
1474  *****************************************************************************/
1475 static int transcode_video_ffmpeg_getframebuf(struct AVCodecContext *p_context,
1476                                               AVFrame *p_frame)
1477 {
1478     sout_stream_sys_t *p_sys = (sout_stream_sys_t *)p_context->opaque;
1479
1480     /* Set PTS */
1481     p_frame->pts = p_sys->i_input_pts;
1482
1483     return avcodec_default_get_buffer( p_context, p_frame );
1484 }