libmpeg2.c 29.4 KB
Newer Older
1 2 3
/*****************************************************************************
 * libmpeg2.c: mpeg2 video decoder module making use of libmpeg2.
 *****************************************************************************
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 11 12 13
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
Sam Hocevar's avatar
Sam Hocevar committed
14
 *
15 16 17 18 19 20 21
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
Antoine Cellerier's avatar
Antoine Cellerier committed
22
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23 24 25 26 27
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/
28 29 30
#ifdef HAVE_CONFIG_H
# include "config.h"
#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>
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
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 48 49 50 51 52 53 54
#define DPB_COUNT (3+1)
typedef struct
{
    picture_t *p_picture;
    bool      b_linked;
    bool      b_displayed;
} picture_dpb_t;

55
struct decoder_sys_t
56 57 58 59 60 61
{
    /*
     * libmpeg2 properties
     */
    mpeg2dec_t          *p_mpeg2dec;
    const mpeg2_info_t  *p_info;
62
    bool                b_skip;
63 64 65 66 67 68

    /*
     * Input properties
     */
    mtime_t          i_previous_pts;
    mtime_t          i_current_pts;
69 70
    mtime_t          i_previous_dts;
    mtime_t          i_current_dts;
71 72
    bool             b_garbage_pic;
    bool             b_after_sequence_header; /* is it the next frame after
73
                                               * the sequence header ?    */
74 75
    bool             b_slice_i;             /* intra-slice refresh stream */
    bool             b_second_field;
76

77
    bool             b_preroll;
Laurent Aimar's avatar
Laurent Aimar committed
78

79 80 81
    /* */
    picture_dpb_t        p_dpb[DPB_COUNT];

82 83 84
    /*
     * Output properties
     */
85
    decoder_synchro_t *p_synchro;
86 87 88 89 90 91 92 93 94
    int             i_sar_num;
    int             i_sar_den;
    mtime_t         i_last_frame_pts;

    /* Closed captioning support */
    uint32_t        i_cc_flags;
    mtime_t         i_cc_pts;
    mtime_t         i_cc_dts;
    cc_data_t       cc;
95 96
    uint8_t        *p_gop_user_data;
    uint32_t        i_gop_user_data;
97
};
98 99 100 101

/*****************************************************************************
 * Local prototypes
 *****************************************************************************/
102 103 104 105
static int  OpenDecoder( vlc_object_t * );
static void CloseDecoder( vlc_object_t * );

static picture_t *DecodeBlock( decoder_t *, block_t ** );
106
#if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
107
static block_t   *GetCc( decoder_t *p_dec, bool pb_present[4] );
108
#endif
109

110 111 112
static picture_t *GetNewPicture( decoder_t * );
static void PutPicture( decoder_t *, picture_t * );

113
static void GetAR( decoder_t *p_dec );
Gildas Bazin's avatar
Gildas Bazin committed
114

115 116
static void Reset( decoder_t *p_dec );

117 118 119 120 121
/* */
static void DpbInit( decoder_t * );
static void DpbClean( decoder_t * );
static picture_t *DpbNewPicture( decoder_t * );
static void DpbUnlinkPicture( decoder_t *, picture_t * );
122
static int DpbDisplayPicture( decoder_t *, picture_t * );
123

124 125 126
/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
127 128
vlc_module_begin ()
    set_description( N_("MPEG I/II video decoder (using libmpeg2)") )
129
    set_capability( "decoder", 50 )
130 131 132 133 134
    set_category( CAT_INPUT )
    set_subcategory( SUBCAT_INPUT_VCODEC )
    set_callbacks( OpenDecoder, CloseDecoder )
    add_shortcut( "libmpeg2" )
vlc_module_end ()
135 136 137 138 139 140

/*****************************************************************************
 * OpenDecoder: probe the decoder and return score
 *****************************************************************************/
