path: root/src/psb_deblock.c

/*
 * Copyright (c) 2011 Intel Corporation. All Rights Reserved.
 * Copyright (c) Imagination Technologies Limited, UK
 *
 * 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, sub license, 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 NON-INFRINGEMENT.
 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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:
 *    Zeng Li <zeng.li@intel.com>
 *
 */

#include "psb_cmdbuf.h"

#include <unistd.h>
#include <stdio.h>

#include "hwdefs/mem_io.h"
#include "hwdefs/msvdx_offsets.h"
#include "hwdefs/reg_io2.h"
#include "hwdefs/msvdx_vec_reg_io2.h"
#include "hwdefs/msvdx_vdmc_reg_io2.h"
#include "hwdefs/msvdx_mtx_reg_io2.h"
#include "hwdefs/msvdx_dmac_linked_list.h"
#include "hwdefs/msvdx_rendec_mtx_slice_cntrl_reg_io2.h"
#include "hwdefs/msvdx_core_regs_io2.h"
#include "hwdefs/h264_macroblock_mem_io.h"
#include "hwdefs/dxva_cmdseq_msg.h"
#include "hwdefs/dxva_fw_ctrl.h"
#include "hwdefs/fwrk_msg_mem_io.h"
#include "hwdefs/dxva_msg.h"
#include "hwdefs/msvdx_cmds_io2.h"
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#include "psb_def.h"

#define H264_MACROBLOCK_DATA_SIZE       0x80

#define MSVDX_CMDS_BASE         0x1000
#define MSVDX_CORE_BASE         0x600
#define MSVDX_VEC_BASE          0x800

#define MSVDX_DEBLOCK_REG_SET   0x10000000
#define MSVDX_DEBLOCK_REG_GET   0x20000000
#define MSVDX_DEBLOCK_REG_POLLn 0x30000000
#define MSVDX_DEBLOCK_REG_POLLx 0x40000000

static int reg_set_count = 0;
static int reg_get_count = 0;
static int reg_poll_x = 0;
static int reg_poll_n = 0;

