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.31 2003/06/16 20:49:12 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 /* ffmpeg header */
  43 #ifdef HAVE_FFMPEG_AVCODEC_H
  44 #   include <ffmpeg/avcodec.h>
  45 #else
  46 #   include <avcodec.h>
  47 #endif
  48
  49 #include "ffmpeg.h"
  50
  51 #ifdef LIBAVCODEC_PP
  52 #   ifdef HAVE_POSTPROC_POSTPROCESS_H
  53 #       include <postproc/postprocess.h>
  54 #   else
  55 #       include <libpostproc/postprocess.h>
  56 #   endif
  57 #else
  58 #   include "postprocessing/postprocessing.h"
  59 #endif
  60
  61 #include "video.h"
  62
  63
  64 /*****************************************************************************
  65  * Local prototypes
  66  *****************************************************************************/
  67 static void ffmpeg_CopyPicture( picture_t *, AVFrame *, vdec_thread_t * );
  68
  69 /* direct rendering */
  70 static int  ffmpeg_GetFrameBuf      ( struct AVCodecContext *, AVFrame *);
  71 static void ffmpeg_ReleaseFrameBuf  ( struct AVCodecContext *, AVFrame *);
  72
  73 /*****************************************************************************
  74  * Local Functions
  75  *****************************************************************************/
  76
  77 static inline uint32_t ffmpeg_PixFmtToChroma( int i_ff_chroma )
  78 {
  79     /* FIXME FIXME some of them are wrong */
  80     switch( i_ff_chroma )
  81     {
  82         case PIX_FMT_YUV420P:
  83         case PIX_FMT_YUV422:
  84             return( VLC_FOURCC('I','4','2','0') );
  85         case PIX_FMT_RGB24:
  86             return( VLC_FOURCC('R','V','2','4') );
  87
  88         case PIX_FMT_YUV422P:
  89             return( VLC_FOURCC('I','4','2','2') );
  90         case PIX_FMT_YUV444P:
  91             return( VLC_FOURCC('I','4','4','4') );
  92         case PIX_FMT_YUV410P:
  93         case PIX_FMT_YUV411P:
  94         case PIX_FMT_BGR24:
  95         default:
  96             return( 0 );
  97     }
  98 }
  99
 100 /* Return a Vout */
 101 static vout_thread_t *ffmpeg_CreateVout( vdec_thread_t  *p_vdec,
 102                                          AVCodecContext *p_context )
 103 {
 104     vout_thread_t *p_vout;
 105     unsigned int   i_width = p_context->width;
 106     unsigned int   i_height = p_context->height;
 107     uint32_t       i_chroma = ffmpeg_PixFmtToChroma( p_context->pix_fmt );
 108     unsigned int   i_aspect;
 109
 110     if( !i_width || !i_height )
 111     {
 112         return( NULL ); /* Can't create a new vout without display size */
 113     }
 114
 115     if( !i_chroma )
 116     {
 117         /* we make conversion if possible*/
 118         i_chroma = VLC_FOURCC('I','4','2','0');
 119     }
 120
 121     i_aspect = VOUT_ASPECT_FACTOR * p_context->aspect_ratio;
 122     if( i_aspect == 0 )
 123     {
 124         i_aspect = VOUT_ASPECT_FACTOR * i_width / i_height;
 125     }
 126
 127     /* Spawn a video output if there is none. First we look for our children,
 128      * then we look for any other vout that might be available. */
 129     p_vout = vout_Request( p_vdec->p_fifo, NULL,
 130                            i_width, i_height, i_chroma, i_aspect );
 131 #ifdef LIBAVCODEC_PP
 132     if( p_vdec->pp_mode && !p_vdec->pp_context )
 133     {
 134         int32_t i_cpu = p_vdec->p_fifo->p_libvlc->i_cpu;
 135         int i_flags = 0;
 136
 137         if( i_cpu & CPU_CAPABILITY_MMX )
 138         {
 139             i_flags |= PP_CPU_CAPS_MMX;
 140         }
 141         if( i_cpu & CPU_CAPABILITY_MMXEXT )
 142         {
 143             i_flags |= PP_CPU_CAPS_MMX2;
 144         }
 145         if( i_cpu & CPU_CAPABILITY_3DNOW )
 146         {
 147             i_flags |= PP_CPU_CAPS_3DNOW;
 148         }
 149
 150         switch( p_context->pix_fmt )
 151         {
 152             case PIX_FMT_YUV444P:
 153                 i_flags |= PP_FORMAT_444;
 154                 break;
 155             case PIX_FMT_YUV422P:
 156                 i_flags |= PP_FORMAT_422;
 157                 break;
 158             case PIX_FMT_YUV411P:
 159                 i_flags |= PP_FORMAT_411;
 160                 break;
 161             default:
 162                 i_flags |= PP_FORMAT_420;
 163                 break;
 164         }
 165
 166         p_vdec->pp_context = pp_get_context( i_width, i_height, i_flags );
 167     }
 168 #endif
 169
 170     return p_vout;
 171 }
 172
 173 /*****************************************************************************
 174  *
 175  * Functions that initialize, decode and end the decoding process
 176  *
 177  * Functions exported for ffmpeg.c
 178  *   * E_( InitThread_Video )
 179  *   * E_( DecodeThread )
 180  *   * E_( EndThread_Video )
 181  *****************************************************************************/
 182
 183 /*****************************************************************************
 184  * InitThread: initialize vdec output thread
 185  *****************************************************************************
 186  * This function is called from decoder_Run and performs the second step
 187  * of the initialization. It returns 0 on success. Note that the thread's
 188  * flag are not modified inside this function.
 189  *
 190  * ffmpeg codec will be open, some memory allocated. But Vout is not yet
 191  * open (done after the first decoded frame)
 192  *****************************************************************************/
 193 static inline void SetDWBE( void *data, uint32_t dw )
 194 {
 195     uint8_t *p = data;
 196
 197     p[0] = (dw >> 24 )&0xff;
 198     p[1] = (dw >> 16 )&0xff;
 199     p[2] = (dw >>  8 )&0xff;
 200     p[3] = (dw )&0xff;
 201 }
 202
 203 int E_( InitThread_Video )( vdec_thread_t *p_vdec )
 204 {
 205     int i_tmp;
 206     int i_truncated;
 207
 208     p_vdec->p_ff_pic = avcodec_alloc_frame();
 209
 210     if( ( p_vdec->p_format =
 211           (BITMAPINFOHEADER *)p_vdec->p_fifo->p_bitmapinfoheader) != NULL )
 212     {
 213         /* ***** Fill p_context with init values ***** */
 214         p_vdec->p_context->width  = p_vdec->p_format->biWidth;
 215         p_vdec->p_context->height = p_vdec->p_format->biHeight;
 216     }
 217     else
 218     {
 219         msg_Warn( p_vdec->p_fifo, "display informations missing" );
 220         p_vdec->p_format = NULL;
 221     }
 222
 223     /*  ***** Get configuration of ffmpeg plugin ***** */
 224     i_tmp = config_GetInt( p_vdec->p_fifo, "ffmpeg-workaround-bugs" );
 225     p_vdec->p_context->workaround_bugs  = __MAX( __MIN( i_tmp, 99 ), 0 );
 226
 227     i_tmp = config_GetInt( p_vdec->p_fifo, "ffmpeg-error-resilience" );
 228     p_vdec->p_context->error_resilience = __MAX( __MIN( i_tmp, 99 ), -1 );
 229
 230     if( config_GetInt( p_vdec->p_fifo, "grayscale" ) )
 231     {
 232         p_vdec->p_context->flags|= CODEC_FLAG_GRAY;
 233     }
 234
 235     p_vdec->b_hurry_up = config_GetInt(p_vdec->p_fifo, "ffmpeg-hurry-up");
 236
 237     /* CODEC_FLAG_TRUNCATED */
 238
 239     /* FIXME search real LIBAVCODEC_BUILD */
 240 #if LIBAVCODEC_BUILD >= 4662
 241     i_truncated = config_GetInt( p_vdec->p_fifo, "ffmpeg-truncated" );
 242     if( i_truncated == 1 || ( i_truncated == -1 &&
 243         ( p_vdec->p_context->width == 0 || p_vdec->p_context->height == 0 ) ) )
 244     {
 245         p_vdec->p_context->flags |= CODEC_FLAG_TRUNCATED;
 246     }
 247 #endif
 248
 249     /* ***** Open the codec ***** */
 250     if( avcodec_open(p_vdec->p_context, p_vdec->p_codec) < 0 )
 251     {
 252         msg_Err( p_vdec->p_fifo, "cannot open codec (%s)",
 253                                  p_vdec->psz_namecodec );
 254         return( VLC_EGENERIC );
 255     }
 256     else
 257     {
 258         msg_Dbg( p_vdec->p_fifo, "ffmpeg codec (%s) started",
 259                                  p_vdec->psz_namecodec );
 260     }
 261
 262     p_vdec->b_direct_rendering = 0;
 263     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-dr" ) &&
 264         p_vdec->p_codec->capabilities & CODEC_CAP_DR1 &&
 265         ffmpeg_PixFmtToChroma( p_vdec->p_context->pix_fmt ) &&
 266         /* Apparently direct rendering doesn't work with YUV422P */
 267         p_vdec->p_context->pix_fmt != PIX_FMT_YUV422P &&
 268         !(p_vdec->p_context->width % 16) && !(p_vdec->p_context->height % 16) )
 269     {
 270         /* Some codecs set pix_fmt only after the 1st frame has been decoded,
 271          * so we need to do another check in ffmpeg_GetFrameBuf() */
 272         p_vdec->b_direct_rendering = 1;
 273     }
 274
 275     /* ***** Load post processing ***** */
 276 #ifdef LIBAVCODEC_PP
 277     p_vdec->pp_context = NULL;
 278     p_vdec->pp_mode    = NULL;
 279
 280     if( config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-q" ) > 0 )
 281     {
 282         int  i_quality = config_GetInt( p_vdec->p_fifo, "ffmpeg-pp-q" );
 283         char *psz_name = config_GetPsz( p_vdec->p_fifo, "ffmpeg-pp-name" );
 284
 285         if( !psz_name )
 286         {
 287             psz_name = strdup( "default" );
 288         }
 289         else if( *psz_name == '\0' )
 290         {
 291             free( psz_name );
 292             psz_name = strdup( "default" );
 293         }
 294
 295         p_vdec->pp_mode =
 296             pp_get_mode_by_name_and_quality( psz_name, i_quality );
 297
 298         if( !p_vdec->pp_mode )
 299         {
 300             msg_Err( p_vdec->p_fifo, "failed geting mode for postproc" );
 301         }
 302         else
 303         {
 304             msg_Info( p_vdec->p_fifo, "postproc activated" );
 305         }
 306         free( psz_name );
 307
 308         /* for now we cannot do postproc and dr */
 309         p_vdec->b_direct_rendering = 0;
 310     }
 311     else
 312     {
 313         msg_Dbg( p_vdec->p_fifo, "no postproc" );
 314     }
 315 #endif
 316
 317     if( p_vdec->b_direct_rendering )
 318     {
 319         msg_Dbg( p_vdec->p_fifo, "using direct rendering" );
 320         p_vdec->p_context->flags|= CODEC_FLAG_EMU_EDGE;
 321         p_vdec->p_context->get_buffer     = ffmpeg_GetFrameBuf;
 322         p_vdec->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
 323         p_vdec->p_context->opaque = p_vdec;
 324
 325     }
 326
 327     /* ***** init this codec with special data ***** */
 328     if( p_vdec->p_format &&
 329             p_vdec->p_format->biSize > sizeof(BITMAPINFOHEADER) )
 330     {
 331         int b_gotpicture;
 332         int i_size = p_vdec->p_format->biSize - sizeof(BITMAPINFOHEADER);
 333
 334         if( p_vdec->i_codec_id == CODEC_ID_MPEG4 )
 335         {
 336             avcodec_decode_video( p_vdec->p_context, p_vdec->p_ff_pic,
 337                                   &b_gotpicture,
 338                                   (void *)&p_vdec->p_format[1],
 339                                   i_size );
 340         }
 341 #if LIBAVCODEC_BUILD >= 4666
 342         else if( p_vdec->i_codec_id == CODEC_ID_SVQ3 )
 343         {
 344             uint8_t *p;
 345
 346             p_vdec->p_context->extradata_size = i_size + 12;
 347             p = p_vdec->p_context->extradata  =
 348                 malloc( p_vdec->p_context->extradata_size );
 349
 350             memcpy( &p[0],  "SVQ3", 4 );
 351             memset( &p[4], 0, 8 );
 352             memcpy( &p[12], &p_vdec->p_format[1], i_size );
 353         }
 354 #endif
 355         else
 356         {
 357             p_vdec->p_context->extradata_size = i_size;
 358             p_vdec->p_context->extradata      = malloc( i_size );
 359             memcpy( p_vdec->p_context->extradata,
 360                     &p_vdec->p_format[1],
 361                     i_size );
 362         }
 363     }
 364
 365     return( VLC_SUCCESS );
 366 }
 367
 368 /*****************************************************************************
 369  * DecodeThread: Called to decode one frame
 370  *****************************************************************************
 371  * We have to get a frame stored in a pes, give it to ffmpeg decoder and send
 372  * the image to the output.
 373  *****************************************************************************/
 374 void  E_( DecodeThread_Video )( vdec_thread_t *p_vdec )
 375 {
 376     pes_packet_t    *p_pes;
 377     int     i_frame_size;
 378     int     i_used;
 379     int     b_drawpicture;
 380     int     b_gotpicture;
 381     picture_t *p_pic;                                    /* videolan picture */
 382     mtime_t   i_pts;
 383
 384
 385     /* TODO implement it in a better way */
 386     /* A good idea could be to decode all I pictures and see for the other */
 387     if( ( p_vdec->b_hurry_up )&& ( p_vdec->i_frame_late > 4 ) )
 388     {
 389         b_drawpicture = 0;
 390         if( p_vdec->i_frame_late < 8 )
 391         {
 392             p_vdec->p_context->hurry_up = 2;
 393         }
 394         else
 395         {
 396             /* too much late picture, won't decode
 397                but break picture until a new I, and for mpeg4 ...*/
 398             p_vdec->i_frame_late--; /* needed else it will never be decrease */
 399             input_ExtractPES( p_vdec->p_fifo, NULL );
 400             return;
 401         }
 402     }
 403     else
 404     {
 405         b_drawpicture = 1;
 406         p_vdec->p_context->hurry_up = 0;
 407     }
 408
 409     if( p_vdec->i_frame_late > 0 &&
 410         mdate() - p_vdec->i_frame_late_start > (mtime_t)5000000 )
 411     {
 412         msg_Err( p_vdec->p_fifo, "more than 5 seconds of late video -> "
 413                  "dropping (to slow computer ?)" );
 414         do
 415         {
 416             input_ExtractPES( p_vdec->p_fifo, &p_pes );
 417             if( !p_pes )
 418             {
 419                 p_vdec->p_fifo->b_error = 1;
 420                 return;
 421             }
 422             i_pts = p_pes->i_pts;
 423             input_DeletePES( p_vdec->p_fifo->p_packets_mgt, p_pes );
 424
 425         } while( i_pts <= 0 || i_pts < mdate() );
 426     }
 427
 428     if( !p_vdec->p_context->width || !p_vdec->p_context->height )
 429     {
 430         p_vdec->p_context->hurry_up = 5;
 431     }
 432
 433     do
 434     {
 435         input_ExtractPES( p_vdec->p_fifo, &p_pes );
 436         if( !p_pes )
 437         {
 438             p_vdec->p_fifo->b_error = 1;
 439             return;
 440         }
 441 #if 0
 442         if( p_vdec->i_codec_id == CODEC_ID_MPEG1VIDEO )
 443         {
 444             if( p_pes->i_dts )
 445             {
 446                 p_vdec->pts = p_pes->i_dts;
 447                 p_vdec->i_frame_count = 0;
 448             }
 449         }
 450         else
 451         {
 452             if( p_pes->i_pts )
 453             {
 454                 p_vdec->pts = p_pes->i_pts;
 455                 p_vdec->i_frame_count = 0;
 456             }
 457         }
 458 #endif
 459         if( p_pes->i_pts )
 460         {
 461             p_vdec->pts = p_pes->i_pts;
 462             p_vdec->i_frame_count = 0;
 463         }
 464
 465         i_frame_size = p_pes->i_pes_size;
 466
 467         if( i_frame_size > 0 )
 468         {
 469             uint8_t *p_last;
 470             int i_need;
 471             /* XXX Don't forget that ffmpeg required a little more bytes
 472              * that the real frame size */
 473             i_need = i_frame_size + 16 + p_vdec->i_buffer;
 474             if( p_vdec->i_buffer_size < i_need)
 475             {
 476                 p_last = p_vdec->p_buffer;
 477                 p_vdec->p_buffer = malloc( i_need );
 478                 p_vdec->i_buffer_size = i_need;
 479                 if( p_vdec->i_buffer > 0 )
 480                 {
 481                     memcpy( p_vdec->p_buffer, p_last, p_vdec->i_buffer );
 482                 }
 483                 FREE( p_last );
 484             }
 485             i_frame_size =
 486                 E_( GetPESData )( p_vdec->p_buffer + p_vdec->i_buffer,
 487                                   i_frame_size ,
 488                                   p_pes );
 489             memset( p_vdec->p_buffer + p_vdec->i_buffer + i_frame_size,
 490                     0,
 491                     16 );
 492         }
 493         input_DeletePES( p_vdec->p_fifo->p_packets_mgt, p_pes );
 494     } while( i_frame_size <= 0 );
 495
 496     i_frame_size += p_vdec->i_buffer;
 497
 498 usenextdata:
 499     i_used = avcodec_decode_video( p_vdec->p_context,
 500                                    p_vdec->p_ff_pic,
 501                                    &b_gotpicture,
 502                                    p_vdec->p_buffer,
 503                                    i_frame_size );
 504
 505     if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error ) return;
 506
 507 #if 0
 508     msg_Dbg( p_vdec->p_fifo,
 509              "used:%d framesize:%d (%s picture)",
 510              i_used, i_frame_size, b_gotpicture ? "got":"no got" );
 511 #endif
 512     if( i_used < 0 )
 513     {
 514         msg_Warn( p_vdec->p_fifo, "cannot decode one frame (%d bytes)",
 515                                   i_frame_size );
 516         p_vdec->i_frame_error++;
 517         p_vdec->i_buffer = 0;
 518         return;
 519     }
 520     else if( i_used < i_frame_size )
 521     {
 522         memmove( p_vdec->p_buffer,
 523                  p_vdec->p_buffer + i_used,
 524                  p_vdec->i_buffer_size - i_used );
 525
 526         p_vdec->i_buffer = i_frame_size - i_used;
 527     }
 528     else
 529     {
 530         p_vdec->i_buffer = 0;
 531     }
 532
 533     if( b_gotpicture )
 534     {
 535         p_vdec->i_frame_count++;
 536     }
 537
 538     /* consumed bytes */
 539     i_frame_size -= i_used;
 540
 541    /* Update frame late count*/
 542     if( p_vdec->pts <= mdate() )
 543     {
 544         p_vdec->i_frame_late++;
 545         if( p_vdec->i_frame_late == 1 )
 546         {
 547             p_vdec->i_frame_late_start = mdate();
 548         }
 549     }
 550     else
 551     {
 552         p_vdec->i_frame_late = 0;
 553     }
 554
 555     if( !b_gotpicture || p_vdec->p_ff_pic->linesize[0] == 0 || !b_drawpicture )
 556     {
 557         return;
 558     }
 559
 560     if( !p_vdec->b_direct_rendering )
 561     {
 562         p_vdec->p_vout = ffmpeg_CreateVout( p_vdec, p_vdec->p_context );
 563         if( !p_vdec->p_vout )
 564         {
 565             msg_Err( p_vdec->p_fifo, "cannot create vout" );
 566             p_vdec->p_fifo->b_error = 1; /* abort */
 567             return;
 568         }
 569
 570         /* Get a new picture */
 571         while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
 572         {
 573             if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
 574             {
 575                 return;
 576             }
 577             msleep( VOUT_OUTMEM_SLEEP );
 578         }
 579
 580         /* fill p_picture_t from AVVideoFrame and do chroma conversion
 581          * if needed */
 582         ffmpeg_CopyPicture( p_pic, p_vdec->p_ff_pic, p_vdec );
 583
 584     }
 585     else
 586     {
 587         p_pic = (picture_t *)p_vdec->p_ff_pic->opaque;
 588     }
 589
 590     /* fix date calculation */
 591     if( p_vdec->pts > 0 )
 592     {
 593         i_pts = p_vdec->pts;
 594
 595         if( p_vdec->p_context->frame_rate > 0 )
 596         {
 597            i_pts += (uint64_t)1000000 *
 598                     ( p_vdec->i_frame_count - 1) /
 599 #if LIBAVCODEC_BUILD >= 4662
 600                     DEFAULT_FRAME_RATE_BASE /
 601 #else
 602                     FRAME_RATE_BASE /
 603 #endif
 604                     p_vdec->p_context->frame_rate;
 605         }
 606     }
 607     else
 608     {
 609         i_pts = mdate() + DEFAULT_PTS_DELAY;  // FIXME
 610     }
 611
 612     vout_DatePicture( p_vdec->p_vout,
 613                       p_pic,
 614                       i_pts );
 615
 616     /* Send decoded frame to vout */
 617     vout_DisplayPicture( p_vdec->p_vout, p_pic );
 618
 619     if( i_frame_size > 0 )
 620     {
 621         goto usenextdata; /* try to use all data */
 622     }
 623 }
 624
 625 /*****************************************************************************
 626  * EndThread: thread destruction
 627  *****************************************************************************
 628  * This function is called when the thread ends after a sucessful
 629  * initialization.
 630  *****************************************************************************/
 631 void E_( EndThread_Video )( vdec_thread_t *p_vdec )
 632 {
 633
 634 #ifdef LIBAVCODEC_PP
 635     if( p_vdec->pp_mode )
 636     {
 637         pp_free_mode( p_vdec->pp_mode );
 638         if( p_vdec->pp_context )
 639         {
 640             pp_free_context( p_vdec->pp_context );
 641         }
 642     }
 643 #endif
 644
 645     if( p_vdec->p_ff_pic )
 646     {
 647         free( p_vdec->p_ff_pic );
 648     }
 649
 650     /* We are about to die. Reattach video output to p_vlc. */
 651     vout_Request( p_vdec->p_fifo, p_vdec->p_vout, 0, 0, 0, 0 );
 652 }
 653
 654 /*****************************************************************************
 655  * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
 656  *                     picture_t structure (when not in direct rendering mode).
 657  *****************************************************************************/
 658 static void ffmpeg_CopyPicture( picture_t    *p_pic,
 659                                 AVFrame *p_ff_pic,
 660                                 vdec_thread_t *p_vdec )
 661 {
 662     int i_plane;
 663     int i_size;
 664     int i_line;
 665
 666     uint8_t *p_dst;
 667     uint8_t *p_src;
 668     int i_src_stride;
 669     int i_dst_stride;
 670
 671     if( ffmpeg_PixFmtToChroma( p_vdec->p_context->pix_fmt ) )
 672     {
 673 #ifdef LIBAVCODEC_PP
 674         if( p_vdec->pp_mode && p_vdec->pp_context )
 675         {
 676             uint8_t *src[3], *dst[3];
 677             int     i_src_stride[3], i_dst_stride[3];
 678
 679             for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 680             {
 681                 src[i_plane] = p_ff_pic->data[i_plane];
 682                 dst[i_plane] = p_pic->p[i_plane].p_pixels;
 683
 684                 i_src_stride[i_plane] = p_ff_pic->linesize[i_plane];
 685                 i_dst_stride[i_plane] = p_pic->p[i_plane].i_pitch;
 686             }
 687             pp_postprocess( src, i_src_stride,
 688                             dst, i_dst_stride,
 689                             p_vdec->p_context->width,
 690                             p_vdec->p_context->height,
 691                             p_ff_pic->qscale_table, p_ff_pic->qstride,
 692                             p_vdec->pp_mode, p_vdec->pp_context,
 693                             p_ff_pic->pict_type );
 694         }
 695         else
 696         {
 697 #endif
 698             for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
 699             {
 700                 p_src  = p_ff_pic->data[i_plane];
 701                 p_dst = p_pic->p[i_plane].p_pixels;
 702                 i_src_stride = p_ff_pic->linesize[i_plane];
 703                 i_dst_stride = p_pic->p[i_plane].i_pitch;
 704
 705                 i_size = __MIN( i_src_stride, i_dst_stride );
 706                 for( i_line = 0; i_line < p_pic->p[i_plane].i_lines; i_line++ )
 707                 {
 708                     p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, i_size );
 709                     p_src += i_src_stride;
 710                     p_dst += i_dst_stride;
 711                 }
 712             }
 713 #ifdef LIBAVCODEC_PP
 714         }
 715 #endif
 716     }
 717     else
 718     {
 719         /* we need to convert to I420 */
 720         switch( p_vdec->p_context->pix_fmt )
 721         {
 722             AVPicture dest_pic;
 723             int i;
 724
 725             case( PIX_FMT_YUV410P ):
 726             case( PIX_FMT_YUV411P ):
 727                 for( i = 0; i < p_pic->i_planes; i++ )
 728                 {
 729                     dest_pic.data[i] = p_pic->p[i].p_pixels;
 730                     dest_pic.linesize[i] = p_pic->p[i].i_pitch;
 731                 }
 732                 img_convert( &dest_pic, PIX_FMT_YUV420P,
 733                              (AVPicture *)p_ff_pic,
 734                              p_vdec->p_context->pix_fmt,
 735                              p_vdec->p_context->width,
 736                              p_vdec->p_context->height );
 737                 break;
 738             default:
 739                 msg_Err( p_vdec->p_fifo, "don't know how to convert chroma %i",
 740                          p_vdec->p_context->pix_fmt );
 741                 p_vdec->p_fifo->b_error = 1;
 742                 break;
 743         }
 744     }
 745 }
 746
 747 /*****************************************************************************
 748  * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
 749  *                     (used for direct rendering)
 750  *****************************************************************************/
 751 static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
 752                                AVFrame *p_ff_pic )
 753 {
 754     vdec_thread_t *p_vdec = (vdec_thread_t *)p_context->opaque;
 755     picture_t *p_pic;
 756
 757     /* Some codecs set pix_fmt only after the 1st frame has been decoded,
 758      * so this check is necessary. */
 759     if( !ffmpeg_PixFmtToChroma( p_context->pix_fmt ) )
 760     {
 761         p_context->get_buffer = avcodec_default_get_buffer;
 762         p_context->release_buffer = avcodec_default_release_buffer;
 763         p_vdec->b_direct_rendering = 0;
 764         msg_Dbg( p_vdec->p_fifo, "disabling direct rendering" );
 765         return p_context->get_buffer( p_context, p_ff_pic );
 766     }
 767
 768     /* Check and (re)create our vout if needed */
 769     p_vdec->p_vout = ffmpeg_CreateVout( p_vdec, p_vdec->p_context );
 770     if( !p_vdec->p_vout )
 771     {
 772         msg_Err( p_vdec->p_fifo, "cannot create vout" );
 773         p_vdec->p_fifo->b_error = 1; /* abort */
 774         p_context->get_buffer= avcodec_default_get_buffer;
 775         return p_context->get_buffer( p_context, p_ff_pic );
 776     }
 777     p_vdec->p_vout->render.b_allow_modify_pics = 0;
 778
 779     /* Get a new picture */
 780     while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
 781     {
 782         if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
 783         {
 784             p_context->get_buffer= avcodec_default_get_buffer;
 785             return p_context->get_buffer( p_context, p_ff_pic );
 786         }
 787         msleep( VOUT_OUTMEM_SLEEP );
 788     }
 789     p_vdec->p_context->draw_horiz_band= NULL;
 790
 791     p_ff_pic->opaque = (void*)p_pic;
 792     p_ff_pic->type = FF_BUFFER_TYPE_USER;
 793     p_ff_pic->data[0] = p_pic->p[0].p_pixels;
 794     p_ff_pic->data[1] = p_pic->p[1].p_pixels;
 795     p_ff_pic->data[2] = p_pic->p[2].p_pixels;
 796     p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
 797
 798     p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
 799     p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
 800     p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
 801     p_ff_pic->linesize[3] = 0;
 802
 803     if( p_ff_pic->reference != 0 )
 804     {
 805         vout_LinkPicture( p_vdec->p_vout, p_pic );
 806     }
 807     /* FIXME what is that, should give good value */
 808     p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
 809
 810     return( 0 );
 811 }
 812
 813 static void  ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
 814                                      AVFrame *p_ff_pic )
 815 {
 816     vdec_thread_t *p_vdec = (vdec_thread_t *)p_context->opaque;
 817     picture_t *p_pic;
 818
 819     if( p_ff_pic->type != FF_BUFFER_TYPE_USER )
 820     {
 821         avcodec_default_release_buffer( p_context, p_ff_pic );
 822         return;
 823     }
 824
 825     //msg_Dbg( p_vdec->p_fifo, "ffmpeg_ReleaseFrameBuf" );
 826     p_pic = (picture_t*)p_ff_pic->opaque;
 827
 828     p_ff_pic->data[0] = NULL;
 829     p_ff_pic->data[1] = NULL;
 830     p_ff_pic->data[2] = NULL;
 831     p_ff_pic->data[3] = NULL;
 832
 833     if( p_ff_pic->reference != 0 )
 834     {
 835         vout_UnlinkPicture( p_vdec->p_vout, p_pic );
 836     }
 837 }