static int OpenDecoder( vlc_object_t *p_this )
{
141
    decoder_t *p_dec = (decoder_t*)p_this;
142
    decoder_sys_t *p_sys;
143
    uint32_t i_accel = 0;
144

Laurent Aimar's avatar
Laurent Aimar committed
145
    if( p_dec->fmt_in.i_codec != VLC_CODEC_MPGV )
146
        return VLC_EGENERIC;
147

148 149 150 151 152 153 154 155 156 157 158 159 160
    /* Select onl recognized original format (standard mpeg video) */
    switch( p_dec->fmt_in.i_original_fourcc )
    {
    case VLC_FOURCC('m','p','g','1'):
    case VLC_FOURCC('m','p','g','2'):
    case VLC_FOURCC('m','p','g','v'):
    case VLC_FOURCC('P','I','M','1'):
    case VLC_FOURCC('h','d','v','2'):
        break;
    default:
        if( p_dec->fmt_in.i_original_fourcc )
            return VLC_EGENERIC;
        break;
161 162
    }

163
    /* Allocate the memory needed to store the decoder's structure */
164
    if( ( p_dec->p_sys = p_sys = calloc( 1, sizeof(*p_sys)) ) == NULL )
165
        return VLC_ENOMEM;
166 167

    /* Initialize the thread properties */
168 169 170 171 172
    p_sys->p_mpeg2dec = NULL;
    p_sys->p_synchro  = NULL;
    p_sys->p_info     = NULL;
    p_sys->i_current_pts  = 0;
    p_sys->i_previous_pts = 0;
173 174
    p_sys->i_current_dts  = 0;
    p_sys->i_previous_dts = 0;
175 176
    p_sys->i_sar_num = 0;
    p_sys->i_sar_den = 0;
177 178 179 180
    p_sys->b_garbage_pic = false;
    p_sys->b_slice_i  = false;
    p_sys->b_second_field = false;
    p_sys->b_skip     = false;
181
    p_sys->b_preroll = false;
182
    DpbInit( p_dec );
183

184 185 186 187 188 189 190
    p_sys->i_cc_pts = 0;
    p_sys->i_cc_dts = 0;
    p_sys->i_cc_flags = 0;
#if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
    p_dec->pf_get_cc = GetCc;
    cc_Init( &p_sys->cc );
#endif
191 192
    p_sys->p_gop_user_data = NULL;
    p_sys->i_gop_user_data = 0;
193

194
#if defined( __i386__ ) || defined( __x86_64__ )
195
    unsigned cpu = vlc_CPU();
196
    if( vlc_CPU_MMX() )
197
        i_accel |= MPEG2_ACCEL_X86_MMX;
198
    if( cpu & CPU_CAPABILITY_3DNOW )
199
        i_accel |= MPEG2_ACCEL_X86_3DNOW;
200
    if( cpu & CPU_CAPABILITY_MMXEXT )
201
        i_accel |= MPEG2_ACCEL_X86_MMXEXT;
202
#elif defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
203
    if( vlc_CPU_ALTIVEC() )
204 205
        i_accel |= MPEG2_ACCEL_PPC_ALTIVEC;

206 207
#elif defined(__arm__)
# ifdef MPEG2_ACCEL_ARM
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
208
    i_accel |= MPEG2_ACCEL_ARM;
209
# endif
210
# ifdef MPEG2_ACCEL_ARM_NEON
211
    if( vlc_CPU_ARM_NEON() )
212 213 214
	i_accel |= MPEG2_ACCEL_ARM_NEON;
# endif

215
    /* TODO: sparc */
216 217 218 219 220 221 222 223 224
#else
    /* If we do not know this CPU, trust libmpeg2's feature detection */
    i_accel = MPEG2_ACCEL_DETECT;

#endif

    /* Set CPU acceleration features */
    mpeg2_accel( i_accel );

225
    /* Initialize decoder */
226 227
    p_sys->p_mpeg2dec = mpeg2_init();
    if( p_sys->p_mpeg2dec == NULL)
228 229
    {
        msg_Err( p_dec, "mpeg2_init() failed" );
230
        free( p_sys );
231 232
        return VLC_EGENERIC;
    }
233

234 235 236
    p_sys->p_info = mpeg2_info( p_sys->p_mpeg2dec );

    p_dec->pf_decode_video = DecodeBlock;
237 238
    p_dec->fmt_out.i_cat = VIDEO_ES;
    p_dec->fmt_out.i_codec = 0;
239 240 241

    return VLC_SUCCESS;
}
242

243 244 245
/*****************************************************************************
 * RunDecoder: the libmpeg2 decoder
 *****************************************************************************/
