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