git.sesse.net Git - vlc/blob - modules/codec/ffmpeg/video.c

   1 /*****************************************************************************
   2  * video.c: video decoder using ffmpeg library
   3  *****************************************************************************
   4  * Copyright (C) 1999-2001 VideoLAN
   5  * $Id: video.c,v 1.3 2002/11/06 21:48:24 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>                                      /* malloc(), free() */
  29
  30 #include <vlc/vlc.h>
  31 #include <vlc/vout.h>
  32 #include <vlc/aout.h>
  33 #include <vlc/decoder.h>
  34 #include <vlc/input.h>
  35
  36 #include <string.h>
  37
  38 #ifdef HAVE_SYS_TIMES_H
  39 #   include <sys/times.h>
  40 #endif
  41
  42 #include "avcodec.h"                                               /* ffmpeg */
  43
  44 #include "postprocessing/postprocessing.h"
  45
  46 #include "ffmpeg.h"
  47 #include "video.h"
  48
  49 /*****************************************************************************
  50  * Local prototypes
  51  *****************************************************************************/
  52 static void ffmpeg_CopyPicture( picture_t *, AVPicture *, vdec_thread_t * );
  53 static void ffmpeg_PostProcPicture( vdec_thread_t *, picture_t * );
  54 static int  ffmpeg_GetFrameBuf( struct AVCodecContext *, int, int, int );
  55
  56 /* FIXME FIXME some of them are wrong */
  57 static int i_ffmpeg_PixFmtToChroma[] =
  58 {
  59     /* PIX_FMT_ANY = -1, PIX_FMT_YUV420P,
  60        PIX_FMT_YUV422,   PIX_FMT_RGB24,
  61        PIX_FMT_BGR24,    PIX_FMT_YUV422P,
  62        PIX_FMT_YUV444P,  PIX_FMT_YUV410P
  63      */
  64     0,                           VLC_FOURCC('I','4','2','0'),
  65     VLC_FOURCC('I','4','2','0'), VLC_FOURCC('R','V','2','4'),
  66     0,                           VLC_FOURCC('Y','4','2','2'),
  67     VLC_FOURCC('I','4','4','4'), 0
  68 };
  69
  70 /*****************************************************************************
  71  * Local Functions
  72  *****************************************************************************/
  73
  74 static inline u32 ffmpeg_PixFmtToChroma( int i_ffmpegchroma )
  75 {
  76     if( ++i_ffmpegchroma > 7 )
  77     {
  78         return( 0 );
  79     }
  80     else
  81     {
  82         return( i_ffmpeg_PixFmtToChroma[i_ffmpegchroma] );
  83     }
  84 }
  85
  86 static inline int ffmpeg_FfAspect( int i_width, int i_height, int i_ffaspect )
  87 {
  88     switch( i_ffaspect )
  89     {
  90         case( FF_ASPECT_4_3_625 ):
  91         case( FF_ASPECT_4_3_525 ):
  92             return( VOUT_ASPECT_FACTOR * 4 / 3);
  93         case( FF_ASPECT_16_9_625 ):
  94         case( FF_ASPECT_16_9_525 ):
  95             return( VOUT_ASPECT_FACTOR * 16 / 9 );
  96         case( FF_ASPECT_SQUARE ):
  97         default:
  98             return( VOUT_ASPECT_FACTOR * i_width / i_height );
  99     }
 100 }
 101
 102 /* Check if we have a Vout with good parameters */
 103 static int ffmpeg_CheckVout( vout_thread_t *p_vout,
 104                              int i_width,
 105                              int i_height,
 106                              int i_aspect,
 107                              int i_chroma )
 108 {
 109     if( !p_vout )
 110     {
 111         return( 0 );
 112     }
 113     if( !i_chroma )
 114     {
 115         /* we will try to make conversion */
 116         i_chroma = VLC_FOURCC('I','4','2','0');
 117     }
 118
 119     if( ( p_vout->render.i_width != i_width )||
 120         ( p_vout->render.i_height != i_height )||
 121         ( p_vout->render.i_chroma != i_chroma )||
 122         ( p_vout->render.i_aspect !=
 123                 ffmpeg_FfAspect( i_width, i_height, i_aspect ) ) )
 124     {
 125         return( 0 );
 126     }
 127     else
 128     {
 129         return( 1 );
 130     }
 131 }
 132
 133 /* Return a Vout */
 134 static vout_thread_t *ffmpeg_CreateVout( vdec_thread_t *p_vdec,
 135                                          int i_width,
 136                                          int i_height,
 137                                          int i_aspect,
 138                                          int i_chroma )
 139 {
 140     vout_thread_t *p_vout;
 141
 142     if( (!i_width)||(!i_height) )
 143     {
 144         return( NULL ); /* Can't create a new vout without display size */
 145     }
 146
 147     if( !i_chroma )
 148     {
 149         /* we make conversion if possible*/
 150         i_chroma = VLC_FOURCC('I','4','2','0');
 151         msg_Warn( p_vdec->p_fifo, "Internal chroma conversion (FIXME)");
 152         /* It's mainly for I410 -> I420 conversion that I've made,
 153            it's buggy and very slow */
 154     }
 155
 156     i_aspect = ffmpeg_FfAspect( i_width, i_height, i_aspect );
 157
 158     /* Spawn a video output if there is none. First we look for our children,
 159      * then we look for any other vout that might be available. */
 160     p_vout = vlc_object_find( p_vdec->p_fifo, VLC_OBJECT_VOUT,
 161                                               FIND_CHILD );
 162     if( !p_vout )
 163     {
 164         p_vout = vlc_object_find( p_vdec->p_fifo, VLC_OBJECT_VOUT,
 165                                                   FIND_ANYWHERE );
 166     }
 167
 168     if( p_vout )
 169     {
 170         if( !ffmpeg_CheckVout( p_vout,
 171                                i_width, i_height, i_aspect,i_chroma ) )
 172         {
 173             /* We are not interested in this format, close this vout */
 174             vlc_object_detach( p_vout );
 175             vlc_object_release( p_vout );
 176             vout_DestroyThread( p_vout );
 177             p_vout = NULL;
 178         }
 179         else
 180         {
 181             /* This video output is cool! Hijack it. */
 182             vlc_object_detach( p_vout );
 183             vlc_object_attach( p_vout, p_vdec->p_fifo );
 184             vlc_object_release( p_vout );
 185         }
 186     }
 187
 188     if( p_vout == NULL )
 189     {
 190         msg_Dbg( p_vdec->p_fifo, "no vout present, spawning one" );
 191
 192         p_vout = vout_CreateThread( p_vdec->p_fifo,
 193                                     i_width, i_height,
 194                                     i_chroma, i_aspect );
 195     }
 196
 197     return( p_vout );
 198 }
 199
 200 /* FIXME FIXME FIXME this is a big shit
 201    does someone want to rewrite this function ?
 202    or said to me how write a better thing
 203    FIXME FIXME FIXME
 204 */
 205 static void ffmpeg_ConvertPictureI410toI420( picture_t *p_pic,
 206                                              AVPicture *p_avpicture,
 207                                              vdec_thread_t   *p_vdec )
 208 {
 209     u8 *p_src, *p_dst;
 210     u8 *p_plane[3];
 211     int i_plane;
 212
 213     int i_stride, i_lines;
 214     int i_height, i_width;
 215     int i_y, i_x;
 216
 217     i_height = p_vdec->p_context->height;
 218     i_width  = p_vdec->p_context->width;
 219
 220     p_dst = p_pic->p[0].p_pixels;
 221     p_src  = p_avpicture->data[0];
 222
 223     /* copy first plane */
 224     for( i_y = 0; i_y < i_height; i_y++ )
 225     {
 226         p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, i_width);
 227         p_dst += p_pic->p[0].i_pitch;
 228         p_src += p_avpicture->linesize[0];
 229     }
 230
 231     /* process each plane in a temporary buffer */
 232     for( i_plane = 1; i_plane < 3; i_plane++ )
 233     {
 234         i_stride = p_avpicture->linesize[i_plane];
 235         i_lines = i_height / 4;
 236
 237         p_dst = p_plane[i_plane] = malloc( i_lines * i_stride * 2 * 2 );
 238         p_src  = p_avpicture->data[i_plane];
 239
 240         /* for each source line */
 241         for( i_y = 0; i_y < i_lines; i_y++ )
 242         {
 243             for( i_x = 0; i_x < i_stride - 1; i_x++ )
 244             {
 245                 p_dst[2 * i_x    ] = p_src[i_x];
 246                 p_dst[2 * i_x + 1] = ( p_src[i_x] + p_src[i_x + 1]) / 2;
 247
 248             }
 249             p_dst[2 * i_stride - 2] = p_src[i_x];
 250             p_dst[2 * i_stride - 1] = p_src[i_x];
 251
 252             p_dst += 4 * i_stride; /* process the next even lines */
 253             p_src += i_stride;
 254         }
 255     }
 256
 257     for( i_plane = 1; i_plane < 3; i_plane++ )
 258     {
 259         i_stride = p_avpicture->linesize[i_plane];
 260         i_lines = i_height / 4;
 261
 262         p_dst = p_plane[i_plane] + 2*i_stride;
 263         p_src  = p_plane[i_plane];
 264
 265         for( i_y = 0; i_y < i_lines - 1; i_y++ )
 266         {
 267             for( i_x = 0; i_x <  2 * i_stride ; i_x++ )
 268             {
 269                 p_dst[i_x] = ( p_src[i_x] + p_src[i_x + 4*i_stride])/2;
 270             }
 271
 272             p_dst += 4 * i_stride; /* process the next odd lines */
 273             p_src += 4 * i_stride;
 274         }
 275         /* last line */
 276         p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, 2*i_stride );
 277     }
 278     /* copy to p_pic, by block
 279        if I do pixel per pixel it segfault. It's why I use
 280        temporaries buffers */
 281     for( i_plane = 1; i_plane < 3; i_plane++ )
 282     {
 283         int i_size;
 284         p_src  = p_plane[i_plane];
 285         p_dst = p_pic->p[i_plane].p_pixels;
 286
 287         i_size = __MIN( 2*i_stride, p_pic->p[i_plane].i_pitch);
 288         for( i_y = 0; i_y < __MIN(p_pic->p[i_plane].i_lines, 2 * i_lines); i_y++ )
 289         {
 290             p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, i_size );
 291             p_src += 2 * i_stride;
 292             p_dst += p_pic->p[i_plane].i_pitch;
 293         }
 294         free( p_plane[i_plane] );
 295     }
 296 }
 297
 298 /*****************************************************************************
 299  *
 300  * Functions that initialize, decode and end the decoding process
 301  *
 302  * Functions exported for ffmpeg.c
 303  *   * E_( InitThread_Video )
 304  *   * E_( DecodeThread )
 305  *   * E_( EndThread_Video )
 306  *****************************************************************************/
 307
 308 /*****************************************************************************
 309  * InitThread: initialize vdec output thread
 310  *****************************************************************************
 311  * This function is called from decoder_Run and performs the second step
 312  * of the initialization. It returns 0 on success. Note that the thread's
 313  * flag are not modified inside this function.
 314  *
 315  * ffmpeg codec will be open, some memory allocated. But Vout is not yet
 316  * open (done after the first decoded frame)
 317  *****************************************************************************/
 318 int E_( InitThread_Video )( vdec_thread_t *p_vdec )
 319 {
 320     int i_tmp;
 321
 322     if( p_vdec->p_fifo->p_demux_data )
 323     {
 324         p_vdec->p_format = (BITMAPINFOHEADER *)p_vdec->p_fifo->p_demux_data;
 325     }
 326     else
 327     {
 328         msg_Warn( p_vdec->p_fifo, "display informations missing" );
 329     }
 330
 331     /* ***** Fill p_context with init values ***** */
 332     p_vdec->p_context->width  = p_vdec->p_format->biWidth;
 333     p_vdec->p_context->height = p_vdec->p_format->biHeight;
 334
 335     /*  ***** Get configuration of ffmpeg plugin ***** */
 336 #if LIBAVCODEC_BUILD >= 4611
 337     i_tmp = config_GetInt( p_vdec->p_fifo, "ffmpeg-workaround-bugs" );
 338     p_vdec->p_context->workaround_bugs  = __MAX( __MIN( i_tmp, 99 ), 0 );
 339
 340     i_tmp = config_GetInt( p_vdec->p_fifo, "ffmpeg-error-resilience" );
 341     p_vdec->p_context->error_resilience = __MAX( __MIN( i_tmp, 99 ), -1 );
 342 #endif
 343 #if LIBAVCODEC_BUILD >= 4614
 344     if( config_GetInt( p_vdec->p_fifo, "grayscale" ) )
 345     {
 346         p_vdec->p_context->flags|= CODEC_FLAG_GRAY;
 347     }
 348 #endif
 349
 350     p_vdec->b_hurry_up = config_GetInt(p_vdec->p_fifo, "ffmpeg-hurry-up");
 351
 352     p_vdec->p_lastpic = NULL;
 353     p_vdec->p_secondlastpic = NULL;
 354     p_vdec->b_direct_rendering = 0;
 355 #if LIBAVCODEC_BUILD > 4615
 356     if( (p_vdec->p_codec->capabilities & CODEC_CAP_DR1)
 357         && (p_vdec->p_context->pix_fmt != PIX_FMT_YUV410P) )
 358     {
 359         msg_Dbg( p_vdec->p_fifo, "using direct rendering" );
 360         p_vdec->b_direct_rendering = 1;
 361         p_vdec->p_context->flags|= CODEC_FLAG_EMU_EDGE | CODEC_FLAG_DR1;
 362         p_vdec->p_context->get_buffer_callback = ffmpeg_GetFrameBuf;
 363         p_vdec->p_context->opaque = p_vdec;
 364     }
 365 #endif
 366
 367     /* ***** Open the codec ***** */
 368     if( avcodec_open(p_vdec->p_context, p_vdec->p_codec) < 0 )
 369     {
 370         msg_Err( p_vdec->p_fifo, "cannot open codec (%s)",
 371                                  p_vdec->psz_namecodec );
 372         return( -1 );
 373     }
 374     else
 375     {
 376         msg_Dbg( p_vdec->p_fifo, "ffmpeg codec (%s) started",
 377                                  p_vdec->psz_namecodec );
 378     }
 379
 380     /* ***** init this codec with special data ***** */
 381     if( p_vdec->p_format->biSize > sizeof(BITMAPINFOHEADER) )
 382     {
 383         AVPicture avpicture;
 384         int b_gotpicture;
 385
 386         switch( p_vdec->i_codec_id )
 387         {
 388             case( CODEC_ID_MPEG4 ):
 389                 avcodec_decode_video( p_vdec->p_context, &avpicture,
 390                                       &b_gotpicture,
 391                                       (void *)&p_vdec->p_format[1],
 392                                       p_vdec->p_format->biSize
 393                                         - sizeof(BITMAPINFOHEADER) );
 394                 break;
 395             default:
 396                 if( p_vdec->p_fifo->i_fourcc == FOURCC_MP4S ||
 397                     p_vdec->p_fifo->i_fourcc == FOURCC_mp4s ||
 398                     p_vdec->p_fifo->i_fourcc == FOURCC_M4S2 ||
 399                     p_vdec->p_fifo->i_fourcc == FOURCC_m4s2 )
 400                 {
 401                     p_vdec->p_context->extradata_size =
 402                         p_vdec->p_format->biSize - sizeof(BITMAPINFOHEADER);
 403                     p_vdec->p_context->extradata =
 404                         malloc( p_vdec->p_context->extradata_size );
 405                     memcpy( p_vdec->p_context->extradata,
 406                             &p_vdec->p_format[1],
 407                             p_vdec->p_context->extradata_size );
 408                 }
 409
 410                 break;
 411         }
 412     }
 413
 414     /* ***** Load post processing ***** */
 415
 416     /* get overridding settings */
 417     p_vdec->i_pp_mode = 0;
 418     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-db-yv" ) )
 419         p_vdec->i_pp_mode |= PP_DEBLOCK_Y_V;
 420     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-db-yh" ) )
 421         p_vdec->i_pp_mode |= PP_DEBLOCK_Y_H;
 422     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-db-cv" ) )
 423         p_vdec->i_pp_mode |= PP_DEBLOCK_C_V;
 424     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-db-ch" ) )
 425         p_vdec->i_pp_mode |= PP_DEBLOCK_C_H;
 426     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-dr-y" ) )
 427         p_vdec->i_pp_mode |= PP_DERING_Y;
 428     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-dr-c" ) )
 429         p_vdec->i_pp_mode |= PP_DERING_C;
 430
 431     if( ( config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-q" ) > 0 )||
 432         ( config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-auto" )  )||
 433         ( p_vdec->i_pp_mode != 0 ) )
 434     {
 435         /* check if the codec support postproc. */
 436         switch( p_vdec->i_codec_id )
 437         {
 438 #if LIBAVCODEC_BUILD > 4608
 439             case( CODEC_ID_MSMPEG4V1 ):
 440             case( CODEC_ID_MSMPEG4V2 ):
 441             case( CODEC_ID_MSMPEG4V3 ):
 442 #else
 443             case( CODEC_ID_MSMPEG4 ):
 444 #endif
 445             case( CODEC_ID_MPEG4 ):
 446             case( CODEC_ID_H263 ):
 447 //            case( CODEC_ID_H263P ): I don't use it up to now
 448             case( CODEC_ID_H263I ):
 449                 /* Ok we can make postprocessing :)) */
 450                 /* first try to get a postprocess module */
 451 #if LIBAVCODEC_BUILD > 4613
 452                 p_vdec->p_pp = vlc_object_create( p_vdec->p_fifo,
 453                                                   sizeof( postprocessing_t ) );
 454                 p_vdec->p_pp->psz_object_name = "postprocessing";
 455                 p_vdec->p_pp->p_module =
 456                    module_Need( p_vdec->p_pp, "postprocessing", "$ffmpeg-pp" );
 457
 458                 if( !p_vdec->p_pp->p_module )
 459                 {
 460                     msg_Warn( p_vdec->p_fifo,
 461                               "no suitable postprocessing module" );
 462                     vlc_object_destroy( p_vdec->p_pp );
 463                     p_vdec->p_pp = NULL;
 464                     p_vdec->i_pp_mode = 0;
 465                 }
 466                 else
 467                 {
 468                     /* get mode upon quality */
 469                     p_vdec->i_pp_mode |=
 470                         p_vdec->p_pp->pf_getmode(
 471                               config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-q" ),
 472                               config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-auto" )
 473                                                 );
 474
 475                     /* allocate table for postprocess */
 476                     p_vdec->p_context->quant_store =
 477                         malloc( sizeof( int ) * ( MBR + 1 ) * ( MBC + 1 ) );
 478                     p_vdec->p_context->qstride = MBC + 1;
 479                 }
 480 #else
 481                 p_vdec->i_pp_mode = 0;
 482                 msg_Warn( p_vdec->p_fifo,
 483                           "post-processing not supported, upgrade ffmpeg" );
 484 #endif
 485                 break;
 486             default:
 487                 p_vdec->i_pp_mode = 0;
 488                 msg_Warn( p_vdec->p_fifo,
 489                           "Post processing unsupported for this codec" );
 490                 break;
 491         }
 492
 493     }
 494 //    memset( &p_vdec->statistic, 0, sizeof( statistic_t ) );
 495
 496     return( 0 );
 497 }
 498
 499 /*****************************************************************************
 500  * DecodeThread: Called for decode one frame
 501  *****************************************************************************
 502  * We have to get a frame stored in a pes, give it to ffmpeg decoder and send
 503  * the image to the output.
 504  *****************************************************************************/
 505 void  E_( DecodeThread_Video )( vdec_thread_t *p_vdec )
 506 {
 507     pes_packet_t    *p_pes;
 508     int     i_frame_size;
 509     int     i_status;
 510     int     b_drawpicture;
 511     int     b_gotpicture;
 512     AVPicture avpicture;                                   /* ffmpeg picture */
 513     picture_t *p_pic;                                    /* videolan picture */
 514
 515     /* TODO implement it in a better way */
 516     /* A good idea could be to decode all I pictures and see for the other */
 517     if( ( p_vdec->b_hurry_up )&& ( p_vdec->i_frame_late > 4 ) )
 518     {
 519 #if LIBAVCODEC_BUILD > 4603
 520         b_drawpicture = 0;
 521         if( p_vdec->i_frame_late < 8 )
 522         {
 523             p_vdec->p_context->hurry_up = 2;
 524         }
 525         else
 526         {
 527             /* too much late picture, won't decode
 528                but break picture until a new I, and for mpeg4 ...*/
 529             p_vdec->i_frame_late--; /* needed else it will never be decrease */
 530             input_ExtractPES( p_vdec->p_fifo, NULL );
 531             return;
 532         }
 533 #else
 534         if( p_vdec->i_frame_late < 8 )
 535         {
 536             b_drawpicture = 0; /* not really good but .. UPGRADE FFMPEG !! */
 537         }
 538         else
 539         {
 540             /* too much late picture, won't decode
 541                but break picture until a new I, and for mpeg4 ...*/
 542             p_vdec->i_frame_late--; /* needed else it will never be decrease */
 543             input_ExtractPES( p_vdec->p_fifo, NULL );
 544             return;
 545         }
 546 #endif
 547     }
 548     else
 549     {
 550         b_drawpicture = 1;
 551 #if LIBAVCODEC_BUILD > 4603
 552         p_vdec->p_context->hurry_up = 0;
 553 #endif
 554     }
 555
 556     do
 557     {
 558         input_ExtractPES( p_vdec->p_fifo, &p_pes );
 559         if( !p_pes )
 560         {
 561             p_vdec->p_fifo->b_error = 1;
 562             return;
 563         }
 564         p_vdec->pts = p_pes->i_pts;
 565         i_frame_size = p_pes->i_pes_size;
 566
 567         if( i_frame_size > 0 )
 568         {
 569             if( p_vdec->i_buffer < i_frame_size + 16 )
 570             {
 571                 FREE( p_vdec->p_buffer );
 572                 p_vdec->p_buffer = malloc( i_frame_size + 16 );
 573                 p_vdec->i_buffer = i_frame_size + 16;
 574             }
 575
 576             E_( GetPESData )( p_vdec->p_buffer, p_vdec->i_buffer, p_pes );
 577         }
 578         input_DeletePES( p_vdec->p_fifo->p_packets_mgt, p_pes );
 579     } while( i_frame_size <= 0 );
 580
 581
 582     i_status = avcodec_decode_video( p_vdec->p_context,
 583                                      &avpicture,
 584                                      &b_gotpicture,
 585                                      p_vdec->p_buffer,
 586                                      i_frame_size );
 587
 588     if( i_status < 0 )
 589     {
 590         msg_Warn( p_vdec->p_fifo, "cannot decode one frame (%d bytes)",
 591                                   i_frame_size );
 592         p_vdec->i_frame_error++;
 593         return;
 594     }
 595     /* Update frame late count*/
 596     /* I don't make statistic on decoding time */
 597     if( p_vdec->pts <= mdate())
 598     {
 599         p_vdec->i_frame_late++;
 600     }
 601     else
 602     {
 603         p_vdec->i_frame_late = 0;
 604     }
 605
 606     if( !b_gotpicture || avpicture.linesize[0] == 0 || !b_drawpicture )
 607     {
 608         return;
 609     }
 610
 611     if( !p_vdec->b_direct_rendering )
 612     {
 613         /* Check our vout */
 614         if( !ffmpeg_CheckVout( p_vdec->p_vout,
 615                            p_vdec->p_context->width,
 616                            p_vdec->p_context->height,
 617                            p_vdec->p_context->aspect_ratio_info,
 618                            ffmpeg_PixFmtToChroma(p_vdec->p_context->pix_fmt)) )
 619         {
 620             p_vdec->p_vout = ffmpeg_CreateVout( p_vdec,
 621                            p_vdec->p_context->width,
 622                            p_vdec->p_context->height,
 623                            p_vdec->p_context->aspect_ratio_info,
 624                            ffmpeg_PixFmtToChroma(p_vdec->p_context->pix_fmt) );
 625             if( !p_vdec->p_vout )
 626             {
 627                 msg_Err( p_vdec->p_fifo, "cannot create vout" );
 628                 p_vdec->p_fifo->b_error = 1; /* abort */
 629                 return;
 630             }
 631         }
 632
 633         /* Get a new picture */
 634         while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
 635         {
 636             if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
 637             {
 638                 return;
 639             }
 640             msleep( VOUT_OUTMEM_SLEEP );
 641         }
 642
 643         /* fill p_picture_t from avpicture, do I410->I420 if needed */
 644         ffmpeg_CopyPicture( p_pic, &avpicture, p_vdec );
 645     }
 646     else
 647     {
 648 #if LIBAVCODEC_BUILD > 4615
 649         p_pic = (picture_t *)p_vdec->p_context->dr_opaque_frame;
 650 #endif
 651     }
 652
 653     /* Do post-processing if requested */
 654     ffmpeg_PostProcPicture( p_vdec, p_pic );
 655
 656     /* FIXME correct avi and use i_dts */
 657
 658     /* Send decoded frame to vout */
 659     vout_DatePicture( p_vdec->p_vout, p_pic, p_vdec->pts);
 660     vout_DisplayPicture( p_vdec->p_vout, p_pic );
 661
 662     return;
 663 }
 664
 665 /*****************************************************************************
 666  * EndThread: thread destruction
 667  *****************************************************************************
 668  * This function is called when the thread ends after a sucessful
 669  * initialization.
 670  *****************************************************************************/
 671 void E_( EndThread_Video )( vdec_thread_t *p_vdec )
 672 {
 673     if( p_vdec->p_secondlastpic )
 674         vout_UnlinkPicture( p_vdec->p_vout, p_vdec->p_secondlastpic );
 675     if( p_vdec->p_lastpic )
 676         vout_UnlinkPicture( p_vdec->p_vout, p_vdec->p_lastpic );
 677
 678     if( p_vdec->p_pp )
 679     {
 680         /* release postprocessing module */
 681         module_Unneed( p_vdec->p_pp, p_vdec->p_pp->p_module );
 682         vlc_object_destroy( p_vdec->p_pp );
 683         p_vdec->p_pp = NULL;
 684     }
 685
 686     if( p_vdec->p_vout != NULL )
 687     {
 688         /* We are about to die. Reattach video output to p_vlc. */
 689         vlc_object_detach( p_vdec->p_vout );
 690         vlc_object_attach( p_vdec->p_vout, p_vdec->p_fifo->p_vlc );
 691     }
 692 }
 693
 694 /*****************************************************************************
 695  * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
 696  *                     picture_t structure (when not in direct rendering mode).
 697  *****************************************************************************/
 698 static void ffmpeg_CopyPicture( picture_t *p_pic, AVPicture *p_avpicture,
 699                                 vdec_thread_t *p_vdec )
 700 {
 701     int i_plane;
 702     int i_size;
 703     int i_line;
 704
 705     u8  *p_dst;
 706     u8  *p_src;
 707     int i_src_stride;
 708     int i_dst_stride;
 709
 710     if( ffmpeg_PixFmtToChroma( p_vdec->p_context->pix_fmt ) )
 711     {
 712         for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 713         {
 714             p_src  = p_avpicture->data[i_plane];
 715             p_dst = p_pic->p[i_plane].p_pixels;
 716             i_src_stride = p_avpicture->linesize[i_plane];
 717             i_dst_stride = p_pic->p[i_plane].i_pitch;
 718
 719             i_size = __MIN( i_src_stride, i_dst_stride );
 720             for( i_line = 0; i_line < p_pic->p[i_plane].i_lines; i_line++ )
 721             {
 722                 p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, i_size );
 723                 p_src += i_src_stride;
 724                 p_dst += i_dst_stride;
 725             }
 726         }
 727     }
 728     else
 729     {
 730         /* we need to convert to I420 */
 731         switch( p_vdec->p_context->pix_fmt )
 732         {
 733 #if LIBAVCODEC_BUILD >= 4615
 734             case( PIX_FMT_YUV410P ):
 735                 ffmpeg_ConvertPictureI410toI420( p_pic, p_avpicture, p_vdec );
 736                 break;
 737 #endif
 738             default:
 739                 p_vdec->p_fifo->b_error = 1;
 740                 break;
 741         }
 742     }
 743 }
 744
 745 /*****************************************************************************
 746  * ffmpeg_PostProcPicture: Postprocessing is done here.
 747  *****************************************************************************/
 748 static void ffmpeg_PostProcPicture( vdec_thread_t *p_vdec, picture_t *p_pic )
 749 {
 750 #if LIBAVCODEC_BUILD > 4313
 751     if( ( p_vdec->i_pp_mode )&&
 752         ( ( p_vdec->p_vout->render.i_chroma ==
 753             VLC_FOURCC( 'I','4','2','0' ) )||
 754           ( p_vdec->p_vout->render.i_chroma ==
 755             VLC_FOURCC( 'Y','V','1','2' ) ) ) )
 756     {
 757         /* Make postproc */
 758         p_vdec->p_pp->pf_postprocess( p_pic,
 759                                       p_vdec->p_context->quant_store,
 760                                       p_vdec->p_context->qstride,
 761                                       p_vdec->i_pp_mode );
 762     }
 763 #endif
 764 }
 765
 766 /*****************************************************************************
 767  * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
 768  *                     (used for direct rendering)
 769  *****************************************************************************/
 770 static int ffmpeg_GetFrameBuf( struct AVCodecContext *avctx, int width,
 771                                int height, int pict_type )
 772 {
 773 #if LIBAVCODEC_BUILD > 4615
 774     vdec_thread_t *p_vdec = (vdec_thread_t *)avctx->opaque;
 775     picture_t *p_pic;
 776
 777     /* Check our vout */
 778     if( !ffmpeg_CheckVout( p_vdec->p_vout,
 779                            p_vdec->p_context->width,
 780                            p_vdec->p_context->height,
 781                            p_vdec->p_context->aspect_ratio_info,
 782                            ffmpeg_PixFmtToChroma(p_vdec->p_context->pix_fmt)) )
 783     {
 784         p_vdec->p_vout = ffmpeg_CreateVout( p_vdec,
 785                            p_vdec->p_context->width,
 786                            p_vdec->p_context->height,
 787                            p_vdec->p_context->aspect_ratio_info,
 788                            ffmpeg_PixFmtToChroma(p_vdec->p_context->pix_fmt) );
 789         if( !p_vdec->p_vout )
 790         {
 791             msg_Err( p_vdec->p_fifo, "cannot create vout" );
 792             p_vdec->p_fifo->b_error = 1; /* abort */
 793             return -1;
 794         }
 795     }
 796
 797     /* Get a new picture */
 798     while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
 799     {
 800         if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
 801         {
 802             return -1;
 803         }
 804         msleep( VOUT_OUTMEM_SLEEP );
 805     }
 806
 807     /* FIXME: We keep the last picture linked until the current one is decoded,
 808      * this trick won't work with streams with B frames though. */
 809     vout_LinkPicture( p_vdec->p_vout, p_pic );
 810     if( p_vdec->p_secondlastpic )
 811         vout_UnlinkPicture( p_vdec->p_vout, p_vdec->p_secondlastpic );
 812     p_vdec->p_secondlastpic = p_vdec->p_lastpic;
 813     p_vdec->p_lastpic = p_pic;
 814
 815     avctx->draw_horiz_band= NULL;
 816     avctx->dr_buffer[0]= p_pic->p[0].p_pixels;
 817     avctx->dr_buffer[1]= p_pic->p[1].p_pixels;
 818     avctx->dr_buffer[2]= p_pic->p[2].p_pixels;
 819
 820     avctx->dr_stride   = p_pic->p[0].i_pitch;
 821     avctx->dr_uvstride = p_pic->p[1].i_pitch;
 822
 823     avctx->dr_opaque_frame = p_pic;
 824
 825     /* FIXME: this variable is used to determine if a macro-block to be written
 826      * can be skipped. The idea behind this is that if a macro-block hasn't
 827      * changed and all the frame-buffers already have the value of this
 828      * macro-block, then we can skip the writting.
 829      * But currently we cannot ensure this is the case, so we decide to write
 830      * everything. */
 831     avctx->dr_ip_buffer_count = 999;
 832
 833     return 0;
 834 #endif
 835 }