/* * 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 * */ #include "psb_cmdbuf.h" #include #include #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 #include #include #include "psb_def.h" #include "psb_drv_debug.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); drv_debug_msg(VIDEO_DEBUG_GENERAL, "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; }