#define psb_deblock_reg_set(group, reg, value) \
        *cmdbuf->regio_idx++ = (group##_##reg##_##OFFSET + group##_##BASE) | MSVDX_DEBLOCK_REG_SET;     \
        *cmdbuf->regio_idx++ = value; reg_set_count++;

#define psb_deblock_reg_set_RELOC( group, reg, buffer, buffer_offset, dst)             \
        *cmdbuf->regio_idx++ = (group##_##reg##_##OFFSET + group##_##BASE) | MSVDX_DEBLOCK_REG_SET;  \
        RELOC_REGIO(*cmdbuf->regio_idx++, buffer_offset, buffer, dst); reg_set_count++;

#define psb_deblock_reg_table_set(group, reg, index, value)             \
        *cmdbuf->regio_idx++ = ( (group##_##reg##_OFFSET + group##_##BASE + index*group##_##reg##_STRIDE) | MSVDX_DEBLOCK_REG_SET); \
        *cmdbuf->regio_idx++ = value; reg_set_count++;

#define psb_deblock_reg_get(group, reg) \
        *cmdbuf->regio_idx++ = (group##_##reg##_##OFFSET + group##_##BASE) | MSVDX_DEBLOCK_REG_GET; reg_get_count++;

#if 1
#define h264_pollForSpaceForNCommands(NumCommands)\
        *cmdbuf->regio_idx++ = (MSVDX_CORE_CR_MSVDX_COMMAND_SPACE_OFFSET + MSVDX_CORE_BASE) | MSVDX_DEBLOCK_REG_POLLn; \
        *cmdbuf->regio_idx++ = NumCommands; reg_poll_n++;
#else
#define h264_pollForSpaceForNCommands(NumCommands)              /* Seems not needed, so just define it null */
#endif

#define PollForSpaceForXCommands  \
        *cmdbuf->regio_idx++ = (MSVDX_CORE_CR_MSVDX_COMMAND_SPACE_OFFSET + MSVDX_CORE_BASE) | MSVDX_DEBLOCK_REG_POLLx; reg_poll_x++;

typedef enum {
    H264_BLOCKSIZE_16X16                = 0, /* 1 block */
    H264_BLOCKSIZE_16X8                 = 1, /* 2 blocks */
    H264_BLOCKSIZE_8X16                 = 2,
    H264_BLOCKSIZE_8X8                  = 3, /* 4 blocks */
    H264_BLOCKSIZE_8X4                  = 4,
    H264_BLOCKSIZE_4X8                  = 5,
    H264_BLOCKSIZE_4X4                  = 6

} h264_eBlockSize;

static  uint32_t        BlockDownsizeMap[] = {
    1, 1, 3, 3, 3, 5, 5
};

static  uint32_t        BlocksToSendMap[] = {
    1, 2, 2, 4, 4, 4, 4
};

static  uint32_t        BlockAddressMap[7][4] = {
    { 0 },                                                                                      /* 16x16        */
    { 0, 2 },                                                                           /* 16x8         */
    { 0, 1 },                                                                           /* 8x16         */
    { 0, 1, 2, 3 },                                                                     /* 8x8          */
    { 0, 1, 2, 3 },                                                                     /* 8x4          */
    { 0, 1, 2, 3 },                                                                     /* 4x8          */
    { 0, 1, 2, 3 }                                                                      /* 4x4          */
};

static  uint32_t        VectorsToSendMap[] = {
    1, 1, 1, 1, 2, 2, 4
};

static  uint32_t        VectorOffsetMap[7][4] = {
    { 0 },                                                                                      /* 16x16        */
    { 0 },                                                                                      /* 16x8         */
    { 0 },                                                                                      /* 8x16         */
    { 0 },                                                                                      /* 8x8          */
    { 0, 2 },                                                                           /* 8x4          */
    { 0, 1 },                                                                           /* 4x8          */
    { 0, 1, 2, 3 }                                                                      /* 4x4          */
};


static  uint32_t        Above1AboveTileMap[] = {
    /*  9, 12, 8, 13    */
    13, 12, 9, 8
};

static  uint32_t        CurrentAboveTileMap[] = {
    /*  11, 14, 10, 15  */
    15, 14, 11, 10
};

static  uint32_t        CurrentColTileMap[] = {
    10, 15, 0, 5, 8, 13, 2, 7, 1, 4, 3, 6, 9, 12
};


static  uint32_t        ColBlockMap[] = {
    2, 3, 0, 1
};

void
h264_above1InterBlockSequence(psb_cmdbuf_p cmdbuf, uint8_t* MbData)
{
    uint32_t    i, BlockNum, Mv, MvAddr, Value;
    uint32_t    Block8x8, blockType;
    uint32_t    InterBlockCmd;
    uint32_t    MotionVecCmd[16];
    uint32_t    BlockType[4] = {0};
    uint32_t    DpbIdx[4];

    /* set MV vars to 0 */
    for (i = 0; i < 16; i++) {
        MotionVecCmd[i] = 0;
    }

    /* Read the size of blocks 2 and 3 and resize them so they are all ?x8 */
    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK2_PREDICTION_SIZE);
    if (Value > (sizeof(BlockDownsizeMap) / sizeof(uint32_t) - 1))
        Value = sizeof(BlockDownsizeMap) / sizeof(uint32_t) - 1;
    BlockType[2] = BlockDownsizeMap[Value];
    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK3_PREDICTION_SIZE);
    if (Value > (sizeof(BlockDownsizeMap) / sizeof(uint32_t) - 1))
        Value = sizeof(BlockDownsizeMap) / sizeof(uint32_t) - 1;
    BlockType[3] = BlockDownsizeMap[Value];

    /* read motion vectors for the bottom row, but store them in the correct locn. for ?x8 blocks */
    for (i = 0; i < 4; i++) {
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_X_ABOVE, i);
        REGIO_WRITE_FIELD(MotionVecCmd[Above1AboveTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_X, Value);
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_Y_ABOVE, i);
        REGIO_WRITE_FIELD(MotionVecCmd[Above1AboveTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_Y, Value);
    }

    /* read DPB index for blocks 2 and 3 */
    for (i = 0; i < 2; i++) {
        DpbIdx[ColBlockMap[i]] = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_DPB_IDX_COL, i);
    }

    /* Send commands required blocks */
    for (BlockNum = BlocksToSendMap[BlockType[2]] / 2;
         BlockNum < BlocksToSendMap[BlockType[2]];
         BlockNum++) {
        /* block address */
        Block8x8 = BlockAddressMap[BlockType[2]][BlockNum];
        /* block type */
        blockType = BlockType[Block8x8];

        InterBlockCmd = 0;
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, INTER_PRED_BLOCK_SIZE, blockType);
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, REF_INDEX_A_VALID, 1);
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, REF_INDEX_A, DpbIdx[Block8x8]);

        /* send commands */
        h264_pollForSpaceForNCommands(1 + VectorsToSendMap[blockType]);
        psb_deblock_reg_table_set(MSVDX_CMDS, INTER_BLOCK_PREDICTION_ABOVE1, Block8x8, InterBlockCmd);

        for (i = 0; i < VectorsToSendMap[blockType]; i++) {
            /* only send forward MVs in baseline */
            MvAddr = (2 * 4 * Block8x8) + VectorOffsetMap[blockType][i];
            Mv = (4 * Block8x8) + VectorOffsetMap[blockType][i];
            psb_deblock_reg_table_set(MSVDX_CMDS, MOTION_VECTOR_ABOVE1, MvAddr, MotionVecCmd[Mv]);
        }
    }
}

