i915_xvmc.c

显驱动 Intel英特尔G45G43G41G35G33G31G965Q963Q965GM965系列显卡最新X.Org驱动2.4.0版For Linux

/*
 * Copyright © 2006 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.
 *
 * Authors:
 *    Xiang Haihao <[e-mail]>
 *
 */

#include <sys/ioctl.h>

#include "i915_xvmc.h"
#include "i915_structs.h"
#include "i915_program.h"

#define YOFFSET(surface)        (surface->srf.offset)
#define UOFFSET(surface)        (surface->srf.offset + \
                                 SIZE_Y420(surface->width, surface->height) + \
                                 SIZE_UV420(surface->width, surface->height))
#define VOFFSET(surface)        (surface->srf.offset + \
                                 SIZE_Y420(surface->width, surface->height))

typedef union {
    int16_t component[2];
    int32_t v;
} vector_t;

#if 0
static int findOverlap(unsigned int width, unsigned int height,
                       short *dstX, short *dstY,
                       short *srcX, short *srcY,
                       unsigned short *areaW, unsigned short *areaH)
{
    int w, h;
    unsigned int mWidth, mHeight;

    w = *areaW;
    h = *areaH;

    if ((*dstX >= width) || (*dstY >= height))
        return 1;

    if (*dstX < 0) {
        w += *dstX;
        *srcX -= *dstX;
        *dstX = 0;
    }

    if (*dstY < 0) {
        h += *dstY;
        *srcY -= *dstY;
        *dstY = 0;
    }

    if ((w <= 0) || ((h <= 0)))
        return 1;

    mWidth = width - *dstX;
    mHeight = height - *dstY;
    *areaW = (w <= mWidth) ? w : mWidth;
    *areaH = (h <= mHeight) ? h : mHeight;
    return 0;
}
#endif

static void i915_inst_arith(unsigned int *inst,
                            unsigned int op,
                            unsigned int dest,
                            unsigned int mask,
                            unsigned int saturate,
                            unsigned int src0, unsigned int src1, unsigned int src2)
{
    dest = UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest));
    *inst = (op | A0_DEST(dest) | mask | saturate | A0_SRC0(src0));
    inst++;
    *inst = (A1_SRC0(src0) | A1_SRC1(src1));
    inst++;
    *inst = (A2_SRC1(src1) | A2_SRC2(src2));
}

static void i915_inst_decl(unsigned int *inst,
                           unsigned int type,
                           unsigned int nr,
                           unsigned int d0_flags)
{
    unsigned int reg = UREG(type, nr);

    *inst = (D0_DCL | D0_DEST(reg) | d0_flags);
    inst++;
    *inst = D1_MBZ;
    inst++;
    *inst = D2_MBZ;
}

static void i915_inst_texld(unsigned int *inst,
                              unsigned int op,
                              unsigned int dest,
                              unsigned int coord,
                              unsigned int sampler)
{
   dest = UREG(GET_UREG_TYPE(dest), GET_UREG_NR(dest));
   *inst = (op | T0_DEST(dest) | T0_SAMPLER(sampler));
   inst++;
   *inst = T1_ADDRESS_REG(coord);
   inst++;
   *inst = T2_MBZ;
}

static void i915_emit_batch(void *data, int size, int flag)
{
    intelBatchbufferData(data, size, flag);
}

/* one time context initialization buffer */
static uint32_t *one_time_load_state_imm1;
static uint32_t *one_time_load_indirect;
static int one_time_load_state_imm1_size, one_time_load_indirect_size;

/* load indirect buffer for mc rendering */
static uint32_t *mc_render_load_indirect;
static int mc_render_load_indirect_size;

