header.c

来自「VLC Player Source Code」· C语言 代码 · 共 995 行 · 第 1/3 页

        switch( sequence->pixel_width )
        {
            case 0:
            case 15: /* illegal */
                sequence->pixel_width = sequence->pixel_height = 0;
                return;
            case 1: /* square pixels */
                sequence->pixel_width = sequence->pixel_height = 1;
                return;
            case 3: /* 720x576 16:9 */
                sequence->pixel_width = 64;	sequence->pixel_height = 45;
                return;
            case 6: /* 720x480 16:9 */
                sequence->pixel_width = 32;	sequence->pixel_height = 27;
                return;
            case 12: /* 720*480 4:3 */
                sequence->pixel_width = 8;	sequence->pixel_height = 9;
                return;
            default:
                height = 88 * sequence->pixel_width + 1171;
                width = 2000;
        }
   }

    sequence->pixel_width = width;
    sequence->pixel_height = height;
    while (width)
    { /* find greatest common divisor */
        int tmp = width;
        width = height % tmp;
        height = tmp;
    }
    sequence->pixel_width /= height;
    sequence->pixel_height /= height;
}

static void copy_matrix( mpeg2dec_t * mpeg2dec, int index )
{
    if( memcmp( mpeg2dec->quantizer_matrix[index],
                mpeg2dec->new_quantizer_matrix[index], 64) )
    {
        memcpy( mpeg2dec->quantizer_matrix[index],
                mpeg2dec->new_quantizer_matrix[index], 64);
        mpeg2dec->scaled[index] = -1;
    }
}

static void finalize_matrix( mpeg2dec_t * mpeg2dec )
{
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
    int i;

    for( i = 0; i < 2; i++ )
    {
        if( mpeg2dec->copy_matrix & (1 << i) )
            copy_matrix (mpeg2dec, i);
        if( (mpeg2dec->copy_matrix & (4 << i)) &&
            memcmp( mpeg2dec->quantizer_matrix[i],
                    mpeg2dec->new_quantizer_matrix[i+2], 64) )
        {
            copy_matrix (mpeg2dec, i + 2);
            decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
        }
        else if( mpeg2dec->copy_matrix & (5 << i) )
        decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
    }
#if 0
    decoder->load_intra_quantizer_matrix = 1;
    decoder->load_non_intra_quantizer_matrix = 1;
#endif
}

static mpeg2_state_t invalid_end_action( mpeg2dec_t * mpeg2dec )
{
    mpeg2_reset_info( &(mpeg2dec->info) );
    mpeg2dec->info.gop = NULL;
    info_user_data( mpeg2dec );
    mpeg2_header_state_init( mpeg2dec );
    mpeg2dec->sequence = mpeg2dec->new_sequence;
    mpeg2dec->action = mpeg2_seek_header;
    mpeg2dec->state = STATE_SEQUENCE;
    return STATE_SEQUENCE;
}

void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
{
    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);

    finalize_sequence (sequence);
    finalize_matrix (mpeg2dec);

    decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
    decoder->progressive_sequence = (sequence->flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE);
    decoder->aspect_ratio_information = sequence->aspect_ratio_information;
    decoder->width = sequence->width;
    decoder->height = sequence->height;
    decoder->vertical_position_extension = (sequence->picture_height > 2800);
    decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
                              (sequence->chroma_height == sequence->height));

    if( mpeg2dec->sequence.width != (unsigned int)-1 )
    {
        unsigned int new_byte_rate;

        /*
         * According to 6.1.1.6, repeat sequence headers should be
         * identical to the original. However some DVDs dont respect
         * that and have different bitrates in the repeat sequence
         * headers. So we'll ignore that in the comparison and still
         * consider these as repeat sequence headers.
         *
         * However, be careful not to alter the current sequence when
         * returning STATE_INVALID_END.
         */
        new_byte_rate = sequence->byte_rate;
        sequence->byte_rate = mpeg2dec->sequence.byte_rate;
        if( memcmp( &(mpeg2dec->sequence), sequence,
                    sizeof (mpeg2_sequence_t)) )
        {
            decoder->stride_frame = sequence->width;
            sequence->byte_rate = new_byte_rate;
            mpeg2_header_end( mpeg2dec );
            mpeg2dec->action = invalid_end_action;
            mpeg2dec->state = STATE_INVALID_END;
            return;
        }
        sequence->byte_rate = new_byte_rate;
        mpeg2dec->state = STATE_SEQUENCE_REPEATED;
    }
    else
        decoder->stride_frame = sequence->width;
    mpeg2dec->sequence = *sequence;
    mpeg2_reset_info( &(mpeg2dec->info) );
    mpeg2dec->info.sequence = &(mpeg2dec->sequence);
    mpeg2dec->info.gop = NULL;
    info_user_data( mpeg2dec );
}

int mpeg2_header_gop( mpeg2dec_t * mpeg2dec )
{
    uint8_t * buffer = mpeg2dec->chunk_start;
    mpeg2_gop_t * gop = &(mpeg2dec->new_gop);

    if( ! (buffer[1] & 8) )
        return 1;
    gop->hours = (buffer[0] >> 2) & 31;
    gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
    gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
    gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
    gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
    mpeg2dec->state = STATE_GOP;
    return 0;
}