void
h264_currentInterBlockSequence(psb_cmdbuf_p cmdbuf, uint8_t * MbData)
{
    uint32_t    i, BlockNum, Mv, MvAddr, Value;
    uint32_t    Block8x8, blockType;
    uint32_t    InterBlockCmd;
    uint32_t    MotionVecCmd[16];
    uint32_t    BlockType[4];
    uint32_t    DpbIdx[4];

    /* set MV vars to 0 */
    for (i = 0; i < 16; i++) {
        MotionVecCmd[i] = 0;
    }

    /* read block size */
    BlockType[0] = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK0_PREDICTION_SIZE);
    BlockType[1] = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK1_PREDICTION_SIZE);
    BlockType[2] = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK2_PREDICTION_SIZE);
    BlockType[3] = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_BLOCK3_PREDICTION_SIZE);

    /* read motion vectors in all 16 4x4 sub-blocks*/
    for (i = 1; i < 3; i++) {   /* get blocks 11 and 14 */
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_X_ABOVE, i);
        REGIO_WRITE_FIELD(MotionVecCmd[CurrentAboveTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_X, Value);
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_Y_ABOVE, i);
        REGIO_WRITE_FIELD(MotionVecCmd[CurrentAboveTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_Y, Value);
    }
    for (i = 0; i < 14; i++) {
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_X_COL, i);
        REGIO_WRITE_FIELD(MotionVecCmd[CurrentColTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_X, Value);
        Value = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COMP_Y_COL, i);
        REGIO_WRITE_FIELD(MotionVecCmd[CurrentColTileMap[i]], MSVDX_CMDS, MOTION_VECTOR, MV_Y, Value);
    }

    /* read DPB index for all 4 blocks */
    for (i = 0; i < 4; i++) {
        DpbIdx[ColBlockMap[i]] = MEMIO_READ_TABLE_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_DPB_IDX_COL, i);
    }

    /* Send commands required blocks */
    for (BlockNum = 0;
         BlockNum < BlocksToSendMap[BlockType[0]];
         BlockNum++) {
        /* block address */
        Block8x8 = BlockAddressMap[BlockType[0]][BlockNum];
        /* block type */
        blockType = BlockType[Block8x8];

        InterBlockCmd = 0;
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, INTER_PRED_BLOCK_SIZE, blockType);
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, REF_INDEX_A_VALID, 1);
        REGIO_WRITE_FIELD(InterBlockCmd, MSVDX_CMDS, INTER_BLOCK_PREDICTION, REF_INDEX_A, DpbIdx[Block8x8]);

        /* send commands */
        h264_pollForSpaceForNCommands(1 + VectorsToSendMap[blockType]);
        psb_deblock_reg_table_set(MSVDX_CMDS, INTER_BLOCK_PREDICTION, Block8x8, InterBlockCmd);

        for (i = 0; i < VectorsToSendMap[blockType]; i++) {
            /* only send forward MVs in baseline */
            MvAddr = (2 * 4 * Block8x8) + VectorOffsetMap[blockType][i];
            Mv = (4 * Block8x8) + VectorOffsetMap[blockType][i];
            psb_deblock_reg_table_set(MSVDX_CMDS, MOTION_VECTOR, MvAddr, MotionVecCmd[Mv]);
        }
    }
}