static void i915_mc_one_time_context_init(XvMCContext *context)
{
    unsigned int dest, src0, src1, src2;
    i915XvMCContext *pI915XvMC = (i915XvMCContext *)context->privData;
    int i;
    struct i915_3dstate_sampler_state *sampler_state;
    struct i915_3dstate_pixel_shader_program *pixel_shader_program;
    struct i915_3dstate_pixel_shader_constants *pixel_shader_constants;

    /* sampler static state */
    sampler_state = (struct i915_3dstate_sampler_state *)pI915XvMC->ssb.map;
    /* pixel shader static state */
    pixel_shader_program = (struct i915_3dstate_pixel_shader_program *)pI915XvMC->psp.map;
    /* pixel shader contant static state */
    pixel_shader_constants = (struct i915_3dstate_pixel_shader_constants *)pI915XvMC->psc.map;

    memset(sampler_state, 0, sizeof(*sampler_state));
    sampler_state->dw0.type = CMD_3D;
    sampler_state->dw0.opcode = OPC_3DSTATE_SAMPLER_STATE;
    sampler_state->dw0.length = 6;
    sampler_state->dw1.sampler_masker = SAMPLER_SAMPLER0 | SAMPLER_SAMPLER1;

    sampler_state->sampler0.ts0.reverse_gamma = 0;
    sampler_state->sampler0.ts0.planar2packet = 0;
    sampler_state->sampler0.ts0.color_conversion = 0;
    sampler_state->sampler0.ts0.chromakey_index = 0;
    sampler_state->sampler0.ts0.base_level = 0;
    sampler_state->sampler0.ts0.mip_filter = MIPFILTER_NONE;        /* NONE */
    sampler_state->sampler0.ts0.mag_filter = MAPFILTER_LINEAR;      /* LINEAR */
    sampler_state->sampler0.ts0.min_filter = MAPFILTER_LINEAR;      /* LINEAR */
    sampler_state->sampler0.ts0.lod_bias = 0;       /* 0.0 */
    sampler_state->sampler0.ts0.shadow_enable = 0;
    sampler_state->sampler0.ts0.max_anisotropy = ANISORATIO_2;
    sampler_state->sampler0.ts0.shadow_function = PREFILTEROP_ALWAYS;
    sampler_state->sampler0.ts1.min_lod = 0;        /* 0.0 Maximum Mip Level */
    sampler_state->sampler0.ts1.kill_pixel = 0;
    sampler_state->sampler0.ts1.keyed_texture_filter = 0;
    sampler_state->sampler0.ts1.chromakey_enable = 0;
    sampler_state->sampler0.ts1.tcx_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler0.ts1.tcy_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler0.ts1.tcz_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler0.ts1.normalized_coor = 0;
    sampler_state->sampler0.ts1.map_index = 0;
    sampler_state->sampler0.ts1.east_deinterlacer = 0;
    sampler_state->sampler0.ts2.default_color = 0;

    sampler_state->sampler1.ts0.reverse_gamma = 0;
    sampler_state->sampler1.ts0.planar2packet = 0;
    sampler_state->sampler1.ts0.color_conversion = 0;
    sampler_state->sampler1.ts0.chromakey_index = 0;
    sampler_state->sampler1.ts0.base_level = 0;
    sampler_state->sampler1.ts0.mip_filter = MIPFILTER_NONE;        /* NONE */
    sampler_state->sampler1.ts0.mag_filter = MAPFILTER_LINEAR;      /* LINEAR */
    sampler_state->sampler1.ts0.min_filter = MAPFILTER_LINEAR;      /* LINEAR */
    sampler_state->sampler1.ts0.lod_bias = 0;       /* 0.0 */
    sampler_state->sampler1.ts0.shadow_enable = 0;
    sampler_state->sampler1.ts0.max_anisotropy = ANISORATIO_2;
    sampler_state->sampler1.ts0.shadow_function = PREFILTEROP_ALWAYS;
    sampler_state->sampler1.ts1.min_lod = 0;        /* 0.0 Maximum Mip Level */
    sampler_state->sampler1.ts1.kill_pixel = 0;
    sampler_state->sampler1.ts1.keyed_texture_filter = 0;
    sampler_state->sampler1.ts1.chromakey_enable = 0;
    sampler_state->sampler1.ts1.tcx_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler1.ts1.tcy_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler1.ts1.tcz_control = TEXCOORDMODE_CLAMP;
    sampler_state->sampler1.ts1.normalized_coor = 0;
    sampler_state->sampler1.ts1.map_index = 1;
    sampler_state->sampler1.ts1.east_deinterlacer = 0;
    sampler_state->sampler1.ts2.default_color = 0;

    memset(pixel_shader_program, 0, sizeof(*pixel_shader_program));
    pixel_shader_program->shader0.type = CMD_3D;
    pixel_shader_program->shader0.opcode = OPC_3DSTATE_PIXEL_SHADER_PROGRAM;
    pixel_shader_program->shader0.retain = 1;
    pixel_shader_program->shader0.length = 2; /* 1 inst */
    i = 0;

    dest = UREG(REG_TYPE_OC, 0);
    src0 = UREG(REG_TYPE_CONST, 0);
    src1 = 0;
    src2 = 0;
    i915_inst_arith(&pixel_shader_program->inst0[i], A0_MOV,
	    dest, A0_DEST_CHANNEL_ALL, A0_DEST_SATURATE, src0, src1, src2);

    pixel_shader_program->shader1.type = CMD_3D;
    pixel_shader_program->shader1.opcode = OPC_3DSTATE_PIXEL_SHADER_PROGRAM;
    pixel_shader_program->shader1.retain = 1;
    pixel_shader_program->shader1.length = 14; /* 5 inst */
    i = 0;
    /* dcl t0.xy */
    i915_inst_decl(&pixel_shader_program->inst1[i], REG_TYPE_T, T_TEX0, D0_CHANNEL_XY);
    i+=3;
    /* dcl t1.xy */
    i915_inst_decl(&pixel_shader_program->inst1[i], REG_TYPE_T, T_TEX1, D0_CHANNEL_XY);
    /* dcl_2D s0 */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst1[i], REG_TYPE_S, 0, D0_SAMPLE_TYPE_2D);
    /* texld r0, t0, s0 */
    i += 3;
    dest = UREG(REG_TYPE_R, 0);
    src0 = UREG(REG_TYPE_T, 0); /* COORD */
    src1 = UREG(REG_TYPE_S, 0); /* SAMPLER */
    i915_inst_texld(&pixel_shader_program->inst1[i], T0_TEXLD, dest, src0, src1);
    /* mov oC, r0 */
    i += 3;
    dest = UREG(REG_TYPE_OC, 0);
    src0 = UREG(REG_TYPE_R, 0);
    src1 = src2 = 0;
    i915_inst_arith(&pixel_shader_program->inst1[i], A0_MOV, dest, A0_DEST_CHANNEL_ALL,
                    A0_DEST_SATURATE, src0, src1, src2);


    pixel_shader_program->shader2.type = CMD_3D;
    pixel_shader_program->shader2.opcode = OPC_3DSTATE_PIXEL_SHADER_PROGRAM;
    pixel_shader_program->shader2.retain = 1;
    pixel_shader_program->shader2.length = 14; /* 5 inst */
    i = 0;
    /* dcl t2.xy */
    i915_inst_decl(&pixel_shader_program->inst2[i], REG_TYPE_T, T_TEX2, D0_CHANNEL_XY);
    /* dcl t3.xy */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst2[i], REG_TYPE_T, T_TEX3, D0_CHANNEL_XY);
    /* dcl_2D s1 */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst2[i], REG_TYPE_S, 1, D0_SAMPLE_TYPE_2D);
    /* texld r0, t2, s1 */
    i += 3;
    dest = UREG(REG_TYPE_R, 0);
    src0 = UREG(REG_TYPE_T, 2); /* COORD */
    src1 = UREG(REG_TYPE_S, 1); /* SAMPLER */
    i915_inst_texld(&pixel_shader_program->inst2[i], T0_TEXLD, dest, src0, src1);
    /* mov oC, r0 */
    i += 3;
    dest = UREG(REG_TYPE_OC, 0);
    src0 = UREG(REG_TYPE_R, 0);
    src1 = src2 = 0;
    i915_inst_arith(&pixel_shader_program->inst2[i], A0_MOV, dest, A0_DEST_CHANNEL_ALL,
                    A0_DEST_SATURATE, src0, src1, src2);

    /* Shader 3 */
    pixel_shader_program->shader3.type = CMD_3D;
    pixel_shader_program->shader3.opcode = OPC_3DSTATE_PIXEL_SHADER_PROGRAM;
    pixel_shader_program->shader3.retain = 1;
    pixel_shader_program->shader3.length = 29; /* 10 inst */
    i = 0;
    /* dcl t0.xy */
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_T, T_TEX0, D0_CHANNEL_XY);
    /* dcl t1.xy */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_T, T_TEX1, D0_CHANNEL_XY);
    /* dcl t2.xy */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_T, T_TEX2, D0_CHANNEL_XY);
    /* dcl t3.xy */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_T, T_TEX3, D0_CHANNEL_XY);
    /* dcl_2D s0 */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_S, 0, D0_SAMPLE_TYPE_2D);
    /* dcl_2D s1 */
    i += 3;
    i915_inst_decl(&pixel_shader_program->inst3[i], REG_TYPE_S, 1, D0_SAMPLE_TYPE_2D);
    /* texld r0, t0, s0 */
    i += 3;
    dest = UREG(REG_TYPE_R, 0);
    src0 = UREG(REG_TYPE_T, 0); /* COORD */
    src1 = UREG(REG_TYPE_S, 0); /* SAMPLER */
    i915_inst_texld(&pixel_shader_program->inst3[i], T0_TEXLD, dest, src0, src1);
    /* texld r1, t2, s1 */
    i += 3;
    dest = UREG(REG_TYPE_R, 1);
    src0 = UREG(REG_TYPE_T, 2); /* COORD */
    src1 = UREG(REG_TYPE_S, 1); /* SAMPLER */
    i915_inst_texld(&pixel_shader_program->inst3[i], T0_TEXLD, dest, src0, src1);
    /* add r0, r0, r1 */
    i += 3;
    dest = UREG(REG_TYPE_R, 0);
    src0 = UREG(REG_TYPE_R, 0);
    src1 = UREG(REG_TYPE_R, 1);
    src2 = 0;
    i915_inst_arith(&pixel_shader_program->inst3[i], A0_ADD, dest, A0_DEST_CHANNEL_ALL,
                    0 /* A0_DEST_SATURATE */, src0, src1, src2);
    /* mul oC, r0, c0 */
    i += 3;
    dest = UREG(REG_TYPE_OC, 0);
    src0 = UREG(REG_TYPE_R, 0);
    src1 = UREG(REG_TYPE_CONST, 0);
    src2 = 0;
    i915_inst_arith(&pixel_shader_program->inst3[i], A0_MUL, dest, A0_DEST_CHANNEL_ALL,
                    A0_DEST_SATURATE, src0, src1, src2);

    memset(pixel_shader_constants, 0, sizeof(*pixel_shader_constants));
    pixel_shader_constants->dw0.type = CMD_3D;
    pixel_shader_constants->dw0.opcode = OPC_3DSTATE_PIXEL_SHADER_CONSTANTS;
    pixel_shader_constants->dw0.length = 4;
    pixel_shader_constants->dw1.reg_mask = REG_CR0;
    pixel_shader_constants->value.x = 0.5;
    pixel_shader_constants->value.y = 0.5;
    pixel_shader_constants->value.z = 0.5;
    pixel_shader_constants->value.w = 0.5;

}

static void i915_mc_one_time_state_init(XvMCContext *context)
{
    struct s3_dword *s3 = NULL;
    struct s6_dword *s6 = NULL;
    dis_state *dis = NULL;
    ssb_state *ssb = NULL;
    psp_state *psp = NULL;
    psc_state *psc = NULL;
    i915XvMCContext *pI915XvMC = (i915XvMCContext *)context->privData;
    struct i915_3dstate_load_state_immediate_1 *load_state_immediate_1;
    struct i915_3dstate_load_indirect *load_indirect;
    int mem_select;

    /* 3DSTATE_LOAD_STATE_IMMEDIATE_1 */
    one_time_load_state_imm1_size = sizeof(*load_state_immediate_1) + sizeof(*s3) + sizeof(*s6);