void mpeg2_header_gop_finalize( mpeg2dec_t * mpeg2dec )
{
    mpeg2dec->gop = mpeg2dec->new_gop;
    mpeg2_reset_info( &(mpeg2dec->info) );
    mpeg2dec->info.gop = &(mpeg2dec->gop);
    info_user_data (mpeg2dec);
}

void mpeg2_set_fbuf( mpeg2dec_t * mpeg2dec, int b_type )
{
    int i;

    for( i = 0; i < 3; i++ )
    {
        if( (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf) &&
            (mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) )
        {
            mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
            mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
            if( b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
            {
                if( b_type || mpeg2dec->convert )
                    mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
                mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
            }
        }
        break;
    }
}

mpeg2_state_t mpeg2_header_picture_start( mpeg2dec_t * mpeg2dec )
{
    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);

    mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
                        STATE_PICTURE : STATE_PICTURE_2ND);
    picture->flags = 0;
    picture->tag = picture->tag2 = 0;
    if( mpeg2dec->num_tags )
    {
        if( mpeg2dec->bytes_since_tag >= 4 )
        {
            mpeg2dec->num_tags = 0;
            picture->tag = mpeg2dec->tag_current;
            picture->tag2 = mpeg2dec->tag2_current;
            picture->flags = PIC_FLAG_TAGS;
        }
        else if( mpeg2dec->num_tags > 1 )
        {
            mpeg2dec->num_tags = 1;
            picture->tag = mpeg2dec->tag_previous;
            picture->tag2 = mpeg2dec->tag2_previous;
            picture->flags = PIC_FLAG_TAGS;
        }
    }
    picture->display_offset[0].x = picture->display_offset[1].x =
    picture->display_offset[2].x = mpeg2dec->display_offset_x;
    picture->display_offset[0].y = picture->display_offset[1].y =
    picture->display_offset[2].y = mpeg2dec->display_offset_y;
    return mpeg2_parse_header (mpeg2dec);
}

int mpeg2_header_picture( mpeg2dec_t * mpeg2dec )
{
    uint8_t * buffer = mpeg2dec->chunk_start;
    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
    int type;

    type = (buffer [1] >> 3) & 7;
    mpeg2dec->ext_state = PIC_CODING_EXT;

    picture->temporal_reference = (buffer[0] << 2) | (buffer[1] >> 6);

    picture->flags |= type;

    if( (type == PIC_FLAG_CODING_TYPE_P) || (type == PIC_FLAG_CODING_TYPE_B) )
    {
        /* forward_f_code and backward_f_code - used in mpeg1 only */
        decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
        decoder->f_motion.f_code[0] =
                            (((buffer[3] << 1) | (buffer[4] >> 7)) & 7) - 1;
        decoder->b_motion.f_code[1] = (buffer[4] >> 6) & 1;
        decoder->b_motion.f_code[0] = ((buffer[4] >> 3) & 7) - 1;
    }

    /* XXXXXX decode extra_information_picture as well */
    picture->nb_fields = 2;

    mpeg2dec->q_scale_type = 0;
    decoder->intra_dc_precision = 7;
    decoder->frame_pred_frame_dct = 1;
    decoder->concealment_motion_vectors = 0;
    decoder->scan = mpeg2_scan_norm;
    decoder->picture_structure = FRAME_PICTURE;
    mpeg2dec->copy_matrix = 0;  
    return 0;
}

static int picture_coding_ext( mpeg2dec_t * mpeg2dec )
{
    uint8_t * buffer = mpeg2dec->chunk_start;
    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
    uint32_t flags;

    /* pre subtract 1 for use later in compute_motion_vector */
    decoder->f_motion.f_code[0] = (buffer[0] & 15) - 1;
    decoder->f_motion.f_code[1] = (buffer[1] >> 4) - 1;
    decoder->b_motion.f_code[0] = (buffer[1] & 15) - 1;
    decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;

    flags = picture->flags;
    decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
    decoder->picture_structure = buffer[2] & 3;

    switch (decoder->picture_structure)
    {
        case TOP_FIELD:
            //flags |= PIC_FLAG_TOP_FIELD_FIRST;
        case BOTTOM_FIELD:
            picture->nb_fields = 1;
            break;
        case FRAME_PICTURE:
            if( !(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE) )
            {
                picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
                flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
            }
            else
                picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
            break;
        default:
            return 1;
    }
    decoder->top_field_first = buffer[3] >> 7;

    if( decoder->top_field_first )
        flags |= PIC_FLAG_TOP_FIELD_FIRST;
    decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
    decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
    decoder->q_scale_type = (buffer[3] >> 4) & 1;
    mpeg2dec->q_scale_type = buffer[3] & 16;
    decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
    decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
    flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;

    if( buffer[4] & 0x40 )
        flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
                  PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
    picture->flags = flags;

    mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
    return 0;
}

static int picture_display_ext( mpeg2dec_t * mpeg2dec )
{
    uint8_t * buffer = mpeg2dec->chunk_start;
    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
    int i, nb_pos;

    nb_pos = picture->nb_fields;
    if( mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE )
        nb_pos >>= 1;

    for( i = 0; i < nb_pos; i++ )
    {
        int x, y;

        x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
            (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
        y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
            (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
        if( !(x & y & 1) )
            return 1;