Subversion Repositories Kolibri OS

/*

 * Copyright (C) 2006-2012 Intel Corporation

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice (including the next

 * paragraph) shall be included in all copies or substantial portions of the

 * Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 */

#include "sysdeps.h"

#include 

#include "intel_batchbuffer.h"

#include "i965_decoder_utils.h"

#include "i965_drv_video.h"

#include "i965_defines.h"

/* Set reference surface if backing store exists */

static inline int

set_ref_frame(

    struct i965_driver_data *i965,

    GenFrameStore           *ref_frame,

    VASurfaceID              va_surface

)

{

    struct object_surface *obj_surface;

    if (va_surface == VA_INVALID_ID)

        return 0;

    obj_surface = SURFACE(va_surface);

    if (!obj_surface || !obj_surface->bo)

        return 0;

    ref_frame->surface_id = va_surface;

    return 1;

}

/* Check wether codec layer incorrectly fills in slice_vertical_position */

int

mpeg2_wa_slice_vertical_position(

    struct decode_state           *decode_state,

    VAPictureParameterBufferMPEG2 *pic_param

)

{

    unsigned int i, j, mb_height, vpos, last_vpos = 0;

    /* Assume progressive sequence if we got a progressive frame */

    if (pic_param->picture_coding_extension.bits.progressive_frame)

        return 0;

    /* Wait for a field coded picture */

    if (pic_param->picture_coding_extension.bits.picture_structure == MPEG_FRAME)

        return -1;

    assert(decode_state && decode_state->slice_params);

    mb_height = (pic_param->vertical_size + 31) / 32;

    for (j = 0; j < decode_state->num_slice_params; j++) {

        struct buffer_store * const buffer_store =

            decode_state->slice_params[j];

        for (i = 0; i < buffer_store->num_elements; i++) {

            VASliceParameterBufferMPEG2 * const slice_param =

                ((VASliceParameterBufferMPEG2 *)buffer_store->buffer) + i;

            vpos = slice_param->slice_vertical_position;

            if (vpos >= mb_height || vpos == last_vpos + 2) {

                WARN_ONCE("codec layer incorrectly fills in MPEG-2 slice_vertical_position. Workaround applied\n");

                return 1;

            }

            last_vpos = vpos;

        }

    }

    return 0;

}

/* Build MPEG-2 reference frames array */

void

mpeg2_set_reference_surfaces(

    VADriverContextP               ctx,

    GenFrameStore                  ref_frames[MAX_GEN_REFERENCE_FRAMES],

    struct decode_state           *decode_state,

    VAPictureParameterBufferMPEG2 *pic_param

)

{

    struct i965_driver_data * const i965 = i965_driver_data(ctx);

    VASurfaceID va_surface;

    unsigned pic_structure, is_second_field, n = 0;

    pic_structure = pic_param->picture_coding_extension.bits.picture_structure;

    is_second_field = pic_structure != MPEG_FRAME &&

        !pic_param->picture_coding_extension.bits.is_first_field;

    ref_frames[0].surface_id = VA_INVALID_ID;

    /* Reference frames are indexed by frame store ID  (0:top, 1:bottom) */

    switch (pic_param->picture_coding_type) {

    case MPEG_P_PICTURE:

        if (is_second_field && pic_structure == MPEG_BOTTOM_FIELD) {

            va_surface = decode_state->current_render_target;

            n += set_ref_frame(i965, &ref_frames[n], va_surface);

        }

        va_surface = pic_param->forward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        break;

    case MPEG_B_PICTURE:

        va_surface = pic_param->forward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        va_surface = pic_param->backward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        break;

    }

    while (n != 2)

        ref_frames[n++].surface_id = ref_frames[0].surface_id;

    if (pic_param->picture_coding_extension.bits.progressive_frame)

        return;

    ref_frames[2].surface_id = VA_INVALID_ID;

    /* Bottom field pictures used as reference */

    switch (pic_param->picture_coding_type) {

    case MPEG_P_PICTURE:

        if (is_second_field && pic_structure == MPEG_TOP_FIELD) {

            va_surface = decode_state->current_render_target;

            n += set_ref_frame(i965, &ref_frames[n], va_surface);

        }

        va_surface = pic_param->forward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        break;

    case MPEG_B_PICTURE:

        va_surface = pic_param->forward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        va_surface = pic_param->backward_reference_picture;

        n += set_ref_frame(i965, &ref_frames[n], va_surface);

        break;

    }

    while (n != 4)

        ref_frames[n++].surface_id = ref_frames[2].surface_id;

}

/* Generate flat scaling matrices for H.264 decoding */

void

avc_gen_default_iq_matrix(VAIQMatrixBufferH264 *iq_matrix)

{

    /* Flat_4x4_16 */

    memset(&iq_matrix->ScalingList4x4, 16, sizeof(iq_matrix->ScalingList4x4));

    /* Flat_8x8_16 */

    memset(&iq_matrix->ScalingList8x8, 16, sizeof(iq_matrix->ScalingList8x8));

}

/* Get first macroblock bit offset for BSD, minus EPB count (AVC) */

/* XXX: slice_data_bit_offset does not account for EPB */

unsigned int

avc_get_first_mb_bit_offset(

    dri_bo                     *slice_data_bo,

    VASliceParameterBufferH264 *slice_param,

    unsigned int                mode_flag

)

{

    unsigned int slice_data_bit_offset = slice_param->slice_data_bit_offset;

    if (mode_flag == ENTROPY_CABAC)

        slice_data_bit_offset = ALIGN(slice_data_bit_offset, 0x8);

    return slice_data_bit_offset;

}

