0cc770210fbefc38533193f64f1125c12a4e0198
[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.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 }