void
h264_currentIntraBlockPrediction(psb_cmdbuf_p cmdbuf, uint8_t * MbData, int bMbIsIPCM)
{
    uint32_t    BlockSizeY, BlockSizeC;
    uint32_t    IntraCmdY, IntraCmdC;

    /* select block size I_PCM or I_16x16 */
    BlockSizeY = (1 == bMbIsIPCM) ? 3 : 0;
    /* select block size I_PCM or I_8x8 */
    BlockSizeC = (1 == bMbIsIPCM) ? 3 : 1;

    IntraCmdY = IntraCmdC = 0;

    REGIO_WRITE_FIELD(
        IntraCmdY,
        MSVDX_CMDS, INTRA_BLOCK_PREDICTION,
        INTRA_PRED_BLOCK_SIZE,
        BlockSizeY);
    REGIO_WRITE_FIELD(
        IntraCmdC,
        MSVDX_CMDS, INTRA_BLOCK_PREDICTION,
        INTRA_PRED_BLOCK_SIZE,
        BlockSizeC);

    h264_pollForSpaceForNCommands(2);
    psb_deblock_reg_table_set(MSVDX_CMDS, INTRA_BLOCK_PREDICTION, 0, IntraCmdY);
    psb_deblock_reg_table_set(MSVDX_CMDS, INTRA_BLOCK_PREDICTION, 4, IntraCmdC);
}

void
h264_above1IntraBlockPrediction(psb_cmdbuf_p cmdbuf, uint8_t * MbData, int bMbIsIPCM)
{
    uint32_t    BlockSizeY;
    uint32_t    IntraCmdY;

    /* select block size I_PCM or I_16x16 */
    BlockSizeY = (1 == bMbIsIPCM) ? 3 : 0;
    IntraCmdY = 0;

    REGIO_WRITE_FIELD(
        IntraCmdY,
        MSVDX_CMDS, INTRA_BLOCK_PREDICTION_ABOVE1,
        INTRA_PRED_BLOCK_SIZE_ABOVE1,
        BlockSizeY);

    h264_pollForSpaceForNCommands(1);
    psb_deblock_reg_table_set(MSVDX_CMDS, INTRA_BLOCK_PREDICTION_ABOVE1, 0, IntraCmdY);
}