246
static picture_t *DecodeBlock( decoder_t *p_dec, block_t **pp_block )
247 248 249 250 251
{
    decoder_sys_t   *p_sys = p_dec->p_sys;
    mpeg2_state_t   state;
    picture_t       *p_pic;

252 253
    block_t *p_block;

254 255
    if( !pp_block || !*pp_block )
        return NULL;
256 257

    p_block = *pp_block;
258
    if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED) )
259
        Reset( p_dec );
260 261

    while( 1 )
262
    {
263
        state = mpeg2_parse( p_sys->p_mpeg2dec );
264 265 266 267

        switch( state )
        {
        case STATE_SEQUENCE:
Gildas Bazin's avatar
Gildas Bazin committed
268
        {
269 270
            /* */
            DpbClean( p_dec );
271

272
            /* */
273
            mpeg2_custom_fbuf( p_sys->p_mpeg2dec, 1 );
Gildas Bazin's avatar
Gildas Bazin committed
274 275

            /* Set the first 2 reference frames */
276 277
            p_sys->i_sar_num = 0;
            p_sys->i_sar_den = 0;
278 279
            GetAR( p_dec );
            for( int i = 0; i < 2; i++ )
280
            {
281 282 283
                picture_t *p_picture = DpbNewPicture( p_dec );
                if( !p_picture )
                {
284
                    Reset( p_dec );
285 286 287 288
                    block_Release( p_block );
                    return NULL;
                }
                PutPicture( p_dec, p_picture );
289
            }
290 291

            if( p_sys->p_synchro )
292
                decoder_SynchroRelease( p_sys->p_synchro );
293

294 295 296 297 298 299
            if( p_sys->p_info->sequence->frame_period <= 0 )
                p_sys->p_synchro = NULL;
            else
                p_sys->p_synchro =
                decoder_SynchroInit( p_dec, (uint32_t)(UINT64_C(1001000000) *
                                27 / p_sys->p_info->sequence->frame_period) );
300 301
            p_sys->b_after_sequence_header = true;
            break;
Gildas Bazin's avatar
Gildas Bazin committed
302
        }
303

304 305 306 307 308 309 310 311 312 313 314 315
        case STATE_GOP:
            /* There can be userdata in a GOP. It needs to be remembered for the next picture. */
            if( p_sys->p_info->user_data_len > 2 )
            {
                free( p_sys->p_gop_user_data );
                p_sys->p_gop_user_data = calloc( p_sys->p_info->user_data_len, sizeof(uint8_t) );
                if( p_sys->p_gop_user_data )
                {
                    p_sys->i_gop_user_data = p_sys->p_info->user_data_len;
                    memcpy( p_sys->p_gop_user_data, p_sys->p_info->user_data, p_sys->p_info->user_data_len );
                }
            }
316 317
            break;

318 319
        case STATE_PICTURE:
        {
320 321 322
            const mpeg2_info_t *p_info = p_sys->p_info;
            const mpeg2_picture_t *p_current = p_info->current_picture;

323
            mtime_t i_pts, i_dts;
324

325 326 327
            if( p_sys->b_after_sequence_header &&
                (p_current->flags &
                    PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P )
328 329
            {
                /* Intra-slice refresh. Simulate a blank I picture. */
330
                msg_Dbg( p_dec, "intra-slice refresh stream" );
331
                decoder_SynchroNewPicture( p_sys->p_synchro,
332 333
                                           I_CODING_TYPE, 2, 0, 0,
                                           p_info->sequence->flags & SEQ_FLAG_LOW_DELAY );
334 335
                decoder_SynchroDecode( p_sys->p_synchro );
                decoder_SynchroEnd( p_sys->p_synchro, I_CODING_TYPE, 0 );
336
                p_sys->b_slice_i = true;
337
            }
338
            p_sys->b_after_sequence_header = false;
339

340
#ifdef PIC_FLAG_PTS
341 342
            i_pts = p_current->flags & PIC_FLAG_PTS ?
                ( ( p_current->pts ==
343 344
                    (uint32_t)p_sys->i_current_pts ) ?
                  p_sys->i_current_pts : p_sys->i_previous_pts ) : 0;
345
            i_dts = 0;
346

347 348 349
            /* Hack to handle demuxers which only have DTS timestamps */
            if( !i_pts && !p_block->i_pts && p_block->i_dts > 0 )
            {
350 351
                if( p_info->sequence->flags & SEQ_FLAG_LOW_DELAY ||
                    (p_current->flags &
352 353 354 355 356 357 358 359
                      PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_B )
                {
                    i_pts = p_block->i_dts;
                }
            }
            p_block->i_pts = p_block->i_dts = 0;
            /* End hack */

360 361
#else /* New interface */

362 363 364 365 366 367
            i_pts = p_current->flags & PIC_FLAG_TAGS ?
                ( ( p_current->tag == (uint32_t)p_sys->i_current_pts ) ?
                            p_sys->i_current_pts : p_sys->i_previous_pts ) : 0;
            i_dts = p_current->flags & PIC_FLAG_TAGS ?
                ( ( p_current->tag2 == (uint32_t)p_sys->i_current_dts ) ?
                            p_sys->i_current_dts : p_sys->i_previous_dts ) : 0;
368 369
#endif

370 371
            /* If nb_fields == 1, it is a field picture, and it will be
             * followed by another field picture for which we won't call
372
             * decoder_SynchroNewPicture() because this would have other
373 374 375
             * problems, so we take it into account here.
             * This kind of sucks, but I didn't think better. --Meuuh
             */
376
            decoder_SynchroNewPicture( p_sys->p_synchro,
377 378 379 380
                                       p_current->flags & PIC_MASK_CODING_TYPE,
                                       p_current->nb_fields == 1 ? 2 :
                                       p_current->nb_fields, i_pts, i_dts,
                                       p_info->sequence->flags & SEQ_FLAG_LOW_DELAY );
381

382 383

            bool b_skip = false;
Laurent Aimar's avatar
Laurent Aimar committed
384
            if( !p_dec->b_pace_control && !p_sys->b_preroll &&
385
                !(p_sys->b_slice_i
386
                   && ((p_current->flags
387
                         & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P))
388
                   && !decoder_SynchroChoose( p_sys->p_synchro,
389
                              p_current->flags
390
                                & PIC_MASK_CODING_TYPE,
391
                              /*p_sys->p_vout->render_time*/ 0 /*FIXME*/,
392
                              p_info->sequence->flags & SEQ_FLAG_LOW_DELAY ) )
393 394 395 396 397 398
            {
                b_skip = true;
            }

            p_pic = NULL;
            if( !b_skip )
399
            {
400
                p_pic = DpbNewPicture( p_dec );
401 402 403
                if( !p_pic )
                {
                    Reset( p_dec );
404 405 406 407 408 409 410 411

                    p_pic = DpbNewPicture( p_dec );
                    if( !p_pic )
                    {
                        mpeg2_reset( p_sys->p_mpeg2dec, 1 );
                        block_Release( p_block );
                        return NULL;
                    }
412 413
                }
            }
414 415

            if( b_skip || !p_pic )
416
            {
417
                mpeg2_skip( p_sys->p_mpeg2dec, 1 );
418
                p_sys->b_skip = true;
419
                decoder_SynchroTrash( p_sys->p_synchro );
420 421

                PutPicture( p_dec, NULL );
422 423 424 425 426 427

                if( !b_skip )
                {
                    block_Release( p_block );
                    return NULL;
                }
428 429
            }
            else
430
            {
431
                mpeg2_skip( p_sys->p_mpeg2dec, 0 );
432
                p_sys->b_skip = false;
433
                decoder_SynchroDecode( p_sys->p_synchro );
434

435
                PutPicture( p_dec, p_pic );
436
            }
437
            if( p_info->user_data_len > 2 || p_sys->i_gop_user_data > 2 )
438 439 440
            {
                p_sys->i_cc_pts = i_pts;
                p_sys->i_cc_dts = i_dts;
441
                if( (p_current->flags
442 443
                             & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_P )
                    p_sys->i_cc_flags = BLOCK_FLAG_TYPE_P;
444
                else if( (p_current->flags
445 446 447
                             & PIC_MASK_CODING_TYPE) == PIC_FLAG_CODING_TYPE_B )
                    p_sys->i_cc_flags = BLOCK_FLAG_TYPE_B;
                else p_sys->i_cc_flags = BLOCK_FLAG_TYPE_I;
448 449
                bool b_top_field_first = p_sys->p_info->current_picture->flags
                                           & PIC_FLAG_TOP_FIELD_FIRST;
450

451 452 453
                if( p_sys->i_gop_user_data > 2 )
                {
                    /* We now have picture info for any cached user_data out of the gop */
454 455
                    cc_Extract( &p_sys->cc, b_top_field_first,
                                &p_sys->p_gop_user_data[0], p_sys->i_gop_user_data );
456 457 458 459
                    p_sys->i_gop_user_data = 0;
                }

                /* Extract the CC from the user_data of the picture */
460
                if( p_info->user_data_len > 2 )
461 462
                    cc_Extract( &p_sys->cc, b_top_field_first,
                                &p_info->user_data[0], p_info->user_data_len );
463 464
            }
        }
465
        break;
466

467 468 469

        case STATE_BUFFER:
            if( !p_block->i_buffer )
470
            {
471 472 473 474 475 476 477 478 479 480 481 482 483
                block_Release( p_block );
                return NULL;
            }

            if( (p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY
                                      | BLOCK_FLAG_CORRUPTED)) &&
                p_sys->p_synchro &&
                p_sys->p_info->sequence &&
                p_sys->p_info->sequence->width != (unsigned)-1 )
            {
                decoder_SynchroReset( p_sys->p_synchro );
                if( p_sys->p_info->current_fbuf != NULL &&
                    p_sys->p_info->current_fbuf->id != NULL )
484
                {
485 486 487 488 489 490 491 492 493 494
                    p_sys->b_garbage_pic = true;
                }
                if( p_sys->b_slice_i )
                {
                    decoder_SynchroNewPicture( p_sys->p_synchro,
                                               I_CODING_TYPE, 2, 0, 0,
                                               p_sys->p_info->sequence->flags &
                                                            SEQ_FLAG_LOW_DELAY );
                    decoder_SynchroDecode( p_sys->p_synchro );
                    decoder_SynchroEnd( p_sys->p_synchro, I_CODING_TYPE, 0 );
495 496
                }
            }
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540

            if( p_block->i_flags & BLOCK_FLAG_PREROLL )
            {
                p_sys->b_preroll = true;
            }
            else if( p_sys->b_preroll )
            {
                p_sys->b_preroll = false;
                if( p_sys->p_synchro )
                    decoder_SynchroReset( p_sys->p_synchro );
            }

#ifdef PIC_FLAG_PTS
            if( p_block->i_pts )
            {
                mpeg2_pts( p_sys->p_mpeg2dec, (uint32_t)p_block->i_pts );

#else /* New interface */
            if( p_block->i_pts || p_block->i_dts )
            {
                mpeg2_tag_picture( p_sys->p_mpeg2dec,
                                   (uint32_t)p_block->i_pts,
                                   (uint32_t)p_block->i_dts );
#endif
                p_sys->i_previous_pts = p_sys->i_current_pts;
                p_sys->i_current_pts = p_block->i_pts;
                p_sys->i_previous_dts = p_sys->i_current_dts;
                p_sys->i_current_dts = p_block->i_dts;
            }

            mpeg2_buffer( p_sys->p_mpeg2dec, p_block->p_buffer,
                          p_block->p_buffer + p_block->i_buffer );

            p_block->i_buffer = 0;
            break;

#if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)

        case STATE_SEQUENCE_MODIFIED:
            GetAR( p_dec );
            break;
#endif
        case STATE_PICTURE_2ND:
            p_sys->b_second_field = true;
541 542
            break;

543 544

        case STATE_INVALID_END:
545
        case STATE_END:
546
        case STATE_SLICE:
547
            p_pic = NULL;
548 549
            if( p_sys->p_info->display_fbuf &&
                p_sys->p_info->display_fbuf->id )
550
            {
551
                p_pic = p_sys->p_info->display_fbuf->id;
552 553
                if( DpbDisplayPicture( p_dec, p_pic ) )
                    p_pic = NULL;
554

555
                decoder_SynchroEnd( p_sys->p_synchro,
556 557
                                    p_sys->p_info->display_picture->flags & PIC_MASK_CODING_TYPE,
                                    p_sys->b_garbage_pic );
558

559 560 561 562 563 564 565
                if( p_pic )
                {
                    p_pic->date = decoder_SynchroDate( p_sys->p_synchro );
                    if( p_sys->b_garbage_pic )
                        p_pic->date = 0; /* ??? */
                    p_sys->b_garbage_pic = false;
                }
566 567
            }

568 569
            if( p_sys->p_info->discard_fbuf &&
                p_sys->p_info->discard_fbuf->id )
570
            {
571
                DpbUnlinkPicture( p_dec, p_sys->p_info->discard_fbuf->id );
572
            }
573

574
            /* For still frames */
575 576
            if( state == STATE_END && p_pic )
                p_pic->b_force = true;
577 578 579 580 581

            if( p_pic )
            {
                /* Avoid frames with identical timestamps.
                 * Especially needed for still frames in DVD menus. */
582 583
                if( p_sys->i_last_frame_pts == p_pic->date )
                    p_pic->date++;
584 585 586
                p_sys->i_last_frame_pts = p_pic->date;
                return p_pic;
            }
587 588
            break;

589
        case STATE_INVALID:
590
        {
591 592 593
            msg_Err( p_dec, "invalid picture encountered" );
            /* I don't think we have anything to do, but well without
             * docs ... */
594
            break;
595
        }
596

597 598 599 600 601
        default:
            break;
        }
    }

602 603
    /* Never reached */
    return NULL;
604 605 606
}

/*****************************************************************************
607
 * CloseDecoder: libmpeg2 decoder destruction
608
 *****************************************************************************/
609
static void CloseDecoder( vlc_object_t *p_this )
610
{
611
    decoder_t *p_dec = (decoder_t *)p_this;
612 613
    decoder_sys_t *p_sys = p_dec->p_sys;

614 615
    DpbClean( p_dec );

616 617
    free( p_sys->p_gop_user_data );

618
    if( p_sys->p_synchro ) decoder_SynchroRelease( p_sys->p_synchro );
619

620
    if( p_sys->p_mpeg2dec ) mpeg2_close( p_sys->p_mpeg2dec );
621

622
    free( p_sys );
623
}
Gildas Bazin's avatar
Gildas Bazin committed
624

625 626 627 628 629 630 631 632
/*****************************************************************************
 * Reset: reset the decoder state
 *****************************************************************************/
static void Reset( decoder_t *p_dec )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    cc_Flush( &p_sys->cc );
633
    mpeg2_reset( p_sys->p_mpeg2dec, 0 );
634 635 636
    DpbClean( p_dec );
}

Gildas Bazin's avatar
Gildas Bazin committed
637 638 639
/*****************************************************************************
 * GetNewPicture: Get a new picture from the vout and set the buf struct
 *****************************************************************************/
640
static picture_t *GetNewPicture( decoder_t *p_dec )
Gildas Bazin's avatar
Gildas Bazin committed
641
{
642
    decoder_sys_t *p_sys = p_dec->p_sys;
Gildas Bazin's avatar
Gildas Bazin committed
643
    picture_t *p_pic;
644

645
    p_dec->fmt_out.video.i_width = p_sys->p_info->sequence->width;
646 647
    p_dec->fmt_out.video.i_visible_width =
        p_sys->p_info->sequence->picture_width;
648
    p_dec->fmt_out.video.i_height = p_sys->p_info->sequence->height;
649 650
    p_dec->fmt_out.video.i_visible_height =
        p_sys->p_info->sequence->picture_height;
651 652
    p_dec->fmt_out.video.i_sar_num = p_sys->i_sar_num;
    p_dec->fmt_out.video.i_sar_den = p_sys->i_sar_den;
Gildas Bazin's avatar
Gildas Bazin committed
653

654 655 656 657 658 659 660 661
    if( p_sys->p_info->sequence->frame_period > 0 )
    {
        p_dec->fmt_out.video.i_frame_rate =
            (uint32_t)( (uint64_t)1001000000 * 27 /
                        p_sys->p_info->sequence->frame_period );
        p_dec->fmt_out.video.i_frame_rate_base = 1001;
    }

662 663 664
    p_dec->fmt_out.i_codec =
        ( p_sys->p_info->sequence->chroma_height <
          p_sys->p_info->sequence->height ) ?
665
        VLC_CODEC_I420 : VLC_CODEC_I422;
Gildas Bazin's avatar
Gildas Bazin committed
666

667
    /* Get a new picture */
668
    p_pic = decoder_NewPicture( p_dec );
669

670 671
    if( p_pic == NULL )
        return NULL;
672

673 674 675 676 677 678 679
    p_pic->b_progressive = p_sys->p_info->current_picture != NULL ?
        p_sys->p_info->current_picture->flags & PIC_FLAG_PROGRESSIVE_FRAME : 1;
    p_pic->b_top_field_first = p_sys->p_info->current_picture != NULL ?
        p_sys->p_info->current_picture->flags & PIC_FLAG_TOP_FIELD_FIRST : 1;
    p_pic->i_nb_fields = p_sys->p_info->current_picture != NULL ?
        p_sys->p_info->current_picture->nb_fields : 2;

Gildas Bazin's avatar
Gildas Bazin committed
680 681
    return p_pic;
}
682

683
#if MPEG2_RELEASE >= MPEG2_VERSION (0, 5, 0)
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
/*****************************************************************************
 * GetCc: Retrieves the Closed Captions for the CC decoder.
 *****************************************************************************/
static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
{
    decoder_sys_t   *p_sys = p_dec->p_sys;
    block_t         *p_cc = NULL;
    int i;

    for( i = 0; i < 4; i++ )
        pb_present[i] = p_sys->cc.pb_present[i];

    if( p_sys->cc.i_data <= 0 )
        return NULL;

    p_cc = block_New( p_dec, p_sys->cc.i_data);
    if( p_cc )
    {
        memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
        p_cc->i_dts =
        p_cc->i_pts = p_sys->cc.b_reorder ? p_sys->i_cc_pts : p_sys->i_cc_dts;
        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);
    }
    cc_Flush( &p_sys->cc );
    return p_cc;
}
710
#endif
711

712 713 714 715 716
/*****************************************************************************
 * GetAR: Get aspect ratio
 *****************************************************************************/
static void GetAR( decoder_t *p_dec )
{
717
    decoder_sys_t *p_sys = p_dec->p_sys;
718 719
    int i_old_sar_num = p_sys->i_sar_num;
    int i_old_sar_den = p_sys->i_sar_den;
720 721

    /* Check whether the input gave a particular aspect ratio */
722 723
    if( p_dec->fmt_in.video.i_sar_num > 0 &&
        p_dec->fmt_in.video.i_sar_den > 0 )
724
    {
725 726
        p_sys->i_sar_num = p_dec->fmt_in.video.i_sar_num;
        p_sys->i_sar_den = p_dec->fmt_in.video.i_sar_den;
727 728 729 730 731 732
    }
    else
    {
        /* Use the value provided in the MPEG sequence header */
        if( p_sys->p_info->sequence->pixel_height > 0 )
        {
733 734
            p_sys->i_sar_num = p_sys->p_info->sequence->pixel_width;
            p_sys->i_sar_den = p_sys->p_info->sequence->pixel_height;
735 736 737 738 739 740
        }
        else
        {
            /* Invalid aspect, assume 4:3.
             * This shouldn't happen and if it does it is a bug
             * in libmpeg2 (likely triggered by an invalid stream) */
741 742
            p_sys->i_sar_num = p_sys->p_info->sequence->picture_height * 4;
            p_sys->i_sar_den = p_sys->p_info->sequence->picture_width * 3;
743 744 745
        }
    }

746 747
    if( p_sys->i_sar_num == i_old_sar_num &&
        p_sys->i_sar_den == i_old_sar_den )
748 749
        return;

750 751
    if( p_sys->p_info->sequence->frame_period > 0 )
        msg_Dbg( p_dec,
752
                 "%dx%d (display %d,%d), sar %i:%i, %u.%03u fps",
753 754 755 756
                 p_sys->p_info->sequence->picture_width,
                 p_sys->p_info->sequence->picture_height,
                 p_sys->p_info->sequence->display_width,
                 p_sys->p_info->sequence->display_height,
757
                 p_sys->i_sar_num, p_sys->i_sar_den,
758 759 760 761 762 763
                 (uint32_t)((uint64_t)1001000000 * 27 /
                     p_sys->p_info->sequence->frame_period / 1001),
                 (uint32_t)((uint64_t)1001000000 * 27 /
                     p_sys->p_info->sequence->frame_period % 1001) );
    else
        msg_Dbg( p_dec, "bad frame period" );
764
}
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868

/*****************************************************************************
 * PutPicture: Put a picture_t in mpeg2 context
 *****************************************************************************/
static void PutPicture( decoder_t *p_dec, picture_t *p_picture )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    /* */
    uint8_t *pp_buf[3];
    for( int j = 0; j < 3; j++ )
        pp_buf[j] = p_picture ? p_picture->p[j].p_pixels : NULL;
    mpeg2_set_buf( p_sys->p_mpeg2dec, pp_buf, p_picture );

    /* Completly broken API, why the hell does it suppose
     * the stride of the chroma planes ! */
    if( p_picture )
        mpeg2_stride( p_sys->p_mpeg2dec, p_picture->p[Y_PLANE].i_pitch );
}


