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