void
h264_macroblockCmdSequence(psb_cmdbuf_p cmdbuf, uint8_t * MbData, uint32_t X, uint32_t  Y, int bCurrent)
{
    int bMbIsIPCM;
    uint32_t    MbType;
    uint32_t    Value;
    uint32_t    MbNumberCmd, MbQuantCmd, MbTransZeroCmd;

    /* Macroblock Type */
    MbType  = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_MBTYPE);

    /* Macroblock Number */
    /* no need for MB_ERROR_FLAG as error info is not stored */
    /* no need for MB_FIELD_CODE as basline is always frame based */
    MbNumberCmd = 0;

    Value = (3 == MbType) ? 0 : MbType;
    REGIO_WRITE_FIELD(MbNumberCmd, MSVDX_CMDS, MACROBLOCK_NUMBER, MB_CODE_TYPE, Value);

    REGIO_WRITE_FIELD(MbNumberCmd, MSVDX_CMDS, MACROBLOCK_NUMBER, MB_NO_Y, Y);
    REGIO_WRITE_FIELD(MbNumberCmd, MSVDX_CMDS, MACROBLOCK_NUMBER, MB_NO_X, X);

    /* H264 Quant */
    /* TRANSFORM_SIZE_8X8 always false in basline */
    MbQuantCmd = 0;

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_QP_CR);
    REGIO_WRITE_FIELD(MbQuantCmd, MSVDX_CMDS, MACROBLOCK_H264_QUANT, MB_QUANT_CHROMA_CR, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_QP_CB);
    REGIO_WRITE_FIELD(MbQuantCmd, MSVDX_CMDS, MACROBLOCK_H264_QUANT, MB_QUANT_CHROMA_CB, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_QP);
    REGIO_WRITE_FIELD(MbQuantCmd, MSVDX_CMDS, MACROBLOCK_H264_QUANT, MB_QUANT_LUMA, Value);

    /* send 2 commands */
    h264_pollForSpaceForNCommands(2);
    if (1 == bCurrent) {
        /* Top and Left available flags are only sent for current MB */
        Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_MB_AVAILABLE_TOP_FLAG);
        Value = (1 == Value) ? 0 : 1;
        REGIO_WRITE_FIELD(MbNumberCmd, MSVDX_CMDS, MACROBLOCK_NUMBER, MB_SLICE_TOP, Value);

        Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_MB_AVAILABLE_LEFT_FLAG);
        Value = (1 == Value) ? 0 : 1;
        REGIO_WRITE_FIELD(MbNumberCmd, MSVDX_CMDS, MACROBLOCK_NUMBER, MB_SLICE_LHS, Value);

        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_NUMBER, MbNumberCmd);
        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_H264_QUANT, MbQuantCmd);
    } else {
        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_NUMBER_ABOVE1, MbNumberCmd);
        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_H264_QUANT_ABOVE1, MbQuantCmd);
    }

    /* Prediction Block Sequence */
    bMbIsIPCM = 0;
    switch (MbType) {
    case 3:             /* IPCM */
        bMbIsIPCM = 1;
        /* deliberate drop through */
    case 0:             /* I */
        if (1 == bCurrent) {
            h264_currentIntraBlockPrediction(cmdbuf, MbData, bMbIsIPCM);
        } else {
            h264_above1IntraBlockPrediction(cmdbuf, MbData, bMbIsIPCM);
        }
        break;
    case 1:             /* P */
        if (1 == bCurrent) {
            h264_currentInterBlockSequence(cmdbuf, MbData);
        } else {
            h264_above1InterBlockSequence(cmdbuf, MbData);
        }
        break;
    case 2:             /* B */
    default:
        /* invalid MB type */
        //IMG_ASSERT( 0 );
        break;
    }

    /* Trasform Zero */
    MbTransZeroCmd = 0;
    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_ASO_MB_TRANSFORM_ZERO);
    REGIO_WRITE_FIELD(MbTransZeroCmd, MSVDX_CMDS, MACROBLOCK_BLOCK_TRANSFORM_ZERO, MB_BLOCK_TRANSFORM_ZERO, Value);

    /* write last command */
    h264_pollForSpaceForNCommands(1);
    if (1 == bCurrent) {
        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_BLOCK_TRANSFORM_ZERO, MbTransZeroCmd);
    } else {
        MbTransZeroCmd &= 0x0000CC00;   /* only send for sub-blocks 10,11,14 and 15 */
        psb_deblock_reg_set(MSVDX_CMDS, MACROBLOCK_BLOCK_TRANSFORM_ZERO_ABOVE1, MbTransZeroCmd);
    }
}

uint32_t
h264_getCurrentSliceCmd(uint8_t* MbData)
{
    uint32_t    Value, Cmd;

    Cmd = 0;

    /* unpack data from stored MB + repack in command */
    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COPY_DISABLE_DEBLOCK_FILTER_IDC);
    REGIO_WRITE_FIELD(Cmd, MSVDX_CMDS, SLICE_PARAMS, DISABLE_DEBLOCK_FILTER_IDC, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COPY_H264_BE_SLICE0_ALPHA_CO_OFFSET_DIV2);
    REGIO_WRITE_FIELD(Cmd, MSVDX_CMDS, SLICE_PARAMS, SLICE_ALPHA_CO_OFFSET_DIV2, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COPY_H264_BE_SLICE0_BETA_OFFSET_DIV2);
    REGIO_WRITE_FIELD(Cmd, MSVDX_CMDS, SLICE_PARAMS, SLICE_BETA_OFFSET_DIV2, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COPY_H264_BE_SLICE0_FIELD_TYPE);
    REGIO_WRITE_FIELD(Cmd, MSVDX_CMDS, SLICE_PARAMS, SLICE_FIELD_TYPE, Value);

    Value = MEMIO_READ_FIELD(MbData, MSVDX_VEC_ENTDEC_VLRIF_H264_MB_UNIT_COPY_H264_BE_SLICE0_CODE_TYPE);
    REGIO_WRITE_FIELD(Cmd, MSVDX_CMDS, SLICE_PARAMS, SLICE_CODE_TYPE, Value);

    return Cmd;
}

