vpar_headers.c

vlc stand 0.1.99 ist sehr einfach

    {
        0.0,
        ((23.0*1000.0)/1001.0),
        24.0,
        25.0,
        ((30.0*1000.0)/1001.0),
        30.0,
        50.0,
        ((60.0*1000.0)/1001.0),
        60.0,
        RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED, RESERVED
    };
#undef RESERVED

    int i_height_save, i_width_save;

    i_height_save = p_vpar->sequence.i_height;
    i_width_save = p_vpar->sequence.i_width;

    p_vpar->sequence.i_width = GetBits( &p_vpar->bit_stream, 12 );
    p_vpar->sequence.i_height = GetBits( &p_vpar->bit_stream, 12 );
    p_vpar->sequence.i_aspect_ratio = GetBits( &p_vpar->bit_stream, 4 );
    p_vpar->sequence.r_frame_rate =
            r_frame_rate_table[ GetBits( &p_vpar->bit_stream, 4 ) ];

    /* We don't need bit_rate_value, marker_bit, vbv_buffer_size,
     * constrained_parameters_flag */
    RemoveBits( &p_vpar->bit_stream, 30 );

    /*
     * Quantization matrices
     */
    if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_intra_quantizer_matrix */
    {
        LoadMatrix( p_vpar, &p_vpar->sequence.intra_quant );
    }
    else
    {
        /* Use default matrix. */
        LinkMatrix( &p_vpar->sequence.intra_quant, pi_default_intra_quant );
    }

    if( GetBits( &p_vpar->bit_stream, 1 ) ) /* load_non_intra_quantizer_matrix */
    {
        LoadMatrix( p_vpar, &p_vpar->sequence.nonintra_quant );
    }
    else
    {
        /* Use default matrix. */
        LinkMatrix( &p_vpar->sequence.nonintra_quant, pi_default_nonintra_quant );
    }

    /* Unless later overwritten by a matrix extension, we have the same
     * matrices for luminance and chrominance. */
    LinkMatrix( &p_vpar->sequence.chroma_intra_quant,
                p_vpar->sequence.intra_quant.pi_matrix );
    LinkMatrix( &p_vpar->sequence.chroma_nonintra_quant,
                p_vpar->sequence.nonintra_quant.pi_matrix );

    /*
     * Sequence Extension
     */
    NextStartCode( p_vpar );
    if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
    {
        int                         i_dummy;

        /* Turn the MPEG2 flag on */
        p_vpar->sequence.b_mpeg2 = 1;

        /* Parse sequence_extension */
        RemoveBits32( &p_vpar->bit_stream );
        /* extension_start_code_identifier, profile_and_level_indication */
        RemoveBits( &p_vpar->bit_stream, 12 );
        p_vpar->sequence.b_progressive = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->sequence.i_chroma_format = GetBits( &p_vpar->bit_stream, 2 );
        p_vpar->sequence.i_width |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
        p_vpar->sequence.i_height |= GetBits( &p_vpar->bit_stream, 2 ) << 12;
        /* bit_rate_extension, marker_bit, vbv_buffer_size_extension, low_delay */
        RemoveBits( &p_vpar->bit_stream, 22 );
        /* frame_rate_extension_n */
        i_dummy = GetBits( &p_vpar->bit_stream, 2 );
        /* frame_rate_extension_d */
        p_vpar->sequence.r_frame_rate *= (i_dummy + 1)
                                  / (GetBits( &p_vpar->bit_stream, 5 ) + 1);
    }
    else
    {
        /* It's an MPEG-1 stream. Put adequate parameters. */

        p_vpar->sequence.b_mpeg2 = 0;
        p_vpar->sequence.b_progressive = 1;
        p_vpar->sequence.i_chroma_format = CHROMA_420;
    }

    /* Update sizes */
    p_vpar->sequence.i_mb_width = (p_vpar->sequence.i_width + 15) / 16;
    p_vpar->sequence.i_mb_height = (p_vpar->sequence.b_progressive) ?
                                   (p_vpar->sequence.i_height + 15) / 16 :
                                   2 * ((p_vpar->sequence.i_height + 31) / 32);
    p_vpar->sequence.i_mb_size = p_vpar->sequence.i_mb_width
                                        * p_vpar->sequence.i_mb_height;
    p_vpar->sequence.i_width = (p_vpar->sequence.i_mb_width * 16);
    p_vpar->sequence.i_height = (p_vpar->sequence.i_mb_height * 16);
    p_vpar->sequence.i_size = p_vpar->sequence.i_width
                                        * p_vpar->sequence.i_height;

    /* Update chromatic information. */
    switch( p_vpar->sequence.i_chroma_format )
    {
    case CHROMA_420:
        p_vpar->sequence.i_chroma_nb_blocks = 2;
        p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
        p_vpar->sequence.i_chroma_mb_width = 8;
        p_vpar->sequence.i_chroma_mb_height = 8;
        break;

    case CHROMA_422:
        p_vpar->sequence.i_chroma_nb_blocks = 4;
        p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width >> 1;
        p_vpar->sequence.i_chroma_mb_width = 8;
        p_vpar->sequence.i_chroma_mb_height = 16;
        break;

    case CHROMA_444:
        p_vpar->sequence.i_chroma_nb_blocks = 8;
        p_vpar->sequence.i_chroma_width = p_vpar->sequence.i_width;
        p_vpar->sequence.i_chroma_mb_width = 16;
        p_vpar->sequence.i_chroma_mb_height = 16;
    }

    /* Reset scalable_mode. */
    p_vpar->sequence.i_scalable_mode = SC_NONE;