/* Get first macroblock bit offset for BSD, with EPB count (AVC) */

/* XXX: slice_data_bit_offset does not account for EPB */

unsigned int

avc_get_first_mb_bit_offset_with_epb(

    dri_bo                     *slice_data_bo,

    VASliceParameterBufferH264 *slice_param,

    unsigned int                mode_flag

)

{

    unsigned int in_slice_data_bit_offset = slice_param->slice_data_bit_offset;

    unsigned int out_slice_data_bit_offset;

    unsigned int i, j, n, buf_size, data_size, header_size;

    uint8_t *buf;

    int ret;

    header_size = slice_param->slice_data_bit_offset / 8;

    data_size   = slice_param->slice_data_size - slice_param->slice_data_offset;

    buf_size    = (header_size * 3 + 1) / 2; // Max possible header size (x1.5)

    if (buf_size > data_size)

        buf_size = data_size;

    buf = alloca(buf_size);

    ret = dri_bo_get_subdata(

        slice_data_bo, slice_param->slice_data_offset,

        buf_size, buf

    );

    assert(ret == 0);

    for (i = 2, j = 2, n = 0; i < buf_size && j < header_size; i++, j++) {

        if (buf[i] == 0x03 && buf[i - 1] == 0x00 && buf[i - 2] == 0x00)

            i += 2, j++, n++;

    }

    out_slice_data_bit_offset = in_slice_data_bit_offset + n * 8;

    if (mode_flag == ENTROPY_CABAC)

        out_slice_data_bit_offset = ALIGN(out_slice_data_bit_offset, 0x8);

    return out_slice_data_bit_offset;

}

static inline uint8_t

get_ref_idx_state_1(const VAPictureH264 *va_pic, unsigned int frame_store_id)

{

    const unsigned int is_long_term =

        !!(va_pic->flags & VA_PICTURE_H264_LONG_TERM_REFERENCE);

    const unsigned int is_top_field =

        !!(va_pic->flags & VA_PICTURE_H264_TOP_FIELD);

    const unsigned int is_bottom_field =

        !!(va_pic->flags & VA_PICTURE_H264_BOTTOM_FIELD);

    return ((is_long_term                         << 6) |

            ((is_top_field ^ is_bottom_field ^ 1) << 5) |

            (frame_store_id                       << 1) |

            ((is_top_field ^ 1) & is_bottom_field));

}

/* Fill in Reference List Entries (Gen5+: ILK, SNB, IVB) */

void

gen5_fill_avc_ref_idx_state(

    uint8_t             state[32],

    const VAPictureH264 ref_list[32],

    unsigned int        ref_list_count,

    const GenFrameStore frame_store[MAX_GEN_REFERENCE_FRAMES]

)

{

    unsigned int i, n, frame_idx;

    for (i = 0, n = 0; i < ref_list_count; i++) {

        const VAPictureH264 * const va_pic = &ref_list[i];

        if (va_pic->flags & VA_PICTURE_H264_INVALID)

            continue;

        for (frame_idx = 0; frame_idx < MAX_GEN_REFERENCE_FRAMES; frame_idx++) {

            const GenFrameStore * const fs = &frame_store[frame_idx];

            if (fs->surface_id != VA_INVALID_ID &&

                fs->surface_id == va_pic->picture_id) {

                assert(frame_idx == fs->frame_store_id);

                break;

            }

        }

        assert(frame_idx < MAX_GEN_REFERENCE_FRAMES);

        state[n++] = get_ref_idx_state_1(va_pic, frame_idx);

    }

    for (; n < 32; n++)

        state[n] = 0xff;

}

/* Emit Reference List Entries (Gen6+: SNB, IVB) */

static void

gen6_send_avc_ref_idx_state_1(

    struct intel_batchbuffer         *batch,

    unsigned int                      list,

    const VAPictureH264              *ref_list,

    unsigned int                      ref_list_count,

    const GenFrameStore               frame_store[MAX_GEN_REFERENCE_FRAMES]

)

{

    uint8_t ref_idx_state[32];

    BEGIN_BCS_BATCH(batch, 10);

    OUT_BCS_BATCH(batch, MFX_AVC_REF_IDX_STATE | (10 - 2));

    OUT_BCS_BATCH(batch, list);

    gen5_fill_avc_ref_idx_state(

        ref_idx_state,

        ref_list, ref_list_count,

        frame_store

    );

    intel_batchbuffer_data(batch, ref_idx_state, sizeof(ref_idx_state));

    ADVANCE_BCS_BATCH(batch);

}

void

gen6_send_avc_ref_idx_state(

    struct intel_batchbuffer         *batch,

    const VASliceParameterBufferH264 *slice_param,

    const GenFrameStore               frame_store[MAX_GEN_REFERENCE_FRAMES]

)

{

    if (slice_param->slice_type == SLICE_TYPE_I ||

        slice_param->slice_type == SLICE_TYPE_SI)

        return;

    /* RefPicList0 */

    gen6_send_avc_ref_idx_state_1(

        batch, 0,

        slice_param->RefPicList0, slice_param->num_ref_idx_l0_active_minus1 + 1,

        frame_store

    );

    if (slice_param->slice_type != SLICE_TYPE_B)

        return;

    /* RefPicList1 */

    gen6_send_avc_ref_idx_state_1(

        batch, 1,

        slice_param->RefPicList1, slice_param->num_ref_idx_l1_active_minus1 + 1,

        frame_store

    );

}