int h264_secondPass(
    psb_cmdbuf_p cmdbuf,
    uint8_t     * MbData,
    uint32_t    OperatingModeCmd,
    uint32_t    Width,
    uint32_t    Height
)
{
    uint32_t    i, PicSize;
    uint32_t    EndOfPictureCmd;
    uint32_t    EndOfSliceCmd;
    uint32_t    SliceCmd, OldSliceCmd;
    uint32_t    EnableReg;
    uint8_t     * CurrMb;
    uint8_t     * Above1Mb;
    int bRetCode = 0;

    PicSize = Width * Height;

    /* End of Slice command */
    EndOfSliceCmd = 0;
    REGIO_WRITE_FIELD(EndOfSliceCmd, MSVDX_CMDS, END_SLICE_PICTURE, PICTURE_END, 0);


    /* put vdeb into second pass mode */
    /* send operating mode command for VDEB only */
    REGIO_WRITE_FIELD(OperatingModeCmd,  MSVDX_CMDS, OPERATING_MODE, ASYNC_MODE, 2);   /* VDEB only */
    h264_pollForSpaceForNCommands(1);
    psb_deblock_reg_get(MSVDX_CORE, CR_MSVDX_COMMAND_SPACE);
    psb_deblock_reg_set(MSVDX_CMDS, OPERATING_MODE, OperatingModeCmd);

    PollForSpaceForXCommands;

    /* Send Slice Command */
    SliceCmd = h264_getCurrentSliceCmd(MbData);
    h264_pollForSpaceForNCommands(2);
    psb_deblock_reg_set(MSVDX_CMDS, SLICE_PARAMS, SliceCmd);
    psb_deblock_reg_set(MSVDX_CMDS, SLICE_PARAMS_ABOVE1, SliceCmd);
    /* process top row */
    for (i = 0, CurrMb = MbData;
         i < Width;
         i++, CurrMb += H264_MACROBLOCK_DATA_SIZE) {
        OldSliceCmd = SliceCmd;
        SliceCmd = h264_getCurrentSliceCmd(CurrMb);
        if (OldSliceCmd != SliceCmd) {
            h264_pollForSpaceForNCommands(2);
            psb_deblock_reg_set(MSVDX_CMDS, END_SLICE_PICTURE, EndOfSliceCmd);
            psb_deblock_reg_set(MSVDX_CMDS, SLICE_PARAMS, SliceCmd);
        }

        h264_macroblockCmdSequence(cmdbuf, CurrMb, i, 0, 1);
    }

    /* process rest of picture */
    for (Above1Mb = MbData;
         i < PicSize;
         i++, CurrMb += H264_MACROBLOCK_DATA_SIZE, Above1Mb += H264_MACROBLOCK_DATA_SIZE) {
        OldSliceCmd = SliceCmd;
        SliceCmd = h264_getCurrentSliceCmd(CurrMb);
        if (OldSliceCmd != SliceCmd) {
            h264_pollForSpaceForNCommands(2);
            psb_deblock_reg_set(MSVDX_CMDS, END_SLICE_PICTURE, EndOfSliceCmd);
            psb_deblock_reg_set(MSVDX_CMDS, SLICE_PARAMS, SliceCmd);
        }

        h264_macroblockCmdSequence(cmdbuf, Above1Mb, (i % Width), (i / Width) - 1, 0);
        h264_macroblockCmdSequence(cmdbuf, CurrMb, (i % Width), (i / Width), 1);
    }

    /* send end of pic + restart back end */
    EndOfPictureCmd = 0;
    EnableReg = 0;
    REGIO_WRITE_FIELD(EndOfPictureCmd, MSVDX_CMDS, END_SLICE_PICTURE, PICTURE_END, 1);
    REGIO_WRITE_FIELD(EnableReg, MSVDX_VEC, CR_VEC_CONTROL, ENTDEC_ENABLE_BE, 1);

    h264_pollForSpaceForNCommands(2);
    psb_deblock_reg_set(MSVDX_CMDS, END_SLICE_PICTURE, EndOfSliceCmd);
    psb_deblock_reg_set(MSVDX_CMDS, END_SLICE_PICTURE, EndOfPictureCmd);
    //psb_deblock_reg_set( MSVDX_VEC, CR_VEC_CONTROL, EnableReg);                       /* this is not a command */
    return bRetCode;
}

