| /* |
| * 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: |
| * Edward Lin <edward.lin@intel.com> |
| * |
| */ |
| |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <memory.h> |
| #include <wsbm/wsbm_manager.h> |
| #include "tng_picmgmt.h" |
| #include "psb_drv_debug.h" |
| |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0 0x0000007F |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0 0 |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1 0x00007F00 |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1 8 |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2 0x007F0000 |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2 16 |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3 0x7F000000 |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3 24 |
| |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0 0x00003FFF |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0 0 |
| #define MASK_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1 0x3FFF0000 |
| #define SHIFT_TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1 16 |
| |
| /************************* MTX_CMDID_PICMGMT *************************/ |
| VAStatus tng_picmgmt_update(context_ENC_p ctx, IMG_PICMGMT_TYPE eType, unsigned int ref) |
| { |
| //VAStatus vaStatus = VA_STATUS_SUCCESS; |
| IMG_UINT32 ui32CmdData = 0; |
| |
| //IMG_V_SetNextRefType eFrameType |
| //IMG_V_SkipFrame bProcess |
| //IMG_V_EndOfStream ui32FrameCount |
| //IMG_PICMGMT_FLUSH ui32FrameCount |
| ui32CmdData = F_ENCODE(eType, MTX_MSG_PICMGMT_SUBTYPE) | |
| F_ENCODE(ref, MTX_MSG_PICMGMT_DATA); |
| |
| /* Send PicMgmt Command */ |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_PICMGMT | MTX_CMDID_PRIORITY, |
| ui32CmdData, 0, 0); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| /*! |
| ****************************************************************************** |
| * |
| * Picture management functions |
| * |
| ******************************************************************************/ |
| void tng__picmgmt_long_term_refs(context_ENC_p __maybe_unused ctx, IMG_UINT32 __maybe_unused ui32FrameNum) |
| { |
| #ifdef _TNG_ENABLE_PITMGMT_ |
| IMG_BOOL bIsLongTermRef; |
| IMG_BOOL bUsesLongTermRef0; |
| IMG_BOOL bUsesLongTermRef1; |
| IMG_UINT32 ui32FrameCnt; |
| |
| // Determine frame position in source stream |
| // This assumes there are no IDR frames after the first one |
| if (ui32FrameNum == 0) { |
| // Initial IDR frame |
| ui32FrameCnt = 0; |
| } else if (((ui32FrameNum - 1) % (ctx->sRCParams.ui16BFrames + 1)) == 0) { |
| // I or P frame |
| ui32FrameCnt = ui32FrameNum + ctx->sRCParams.ui16BFrames; |
| if (ui32FrameCnt >= ctx->ui32Framecount) ui32FrameCnt = ctx->ui32Framecount - 1; |
| } else { |
| // B frame |
| // This will be incorrect for hierarchical B-pictures |
| ui32FrameCnt = ui32FrameNum - 1; |
| } |
| |
| // Decide if the current frame should be used as a long-term reference |
| bIsLongTermRef = ctx->ui32LongTermRefFreq ? |
| (ui32FrameCnt % ctx->ui32LongTermRefFreq == 0) : |
| IMG_FALSE; |
| |
| // Decide if the current frame should refer to a long-term reference |
| bUsesLongTermRef0 = ctx->ui32LongTermRefUsageFreq ? |
| (ui32FrameCnt % ctx->ui32LongTermRefUsageFreq == ctx->ui32LongTermRefUsageOffset) : |
| IMG_FALSE; |
| bUsesLongTermRef1 = IMG_FALSE; |
| |
| if (bIsLongTermRef || bUsesLongTermRef0 || bUsesLongTermRef1) { |
| // Reconstructed/reference frame to be written to host buffer |
| // Send the buffer to be used as reference |
| tng__send_ref_frames(ctx, 0, bIsLongTermRef); |
| if (bIsLongTermRef) ctx->byCurBufPointer = (ctx->byCurBufPointer + 1) % 3; |
| } |
| #endif |
| } |
| |
| static VAStatus tng__H264ES_CalcCustomQuantSp(IMG_UINT8 list, IMG_UINT8 param, IMG_UINT8 customQuantQ) |
| { |
| // Derived from sim/topaz/testbench/tests/mved1_tests.c |
| IMG_UINT32 mfflat[2][16] = { |
| { |
| 13107, 8066, 13107, 8066, |
| 8066, 5243, 8066, 5243, |
| 13107, 8066, 13107, 8066, |
| 8066, 5243, 8066, 5243 |
| }, // 4x4 |
| { |
| 13107, 12222, 16777, 12222, |
| 12222, 11428, 15481, 11428, |
| 16777, 15481, 20972, 15481, |
| 12222, 11428, 15481, 11428 |
| } // 8x8 |
| }; |
| IMG_UINT8 uVi[2][16] = { |
| { |
| 20, 26, 20, 26, |
| 26, 32, 26, 32, |
| 20, 26, 20, 26, |
| 26, 32, 26, 32 |
| }, // 4x4 |
| { |
| 20, 19, 25, 19, |
| 19, 18, 24, 18, |
| 25, 24, 32, 24, |
| 19, 18, 24, 18 |
| } // 8x8 |
| }; |
| |
| int mfnew; |
| double fSp; |
| int uSp; |
| |
| if (customQuantQ == 0) customQuantQ = 1; |
| mfnew = (mfflat[list][param] * 16) / customQuantQ; |
| fSp = ((double)(mfnew * uVi[list][param])) / (double)(1 << 22); |
| fSp = (fSp * 100000000.0f) / 100000000.0f; |
| uSp = (IMG_UINT16)(fSp * 65536); |
| |
| return uSp & 0x03FFF; |
| } |
| |
| |
| static VAStatus tng__set_custom_scaling_values( |
| context_ENC_p ctx, |
| IMG_UINT8* aui8Sl4x4IntraY, |
| IMG_UINT8* aui8Sl4x4IntraCb, |
| IMG_UINT8* aui8Sl4x4IntraCr, |
| IMG_UINT8* aui8Sl4x4InterY, |
| IMG_UINT8* aui8Sl4x4InterCb, |
| IMG_UINT8* aui8Sl4x4InterCr, |
| IMG_UINT8* aui8Sl8x8IntraY, |
| IMG_UINT8* aui8Sl8x8InterY) |
| { |
| IMG_UINT8 *pui8QuantMem; |
| IMG_UINT32 *pui32QuantReg; |
| IMG_UINT8 *apui8QuantTables[8]; |
| IMG_UINT32 ui32Table, ui32Val; |
| psb_buffer_p pCustomBuf = NULL; |
| IMG_UINT32 custom_quant_size = 0; |
| |
| // Scanning order for coefficients, see section 8.5.5 of H.264 specification |
| // Note that even for interlaced mode, hardware takes the scaling values as if frame zig-zag scanning were being used |
| IMG_UINT8 aui8ZigZagScan4x4[16] = { |
| 0, 1, 5, 6, |
| 2, 4, 7, 12, |
| 3, 8, 11, 13, |
| 9, 10, 14, 15 |
| }; |
| IMG_UINT8 aui8ZigZagScan8x8[64] = { |
| 0, 1, 5, 6, 14, 15, 27, 28, |
| 2, 4, 7, 13, 16, 26, 29, 42, |
| 3, 8, 12, 17, 25, 30, 41, 43, |
| 9, 11, 18, 24, 31, 40, 44, 53, |
| 10, 19, 23, 32, 39, 45, 52, 54, |
| 20, 22, 33, 38, 46, 51, 55, 60, |
| 21, 34, 37, 47, 50, 56, 59, 61, |
| 35, 36, 48, 49, 57, 58, 62, 63 |
| }; |
| |
| |
| if (ctx == NULL) { |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| if (ctx->bCustomScaling == IMG_FALSE) { |
| return VA_STATUS_ERROR_UNKNOWN; |
| } |
| |
| pCustomBuf = &(ctx->ctx_mem[ctx->ui32StreamID].bufs_custom_quant); |
| custom_quant_size = ctx->ctx_mem_size.custom_quant; |
| |
| |
| /* Copy quantization values (in header order) */ |
| pui8QuantMem = (IMG_UINT8*)(pCustomBuf); |
| memcpy(pui8QuantMem, aui8Sl4x4IntraY, 16); |
| memcpy(pui8QuantMem + 16, aui8Sl4x4IntraCb, 16); |
| memcpy(pui8QuantMem + 32, aui8Sl4x4IntraCr, 16); |
| memcpy(pui8QuantMem + 48, aui8Sl4x4InterY, 16); |
| memcpy(pui8QuantMem + 64, aui8Sl4x4InterCb, 16); |
| memcpy(pui8QuantMem + 80, aui8Sl4x4InterCr, 16); |
| memcpy(pui8QuantMem + 96, aui8Sl8x8IntraY, 64); |
| memcpy(pui8QuantMem + 160, aui8Sl8x8InterY, 64); |
| |
| /* Create quantization register values */ |
| |
| /* Assign based on the order values are written to registers */ |
| apui8QuantTables[0] = aui8Sl4x4IntraY; |
| apui8QuantTables[1] = aui8Sl4x4InterY; |
| apui8QuantTables[2] = aui8Sl4x4IntraCb; |
| apui8QuantTables[3] = aui8Sl4x4InterCb; |
| apui8QuantTables[4] = aui8Sl4x4IntraCr; |
| apui8QuantTables[5] = aui8Sl4x4InterCr; |
| apui8QuantTables[6] = aui8Sl8x8IntraY; |
| apui8QuantTables[7] = aui8Sl8x8InterY; |
| |
| /* H264COMP_CUSTOM_QUANT_SP register values "psCustomQuantRegs4x4Sp"*/ |
| pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size); |
| pui32QuantReg = (IMG_UINT32 *)pui8QuantMem; |
| for (ui32Table = 0; ui32Table < 6; ui32Table++) { |
| for (ui32Val = 0; ui32Val < 16; ui32Val += 4) { |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 1, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 1]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 2, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 2]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(0, ui32Val + 3, apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 3]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| } |
| } |
| |
| /*psCustomQuantRegs8x8Sp*/ |
| pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size); |
| pui32QuantReg = (IMG_UINT32 *)pui8QuantMem; |
| for (; ui32Table < 8; ui32Table++) { |
| for (ui32Val = 0; ui32Val < 64; ui32Val += 8) { |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1), apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 1, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 1]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 2, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 2]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 3, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 3]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1), apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 4]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 1, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 5]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| *pui32QuantReg = F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 2, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 6]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_0) |
| | F_ENCODE(tng__H264ES_CalcCustomQuantSp(1, ((ui32Val & 24) >> 1) + 3, apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 7]]), TOPAZHP_CR_H264COMP_CUSTOM_QUANT_SP_1); |
| pui32QuantReg++; |
| } |
| } |
| |
| /* H264COMP_CUSTOM_QUANT_Q register values "psCustomQuantRegs4x4Q" */ |
| pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size + custom_quant_size); |
| pui32QuantReg = (IMG_UINT32 *)pui8QuantMem; |
| for (ui32Table = 0; ui32Table < 6; ui32Table++) { |
| for (ui32Val = 0; ui32Val < 16; ui32Val += 4) { |
| *pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 1]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 2]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan4x4[ui32Val + 3]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3); |
| pui32QuantReg++; |
| } |
| } |
| |
| /*psCustomQuantRegs8x8Q)*/ |
| pui8QuantMem = (IMG_UINT8*)(pCustomBuf + custom_quant_size + custom_quant_size + custom_quant_size + custom_quant_size); |
| |
| pui32QuantReg = (IMG_UINT32 *)pui8QuantMem; |
| for (; ui32Table < 8; ui32Table++) { |
| for (ui32Val = 0; ui32Val < 64; ui32Val += 8) { |
| *pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 1]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 2]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 3]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3); |
| pui32QuantReg++; |
| *pui32QuantReg = F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 4]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_0) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 5]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_1) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 6]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_2) |
| | F_ENCODE(apui8QuantTables[ui32Table][aui8ZigZagScan8x8[ui32Val + 7]], TOPAZHP_CR_H264COMP_CUSTOM_QUANT_Q_3); |
| pui32QuantReg++; |
| } |
| } |
| |
| if (ctx->bPpsScaling) |
| ctx->bInsertPicHeader = IMG_TRUE; |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
| |
| void tng__picmgmt_custom_scaling(context_ENC_p ctx, IMG_UINT32 ui32FrameNum) |
| { |
| if (ui32FrameNum % ctx->ui32PpsScalingCnt == 0) { |
| // Swap inter and intra scaling lists on alternating picture parameter sets |
| if (ui32FrameNum % (ctx->ui32PpsScalingCnt * 2) == 0) { |
| tng__set_custom_scaling_values( |
| ctx, |
| ctx->aui8CustomQuantParams4x4[0], |
| ctx->aui8CustomQuantParams4x4[1], |
| ctx->aui8CustomQuantParams4x4[2], |
| ctx->aui8CustomQuantParams4x4[3], |
| ctx->aui8CustomQuantParams4x4[4], |
| ctx->aui8CustomQuantParams4x4[5], |
| ctx->aui8CustomQuantParams8x8[0], |
| ctx->aui8CustomQuantParams8x8[1]); |
| } else { |
| tng__set_custom_scaling_values( |
| ctx, |
| ctx->aui8CustomQuantParams4x4[3], |
| ctx->aui8CustomQuantParams4x4[4], |
| ctx->aui8CustomQuantParams4x4[5], |
| ctx->aui8CustomQuantParams4x4[0], |
| ctx->aui8CustomQuantParams4x4[1], |
| ctx->aui8CustomQuantParams4x4[2], |
| ctx->aui8CustomQuantParams8x8[1], |
| ctx->aui8CustomQuantParams8x8[0]); |
| } |
| } |
| } |
| |
| /************************* MTX_CMDID_PROVIDE_BUFFER *************************/ |
| IMG_UINT32 tng_send_codedbuf( |
| context_ENC_p ctx, |
| IMG_UINT32 ui32SlotIndex) |
| { |
| context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); |
| object_buffer_p object_buffer = ps_buf->coded_buf; |
| IMG_UINT32 ui32Offset = 0; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s slot 1 = %x\n", __FUNCTION__, ui32SlotIndex); |
| |
| if ((ctx->ui8PipesToUse == 2) && ((ui32SlotIndex & 1) == 1)) |
| ui32Offset = object_buffer->size >> 1; |
| |
| tng_cmdbuf_insert_command( |
| ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_PROVIDE_CODED_BUFFER, |
| F_ENCODE(object_buffer->size, MTX_MSG_PROVIDE_CODED_BUFFER_SIZE) | |
| F_ENCODE(ui32SlotIndex, MTX_MSG_PROVIDE_CODED_BUFFER_SLOT), |
| object_buffer->psb_buffer, tng_align_KB(ui32Offset)); |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s end\n", __FUNCTION__); |
| return VA_STATUS_SUCCESS; |
| } |
| |
| static VAStatus tng__set_component_offsets( |
| context_ENC_p ctx, |
| object_surface_p obj_surface_p, |
| IMG_FRAME * psFrame |
| ) |
| { |
| IMG_FORMAT eFormat; |
| IMG_UINT16 ui16Width; |
| IMG_UINT16 ui16Stride; |
| IMG_UINT16 ui16PictureHeight; |
| |
| if (!ctx) |
| return VA_STATUS_ERROR_UNKNOWN; |
| // if source slot is NULL then it's just a next portion of slices |
| if (psFrame == IMG_NULL) |
| return VA_STATUS_ERROR_UNKNOWN; |
| |
| eFormat = ctx->eFormat; |
| ui16Width = obj_surface_p->width; |
| ui16PictureHeight = obj_surface_p->height; |
| ui16Stride = obj_surface_p->psb_surface->stride; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s eFormat = %d, w = %d, h = %d, stride = %d\n", |
| __FUNCTION__, eFormat, ui16Width, ui16PictureHeight, ui16Stride); |
| // 3 Components: Y, U, V |
| // Y component is always at the beginning |
| psFrame->i32YComponentOffset = 0; |
| psFrame->ui16SrcYStride = ui16Stride; |
| |
| // Assume for now that field 0 comes first |
| psFrame->i32Field0YOffset = 0; |
| psFrame->i32Field0UOffset = 0; |
| psFrame->i32Field0VOffset = 0; |
| |
| |
| switch (eFormat) { |
| case IMG_CODEC_YUV: |
| psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * (ui16PictureHeight / 2); // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_PL8: |
| psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = 0; // ui16SrcUBase |
| psFrame->i32VComponentOffset = 0; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_PL12: |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| //FIXME |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_YV12: /* YV12 */ |
| psFrame->ui16SrcUVStride = ui16Stride / 2; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * (ui16PictureHeight / 2); // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_IMC2: /* IMC2 */ |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2); // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_422_YUV: |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_422_YV12: /* YV16 */ |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2) * ui16PictureHeight; // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_422_PL8: |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = 0; // ui16SrcUBase |
| psFrame->i32VComponentOffset = 0; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_422_IMC2: /* IMC2 */ |
| psFrame->ui16SrcUVStride = ui16Stride * 2; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = ui16Stride * ui16PictureHeight + (ui16Stride / 2); // ui16SrcUBase |
| psFrame->i32VComponentOffset = ui16Stride * ui16PictureHeight; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_422_PL12: |
| psFrame->ui16SrcUVStride = ui16Stride * 2; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = 0; // ui16SrcUBase |
| psFrame->i32VComponentOffset = 0; // ui16SrcVBase |
| break; |
| |
| case IMG_CODEC_Y0UY1V_8888: |
| case IMG_CODEC_Y0VY1U_8888: |
| case IMG_CODEC_UY0VY1_8888: |
| case IMG_CODEC_VY0UY1_8888: |
| psFrame->ui16SrcUVStride = ui16Stride; // ui16SrcUStride |
| |
| psFrame->i32UComponentOffset = 0; // ui16SrcUBase |
| psFrame->i32VComponentOffset = 0; // ui16SrcVBase |
| break; |
| |
| default: |
| break; |
| } |
| |
| if (ctx->bIsInterlaced) { |
| if (ctx->bIsInterleaved) { |
| switch (eFormat) { |
| case IMG_CODEC_IMC2: |
| case IMG_CODEC_422_IMC2: |
| psFrame->i32VComponentOffset *= 2; |
| psFrame->i32UComponentOffset = psFrame->i32VComponentOffset + (ui16Stride / 2); |
| break; |
| default: |
| psFrame->i32UComponentOffset *= 2; |
| psFrame->i32VComponentOffset *= 2; |
| break; |
| } |
| |
| psFrame->i32Field1YOffset = psFrame->i32Field0YOffset + psFrame->ui16SrcYStride; |
| psFrame->i32Field1UOffset = psFrame->i32Field0UOffset + psFrame->ui16SrcUVStride; |
| psFrame->i32Field1VOffset = psFrame->i32Field0VOffset + psFrame->ui16SrcUVStride; |
| |
| psFrame->ui16SrcYStride *= 2; // ui16SrcYStride |
| psFrame->ui16SrcUVStride *= 2; // ui16SrcUStride |
| |
| if (!ctx->bTopFieldFirst) { |
| IMG_INT32 i32Temp; |
| |
| i32Temp = psFrame->i32Field1YOffset; |
| psFrame->i32Field1YOffset = psFrame->i32Field0YOffset; |
| psFrame->i32Field0YOffset = i32Temp; |
| |
| i32Temp = psFrame->i32Field1UOffset; |
| psFrame->i32Field1UOffset = psFrame->i32Field0UOffset; |
| psFrame->i32Field0UOffset = i32Temp; |
| |
| i32Temp = psFrame->i32Field1VOffset; |
| psFrame->i32Field1VOffset = psFrame->i32Field0VOffset; |
| psFrame->i32Field0VOffset = i32Temp; |
| } |
| } else { |
| IMG_UINT32 ui32YFieldSize, ui32CFieldSize; |
| |
| switch (eFormat) { |
| case IMG_CODEC_Y0UY1V_8888: |
| case IMG_CODEC_UY0VY1_8888: |
| case IMG_CODEC_Y0VY1U_8888: |
| case IMG_CODEC_VY0UY1_8888: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride * 2; |
| ui32CFieldSize = ui32YFieldSize; |
| break; |
| case IMG_CODEC_PL8: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride; |
| ui32CFieldSize = ui16PictureHeight * ui16Stride / 4; |
| break; |
| case IMG_CODEC_PL12: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride; |
| ui32CFieldSize = ui16PictureHeight * ui16Stride / 2; |
| break; |
| case IMG_CODEC_422_YUV: |
| case IMG_CODEC_422_YV12: |
| case IMG_CODEC_422_IMC2: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride * 2; |
| ui32CFieldSize = ui32YFieldSize; |
| break; |
| case IMG_CODEC_422_PL8: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride; |
| ui32CFieldSize = ui16PictureHeight * ui16Stride / 2; |
| break; |
| case IMG_CODEC_422_PL12: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride; |
| ui32CFieldSize = ui32YFieldSize; |
| break; |
| default: |
| ui32YFieldSize = ui16PictureHeight * ui16Stride * 3 / 2; |
| ui32CFieldSize = ui32YFieldSize; |
| break; |
| } |
| |
| psFrame->i32Field1YOffset = ui32YFieldSize; |
| psFrame->i32Field1UOffset = ui32CFieldSize; |
| psFrame->i32Field1VOffset = ui32CFieldSize; |
| } |
| } else { |
| psFrame->i32Field1YOffset = psFrame->i32Field0YOffset; |
| psFrame->i32Field1UOffset = psFrame->i32Field0UOffset; |
| psFrame->i32Field1VOffset = psFrame->i32Field0VOffset; |
| } |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s i32YComponentOffset = %d, i32UComponentOffset = %d, i32VComponentOffset = %d\n", |
| __FUNCTION__, (int)(psFrame->i32YComponentOffset), (int)(psFrame->i32UComponentOffset), (int)(psFrame->i32VComponentOffset)); |
| return VA_STATUS_SUCCESS; |
| } |
| |
| IMG_UINT32 tng_send_source_frame( |
| context_ENC_p ctx, |
| IMG_UINT32 ui32SlotIndex, |
| IMG_UINT32 ui32DisplayOrder) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); |
| IMG_FRAME sSrcFrame; |
| IMG_FRAME *psSrcFrame = &sSrcFrame; |
| tng_cmdbuf_p cmdbuf = ctx->obj_context->tng_cmdbuf; |
| IMG_SOURCE_BUFFER_PARAMS *psSrcBufParams = NULL; |
| object_surface_p src_surface = ps_buf->src_surface; |
| unsigned int frame_mem_index = 0; |
| unsigned int srf_buf_offset = src_surface->psb_surface->buf.buffer_ofs; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: ui32SlotIndex = %d, ui32DisplayOrder = %d\n", |
| __FUNCTION__, ui32SlotIndex, ui32DisplayOrder); |
| |
| if (cmdbuf->frame_mem_index >= COMM_CMD_FRAME_BUF_NUM) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: Error: frame_mem buffer index overflow\n", __FUNCTION__); |
| cmdbuf->frame_mem_index = 0; |
| } |
| |
| vaStatus = psb_buffer_map(&cmdbuf->frame_mem, &(cmdbuf->frame_mem_p)); |
| if (vaStatus) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: map frame buf\n", __FUNCTION__); |
| return vaStatus; |
| } |
| |
| frame_mem_index = cmdbuf->frame_mem_index * cmdbuf->mem_size; |
| psSrcBufParams = (IMG_SOURCE_BUFFER_PARAMS *)(cmdbuf->frame_mem_p + frame_mem_index); |
| memset(psSrcBufParams, 0, sizeof(IMG_SOURCE_BUFFER_PARAMS)); |
| memset(psSrcFrame, 0, sizeof(IMG_FRAME)); |
| tng__set_component_offsets(ctx, src_surface, psSrcFrame); |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: cmdbuf->frame_mem_index = %d, frame_mem_index = 0x%08x, cmdbuf->frame_mem_p = 0x%08x\n", |
| __FUNCTION__, cmdbuf->frame_mem_index, frame_mem_index, cmdbuf->frame_mem_p); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: frame_mem_index = %d, psBufferParams = 0x%08x\n", |
| __FUNCTION__, frame_mem_index, (unsigned int)psSrcBufParams); |
| |
| /* Prepare ProvideBuffer data */ |
| { |
| psSrcBufParams->ui8SlotNum = (IMG_UINT8)(ui32SlotIndex & 0xff); |
| psSrcBufParams->ui8DisplayOrderNum = (IMG_UINT8)(ui32DisplayOrder & 0xff); |
| psSrcBufParams->ui32HostContext = (IMG_UINT32)ctx; |
| |
| #ifdef _TNG_RELOC_ |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrYPlane_Field0), |
| srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field0YOffset, |
| &(src_surface->psb_surface->buf)); |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrUPlane_Field0), |
| srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field0UOffset, |
| &(src_surface->psb_surface->buf)); |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrVPlane_Field0), |
| srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field0VOffset, |
| &(src_surface->psb_surface->buf)); |
| |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrYPlane_Field1), |
| srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field1YOffset, |
| &(src_surface->psb_surface->buf)); |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrUPlane_Field1), |
| srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field1UOffset, |
| &(src_surface->psb_surface->buf)); |
| TNG_RELOC_CMDBUF_FRAMES( |
| &(psSrcBufParams->ui32PhysAddrVPlane_Field1), |
| srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field1VOffset, |
| &(src_surface->psb_surface->buf)); |
| #else |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrYPlane_Field0), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field0YOffset, 0); |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrUPlane_Field0), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field0UOffset, 0); |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrVPlane_Field0), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field0VOffset, 0); |
| |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrYPlane_Field1), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32YComponentOffset + psSrcFrame->i32Field1YOffset, 0); |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrUPlane_Field1), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32UComponentOffset + psSrcFrame->i32Field1UOffset, 0); |
| tng_cmdbuf_set_phys(&(psSrcBufParams->ui32PhysAddrVPlane_Field1), 0, |
| &(src_surface->psb_surface->buf), |
| srf_buf_offset + psSrcFrame->i32VComponentOffset + psSrcFrame->i32Field1VOffset, 0); |
| #endif |
| } |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s slot_idx = %d, frame_count = %d\n", __FUNCTION__, |
| (int)(ui32SlotIndex), (int)(ctx->ui32FrameCount[ctx->ui32StreamID])); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: YPlane_Field0 = 0x%08x, UPlane_Field0 = 0x%08x, VPlane_Field0 = 0x%08x\n", |
| __FUNCTION__, (unsigned int)(psSrcBufParams->ui32PhysAddrYPlane_Field0), |
| (unsigned int)(psSrcBufParams->ui32PhysAddrUPlane_Field0), |
| (unsigned int)(psSrcBufParams->ui32PhysAddrVPlane_Field0)); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, |
| "%s: YPlane_Field1 = 0x%08x, UPlane_Field1 = 0x%08x, VPlane_Field1 = 0x%08x\n", |
| __FUNCTION__, (unsigned int)(psSrcBufParams->ui32PhysAddrYPlane_Field1), |
| (unsigned int)(psSrcBufParams->ui32PhysAddrUPlane_Field1), |
| (unsigned int)(psSrcBufParams->ui32PhysAddrVPlane_Field1)); |
| |
| /* Send ProvideBuffer Command */ |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_PROVIDE_SOURCE_BUFFER, |
| 0, &(cmdbuf->frame_mem), frame_mem_index); |
| |
| ++(cmdbuf->frame_mem_index); |
| psb_buffer_unmap(&cmdbuf->frame_mem); |
| |
| return 0; |
| } |
| |
| |
| IMG_UINT32 tng_send_rec_frames( |
| context_ENC_p ctx, |
| IMG_INT8 i8HeaderSlotNum, |
| IMG_BOOL bLongTerm) |
| { |
| //VAStatus vaStatus = VA_STATUS_SUCCESS; |
| unsigned int srf_buf_offset; |
| context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); |
| object_surface_p rec_surface = ps_buf->rec_surface; |
| IMG_UINT32 ui32CmdData = 0; |
| |
| srf_buf_offset = rec_surface->psb_surface->buf.buffer_ofs; |
| /* Send ProvideBuffer Command */ |
| ui32CmdData = F_ENCODE(IMG_BUFFER_RECON, MTX_MSG_PROVIDE_REF_BUFFER_USE) | |
| F_ENCODE(i8HeaderSlotNum, MTX_MSG_PROVIDE_REF_BUFFER_SLOT) | |
| F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT); |
| |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_PROVIDE_REF_BUFFER, |
| ui32CmdData, &(rec_surface->psb_surface->buf), 0); |
| |
| return 0; |
| } |
| |
| IMG_UINT32 tng_send_ref_frames( |
| context_ENC_p ctx, |
| IMG_UINT32 ui32refindex, |
| IMG_BOOL __maybe_unused bLongTerm) |
| { |
| //VAStatus vaStatus = VA_STATUS_SUCCESS; |
| unsigned int srf_buf_offset; |
| context_ENC_frame_buf *ps_buf = &(ctx->ctx_frame_buf); |
| object_surface_p ref_surface = ps_buf->ref_surface[ui32refindex]; |
| IMG_UINT32 ui32CmdData = 0; |
| |
| #ifdef _TNG_FRAMES_ |
| if (ui32RefIndex == 0) { |
| ref_surface = ps_buf->ref_surface; |
| ui32CmdData = F_ENCODE(IMG_BUFFER_REF0, MTX_MSG_PROVIDE_REF_BUFFER_USE) | |
| F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT); |
| } else { |
| ref_surface = ps_buf->ref_surface1; |
| ui32CmdData = F_ENCODE(IMG_BUFFER_REF1, MTX_MSG_PROVIDE_REF_BUFFER_USE) | |
| F_ENCODE(bLongTerm, MTX_MSG_PROVIDE_REF_BUFFER_LT); |
| } |
| #endif |
| srf_buf_offset = ref_surface->psb_surface->buf.buffer_ofs; |
| /* Send ProvideBuffer Command */ |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_PROVIDE_REF_BUFFER, |
| ui32CmdData, &(ref_surface->psb_surface->buf), 0); |
| |
| return VA_STATUS_SUCCESS; |
| } |
| |
