39bde8dd09931cec15a5572a6b436c469970c245
[vlc.git] / modules / codec / libmpeg2.c
1 /*****************************************************************************
2  * libmpeg2.c: mpeg2 video decoder module making use of libmpeg2.
3  *****************************************************************************
4  * Copyright (C) 1999-2001 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *          Christophe Massiot <massiot@via.ecp.fr>
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31 #include <assert.h>
32
33 #include <vlc_common.h>
34 #include <vlc_plugin.h>
35 #include <vlc_codec.h>
36 #include <vlc_block_helper.h>
37 #include <vlc_cpu.h>
38 #include "../codec/cc.h"
39
40 #include <mpeg2.h>
41
42 #include <vlc_codec_synchro.h>
43
44 /*****************************************************************************
45  * decoder_sys_t : libmpeg2 decoder descriptor
46  *****************************************************************************/
47 #define DPB_COUNT (3+1)
48 typedef struct
49 {
50     picture_t *p_picture;
51     bool      b_linked;
52     bool      b_displayed;
53 } picture_dpb_t;
54
55 struct decoder_sys_t
56 {
57     /*
58      * libmpeg2 properties
59      */
60     mpeg2dec_t          *p_mpeg2dec;
61     const mpeg2_info_t  *p_info;
62     bool                b_skip;
63
64     /*
65      * Input properties
66      */
67     mtime_t          i_previous_pts;
68     mtime_t          i_current_pts;
69     mtime_t          i_previous_dts;
70     mtime_t          i_current_dts;
71     bool             b_garbage_pic;
72     bool             b_after_sequence_header; /* is it the next frame after
73                                                * the sequence header ?    */
74     bool             b_slice_i;             /* intra-slice refresh stream */
75     bool             b_second_field;
76
77     bool             b_preroll;
78
79     /* */
80     picture_dpb_t        p_dpb[DPB_COUNT];
81
82     /*
83      * Output properties
84      */
85     decoder_synchro_t *p_synchro;
86     int             i_aspect;
87     int             i_sar_num;
88     int             i_sar_den;
89     mtime_t         i_last_frame_pts;
90
91     /* Closed captioning support */
92     uint32_t        i_cc_flags;
93     mtime_t         i_cc_pts;
94     mtime_t         i_cc_dts;
95     cc_data_t       cc;
96     uint8_t        *p_gop_user_data;
97     uint32_t        i_gop_user_data;
98 };
99
100 /*****************************************************************************
101  * Local prototypes
102  *****************************************************************************/
103 static int  OpenDecoder( vlc_object_t * );
104 static void CloseDecoder( vlc_object_t * );
105
106 static picture_t *DecodeBlock( decoder_t *, block_t ** );
107 #if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
108 static block_t   *GetCc( decoder_t *p_dec, bool pb_present[4] );
109 #endif
110
111 static picture_t *GetNewPicture( decoder_t * );
112 static void PutPicture( decoder_t *, picture_t * );
113
114 static void GetAR( decoder_t *p_dec );
115
116 static void Reset( decoder_t *p_dec );
117
118 /* */
119 static void DpbInit( decoder_t * );
120 static void DpbClean( decoder_t * );
121 static picture_t *DpbNewPicture( decoder_t * );
122 static void DpbUnlinkPicture( decoder_t *, picture_t * );
123 static int DpbDisplayPicture( decoder_t *, picture_t * );
124
125 /*****************************************************************************
126  * Module descriptor
127  *****************************************************************************/
128 vlc_module_begin ()
129     set_description( N_("MPEG I/II video decoder (using libmpeg2)") )
130     set_capability( "decoder", 150 )
131     set_category( CAT_INPUT )
132     set_subcategory( SUBCAT_INPUT_VCODEC )
133     set_callbacks( OpenDecoder, CloseDecoder )
134     add_shortcut( "libmpeg2" )
135 vlc_module_end ()
136
137 /*****************************************************************************
138  * OpenDecoder: probe the decoder and return score
139  *****************************************************************************/
140 static int OpenDecoder( vlc_object_t *p_this )
141 {
142     decoder_t *p_dec = (decoder_t*)p_this;
143     decoder_sys_t *p_sys;
144     uint32_t i_accel = 0;
145
146     if( p_dec->fmt_in.i_codec != VLC_CODEC_MPGV )
147         return VLC_EGENERIC;
148
149     /* Select onl recognized original format (standard mpeg video) */
150     switch( p_dec->fmt_in.i_original_fourcc )
151     {
152     case VLC_FOURCC('m','p','g','1'):
153     case VLC_FOURCC('m','p','g','2'):
154     case VLC_FOURCC('m','p','g','v'):
155     case VLC_FOURCC('P','I','M','1'):
156     case VLC_FOURCC('h','d','v','2'):
157         break;
158     default:
159         if( p_dec->fmt_in.i_original_fourcc )
160             return VLC_EGENERIC;
161         break;
162     }
163
164     /* Allocate the memory needed to store the decoder's structure */
165     if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(*p_sys)) ) == NULL )
166         return VLC_ENOMEM;
167
168     /* Initialize the thread properties */
169     p_sys->p_mpeg2dec = NULL;
170     p_sys->p_synchro  = NULL;
171     p_sys->p_info     = NULL;
172     p_sys->i_current_pts  = 0;
173     p_sys->i_previous_pts = 0;
174     p_sys->i_current_dts  = 0;
175     p_sys->i_previous_dts = 0;
176     p_sys->i_aspect = 0;
177     p_sys->b_garbage_pic = false;
178     p_sys->b_slice_i  = false;
179     p_sys->b_second_field = false;
180     p_sys->b_skip     = false;
181     p_sys->b_preroll = false;
182     DpbInit( p_dec );
183
184     p_sys->i_cc_pts = 0;
185     p_sys->i_cc_dts = 0;
186     p_sys->i_cc_flags = 0;
187 #if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
188     p_dec->pf_get_cc = GetCc;
189     cc_Init( &p_sys->cc );
190 #endif
191     p_sys->p_gop_user_data = NULL;
192     p_sys->i_gop_user_data = 0;
193
194 #if defined( __i386__ ) || defined( __x86_64__ )
195     if( vlc_CPU() & CPU_CAPABILITY_MMX )
196     {
197         i_accel |= MPEG2_ACCEL_X86_MMX;
198     }
199
200     if( vlc_CPU() & CPU_CAPABILITY_3DNOW )
201     {
202         i_accel |= MPEG2_ACCEL_X86_3DNOW;
203     }
204
205     if( vlc_CPU() & CPU_CAPABILITY_MMXEXT )
206     {
207         i_accel |= MPEG2_ACCEL_X86_MMXEXT;
208     }
209
210 #elif defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
211     if( vlc_CPU() & CPU_CAPABILITY_ALTIVEC )
212     {
213         i_accel |= MPEG2_ACCEL_PPC_ALTIVEC;
214     }
215
216 #elif defined(__arm__)
217     i_accel |= MPEG2_ACCEL_ARM;
218
219 #else
220     /* If we do not know this CPU, trust libmpeg2's feature detection */
221     i_accel = MPEG2_ACCEL_DETECT;
222
223 #endif
224
225     /* Set CPU acceleration features */
226     mpeg2_accel( i_accel );
227
228     /* Initialize decoder */
229     p_sys->p_mpeg2dec = mpeg2_init();
230     if( p_sys->p_mpeg2dec == NULL)
231     {
232         msg_Err( p_dec, "mpeg2_init() failed" );
233         free( p_sys );
234         return VLC_EGENERIC;
235     }
236
237     p_sys->p_info = mpeg2_info( p_sys->p_mpeg2dec );
238
239     p_dec->pf_decode_video = DecodeBlock;
240     p_dec->fmt_out.i_cat = VIDEO_ES;
241     p_dec->fmt_out.i_codec = 0;
242
243     return VLC_SUCCESS;
244 }
245
246 /*****************************************************************************
247  * RunDecoder: the libmpeg2 decoder
248  *****************************************************************************/
249 static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
250 {
251     decoder_sys_t   *p_sys = p_dec->p_sys;
252     mpeg2_state_t   state;
253     picture_t       *p_pic;
254
255     block_t *p_block;
256
257     if( !pp_block || !*pp_block )
258         return NULL;
259
260     p_block = *pp_block;
261     if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED) )
262         Reset( p_dec );
263
264     while( 1 )
265     {
266         state = mpeg2_parse( p_sys->p_mpeg2dec );
267
268         switch( state )
269         {
270         case STATE_SEQUENCE:
271         {
272             /* */
273             DpbClean( p_dec );
274
275             /* */
276             mpeg2_custom_fbuf( p_sys->p_mpeg2dec, 1 );
277
278             /* Set the first 2 reference frames */
279             p_sys->i_aspect = 0;
280             GetAR( p_dec );
281             for( int i = 0; i < 2; i++ )
282             {
283                 picture_t *p_picture = DpbNewPicture( p_dec );
284                 if( !p_picture )
285                 {
286                     Reset( p_dec );
287                     block_Release( p_block );
288                     return NULL;
289                 }
290                 PutPicture( p_dec, p_picture );
291             }
292
293             if( p_sys->p_synchro )
294                 decoder_SynchroRelease( p_sys->p_synchro );
295
296             if( p_sys->p_info->sequence->frame_period <= 0 )
297                 p_sys->p_synchro = NULL;
298             else
299                 p_sys->p_synchro =
300                 decoder_SynchroInit( p_dec, (uint32_t)(UINT64_C(1001000000) *
301                                 27 / p_sys->p_info->sequence->frame_period) );
302             p_sys->b_after_sequence_header = true;
303             break;
304         }
305
306         case STATE_GOP:
307             /* There can be userdata in a GOP. It needs to be remembered for the next picture. */
308             if( p_sys->p_info->user_data_len > 2 )
309             {
310                 free( p_sys->p_gop_user_data );
311                 p_sys->p_gop_user_data = calloc( p_sys->p_info->user_data_len, sizeof(uint8_t) );
312                 if( p_sys->p_gop_user_data )
313                 {
314                     p_sys->i_gop_user_data = p_sys->p_info->user_data_len;
315                     memcpy( p_sys->p_gop_user_data, p_sys->p_info->user_data, p_sys->p_info->user_data_len );
316                 }
317             }
318             break;
319
320         case STATE_PICTURE:
321         {
322             const mpeg2_info_t *p_info = p_sys->p_info;
323             const mpeg2_picture_t *p_current = p_info->current_picture;
324
325             mtime_t i_pts, i_dts;
326
327             if( p_sys->b_after_sequence_header &&
328                 (p_current->flags &
329                     PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P )
330             {
331                 /* Intra-slice refresh. Simulate a blank I picture. */
332                 msg_Dbg( p_dec, "intra-slice refresh stream" );
333                 decoder_SynchroNewPicture( p_sys->p_synchro,
334                                            I_CODING_TYPE, 2, 0, 0,
335                                            p_info->sequence->flags & SEQ_FLAG_LOW_DELAY );
336                 decoder_SynchroDecode( p_sys->p_synchro );
337                 decoder_SynchroEnd( p_sys->p_synchro, I_CODING_TYPE, 0 );
338                 p_sys->b_slice_i = true;
339             }
340             p_sys->b_after_sequence_header = false;
341
342 #ifdef PIC_FLAG_PTS
343             i_pts = p_current->flags & PIC_FLAG_PTS ?
344                 ( ( p_current->pts ==
345                     (uint32_t)p_sys->i_current_pts ) ?
346                   p_sys->i_current_pts : p_sys->i_previous_pts ) : 0;
347             i_dts = 0;
348
349             /* Hack to handle demuxers which only have DTS timestamps */
350             if( !i_pts && !p_block->i_pts && p_block->i_dts > 0 )
351             {
352                 if( p_info->sequence->flags & SEQ_FLAG_LOW_DELAY ||
353                     (p_current->flags &
354                       PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_B )
355                 {
356                     i_pts = p_block->i_dts;
357                 }
358             }
359             p_block->i_pts = p_block->i_dts = 0;
360             /* End hack */
361
362 #else /* New interface */
363
364             i_pts = p_current->flags & PIC_FLAG_TAGS ?
365                 ( ( p_current->tag == (uint32_t)p_sys->i_current_pts ) ?
366                             p_sys->i_current_pts : p_sys->i_previous_pts ) : 0;
367             i_dts = p_current->flags & PIC_FLAG_TAGS ?
368                 ( ( p_current->tag2 == (uint32_t)p_sys->i_current_dts ) ?
369                             p_sys->i_current_dts : p_sys->i_previous_dts ) : 0;
370 #endif
371
372             /* If nb_fields == 1, it is a field picture, and it will be
373              * followed by another field picture for which we won't call
374              * decoder_SynchroNewPicture() because this would have other
375              * problems, so we take it into account here.
376              * This kind of sucks, but I didn't think better. --Meuuh
377              */
378             decoder_SynchroNewPicture( p_sys->p_synchro,
379                                        p_current->flags & PIC_MASK_CODING_TYPE,
380                                        p_current->nb_fields == 1 ? 2 :
381                                        p_current->nb_fields, i_pts, i_dts,
382                                        p_info->sequence->flags & SEQ_FLAG_LOW_DELAY );
383
384
385             bool b_skip = false;
386             if( !p_dec->b_pace_control && !p_sys->b_preroll &&
387                 !(p_sys->b_slice_i
388                    && ((p_current->flags
389                          & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P))
390                    && !decoder_SynchroChoose( p_sys->p_synchro,
391                               p_current->flags
392                                 & PIC_MASK_CODING_TYPE,
393                               /*p_sys->p_vout->render_time*/ 0 /*FIXME*/,
394                               p_info->sequence->flags & SEQ_FLAG_LOW_DELAY ) )
395             {
396                 b_skip = true;
397             }
398
399             p_pic = NULL;
400             if( !b_skip )
401             {
402                 p_pic = DpbNewPicture( p_dec );
403                 if( !p_pic )
404                 {
405                     Reset( p_dec );
406
407                     p_pic = DpbNewPicture( p_dec );
408                     if( !p_pic )
409                     {
410                         mpeg2_reset( p_sys->p_mpeg2dec, 1 );
411                         block_Release( p_block );
412                         return NULL;
413                     }
414                 }
415             }
416
417             if( b_skip || !p_pic )
418             {
419                 mpeg2_skip( p_sys->p_mpeg2dec, 1 );
420                 p_sys->b_skip = true;
421                 decoder_SynchroTrash( p_sys->p_synchro );
422
423                 PutPicture( p_dec, NULL );
424
425                 if( !b_skip )
426                 {
427                     block_Release( p_block );
428                     return NULL;
429                 }
430             }
431             else
432             {
433                 mpeg2_skip( p_sys->p_mpeg2dec, 0 );
434                 p_sys->b_skip = false;
435                 decoder_SynchroDecode( p_sys->p_synchro );
436
437                 PutPicture( p_dec, p_pic );
438             }
439             if( p_info->user_data_len > 2 || p_sys->i_gop_user_data > 2 )
440             {
441                 p_sys->i_cc_pts = i_pts;
442                 p_sys->i_cc_dts = i_dts;
443                 if( (p_current->flags
444                              & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P )
445                     p_sys->i_cc_flags = BLOCK_FLAG_TYPE_P;
446                 else if( (p_current->flags
447                              & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_B )
448                     p_sys->i_cc_flags = BLOCK_FLAG_TYPE_B;
449                 else p_sys->i_cc_flags = BLOCK_FLAG_TYPE_I;
450
451                 if( p_sys->i_gop_user_data > 2 )
452                 {
453                     /* We now have picture info for any cached user_data out of the gop */
454                     cc_Extract( &p_sys->cc, &p_sys->p_gop_user_data[0], p_sys->i_gop_user_data );
455                     p_sys->i_gop_user_data = 0;
456                 }
457
458                 /* Extract the CC from the user_data of the picture */
459                 if( p_info->user_data_len > 2 )
460                     cc_Extract( &p_sys->cc, &p_info->user_data[0], p_info->user_data_len );
461             }
462         }
463         break;
464
465
466         case STATE_BUFFER:
467             if( !p_block->i_buffer )
468             {
469                 block_Release( p_block );
470                 return NULL;
471             }
472
473             if( (p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY
474                                       | BLOCK_FLAG_CORRUPTED)) &&
475                 p_sys->p_synchro &&
476                 p_sys->p_info->sequence &&
477                 p_sys->p_info->sequence->width != (unsigned)-1 )
478             {
479                 decoder_SynchroReset( p_sys->p_synchro );
480                 if( p_sys->p_info->current_fbuf != NULL &&
481                     p_sys->p_info->current_fbuf->id != NULL )
482                 {
483                     p_sys->b_garbage_pic = true;
484                 }
485                 if( p_sys->b_slice_i )
486                 {
487                     decoder_SynchroNewPicture( p_sys->p_synchro,
488                                                I_CODING_TYPE, 2, 0, 0,
489                                                p_sys->p_info->sequence->flags &
490                                                             SEQ_FLAG_LOW_DELAY );
491                     decoder_SynchroDecode( p_sys->p_synchro );
492                     decoder_SynchroEnd( p_sys->p_synchro, I_CODING_TYPE, 0 );
493                 }
494             }
495
496             if( p_block->i_flags & BLOCK_FLAG_PREROLL )
497             {
498                 p_sys->b_preroll = true;
499             }
500             else if( p_sys->b_preroll )
501             {
502                 p_sys->b_preroll = false;
503                 if( p_sys->p_synchro )
504                     decoder_SynchroReset( p_sys->p_synchro );
505             }
506
507 #ifdef PIC_FLAG_PTS
508             if( p_block->i_pts )
509             {
510                 mpeg2_pts( p_sys->p_mpeg2dec, (uint32_t)p_block->i_pts );
511
512 #else /* New interface */
513             if( p_block->i_pts || p_block->i_dts )
514             {
515                 mpeg2_tag_picture( p_sys->p_mpeg2dec,
516                                    (uint32_t)p_block->i_pts,
517                                    (uint32_t)p_block->i_dts );
518 #endif
519                 p_sys->i_previous_pts = p_sys->i_current_pts;
520                 p_sys->i_current_pts = p_block->i_pts;
521                 p_sys->i_previous_dts = p_sys->i_current_dts;
522                 p_sys->i_current_dts = p_block->i_dts;
523             }
524
525             mpeg2_buffer( p_sys->p_mpeg2dec, p_block->p_buffer,
526                           p_block->p_buffer + p_block->i_buffer );
527
528             p_block->i_buffer = 0;
529             break;
530
531 #if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
532
533         case STATE_SEQUENCE_MODIFIED:
534             GetAR( p_dec );
535             break;
536 #endif
537         case STATE_PICTURE_2ND:
538             p_sys->b_second_field = true;
539             break;
540
541
542         case STATE_INVALID_END:
543         case STATE_END:
544         case STATE_SLICE:
545             p_pic = NULL;
546             if( p_sys->p_info->display_fbuf &&
547                 p_sys->p_info->display_fbuf->id )
548             {
549                 p_pic = p_sys->p_info->display_fbuf->id;
550                 if( DpbDisplayPicture( p_dec, p_pic ) )
551                     p_pic = NULL;
552
553                 decoder_SynchroEnd( p_sys->p_synchro,
554                                     p_sys->p_info->display_picture->flags & PIC_MASK_CODING_TYPE,
555                                     p_sys->b_garbage_pic );
556
557                 if( p_pic )
558                 {
559                     p_pic->date = decoder_SynchroDate( p_sys->p_synchro );
560                     if( p_sys->b_garbage_pic )
561                         p_pic->date = 0; /* ??? */
562                     p_sys->b_garbage_pic = false;
563                 }
564             }
565
566             if( p_sys->p_info->discard_fbuf &&
567                 p_sys->p_info->discard_fbuf->id )
568             {
569                 DpbUnlinkPicture( p_dec, p_sys->p_info->discard_fbuf->id );
570             }
571
572             /* For still frames */
573             if( state == STATE_END && p_pic )
574                 p_pic->b_force = true;
575
576             if( p_pic )
577             {
578                 /* Avoid frames with identical timestamps.
579                  * Especially needed for still frames in DVD menus. */
580                 if( p_sys->i_last_frame_pts == p_pic->date )
581                     p_pic->date++;
582                 p_sys->i_last_frame_pts = p_pic->date;
583                 return p_pic;
584             }
585             break;
586
587         case STATE_INVALID:
588         {
589             msg_Err( p_dec, "invalid picture encountered" );
590             /* I don't think we have anything to do, but well without
591              * docs ... */
592             break;
593         }
594
595         default:
596             break;
597         }
598     }
599
600     /* Never reached */
601     return NULL;
602 }
603
604 /*****************************************************************************
605  * CloseDecoder: libmpeg2 decoder destruction
606  *****************************************************************************/
607 static void CloseDecoder( vlc_object_t *p_this )
608 {
609     decoder_t *p_dec = (decoder_t *)p_this;
610     decoder_sys_t *p_sys = p_dec->p_sys;
611
612     DpbClean( p_dec );
613
614     free( p_sys->p_gop_user_data );
615
616     if( p_sys->p_synchro ) decoder_SynchroRelease( p_sys->p_synchro );
617
618     if( p_sys->p_mpeg2dec ) mpeg2_close( p_sys->p_mpeg2dec );
619
620     free( p_sys );
621 }
622
623 /*****************************************************************************
624  * Reset: reset the decoder state
625  *****************************************************************************/
626 static void Reset( decoder_t *p_dec )
627 {
628     decoder_sys_t *p_sys = p_dec->p_sys;
629
630     cc_Flush( &p_sys->cc );
631     mpeg2_reset( p_sys->p_mpeg2dec, 0 );
632     DpbClean( p_dec );
633 }
634
635 /*****************************************************************************
636  * GetNewPicture: Get a new picture from the vout and set the buf struct
637  *****************************************************************************/
638 static picture_t *GetNewPicture( decoder_t *p_dec )
639 {
640     decoder_sys_t *p_sys = p_dec->p_sys;
641     picture_t *p_pic;
642
643     p_dec->fmt_out.video.i_width = p_sys->p_info->sequence->width;
644     p_dec->fmt_out.video.i_visible_width =
645         p_sys->p_info->sequence->picture_width;
646     p_dec->fmt_out.video.i_height = p_sys->p_info->sequence->height;
647     p_dec->fmt_out.video.i_visible_height =
648         p_sys->p_info->sequence->picture_height;
649     p_dec->fmt_out.video.i_aspect = p_sys->i_aspect;
650     p_dec->fmt_out.video.i_sar_num = p_sys->i_sar_num;
651     p_dec->fmt_out.video.i_sar_den = p_sys->i_sar_den;
652
653     if( p_sys->p_info->sequence->frame_period > 0 )
654     {
655         p_dec->fmt_out.video.i_frame_rate =
656             (uint32_t)( (uint64_t)1001000000 * 27 /
657                         p_sys->p_info->sequence->frame_period );
658         p_dec->fmt_out.video.i_frame_rate_base = 1001;
659     }
660
661     p_dec->fmt_out.i_codec =
662         ( p_sys->p_info->sequence->chroma_height <
663           p_sys->p_info->sequence->height ) ?
664         VLC_CODEC_I420 : VLC_CODEC_I422;
665
666     /* Get a new picture */
667     p_pic = decoder_NewPicture( p_dec );
668
669     if( p_pic == NULL )
670         return NULL;
671
672     p_pic->b_progressive = p_sys->p_info->current_picture != NULL ?
673         p_sys->p_info->current_picture->flags & PIC_FLAG_PROGRESSIVE_FRAME : 1;
674     p_pic->b_top_field_first = p_sys->p_info->current_picture != NULL ?
675         p_sys->p_info->current_picture->flags & PIC_FLAG_TOP_FIELD_FIRST : 1;
676     p_pic->i_nb_fields = p_sys->p_info->current_picture != NULL ?
677         p_sys->p_info->current_picture->nb_fields : 2;
678
679     return p_pic;
680 }
681
682 #if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
683 /*****************************************************************************
684  * GetCc: Retrieves the Closed Captions for the CC decoder.
685  *****************************************************************************/
686 static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
687 {
688     decoder_sys_t   *p_sys = p_dec->p_sys;
689     block_t         *p_cc = NULL;
690     int i;
691
692     for( i = 0; i < 4; i++ )
693         pb_present[i] = p_sys->cc.pb_present[i];
694
695     if( p_sys->cc.i_data <= 0 )
696         return NULL;
697
698     p_cc = block_New( p_dec, p_sys->cc.i_data);
699     if( p_cc )
700     {
701         memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
702         p_cc->i_dts =
703         p_cc->i_pts = p_sys->cc.b_reorder ? p_sys->i_cc_pts : p_sys->i_cc_dts;
704         p_cc->i_flags = ( p_sys->cc.b_reorder  ? p_sys->i_cc_flags : BLOCK_FLAG_TYPE_P ) & ( BLOCK_FLAG_TYPE_I|BLOCK_FLAG_TYPE_P|BLOCK_FLAG_TYPE_B);
705     }
706     cc_Flush( &p_sys->cc );
707     return p_cc;
708 }
709 #endif
710
711 /*****************************************************************************
712  * GetAR: Get aspect ratio
713  *****************************************************************************/
714 static void GetAR( decoder_t *p_dec )
715 {
716     decoder_sys_t *p_sys = p_dec->p_sys;
717     int i_old_aspect = p_sys->i_aspect;
718
719     /* Check whether the input gave a particular aspect ratio */
720     if( p_dec->fmt_in.video.i_aspect )
721     {
722         p_sys->i_aspect = p_dec->fmt_in.video.i_aspect;
723     }
724     else
725     {
726         /* Use the value provided in the MPEG sequence header */
727         if( p_sys->p_info->sequence->pixel_height > 0 )
728         {
729             p_sys->i_aspect =
730                 ((uint64_t)p_sys->p_info->sequence->picture_width) *
731                 p_sys->p_info->sequence->pixel_width *
732                 VOUT_ASPECT_FACTOR /
733                 p_sys->p_info->sequence->picture_height /
734                 p_sys->p_info->sequence->pixel_height;
735             p_sys->i_sar_num = p_sys->p_info->sequence->pixel_width;
736             p_sys->i_sar_den = p_sys->p_info->sequence->pixel_height;
737         }
738         else
739         {
740             /* Invalid aspect, assume 4:3.
741              * This shouldn't happen and if it does it is a bug
742              * in libmpeg2 (likely triggered by an invalid stream) */
743             p_sys->i_aspect = VOUT_ASPECT_FACTOR * 4 / 3;
744             p_sys->i_sar_num = p_sys->p_info->sequence->picture_height * 4;
745             p_sys->i_sar_den = p_sys->p_info->sequence->picture_width * 3;
746         }
747     }
748
749     if( p_sys->i_aspect == i_old_aspect )
750         return;
751
752     if( p_sys->p_info->sequence->frame_period > 0 )
753         msg_Dbg( p_dec,
754                  "%dx%d (display %d,%d), aspect %d, sar %i:%i, %u.%03u fps",
755                  p_sys->p_info->sequence->picture_width,
756                  p_sys->p_info->sequence->picture_height,
757                  p_sys->p_info->sequence->display_width,
758                  p_sys->p_info->sequence->display_height,
759                  p_sys->i_aspect, p_sys->i_sar_num, p_sys->i_sar_den,
760                  (uint32_t)((uint64_t)1001000000 * 27 /
761                      p_sys->p_info->sequence->frame_period / 1001),
762                  (uint32_t)((uint64_t)1001000000 * 27 /
763                      p_sys->p_info->sequence->frame_period % 1001) );
764     else
765         msg_Dbg( p_dec, "bad frame period" );
766 }
767
768 /*****************************************************************************
769  * PutPicture: Put a picture_t in mpeg2 context
770  *****************************************************************************/
771 static void PutPicture( decoder_t *p_dec, picture_t *p_picture )
772 {
773     decoder_sys_t *p_sys = p_dec->p_sys;
774
775     /* */
776     uint8_t *pp_buf[3];
777     for( int j = 0; j < 3; j++ )
778         pp_buf[j] = p_picture ? p_picture->p[j].p_pixels : NULL;
779     mpeg2_set_buf( p_sys->p_mpeg2dec, pp_buf, p_picture );
780
781     /* Completly broken API, why the hell does it suppose
782      * the stride of the chroma planes ! */
783     if( p_picture )
784         mpeg2_stride( p_sys->p_mpeg2dec, p_picture->p[Y_PLANE].i_pitch );
785 }
786
787
788 /**
789  * Initialize a virtual Decoded Picture Buffer to workaround
790  * libmpeg2 deficient API
791  */
792 static void DpbInit( decoder_t *p_dec )
793 {
794     decoder_sys_t *p_sys = p_dec->p_sys;
795
796     for( int i = 0; i < DPB_COUNT; i++ )
797         p_sys->p_dpb[i].p_picture = NULL;
798 }
799 /**
800  * Empty and reset the current DPB
801  */
802 static void DpbClean( decoder_t *p_dec )
803 {
804     decoder_sys_t *p_sys = p_dec->p_sys;
805
806     for( int i = 0; i < DPB_COUNT; i++ )
807     {
808         picture_dpb_t *p = &p_sys->p_dpb[i];
809         if( !p->p_picture )
810             continue;
811         if( p->b_linked )
812             decoder_UnlinkPicture( p_dec, p->p_picture );
813         if( !p->b_displayed )
814             decoder_DeletePicture( p_dec, p->p_picture );
815
816         p->p_picture = NULL;
817     }
818 }
819 /**
820  * Retreive a picture and reserve a place in the DPB
821  */
822 static picture_t *DpbNewPicture( decoder_t *p_dec )
823 {
824     decoder_sys_t *p_sys = p_dec->p_sys;
825
826     picture_dpb_t *p;
827     int i;
828
829     for( i = 0; i < DPB_COUNT; i++ )
830     {
831         p = &p_sys->p_dpb[i];
832         if( !p->p_picture )
833             break;
834     }
835     if( i >= DPB_COUNT )
836     {
837         msg_Err( p_dec, "Leaking picture" );
838         return NULL;
839     }
840
841     p->p_picture = GetNewPicture( p_dec );
842     if( p->p_picture )
843     {
844         decoder_LinkPicture( p_dec, p->p_picture );
845         p->b_linked = true;
846         p->b_displayed = false;
847
848         p->p_picture->date = 0;
849     }
850     return p->p_picture;
851 }
852 static picture_dpb_t *DpbFindPicture( decoder_t *p_dec, picture_t *p_picture )
853 {
854     decoder_sys_t *p_sys = p_dec->p_sys;
855
856     for( int i = 0; i < DPB_COUNT; i++ )
857     {
858         picture_dpb_t *p = &p_sys->p_dpb[i];
859         if( p->p_picture == p_picture )
860             return p;
861     }
862     return NULL;
863 }
864 /**
865  * Unlink the provided picture and ensure that the decoder
866  * does not own it anymore.
867  */
868 static void DpbUnlinkPicture( decoder_t *p_dec, picture_t *p_picture )
869 {
870     picture_dpb_t *p = DpbFindPicture( p_dec, p_picture );
871
872     /* XXX it is needed to workaround libmpeg2 bugs */
873     if( !p || !p->b_linked )
874     {
875         msg_Err( p_dec, "DpbUnlinkPicture called on an invalid picture" );
876         return;
877     }
878
879     assert( p && p->b_linked );
880
881     decoder_UnlinkPicture( p_dec, p->p_picture );
882     p->b_linked = false;
883
884     if( !p->b_displayed )
885         decoder_DeletePicture( p_dec, p->p_picture );
886     p->p_picture = NULL;
887 }
888 /**
889  * Mark the provided picture as displayed.
890  */
891 static int DpbDisplayPicture( decoder_t *p_dec, picture_t *p_picture )
892 {
893     picture_dpb_t *p = DpbFindPicture( p_dec, p_picture );
894
895     /* XXX it is needed to workaround libmpeg2 bugs */
896     if( !p || p->b_displayed || !p->b_linked )
897     {
898         msg_Err( p_dec, "DpbDisplayPicture called on an invalid picture" );
899         return VLC_EGENERIC;
900     }
901
902     assert( p && !p->b_displayed && p->b_linked );
903
904     p->b_displayed = true;
905     return VLC_SUCCESS;
906 }
907
908