int psb_cmdbuf_second_pass(object_context_p obj_context,
                           uint32_t OperatingModeCmd,
                           unsigned char * pvParamBase,
                           uint32_t PicWidthInMbs,
                           uint32_t FrameHeightInMbs,
                           psb_buffer_p target_buffer,
                           uint32_t chroma_offset
                          )
{
    int bRetVal = 1;
    uint32_t Cmd, item_loc;
    uint32_t *cmd_size;
    psb_cmdbuf_p cmdbuf =  obj_context->cmdbuf;

    if (psb_buffer_map(&cmdbuf->regio_buf, &cmdbuf->regio_base)) {
        //printf("map cmdbuf->regio_buf error\n");
        return bRetVal;
    }

    item_loc = psb_cmdbuf_buffer_ref(cmdbuf, &cmdbuf->regio_buf);

    cmdbuf->regio_idx = (uint32_t *)cmdbuf->regio_base;
    cmd_size = cmdbuf->regio_idx++;

    h264_pollForSpaceForNCommands(4);

    psb_deblock_reg_set_RELOC(MSVDX_CMDS, LUMA_RECONSTRUCTED_PICTURE_BASE_ADDRESSES, target_buffer, target_buffer->buffer_ofs, item_loc);
    psb_deblock_reg_set_RELOC(MSVDX_CMDS, CHROMA_RECONSTRUCTED_PICTURE_BASE_ADDRESSES, target_buffer, target_buffer->buffer_ofs + chroma_offset, item_loc);

    Cmd = 0;
    REGIO_WRITE_FIELD_LITE(Cmd, MSVDX_CMDS, DISPLAY_PICTURE_SIZE, DISPLAY_PICTURE_HEIGHT, (FrameHeightInMbs * 16) - 1);
    REGIO_WRITE_FIELD_LITE(Cmd, MSVDX_CMDS, DISPLAY_PICTURE_SIZE, DISPLAY_PICTURE_WIDTH, (PicWidthInMbs * 16) - 1);
    psb_deblock_reg_set(MSVDX_CMDS, DISPLAY_PICTURE_SIZE, Cmd);


    Cmd = 0;
    REGIO_WRITE_FIELD_LITE(Cmd, MSVDX_CMDS, CODED_PICTURE_SIZE, CODED_PICTURE_HEIGHT, (FrameHeightInMbs * 16) - 1);
    REGIO_WRITE_FIELD_LITE(Cmd, MSVDX_CMDS, CODED_PICTURE_SIZE, CODED_PICTURE_WIDTH, (PicWidthInMbs * 16) - 1);
    psb_deblock_reg_set(MSVDX_CMDS, CODED_PICTURE_SIZE, Cmd);

    /* BRN25312 */
    psb_deblock_reg_set(MSVDX_CMDS, VC1_LUMA_RANGE_MAPPING_BASE_ADDRESS, 0);
    psb_deblock_reg_set(MSVDX_CMDS, VC1_CHROMA_RANGE_MAPPING_BASE_ADDRESS, 0);
    psb_deblock_reg_set(MSVDX_CMDS, VC1_RANGE_MAPPING_FLAGS, 0);

    /* process second pass */
    bRetVal = h264_secondPass(cmdbuf,
                              (uint8_t*)pvParamBase,
                              OperatingModeCmd,
                              PicWidthInMbs,
                              FrameHeightInMbs);

    *cmd_size = (cmdbuf->regio_idx - (uint32_t *)cmdbuf->regio_base - 1);

    psb__information_message("DEBLOCK: REGIO size is %d\n", (uint32_t)(cmdbuf->regio_idx - (uint32_t *)cmdbuf->regio_base) - 1);
    //printf("DEBLOCK: REGIO size is %d\n", (uint32_t)(cmdbuf->regio_idx - (uint32_t *)cmdbuf->regio_base) - 1);
    psb_buffer_unmap(&cmdbuf->regio_buf);
    return bRetVal;
}