* modules/codec/ffmpeg/video.c: disabled direct rendering when hurry-up is
[vlc.git] / 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.32 2003/06/19 21:09:27 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     /* ffmpeg doesn't properly release old pictures when frames are skipped */
318     if( p_vdec->b_hurry_up ) p_vdec->b_direct_rendering = 0;
319
320     if( p_vdec->b_direct_rendering )
321     {
322         msg_Dbg( p_vdec->p_fifo, "using direct rendering" );
323         p_vdec->p_context->flags|= CODEC_FLAG_EMU_EDGE;
324         p_vdec->p_context->get_buffer     = ffmpeg_GetFrameBuf;
325         p_vdec->p_context->release_buffer = ffmpeg_ReleaseFrameBuf;
326         p_vdec->p_context->opaque = p_vdec;
327
328     }
329
330     /* ***** init this codec with special data ***** */
331     if( p_vdec->p_format &&
332             p_vdec->p_format->biSize > sizeof(BITMAPINFOHEADER) )
333     {
334         int b_gotpicture;
335         int i_size = p_vdec->p_format->biSize - sizeof(BITMAPINFOHEADER);
336
337         if( p_vdec->i_codec_id == CODEC_ID_MPEG4 )
338         {
339             avcodec_decode_video( p_vdec->p_context, p_vdec->p_ff_pic,
340                                   &b_gotpicture,
341                                   (void *)&p_vdec->p_format[1],
342                                   i_size );
343         }
344 #if LIBAVCODEC_BUILD >= 4666
345         else if( p_vdec->i_codec_id == CODEC_ID_SVQ3 )
346         {
347             uint8_t *p;
348
349             p_vdec->p_context->extradata_size = i_size + 12;
350             p = p_vdec->p_context->extradata  =
351                 malloc( p_vdec->p_context->extradata_size );
352
353             memcpy( &p[0],  "SVQ3", 4 );
354             memset( &p[4], 0, 8 );
355             memcpy( &p[12], &p_vdec->p_format[1], i_size );
356         }
357 #endif
358         else
359         {
360             p_vdec->p_context->extradata_size = i_size;
361             p_vdec->p_context->extradata      = malloc( i_size );
362             memcpy( p_vdec->p_context->extradata,
363                     &p_vdec->p_format[1],
364                     i_size );
365         }
366     }
367
368     return( VLC_SUCCESS );
369 }
370
371 /*****************************************************************************
372  * DecodeThread: Called to decode one frame
373  *****************************************************************************
374  * We have to get a frame stored in a pes, give it to ffmpeg decoder and send
375  * the image to the output.
376  *****************************************************************************/
377 void  E_( DecodeThread_Video )( vdec_thread_t *p_vdec )
378 {
379     pes_packet_t    *p_pes;
380     int     i_frame_size;
381     int     i_used;
382     int     b_drawpicture;
383     int     b_gotpicture;
384     picture_t *p_pic;                                    /* videolan picture */
385     mtime_t   i_pts;
386
387
388     /* TODO implement it in a better way */
389     /* A good idea could be to decode all I pictures and see for the other */
390     if( ( p_vdec->b_hurry_up )&& ( p_vdec->i_frame_late > 4 ) )
391     {
392         b_drawpicture = 0;
393         if( p_vdec->i_frame_late < 8 )
394         {
395             p_vdec->p_context->hurry_up = 2;
396         }
397         else
398         {
399             /* too much late picture, won't decode
400                but break picture until a new I, and for mpeg4 ...*/
401             p_vdec->i_frame_late--; /* needed else it will never be decrease */
402             input_ExtractPES( p_vdec->p_fifo, NULL );
403             return;
404         }
405     }
406     else
407     {
408         b_drawpicture = 1;
409         p_vdec->p_context->hurry_up = 0;
410     }
411
412     if( p_vdec->i_frame_late > 0 &&
413         mdate() - p_vdec->i_frame_late_start > (mtime_t)5000000 )
414     {
415         msg_Err( p_vdec->p_fifo, "more than 5 seconds of late video -> "
416                  "dropping (to slow computer ?)" );
417         do
418         {
419             input_ExtractPES( p_vdec->p_fifo, &p_pes );
420             if( !p_pes )
421             {
422                 p_vdec->p_fifo->b_error = 1;
423                 return;
424             }
425             i_pts = p_pes->i_pts;
426             input_DeletePES( p_vdec->p_fifo->p_packets_mgt, p_pes );
427
428         } while( i_pts <= 0 || i_pts < mdate() );
429     }
430
431     if( !p_vdec->p_context->width || !p_vdec->p_context->height )
432     {
433         p_vdec->p_context->hurry_up = 5;
434     }
435
436     do
437     {
438         input_ExtractPES( p_vdec->p_fifo, &p_pes );
439         if( !p_pes )
440         {
441             p_vdec->p_fifo->b_error = 1;
442             return;
443         }
444 #if 0
445         if( p_vdec->i_codec_id == CODEC_ID_MPEG1VIDEO )
446         {
447             if( p_pes->i_dts )
448             {
449                 p_vdec->pts = p_pes->i_dts;
450                 p_vdec->i_frame_count = 0;
451             }
452         }
453         else
454         {
455             if( p_pes->i_pts )
456             {
457                 p_vdec->pts = p_pes->i_pts;
458                 p_vdec->i_frame_count = 0;
459             }
460         }
461 #endif
462         if( p_pes->i_pts )
463         {
464             p_vdec->pts = p_pes->i_pts;
465             p_vdec->i_frame_count = 0;
466         }
467
468         i_frame_size = p_pes->i_pes_size;
469
470         if( i_frame_size > 0 )
471         {
472             uint8_t *p_last;
473             int i_need;
474             /* XXX Don't forget that ffmpeg required a little more bytes
475              * that the real frame size */
476             i_need = i_frame_size + 16 + p_vdec->i_buffer;
477             if( p_vdec->i_buffer_size < i_need)
478             {
479                 p_last = p_vdec->p_buffer;
480                 p_vdec->p_buffer = malloc( i_need );
481                 p_vdec->i_buffer_size = i_need;
482                 if( p_vdec->i_buffer > 0 )
483                 {
484                     memcpy( p_vdec->p_buffer, p_last, p_vdec->i_buffer );
485                 }
486                 FREE( p_last );
487             }
488             i_frame_size =
489                 E_( GetPESData )( p_vdec->p_buffer + p_vdec->i_buffer,
490                                   i_frame_size ,
491                                   p_pes );
492             memset( p_vdec->p_buffer + p_vdec->i_buffer + i_frame_size,
493                     0,
494                     16 );
495         }
496         input_DeletePES( p_vdec->p_fifo->p_packets_mgt, p_pes );
497     } while( i_frame_size <= 0 );
498
499     i_frame_size += p_vdec->i_buffer;
500
501 usenextdata:
502     i_used = avcodec_decode_video( p_vdec->p_context,
503                                    p_vdec->p_ff_pic,
504                                    &b_gotpicture,
505                                    p_vdec->p_buffer,
506                                    i_frame_size );
507
508     if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error ) return;
509
510 #if 0
511     msg_Dbg( p_vdec->p_fifo,
512              "used:%d framesize:%d (%s picture)",
513              i_used, i_frame_size, b_gotpicture ? "got":"no got" );
514 #endif
515     if( i_used < 0 )
516     {
517         msg_Warn( p_vdec->p_fifo, "cannot decode one frame (%d bytes)",
518                                   i_frame_size );
519         p_vdec->i_frame_error++;
520         p_vdec->i_buffer = 0;
521         return;
522     }
523     else if( i_used < i_frame_size )
524     {
525         memmove( p_vdec->p_buffer,
526                  p_vdec->p_buffer + i_used,
527                  p_vdec->i_buffer_size - i_used );
528
529         p_vdec->i_buffer = i_frame_size - i_used;
530     }
531     else
532     {
533         p_vdec->i_buffer = 0;
534     }
535
536     if( b_gotpicture )
537     {
538         p_vdec->i_frame_count++;
539     }
540
541     /* consumed bytes */
542     i_frame_size -= i_used;
543
544    /* Update frame late count*/
545     if( p_vdec->pts <= mdate() )
546     {
547         p_vdec->i_frame_late++;
548         if( p_vdec->i_frame_late == 1 )
549         {
550             p_vdec->i_frame_late_start = mdate();
551         }
552     }
553     else
554     {
555         p_vdec->i_frame_late = 0;
556     }
557
558     if( !b_gotpicture || p_vdec->p_ff_pic->linesize[0] == 0 || !b_drawpicture )
559     {
560         return;
561     }
562
563     if( !p_vdec->b_direct_rendering )
564     {
565         p_vdec->p_vout = ffmpeg_CreateVout( p_vdec, p_vdec->p_context );
566         if( !p_vdec->p_vout )
567         {
568             msg_Err( p_vdec->p_fifo, "cannot create vout" );
569             p_vdec->p_fifo->b_error = 1; /* abort */
570             return;
571         }
572
573         /* Get a new picture */
574         while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
575         {
576             if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
577             {
578                 return;
579             }
580             msleep( VOUT_OUTMEM_SLEEP );
581         }
582
583         /* fill p_picture_t from AVVideoFrame and do chroma conversion
584          * if needed */
585         ffmpeg_CopyPicture( p_pic, p_vdec->p_ff_pic, p_vdec );
586
587     }
588     else
589     {
590         p_pic = (picture_t *)p_vdec->p_ff_pic->opaque;
591     }
592
593     /* fix date calculation */
594     if( p_vdec->pts > 0 )
595     {
596         i_pts = p_vdec->pts;
597
598         if( p_vdec->p_context->frame_rate > 0 )
599         {
600            i_pts += (uint64_t)1000000 *
601                     ( p_vdec->i_frame_count - 1) /
602 #if LIBAVCODEC_BUILD >= 4662
603                     DEFAULT_FRAME_RATE_BASE /
604 #else
605                     FRAME_RATE_BASE /
606 #endif
607                     p_vdec->p_context->frame_rate;
608         }
609     }
610     else
611     {
612         i_pts = mdate() + DEFAULT_PTS_DELAY;  // FIXME
613     }
614
615     vout_DatePicture( p_vdec->p_vout,
616                       p_pic,
617                       i_pts );
618
619     /* Send decoded frame to vout */
620     vout_DisplayPicture( p_vdec->p_vout, p_pic );
621
622     if( i_frame_size > 0 )
623     {
624         goto usenextdata; /* try to use all data */
625     }
626 }
627
628 /*****************************************************************************
629  * EndThread: thread destruction
630  *****************************************************************************
631  * This function is called when the thread ends after a sucessful
632  * initialization.
633  *****************************************************************************/
634 void E_( EndThread_Video )( vdec_thread_t *p_vdec )
635 {
636
637 #ifdef LIBAVCODEC_PP
638     if( p_vdec->pp_mode )
639     {
640         pp_free_mode( p_vdec->pp_mode );
641         if( p_vdec->pp_context )
642         {
643             pp_free_context( p_vdec->pp_context );
644         }
645     }
646 #endif
647
648     if( p_vdec->p_ff_pic )
649     {
650         free( p_vdec->p_ff_pic );
651     }
652
653     /* We are about to die. Reattach video output to p_vlc. */
654     vout_Request( p_vdec->p_fifo, p_vdec->p_vout, 0, 0, 0, 0 );
655 }
656
657 /*****************************************************************************
658  * ffmpeg_CopyPicture: copy a picture from ffmpeg internal buffers to a
659  *                     picture_t structure (when not in direct rendering mode).
660  *****************************************************************************/
661 static void ffmpeg_CopyPicture( picture_t    *p_pic,
662                                 AVFrame *p_ff_pic,
663                                 vdec_thread_t *p_vdec )
664 {
665     int i_plane;
666     int i_size;
667     int i_line;
668
669     uint8_t *p_dst;
670     uint8_t *p_src;
671     int i_src_stride;
672     int i_dst_stride;
673
674     if( ffmpeg_PixFmtToChroma( p_vdec->p_context->pix_fmt ) )
675     {
676 #ifdef LIBAVCODEC_PP
677         if( p_vdec->pp_mode && p_vdec->pp_context )
678         {
679             uint8_t *src[3], *dst[3];
680             int     i_src_stride[3], i_dst_stride[3];
681
682             for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
683             {
684                 src[i_plane] = p_ff_pic->data[i_plane];
685                 dst[i_plane] = p_pic->p[i_plane].p_pixels;
686
687                 i_src_stride[i_plane] = p_ff_pic->linesize[i_plane];
688                 i_dst_stride[i_plane] = p_pic->p[i_plane].i_pitch;
689             }
690             pp_postprocess( src, i_src_stride,
691                             dst, i_dst_stride,
692                             p_vdec->p_context->width,
693                             p_vdec->p_context->height,
694                             p_ff_pic->qscale_table, p_ff_pic->qstride,
695                             p_vdec->pp_mode, p_vdec->pp_context,
696                             p_ff_pic->pict_type );
697         }
698         else
699         {
700 #endif
701             for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
702             {
703                 p_src  = p_ff_pic->data[i_plane];
704                 p_dst = p_pic->p[i_plane].p_pixels;
705                 i_src_stride = p_ff_pic->linesize[i_plane];
706                 i_dst_stride = p_pic->p[i_plane].i_pitch;
707
708                 i_size = __MIN( i_src_stride, i_dst_stride );
709                 for( i_line = 0; i_line < p_pic->p[i_plane].i_lines; i_line++ )
710                 {
711                     p_vdec->p_fifo->p_vlc->pf_memcpy( p_dst, p_src, i_size );
712                     p_src += i_src_stride;
713                     p_dst += i_dst_stride;
714                 }
715             }
716 #ifdef LIBAVCODEC_PP
717         }
718 #endif
719     }
720     else
721     {
722         /* we need to convert to I420 */
723         switch( p_vdec->p_context->pix_fmt )
724         {
725             AVPicture dest_pic;
726             int i;
727
728             case( PIX_FMT_YUV410P ):
729             case( PIX_FMT_YUV411P ):
730                 for( i = 0; i < p_pic->i_planes; i++ )
731                 {
732                     dest_pic.data[i] = p_pic->p[i].p_pixels;
733                     dest_pic.linesize[i] = p_pic->p[i].i_pitch;
734                 }
735                 img_convert( &dest_pic, PIX_FMT_YUV420P,
736                              (AVPicture *)p_ff_pic,
737                              p_vdec->p_context->pix_fmt,
738                              p_vdec->p_context->width,
739                              p_vdec->p_context->height );
740                 break;
741             default:
742                 msg_Err( p_vdec->p_fifo, "don't know how to convert chroma %i",
743                          p_vdec->p_context->pix_fmt );
744                 p_vdec->p_fifo->b_error = 1;
745                 break;
746         }
747     }
748 }
749
750 /*****************************************************************************
751  * ffmpeg_GetFrameBuf: callback used by ffmpeg to get a frame buffer.
752  *                     (used for direct rendering)
753  *****************************************************************************/
754 static int ffmpeg_GetFrameBuf( struct AVCodecContext *p_context,
755                                AVFrame *p_ff_pic )
756 {
757     vdec_thread_t *p_vdec = (vdec_thread_t *)p_context->opaque;
758     picture_t *p_pic;
759
760     /* Some codecs set pix_fmt only after the 1st frame has been decoded,
761      * so this check is necessary. */
762     if( !ffmpeg_PixFmtToChroma( p_context->pix_fmt ) )
763     {
764         p_context->get_buffer = avcodec_default_get_buffer;
765         p_context->release_buffer = avcodec_default_release_buffer;
766         p_vdec->b_direct_rendering = 0;
767         msg_Dbg( p_vdec->p_fifo, "disabling direct rendering" );
768         return p_context->get_buffer( p_context, p_ff_pic );
769     }
770
771     /* Check and (re)create our vout if needed */
772     p_vdec->p_vout = ffmpeg_CreateVout( p_vdec, p_vdec->p_context );
773     if( !p_vdec->p_vout )
774     {
775         msg_Err( p_vdec->p_fifo, "cannot create vout" );
776         p_vdec->p_fifo->b_error = 1; /* abort */
777         p_context->get_buffer= avcodec_default_get_buffer;
778         return p_context->get_buffer( p_context, p_ff_pic );
779     }
780     p_vdec->p_vout->render.b_allow_modify_pics = 0;
781
782     /* Get a new picture */
783     while( !(p_pic = vout_CreatePicture( p_vdec->p_vout, 0, 0, 0 ) ) )
784     {
785         if( p_vdec->p_fifo->b_die || p_vdec->p_fifo->b_error )
786         {
787             p_context->get_buffer= avcodec_default_get_buffer;
788             return p_context->get_buffer( p_context, p_ff_pic );
789         }
790         msleep( VOUT_OUTMEM_SLEEP );
791     }
792     p_vdec->p_context->draw_horiz_band= NULL;
793
794     p_ff_pic->opaque = (void*)p_pic;
795     p_ff_pic->type = FF_BUFFER_TYPE_USER;
796     p_ff_pic->data[0] = p_pic->p[0].p_pixels;
797     p_ff_pic->data[1] = p_pic->p[1].p_pixels;
798     p_ff_pic->data[2] = p_pic->p[2].p_pixels;
799     p_ff_pic->data[3] = NULL; /* alpha channel but I'm not sure */
800
801     p_ff_pic->linesize[0] = p_pic->p[0].i_pitch;
802     p_ff_pic->linesize[1] = p_pic->p[1].i_pitch;
803     p_ff_pic->linesize[2] = p_pic->p[2].i_pitch;
804     p_ff_pic->linesize[3] = 0;
805
806     if( p_ff_pic->reference != 0 )
807     {
808         vout_LinkPicture( p_vdec->p_vout, p_pic );
809     }
810     /* FIXME what is that, should give good value */
811     p_ff_pic->age = 256*256*256*64; // FIXME FIXME from ffmpeg
812
813     return( 0 );
814 }
815
816 static void  ffmpeg_ReleaseFrameBuf( struct AVCodecContext *p_context,
817                                      AVFrame *p_ff_pic )
818 {
819     vdec_thread_t *p_vdec = (vdec_thread_t *)p_context->opaque;
820     picture_t *p_pic;
821
822     if( p_ff_pic->type != FF_BUFFER_TYPE_USER )
823     {
824         avcodec_default_release_buffer( p_context, p_ff_pic );
825         return;
826     }
827
828     //msg_Dbg( p_vdec->p_fifo, "ffmpeg_ReleaseFrameBuf" );
829     p_pic = (picture_t*)p_ff_pic->opaque;
830
831     p_ff_pic->data[0] = NULL;
832     p_ff_pic->data[1] = NULL;
833     p_ff_pic->data[2] = NULL;
834     p_ff_pic->data[3] = NULL;
835
836     if( p_ff_pic->reference != 0 )
837     {
838         vout_UnlinkPicture( p_vdec->p_vout, p_pic );
839     }
840 }