#if 0
    if(    p_vpar->sequence.i_width != i_width_save
        || p_vpar->sequence.i_height != i_height_save )
    {
         /* FIXME: What do we do in case of a size change ?? */
    }
#endif

    /* Extension and User data */
    ExtensionAndUserData( p_vpar );
}

/*****************************************************************************
 * GroupHeader : Parse the next group of pictures header
 *****************************************************************************/
static void GroupHeader( vpar_thread_t * p_vpar )
{
    /* Nothing to do, we don't care. */
    RemoveBits( &p_vpar->bit_stream, 27 );
    ExtensionAndUserData( p_vpar );
}

/*****************************************************************************
 * PictureHeader : Parse the next picture header
 *****************************************************************************/
static void PictureHeader( vpar_thread_t * p_vpar )
{
    /* Table of optimized PictureData functions. */
    static f_picture_data_t ppf_picture_data[4][4] =
    {
        {
            NULL, NULL, NULL, NULL
        },
        {
            /* TOP_FIELD */
#if (VPAR_OPTIM_LEVEL > 1)
            NULL, vpar_PictureData2I420TZ, vpar_PictureData2P420TZ,
            vpar_PictureData2B420TZ
#else
            NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
            vpar_PictureDataGENERIC
#endif
        },
        {
            /* BOTTOM_FIELD */
#if (VPAR_OPTIM_LEVEL > 1)
            NULL, vpar_PictureData2I420BZ, vpar_PictureData2P420BZ,
            vpar_PictureData2B420BZ
#else
            NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
            vpar_PictureDataGENERIC
#endif
        },
        {
            /* FRAME_PICTURE */
#if (VPAR_OPTIM_LEVEL > 0)
            NULL, vpar_PictureData2I420F0, vpar_PictureData2P420F0,
            vpar_PictureData2B420F0
#else
            NULL, vpar_PictureDataGENERIC, vpar_PictureDataGENERIC,
            vpar_PictureDataGENERIC
#endif
        }
    };

    int                 i_structure;
    int                 i_mb_base;
    boolean_t           b_parsable;
#ifdef VDEC_SMP
    int                 i_mb;
#endif

    RemoveBits( &p_vpar->bit_stream, 10 ); /* temporal_reference */
    p_vpar->picture.i_coding_type = GetBits( &p_vpar->bit_stream, 3 );
    RemoveBits( &p_vpar->bit_stream, 16 ); /* vbv_delay */

    if( p_vpar->picture.i_coding_type == P_CODING_TYPE
        || p_vpar->picture.i_coding_type == B_CODING_TYPE )
    {
        p_vpar->picture.pb_full_pel_vector[0] = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.i_forward_f_code = GetBits( &p_vpar->bit_stream, 3 );
    }
    if( p_vpar->picture.i_coding_type == B_CODING_TYPE )
    {
        p_vpar->picture.pb_full_pel_vector[1] = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.i_backward_f_code = GetBits( &p_vpar->bit_stream, 3 );
    }

    /* extra_information_picture */
    while( GetBits( &p_vpar->bit_stream, 1 ) )
    {
        RemoveBits( &p_vpar->bit_stream, 8 );
    }

    /*
     * Picture Coding Extension
     */
    NextStartCode( p_vpar );
    if( ShowBits( &p_vpar->bit_stream, 32 ) == EXTENSION_START_CODE )
    {
        /* Parse picture_coding_extension */
        RemoveBits32( &p_vpar->bit_stream );
        /* extension_start_code_identifier */
        RemoveBits( &p_vpar->bit_stream, 4 );

        p_vpar->picture.ppi_f_code[0][0] = GetBits( &p_vpar->bit_stream, 4 );
        p_vpar->picture.ppi_f_code[0][1] = GetBits( &p_vpar->bit_stream, 4 );
        p_vpar->picture.ppi_f_code[1][0] = GetBits( &p_vpar->bit_stream, 4 );
        p_vpar->picture.ppi_f_code[1][1] = GetBits( &p_vpar->bit_stream, 4 );
        p_vpar->picture.i_intra_dc_precision = GetBits( &p_vpar->bit_stream, 2 );
        i_structure = GetBits( &p_vpar->bit_stream, 2 );
        p_vpar->picture.b_top_field_first = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_frame_pred_frame_dct
             = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_concealment_mv = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_q_scale_type = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_intra_vlc_format = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_alternate_scan = GetBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_repeat_first_field = GetBits( &p_vpar->bit_stream, 1 );
        /* repeat_first_field (ISO/IEC 13818-2 6.3.10 is necessary to know
         * the length of the picture_display_extension structure.
         * chroma_420_type (obsolete) */
        RemoveBits( &p_vpar->bit_stream, 1 );
        p_vpar->picture.b_progressive_frame = GetBits( &p_vpar->bit_stream, 1 );

        /* composite_display_flag */
        if( GetBits( &p_vpar->bit_stream, 1 ) )
        {
            /* v_axis, field_sequence, sub_carrier, burst_amplitude,
             * sub_carrier_phase */
            RemoveBits( &p_vpar->bit_stream, 20 );
        }
    }
    else
    {
        /* MPEG-1 compatibility flags */
        p_vpar->picture.i_intra_dc_precision = 0; /* 8 bits */
        i_structure = FRAME_STRUCTURE;
        p_vpar->picture.b_frame_pred_frame_dct = 1;
        p_vpar->picture.b_concealment_mv = 0;
        p_vpar->picture.b_q_scale_type = 0;
        p_vpar->picture.b_intra_vlc_format = 0;
        p_vpar->picture.b_alternate_scan = 0; /* zigzag */
        p_vpar->picture.b_repeat_first_field = 0;
        p_vpar->picture.b_progressive_frame = 1;
    }

    if( p_vpar->picture.i_current_structure &&
        (i_structure == FRAME_STRUCTURE ||
         i_structure == p_vpar->picture.i_current_structure) )
    {
        /* We don't have the second field of the buffered frame. */
        if( p_vpar->picture.p_picture != NULL )
        {
            ReferenceReplace( p_vpar,
                      p_vpar->picture.i_coding_type,
                      NULL );

#ifdef VDEC_SMP
            for( i_mb = 0; p_vpar->picture.pp_mb[i_mb] != NULL; i_mb++ )
            {
                vpar_DestroyMacroblock( &p_vpar->vfifo,
                                        p_vpar->picture.pp_mb[i_mb] );
            }
#endif
            vout_DestroyPicture( p_vpar->p_vout, p_vpar->picture.p_picture );
        }

        p_vpar->picture.i_current_structure = 0;

        intf_DbgMsg("vpar debug: odd number of field picture.\n");
    }

    /* Do we have the reference pictures ? */
    b_parsable = !(((p_vpar->picture.i_coding_type == P_CODING_TYPE) &&
                    (p_vpar->sequence.p_backward == NULL)) ||
                     /* p_backward will become p_forward later */
                   ((p_vpar->picture.i_coding_type == B_CODING_TYPE) &&
                    (p_vpar->sequence.p_forward == NULL ||
                     p_vpar->sequence.p_backward == NULL)));

    if( b_parsable )
    {
        if( p_vpar->picture.i_current_structure )
        {
            /* Second field of a frame. We will decode it if, and only if we
            * have decoded the first field. */
            b_parsable = (p_vpar->picture.p_picture != NULL);
        }
        else
        {
            /* Does synchro say we have enough time to decode it ? */
            b_parsable = vpar_SynchroChoose( p_vpar,
                               p_vpar->picture.i_coding_type, i_structure );
        }
    }
#ifdef POLUX_SYNCHRO
    else if( !p_vpar->picture.i_current_structure )
    {
        vpar_SynchroTrash( p_vpar, p_vpar->picture.i_coding_type, i_structure );
    }
#endif