/**
 * Initialize a virtual Decoded Picture Buffer to workaround
 * libmpeg2 deficient API
 */
static void DpbInit( decoder_t *p_dec )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    for( int i = 0; i < DPB_COUNT; i++ )
        p_sys->p_dpb[i].p_picture = NULL;
}
/**
 * Empty and reset the current DPB
 */
static void DpbClean( decoder_t *p_dec )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    for( int i = 0; i < DPB_COUNT; i++ )
    {
        picture_dpb_t *p = &p_sys->p_dpb[i];
        if( !p->p_picture )
            continue;
        if( p->b_linked )
            decoder_UnlinkPicture( p_dec, p->p_picture );
        if( !p->b_displayed )
            decoder_DeletePicture( p_dec, p->p_picture );

        p->p_picture = NULL;
    }
}
/**
 * Retreive a picture and reserve a place in the DPB
 */
static picture_t *DpbNewPicture( decoder_t *p_dec )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    picture_dpb_t *p;
    int i;

    for( i = 0; i < DPB_COUNT; i++ )
    {
        p = &p_sys->p_dpb[i];
        if( !p->p_picture )
            break;
    }
    if( i >= DPB_COUNT )
    {
        msg_Err( p_dec, "Leaking picture" );
        return NULL;
    }

    p->p_picture = GetNewPicture( p_dec );
    if( p->p_picture )
    {
        decoder_LinkPicture( p_dec, p->p_picture );
        p->b_linked = true;
        p->b_displayed = false;

        p->p_picture->date = 0;
    }
    return p->p_picture;
}
static picture_dpb_t *DpbFindPicture( decoder_t *p_dec, picture_t *p_picture )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

    for( int i = 0; i < DPB_COUNT; i++ )
    {
        picture_dpb_t *p = &p_sys->p_dpb[i];
        if( p->p_picture == p_picture )
            return p;
    }
    return NULL;
}
/**
 * Unlink the provided picture and ensure that the decoder
 * does not own it anymore.
 */
