header.c

VLC Player Source Code

        picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
        picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
    }
    for( ; i < 3; i++ )
    {
        picture->display_offset[i].x = mpeg2dec->display_offset_x;
        picture->display_offset[i].y = mpeg2dec->display_offset_y;
    }
    return 0;
}

void mpeg2_header_picture_finalize( mpeg2dec_t * mpeg2dec, uint32_t accels )
{
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
    int old_type_b = (decoder->coding_type == B_TYPE);
    int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;

    finalize_matrix( mpeg2dec );
    decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;

    /* move in header_process_picture_header */
    decoder->second_field = (decoder->picture_structure != FRAME_PICTURE) &&
            !(decoder->second_field);

    if( mpeg2dec->state == STATE_PICTURE )
    {
        mpeg2_picture_t * picture;
        mpeg2_picture_t * other;

        /* decoder->second_field = 0; */

        picture = other = mpeg2dec->pictures;
        if( old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2) )
            picture += 2;
        else
            other += 2;
        mpeg2dec->picture = picture;
        *picture = mpeg2dec->new_picture;

        if( !old_type_b )
        {
            mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
            mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
        }
        mpeg2dec->fbuf[0] = NULL;
        mpeg2_reset_info (&(mpeg2dec->info));
        mpeg2dec->info.current_picture = picture;
        mpeg2dec->info.display_picture = picture;

        if( decoder->coding_type != B_TYPE )
        {
            if (!low_delay)
            {
                if (mpeg2dec->first)
                {
                    mpeg2dec->info.display_picture = NULL;
                    mpeg2dec->first = 0;
                }
                else
                {
                    mpeg2dec->info.display_picture = other;
                    if (other->nb_fields == 1)
                        mpeg2dec->info.display_picture_2nd = other + 1;
                    mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
                }
            }
            if( !low_delay + !mpeg2dec->convert )
                mpeg2dec->info.discard_fbuf =
                    mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
        }
        if (mpeg2dec->convert)
        {
            mpeg2_convert_init_t convert_init;
            if (!mpeg2dec->convert_start)
            {
                int y_size, uv_size;

                mpeg2dec->decoder.convert_id =
                    mpeg2_malloc( mpeg2dec->convert_id_size,
                                  MPEG2_ALLOC_CONVERT_ID );
                mpeg2dec->convert( MPEG2_CONVERT_START,
                                   mpeg2dec->decoder.convert_id,
                                   &(mpeg2dec->sequence),
                                   mpeg2dec->convert_stride, accels,
                                   mpeg2dec->convert_arg, &convert_init );
                mpeg2dec->convert_start = convert_init.start;
                mpeg2dec->decoder.convert = convert_init.copy;

                y_size = decoder->stride_frame * mpeg2dec->sequence.height;
                uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
                mpeg2dec->yuv_buf[0][0] =
                        (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[0][1] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[0][2] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[1][0] =
                        (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[1][1] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[1][2] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
                y_size = decoder->stride_frame * 32;
                uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
                mpeg2dec->yuv_buf[2][0] =
                        (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[2][1] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
                mpeg2dec->yuv_buf[2][2] =
                        (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
            }
            if (!mpeg2dec->custom_fbuf)
            {
                while( mpeg2dec->alloc_index < 3 )
                {
                    mpeg2_fbuf_t * fbuf;

                    fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
                    fbuf->id = NULL;
                    fbuf->buf[0] =
                            (uint8_t *) mpeg2_malloc( convert_init.buf_size[0],
                                                      MPEG2_ALLOC_CONVERTED );
                    fbuf->buf[1] =
                            (uint8_t *) mpeg2_malloc( convert_init.buf_size[1],
                                                      MPEG2_ALLOC_CONVERTED );
                    fbuf->buf[2] =
                            (uint8_t *) mpeg2_malloc( convert_init.buf_size[2],
                                                      MPEG2_ALLOC_CONVERTED );
                }
                mpeg2_set_fbuf( mpeg2dec, (decoder->coding_type == B_TYPE) );
            }
        }
        else if( !mpeg2dec->custom_fbuf )
        {
            while (mpeg2dec->alloc_index < 3)
            {
                mpeg2_fbuf_t * fbuf;
                int y_size, uv_size;

                fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
                fbuf->id = NULL;
                y_size = decoder->stride_frame * mpeg2dec->sequence.height;
                         uv_size = y_size >> (2 - decoder->chroma_format);
                fbuf->buf[0] = (uint8_t *) mpeg2_malloc( y_size,
                                                         MPEG2_ALLOC_YUV );
                fbuf->buf[1] = (uint8_t *) mpeg2_malloc( uv_size,
                                                         MPEG2_ALLOC_YUV );
                fbuf->buf[2] = (uint8_t *) mpeg2_malloc( uv_size,
                                                         MPEG2_ALLOC_YUV );
            }
            mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
        }
    }
    else
    {
        /* decoder->second_field = 1; */
        mpeg2dec->picture++;	/* second field picture */
        *(mpeg2dec->picture) = mpeg2dec->new_picture;
        mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
        if (low_delay || decoder->coding_type == B_TYPE)
            mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
    }
    info_user_data( mpeg2dec );
}

static int copyright_ext( mpeg2dec_t * mpeg2dec )
{
    return 0;
}

static int quant_matrix_ext( mpeg2dec_t * mpeg2dec )
{
    uint8_t * buffer = mpeg2dec->chunk_start;
    int i, j;

    for (i = 0; i < 4; i++)
    {
        if (buffer[0] & (8 >> i))
        {
            for (j = 0; j < 64; j++)
                mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
                            (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
            mpeg2dec->copy_matrix |= 1 << i;
            buffer += 64;
        }
    }
    return 0;
}

int mpeg2_header_extension( mpeg2dec_t * mpeg2dec )
{
    static int (* parser[]) (mpeg2dec_t *) = {
                    0, sequence_ext, sequence_display_ext, quant_matrix_ext,
                    copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
                };
    int ext, ext_bit;

    ext = mpeg2dec->chunk_start[0] >> 4;
    ext_bit = 1 << ext;

    if( !(mpeg2dec->ext_state & ext_bit) )
        return 0; /* ignore illegal extensions */
    mpeg2dec->ext_state &= ~ext_bit;
    return parser[ext] (mpeg2dec);
}

int mpeg2_header_user_data( mpeg2dec_t * mpeg2dec )
{
    mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
    mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
    return 0;
}

static void prescale( mpeg2dec_t * mpeg2dec, int index )
{
    static int non_linear_scale [] =
    {
         0,  1,  2,  3,  4,  5,   6,   7,
         8, 10, 12, 14, 16, 18,  20,  22,
        24, 28, 32, 36, 40, 44,  48,  52,
        56, 64, 72, 80, 88, 96, 104, 112
    };
    int i, j, k;
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);

    if( mpeg2dec->scaled[index] != mpeg2dec->q_scale_type )
    {
        mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
        for( i = 0; i < 32; i++ )
        {
            k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
            for( j = 0; j < 64; j++ )
                decoder->quantizer_prescale[index][i][j] =
                            k * mpeg2dec->quantizer_matrix[index][j];
        }
    }
}

mpeg2_state_t mpeg2_header_slice_start( mpeg2dec_t * mpeg2dec )
{
    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);

    mpeg2dec->info.user_data = NULL;
    mpeg2dec->info.user_data_len = 0;
    mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
                        mpeg2dec->state == STATE_PICTURE_2ND) ?
                        STATE_SLICE : STATE_SLICE_1ST);

    if (mpeg2dec->decoder.coding_type != D_TYPE)
    {
        prescale (mpeg2dec, 0);
        if( decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2] )
            prescale (mpeg2dec, 2);
        if( mpeg2dec->decoder.coding_type != I_TYPE )
        {
            prescale (mpeg2dec, 1);
            if( decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3] )
                prescale (mpeg2dec, 3);
        }
    }

    if( !(mpeg2dec->nb_decode_slices) )
        mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
    else if( mpeg2dec->convert_start )
    {
        mpeg2dec->convert_start( decoder->convert_id, mpeg2dec->fbuf[0],
                                 mpeg2dec->picture, mpeg2dec->info.gop );

        if( mpeg2dec->decoder.coding_type == B_TYPE )
            mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
                               mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
                               mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
        else
        {
            mpeg2_init_fbuf( &(mpeg2dec->decoder),
                             mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
                             mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
                             mpeg2dec->yuv_buf[mpeg2dec->yuv_index] );
            if( mpeg2dec->state == STATE_SLICE )
                mpeg2dec->yuv_index ^= 1;
        }
    }
    else
    {
        int b_type;

        b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
        mpeg2_init_fbuf( &(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
                         mpeg2dec->fbuf[b_type + 1]->buf,
                        mpeg2dec->fbuf[b_type]->buf );
    }
    mpeg2dec->action = NULL;
    return (mpeg2_state_t)-1;
}

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

mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
{
    mpeg2_picture_t * picture;
    int b_type;

    b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
    picture = mpeg2dec->pictures;
    if( (mpeg2dec->picture >= picture + 2) ^ b_type )
        picture = mpeg2dec->pictures + 2;

    mpeg2_reset_info (&(mpeg2dec->info));
    if( !(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY) )
    {
        mpeg2dec->info.display_picture = picture;
        if( picture->nb_fields == 1 )
            mpeg2dec->info.display_picture_2nd = picture + 1;
        mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
        if( !mpeg2dec->convert )
            mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
    }
    else if( !mpeg2dec->convert )
        mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
    mpeg2dec->action = seek_sequence;
    return STATE_END;
}