static void DpbUnlinkPicture( decoder_t *p_dec, picture_t *p_picture )
{
    picture_dpb_t *p = DpbFindPicture( p_dec, p_picture );
869 870 871 872 873 874 875 876

    /* XXX it is needed to workaround libmpeg2 bugs */
    if( !p || !p->b_linked )
    {
        msg_Err( p_dec, "DpbUnlinkPicture called on an invalid picture" );
        return;
    }

877 878 879 880 881 882 883 884 885 886 887 888
    assert( p && p->b_linked );

    decoder_UnlinkPicture( p_dec, p->p_picture );
    p->b_linked = false;

    if( !p->b_displayed )
        decoder_DeletePicture( p_dec, p->p_picture );
    p->p_picture = NULL;
}
/**
 * Mark the provided picture as displayed.
 */
889
static int DpbDisplayPicture( decoder_t *p_dec, picture_t *p_picture )
890 891
{
    picture_dpb_t *p = DpbFindPicture( p_dec, p_picture );
892 893 894 895 896 897 898 899

    /* XXX it is needed to workaround libmpeg2 bugs */
    if( !p || p->b_displayed || !p->b_linked )
    {
        msg_Err( p_dec, "DpbDisplayPicture called on an invalid picture" );
        return VLC_EGENERIC;
    }

900 901 902
    assert( p && !p->b_displayed && p->b_linked );

    p->b_displayed = true;
903
    return VLC_SUCCESS;
904 905 906
}