| /* |
| * 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 <malloc.h> |
| #include <memory.h> |
| #include "psb_drv_video.h" |
| #include "psb_drv_debug.h" |
| #include "tng_hostdefs.h" |
| #include "tng_hostcode.h" |
| #include "tng_hostair.h" |
| |
| /*********************************************************************************** |
| * Function Name : functions of pi8AIR_Table table |
| ************************************************************************************/ |
| VAStatus tng_air_buf_create(context_ENC_p ctx) |
| { |
| IMG_UINT32 ui32MbNum = (ctx->ui16PictureHeight * ctx->ui16Width) >> 8; |
| ctx->sAirInfo.pi8AIR_Table = (IMG_INT8 *)malloc(ui32MbNum); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: ui32MbNum = %d\n", __FUNCTION__, ui32MbNum); |
| if (!ctx->sAirInfo.pi8AIR_Table) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, |
| "\nERROR: Error allocating Adaptive Intra Refresh table of Application context (APP_SetVideoParams)"); |
| return VA_STATUS_ERROR_ALLOCATION_FAILED; |
| } |
| memset(ctx->sAirInfo.pi8AIR_Table, 0, ui32MbNum); |
| return VA_STATUS_SUCCESS; |
| } |
| |
| static void tng_air_buf_clear(context_ENC_p ctx) |
| { |
| #if 0 |
| IMG_UINT32 ui32MbNum = (ctx->ui16PictureHeight * ctx->ui16Width) >> 8; |
| drv_debug_msg(VIDEO_DEBUG_ERROR,"%s: ui32MbNum = %d, ctx->sAirInfo.pi8AIR_Table = 0x%08x\n", __FUNCTION__, ui32MbNum, ctx->sAirInfo.pi8AIR_Table); |
| memset(ctx->sAirInfo.pi8AIR_Table, 0, ui32MbNum); |
| drv_debug_msg(VIDEO_DEBUG_ERROR,"%s: ui32MbNum = %d, ctx->sAirInfo.pi8AIR_Table = 0x%08x\n", __FUNCTION__, ui32MbNum, ctx->sAirInfo.pi8AIR_Table); |
| #endif |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_SW_AIR_BUF_CLEAR, 0, 0, 0); |
| return ; |
| } |
| |
| void tng_air_buf_free(context_ENC_p ctx) |
| { |
| if (ctx->sAirInfo.pi8AIR_Table != NULL) |
| free(ctx->sAirInfo.pi8AIR_Table); |
| return ; |
| } |
| |
| /*********************************************************************************** |
| * Function Name : functions for input control |
| ************************************************************************************/ |
| static IMG_UINT16 tng__rand(context_ENC_p ctx) |
| { |
| IMG_UINT16 ui16ret = 0; |
| ctx->ui32pseudo_rand_seed = (IMG_UINT32) ((ctx->ui32pseudo_rand_seed * 1103515245 + 12345) & 0xffffffff); //Using mask, just in case |
| ui16ret = (IMG_UINT16)(ctx->ui32pseudo_rand_seed / 65536) % 32768; |
| return ui16ret; |
| } |
| |
| //APP_FillSliceMap |
| IMG_UINT32 tng_fill_slice_map(context_ENC_p ctx, IMG_INT32 i32SlotNum, IMG_UINT32 ui32StreamIndex) |
| { |
| context_ENC_mem *ps_mem = &(ctx->ctx_mem[ui32StreamIndex]); |
| unsigned char *pvBuffer; |
| IMG_UINT8 ui8SlicesPerPicture; |
| IMG_UINT8 ui8HalfWaySlice; |
| IMG_UINT32 ui32HalfwayBU; |
| |
| ui8SlicesPerPicture = ctx->ui8SlicesPerPicture; |
| ui32HalfwayBU = 0; |
| ui8HalfWaySlice=ui8SlicesPerPicture/2; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: slot num = %d, aso = %d\n", __FUNCTION__, i32SlotNum, ctx->bArbitrarySO); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: stream id = %d, addr = 0x%x\n", __FUNCTION__, ui32StreamIndex, ps_mem->bufs_slice_map.virtual_addr); |
| |
| psb_buffer_map(&(ps_mem->bufs_slice_map), &(ps_mem->bufs_slice_map.virtual_addr)); |
| if (ps_mem->bufs_slice_map.virtual_addr == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s error: mapping slice map\n", __FUNCTION__); |
| goto out1; |
| } |
| |
| pvBuffer = (unsigned char*)(ps_mem->bufs_slice_map.virtual_addr + (i32SlotNum * ctx->ctx_mem_size.slice_map)); |
| if (pvBuffer == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_ERROR, "%s: pvBuffer == NULL\n", __FUNCTION__); |
| goto out1; |
| } |
| |
| if (ctx->bArbitrarySO) { |
| IMG_UINT8 ui8Index; |
| IMG_UINT8 ui32FirstBUInSlice; |
| IMG_UINT8 ui8SizeInKicks; |
| IMG_UINT8 ui8TotalBUs; |
| IMG_UINT8 aui8SliceNumbers[MAX_SLICESPERPIC]; |
| |
| memset(aui8SliceNumbers, 0, MAX_SLICESPERPIC); |
| |
| ui8SlicesPerPicture = tng__rand(ctx) % ctx->ui8SlicesPerPicture + 1; |
| // Fill slice map |
| // Fill number of slices |
| * pvBuffer = ui8SlicesPerPicture; |
| pvBuffer++; |
| |
| for (ui8Index = 0; ui8Index < ui8SlicesPerPicture; ui8Index++) |
| aui8SliceNumbers[ui8Index] = ui8Index; |
| |
| // randomise slice numbers |
| for (ui8Index = 0; ui8Index < 20; ui8Index++) { |
| IMG_UINT8 ui8FirstCandidate; |
| IMG_UINT8 ui8SecondCandidate; |
| IMG_UINT8 ui8Temp; |
| |
| ui8FirstCandidate = tng__rand(ctx) % ui8SlicesPerPicture; |
| ui8SecondCandidate = tng__rand(ctx) % ui8SlicesPerPicture; |
| |
| ui8Temp = aui8SliceNumbers[ui8FirstCandidate]; |
| aui8SliceNumbers[ui8FirstCandidate] = aui8SliceNumbers[ui8SecondCandidate]; |
| aui8SliceNumbers[ui8SecondCandidate] = ui8Temp; |
| } |
| |
| ui8TotalBUs = (ctx->ui16PictureHeight / 16) * (ctx->ui16Width / 16) / ctx->sRCParams.ui32BUSize; |
| |
| ui32FirstBUInSlice = 0; |
| |
| for (ui8Index = 0; ui8Index < ui8SlicesPerPicture - 1; ui8Index++) { |
| IMG_UINT32 ui32BUsCalc; |
| if (ui8Index==ui8HalfWaySlice) ui32HalfwayBU=ui32FirstBUInSlice; |
| |
| ui32BUsCalc=(ui8TotalBUs - 1 * (ui8SlicesPerPicture - ui8Index)); |
| if(ui32BUsCalc) |
| ui8SizeInKicks = tng__rand(ctx) %ui32BUsCalc + 1; |
| else |
| ui8SizeInKicks = 1; |
| ui8TotalBUs -= ui8SizeInKicks; |
| |
| // slice number |
| * pvBuffer = aui8SliceNumbers[ui8Index]; |
| pvBuffer++; |
| |
| // SizeInKicks BU |
| * pvBuffer = ui8SizeInKicks; |
| pvBuffer++; |
| ui32FirstBUInSlice += (IMG_UINT32) ui8SizeInKicks; |
| } |
| ui8SizeInKicks = ui8TotalBUs; |
| // slice number |
| * pvBuffer = aui8SliceNumbers[ui8SlicesPerPicture - 1]; |
| pvBuffer++; |
| |
| // last BU |
| * pvBuffer = ui8SizeInKicks; |
| pvBuffer++; |
| } else { |
| // Fill standard Slice Map (non arbitrary) |
| IMG_UINT8 ui8Index; |
| IMG_UINT8 ui8SliceNumber; |
| IMG_UINT8 ui32FirstBUInSlice; |
| IMG_UINT8 ui8SizeInKicks; |
| IMG_UINT32 ui32SliceHeight; |
| |
| // Fill number of slices |
| * pvBuffer = ui8SlicesPerPicture; |
| pvBuffer++; |
| |
| |
| ui32SliceHeight = (ctx->ui16PictureHeight / ctx->ui8SlicesPerPicture) & ~15; |
| |
| ui32FirstBUInSlice = 0; |
| ui8SliceNumber = 0; |
| for (ui8Index = 0; ui8Index < ui8SlicesPerPicture - 1; ui8Index++) { |
| if (ui8Index==ui8HalfWaySlice) ui32HalfwayBU=ui32FirstBUInSlice; |
| ui8SizeInKicks = ((ui32SliceHeight / 16)*(ctx->ui16Width/16))/ctx->sRCParams.ui32BUSize; |
| |
| // slice number |
| * pvBuffer = ui8SliceNumber; |
| pvBuffer++; |
| // SizeInKicks BU |
| * pvBuffer = ui8SizeInKicks; |
| pvBuffer++; |
| |
| ui8SliceNumber++; |
| ui32FirstBUInSlice += (IMG_UINT32) ui8SizeInKicks; |
| } |
| ui32SliceHeight = ctx->ui16PictureHeight - ui32SliceHeight * (ctx->ui8SlicesPerPicture - 1); |
| if (ui8Index==ui8HalfWaySlice) ui32HalfwayBU=ui32FirstBUInSlice; |
| ui8SizeInKicks = ((ui32SliceHeight / 16)*(ctx->ui16Width/16))/ctx->sRCParams.ui32BUSize; |
| |
| // slice number |
| * pvBuffer = ui8SliceNumber; pvBuffer++; |
| // last BU |
| * pvBuffer = ui8SizeInKicks; pvBuffer++; |
| } |
| |
| out1: |
| psb_buffer_unmap(&(ps_mem->bufs_slice_map)); |
| ctx->ui32HalfWayBU[i32SlotNum] = ui32HalfwayBU; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: ui32HalfWayBU = %d\n", __FUNCTION__, ctx->ui32HalfWayBU[i32SlotNum]); |
| return ui32HalfwayBU; |
| } |
| |
| //IMG_V_GetInpCtrlBuf |
| static VAStatus tng__map_inp_ctrl_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 ui8SlotNumber, |
| IMG_UINT8 **ppsInpCtrlBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| context_ENC_mem_size *ps_mem_size = &(ctx->ctx_mem_size); |
| if (ppsInpCtrlBuf == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: ppsInpCtrlBuf == NULL\n", __FUNCTION__); |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| *ppsInpCtrlBuf = NULL; // Not enabled |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (ctx->bEnableInpCtrl) { |
| vaStatus = psb_buffer_map(&(ps_mem->bufs_mb_ctrl_in_params), ppsInpCtrlBuf); |
| if (vaStatus == VA_STATUS_SUCCESS) |
| *ppsInpCtrlBuf += ui8SlotNumber * ps_mem_size->mb_ctrl_in_params; |
| else |
| psb_buffer_unmap(&(ps_mem->bufs_mb_ctrl_in_params)); |
| } |
| |
| return vaStatus; |
| } |
| |
| static VAStatus tng__unmap_inp_ctrl_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 __maybe_unused ui8SlotNumber, |
| IMG_UINT8 **ppsInpCtrlBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (*ppsInpCtrlBuf != NULL) { |
| psb_buffer_unmap(&(ps_mem->bufs_mb_ctrl_in_params)); |
| *ppsInpCtrlBuf = NULL; // Not enabled |
| } |
| return vaStatus; |
| } |
| |
| //APP_FillInpCtrlBuf |
| #define DEFAULT_INTER_INTRA_SCALE_TBL_IDX (0) |
| #define DEFAULT_CODED_SKIPPED_SCALE_TBL_IDX (0) |
| #define DEFAULT_INPUT_QP (0xF) |
| #define SIZEOF_MB_IN_CTRL_PARAM (2) |
| |
| static void tng__fill_inp_ctrl_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 *pInpCtrlBuf, |
| IMG_INT16 i16IntraRefresh, |
| IMG_INT8* pi8QP, |
| IMG_UINT32 __maybe_unused ui32HalfWayBU) |
| { |
| IMG_PVOID pvBuffer; |
| IMG_UINT32 ui32MBFrameWidth; |
| IMG_UINT32 ui32MBPictureHeight; |
| IMG_UINT32 ui32MBSliceHeight; |
| IMG_UINT16 ui16DefaultParam; |
| IMG_UINT16 ui16IntraParam; |
| IMG_BOOL bRefresh=IMG_FALSE; |
| IMG_UINT32 ui32CurrentIndex; |
| IMG_UINT32 ui32MBx, ui32MBy; |
| IMG_UINT16 *pui16MBParam; |
| IMG_INT8 i8QPInit; |
| IMG_INT8 i8QP; |
| IMG_INT8 iMaxQP; |
| |
| #ifdef BRN_30324 |
| IMG_UINT32 ui32HalfWayMB=ui32HalfWayBU * ctx->sRCParams.ui32BUSize; |
| #endif |
| |
| if (pi8QP == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: start QP == NULL\n", __FUNCTION__); |
| return ; |
| } |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: start QP = %d\n", __FUNCTION__, *pi8QP); |
| |
| if (i16IntraRefresh > 0) { |
| bRefresh=IMG_TRUE; |
| } |
| |
| iMaxQP = 31; |
| if (ctx->eStandard == IMG_STANDARD_H264) { |
| iMaxQP = 51; |
| } |
| if(pi8QP) { |
| i8QPInit = * pi8QP; |
| } else { |
| i8QPInit = DEFAULT_INPUT_QP; |
| } |
| // get the buffer |
| // IMG_C_GetBuffer(psActiveContext->hContext, pInpCtrlBuf, &pvBuffer,IMG_TRUE); |
| pvBuffer = (IMG_PVOID) pInpCtrlBuf; |
| |
| //fill data |
| ui32MBFrameWidth = (ctx->ui16Width/16); |
| ui32MBPictureHeight = (ctx->ui16PictureHeight/16); |
| ui32MBSliceHeight = (ui32MBPictureHeight/ctx->ui8SlicesPerPicture); |
| |
| pui16MBParam = (IMG_UINT16 *)pvBuffer; |
| ui32CurrentIndex=0; |
| |
| for(ui32MBy = 0; ui32MBy < (IMG_UINT32)(ctx->ui16PictureHeight / 16); ui32MBy++) { |
| for(ui32MBx = 0; ui32MBx < ui32MBFrameWidth; ui32MBx++) { |
| IMG_UINT16 ui16MBParam = 0; |
| |
| #ifdef BRN_30324 |
| if (ui32HalfWayMB && ui32CurrentIndex == ui32HalfWayMB) |
| if (ctx->ui8SlicesPerPicture > 1 && ctx->i32NumPipes > 1) { |
| ui32CurrentIndex=(((ui32CurrentIndex)+31)&(~31)); |
| } |
| #endif |
| i8QP = i8QPInit + ((tng__rand(ctx)%6)-3); |
| i8QP = tng__max(tng__min(i8QP, iMaxQP), ctx->sRCParams.iMinQP); |
| |
| ui16DefaultParam = ( i8QP<<10) | (3 <<7) |(3<<4); |
| ui16IntraParam = ( i8QP<<10) | (0 <<7) |(0<<4); |
| |
| ui16MBParam = ui16DefaultParam; |
| if (bRefresh) { |
| if ((IMG_INT32)ui32CurrentIndex > ctx->i32LastCIRIndex) { |
| ctx->i32LastCIRIndex = ui32CurrentIndex; |
| ui16MBParam = ui16IntraParam; |
| i16IntraRefresh--; |
| if(i16IntraRefresh <= 0) |
| bRefresh = IMG_FALSE; |
| } |
| } |
| pui16MBParam[ui32CurrentIndex++] = ui16MBParam; |
| } |
| } |
| |
| if (bRefresh) { |
| ctx->i32LastCIRIndex = -1; |
| while (i16IntraRefresh) { |
| i8QP = i8QPInit + ((tng__rand(ctx)%6)-3); |
| i8QP = tng__max(tng__min(i8QP, iMaxQP), ctx->sRCParams.iMinQP); |
| ui16IntraParam = ( i8QP<<10) |(0 <<7) |(0<<4); |
| pui16MBParam[++ctx->i32LastCIRIndex] = ui16IntraParam; |
| i16IntraRefresh--; |
| } |
| } |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: end QP = %d\n", __FUNCTION__, *pi8QP); |
| //release buffer |
| //IMG_C_ReleaseBuffer(psActiveContext->hContext, pInpCtrlBuf,IMG_TRUE); |
| return ; |
| } |
| |
| /*********************************************************************************** |
| * Function Name : APP_FillInputControl |
| * Inputs : psContext |
| * Description : Fills input control buffer for a given source picture |
| ************************************************************************************/ |
| static void tng__fill_input_control( |
| context_ENC_p ctx, |
| IMG_UINT8 ui8SlotNum, |
| IMG_UINT32 __maybe_unused ui32HalfWayBU) |
| { |
| IMG_UINT8 * pInpCtrlBuf = NULL; |
| IMG_INT8 i8InitialQp = ctx->sRCParams.ui32InitialQp; |
| // Get pointer to MB Control buffer for current source buffer (if input control is enabled, otherwise buffer is NULL) |
| // Please refer to kernel tng_setup_cir_buf() |
| /* |
| tng__map_inp_ctrl_buf(ctx, ui8SlotNum, &pInpCtrlBuf); |
| if (pInpCtrlBuf!= IMG_NULL) { |
| tng__fill_inp_ctrl_buf(ctx, pInpCtrlBuf,(IMG_INT16)(ctx->ui16IntraRefresh), &i8InitialQp, ui32HalfWayBU); |
| } |
| tng__unmap_inp_ctrl_buf(ctx, ui8SlotNum, &pInpCtrlBuf); |
| */ |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_SW_FILL_INPUT_CTRL, ui8SlotNum, 0, 0); |
| |
| return ; |
| } |
| |
| static void tng__send_air_inp_ctrl_buf(context_ENC_p ctx, IMG_INT8 *pInpCtrlBuf) |
| { |
| //IMG_PVOID pvICBuffer; |
| IMG_UINT16 ui16IntraParam; |
| //IMG_BOOL bRefresh = IMG_FALSE; |
| IMG_UINT32 ui32CurrentCnt, ui32SentCnt; |
| IMG_UINT32 ui32MBMaxSize; |
| IMG_UINT16 *pui16MBParam; |
| IMG_UINT32 ui32NewScanPos, ui32Skip; |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| IMG_CHAR TmpOutputTble[396]; //Debug only |
| #endif |
| ui16IntraParam = (0 << 7) | (0 << 4); |
| |
| if (ctx->ui32FrameCount[0] < 1) |
| return; |
| |
| // get the buffer |
| pui16MBParam = (IMG_UINT16 *) pInpCtrlBuf; |
| |
| //fill data |
| ui32MBMaxSize = (IMG_UINT32)(ctx->ui16PictureHeight / 16) * (IMG_UINT32)(ctx->ui16Width / 16); |
| ui32CurrentCnt = 0; |
| if (ctx->sAirInfo.i16AIRSkipCnt >= 0) |
| ui32Skip = ctx->sAirInfo.i16AIRSkipCnt; |
| else |
| //ui32Skip=APP_Rand() % psActiveContext->sAirInfo.i32NumAIRSPerFrame; // Pseudorandom skip. |
| ui32Skip = (ctx->ui32FrameCount[0] & 0x7) + 1; // Pseudorandom skip. |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| { |
| IMG_UINT32 tsp; |
| if (fp) |
| { |
| fp = fopen("SADvals.txt", "a"); |
| } |
| else |
| { |
| fp = fopen("SADvals.txt", "w"); |
| } |
| |
| fprintf(fp, "\n---------------------------------------------------------------------------\n"); |
| fprintf(fp, "SENDING SADvals (skip:%i)\n", ui32Skip); |
| |
| for (tsp = 0; tsp < ui32MBMaxSize; tsp++) |
| { |
| if (ctx->sAirInfo.pi8AIR_Table[tsp] > 0) |
| { |
| TmpOutputTble[tsp] = 'x'; |
| } |
| else |
| { |
| TmpOutputTble[tsp] = 'o'; |
| } |
| } |
| } |
| #endif |
| |
| ui32NewScanPos = (IMG_UINT32) (ctx->sAirInfo.ui16AIRScanPos + ui32Skip) % ui32MBMaxSize; |
| ui32CurrentCnt = ui32SentCnt = 0; |
| |
| while (ui32CurrentCnt < ui32MBMaxSize && |
| ((ctx->sAirInfo.i32NumAIRSPerFrame == 0) || |
| ui32SentCnt < (IMG_UINT32) ctx->sAirInfo.i32NumAIRSPerFrame)) { |
| IMG_UINT16 ui16MBParam; |
| |
| if (ctx->sAirInfo.pi8AIR_Table[ui32NewScanPos] >= 0) { |
| // Mark the entry as 'touched' |
| ctx->sAirInfo.pi8AIR_Table[ui32NewScanPos] = -1 - ctx->sAirInfo.pi8AIR_Table[ui32NewScanPos]; |
| |
| if (ctx->sAirInfo.pi8AIR_Table[ui32NewScanPos] < -1) { |
| ui16MBParam = pui16MBParam[ui32NewScanPos] & (0xFF << 10); |
| ui16MBParam |= ui16IntraParam; |
| pui16MBParam[ui32NewScanPos] = ui16MBParam; |
| ctx->sAirInfo.pi8AIR_Table[ui32NewScanPos]++; |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| TmpOutputTble[ui32NewScanPos]='I'; |
| #endif |
| ui32NewScanPos += ui32Skip; |
| ui32SentCnt++; |
| } |
| ui32CurrentCnt++; |
| } |
| |
| ui32NewScanPos++; |
| ui32NewScanPos = ui32NewScanPos % ui32MBMaxSize; |
| if (ui32NewScanPos == ctx->sAirInfo.ui16AIRScanPos) { |
| /* we have looped around */ |
| break; |
| } |
| } |
| |
| ctx->sAirInfo.ui16AIRScanPos = ui32NewScanPos; |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| { |
| IMG_UINT32 tsp; |
| for (tsp = 0; tsp < ui32MBMaxSize; tsp++) |
| { |
| if (tsp % ((IMG_UINT32)(ctx->ui16Width/16)) == 0) |
| { |
| fprintf(fp, "\n%c", TmpOutputTble[tsp]); |
| } |
| else |
| { |
| fprintf(fp, "%c", TmpOutputTble[tsp]); |
| } |
| } |
| |
| fprintf(fp, "\n---------------------------------------------------------------------------\n"); |
| fclose(fp); |
| } |
| #endif |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: end\n", __FUNCTION__); |
| return ; |
| } |
| |
| // Adaptive Intra Refresh (AIR) - send the AIR values to the next bufferk |
| // APP_UpdateAdaptiveIntraRefresh_Send |
| static void tng__update_air_send(context_ENC_p ctx, IMG_UINT8 ui8SlotNum) |
| { |
| IMG_UINT8 *pInpCtrlBuf = NULL; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: start\n", __FUNCTION__); |
| // Get pointer to MB Control buffer for current source buffer (if input control is enabled, otherwise buffer is NULL) |
| #if 0 |
| tng__map_inp_ctrl_buf(ctx, ui8SlotNum, &pInpCtrlBuf); |
| if(pInpCtrlBuf!= IMG_NULL) { |
| tng__send_air_inp_ctrl_buf(ctx, (IMG_INT8 *)pInpCtrlBuf); |
| } |
| tng__unmap_inp_ctrl_buf(ctx, ui8SlotNum, &pInpCtrlBuf); |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: end\n", __FUNCTION__); |
| #endif |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_SW_UPDATE_AIR_SEND, ui8SlotNum, 0, 0); |
| return ; |
| } |
| |
| /*********************************************************************************** |
| * Function Name : functions for output control |
| ************************************************************************************/ |
| //IMG_V_GetFirstPassOutBuf |
| VAStatus tng__map_first_pass_out_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 __maybe_unused ui8SlotNumber, |
| IMG_UINT8 **ppsFirstPassOutBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| |
| if (ppsFirstPassOutBuf == NULL) { |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: ppsFirstPassOutBuf == NULL\n", __FUNCTION__); |
| return VA_STATUS_ERROR_INVALID_PARAMETER; |
| } |
| |
| *ppsFirstPassOutBuf = NULL; // Not enabled |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (ctx->bEnableInpCtrl) { |
| vaStatus = psb_buffer_map(&(ps_mem->bufs_first_pass_out_params), ppsFirstPassOutBuf); |
| if (vaStatus != VA_STATUS_SUCCESS) |
| psb_buffer_unmap(&(ps_mem->bufs_first_pass_out_params)); |
| } |
| |
| return vaStatus; |
| } |
| |
| VAStatus tng__unmap_first_pass_out_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 __maybe_unused ui8SlotNumber, |
| IMG_UINT8 **ppsFirstPassOutBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (*ppsFirstPassOutBuf != NULL) { |
| psb_buffer_unmap(&(ps_mem->bufs_first_pass_out_params)); |
| *ppsFirstPassOutBuf = NULL; // Not enabled |
| } |
| |
| return vaStatus; |
| } |
| |
| //IMG_V_GetBestMBDecisionOutBuf |
| VAStatus tng__map_best_mb_decision_out_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 __maybe_unused ui8SlotNumber, |
| IMG_UINT8 **ppsBestMBDecisionOutBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (ctx->bEnableInpCtrl) |
| vaStatus = psb_buffer_map(&(ps_mem->bufs_first_pass_out_best_multipass_param), ppsBestMBDecisionOutBuf); |
| else |
| *ppsBestMBDecisionOutBuf = NULL; // Not enabled |
| |
| return vaStatus; |
| } |
| |
| VAStatus tng__unmap_best_mb_decision_out_buf( |
| context_ENC_p ctx, |
| IMG_UINT8 __maybe_unused ui8SlotNumber, |
| IMG_UINT8 **ppsBestMBDecisionOutBuf) |
| { |
| VAStatus vaStatus = VA_STATUS_SUCCESS; |
| context_ENC_mem* ps_mem = &(ctx->ctx_mem[0]); |
| |
| // if enabled, return the input-control buffer corresponding to this slot |
| if (*ppsBestMBDecisionOutBuf != NULL) { |
| psb_buffer_unmap(&(ps_mem->bufs_first_pass_out_best_multipass_param)); |
| *ppsBestMBDecisionOutBuf = NULL; // Not enabled |
| } |
| |
| return vaStatus; |
| } |
| |
| // Calculate Adaptive Intra Refresh (AIR) |
| static void tng__calc_air_inp_ctrl_buf(context_ENC_p ctx, IMG_UINT8 *pFirstPassOutBuf, IMG_UINT8 *pBestMBDecisionCtrlBuf) |
| { |
| IMG_UINT8 *pSADPointer; |
| IMG_UINT8 *pvSADBuffer; |
| IMG_UINT8 ui8IsAlreadyIntra; |
| IMG_UINT32 ui32MBFrameWidth; |
| IMG_UINT32 ui32MBPictureHeight; |
| IMG_UINT16 ui16IntraParam; |
| IMG_UINT32 ui32MBx, ui32MBy; |
| IMG_UINT32 ui32SADParam; |
| IMG_UINT32 ui32tSAD_Threshold, ui32tSAD_ThresholdLo, ui32tSAD_ThresholdHi; |
| IMG_UINT32 ui32MaxMBs, ui32NumMBsOverThreshold, ui32NumMBsOverLo, ui32NumMBsOverHi; |
| IMG_BEST_MULTIPASS_MB_PARAMS *psBestMB_Params; |
| IMG_FIRST_STAGE_MB_PARAMS *psFirstMB_Params; |
| |
| ui16IntraParam = (0 << 7) | (0 << 4); |
| ui32NumMBsOverThreshold = ui32NumMBsOverLo = ui32NumMBsOverHi = 0; |
| //drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: start\n", __FUNCTION__); |
| |
| // if (psActiveContext->ui32EncodeSent < (IMG_UINT32)psActiveContext->ui8MaxSourceSlots + 1) |
| // if (ctx->ui32FrameCount[0] < (IMG_UINT32)(ctx->ui8SlotsInUse + 1)) |
| // return; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: start\n", __FUNCTION__); |
| //fill data |
| ui32MBFrameWidth = (ctx->ui16Width/16); |
| ui32MBPictureHeight = (ctx->ui16PictureHeight/16); |
| |
| // get the SAD results buffer (either IPE0 and IPE1 results or, preferably, the more accurate Best Multipass SAD results) |
| if (pBestMBDecisionCtrlBuf) { |
| pvSADBuffer = pBestMBDecisionCtrlBuf; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"AIR active: Using Best Multipass SAD values "); |
| |
| //#ifdef MULTIPASS_MV_PLACEMENT_ISSUE_FIXED |
| if ((ctx->ui8EnableSelStatsFlags & ESF_MP_BEST_MOTION_VECTOR_STATS)) |
| //#endif |
| { |
| // The actual Param structures (which contain SADs) are located after the Multipass Motion Vector entries |
| pvSADBuffer += (ui32MBPictureHeight * (ui32MBFrameWidth) * sizeof(IMG_BEST_MULTIPASS_MB_PARAMS_IPMV)); |
| } |
| } else { |
| pvSADBuffer = pFirstPassOutBuf; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"AIR active: Using IPE SAD values "); |
| } |
| |
| if (ctx->sAirInfo.i32NumAIRSPerFrame == 0) |
| ui32MaxMBs = ui32MBFrameWidth * ui32MBPictureHeight; // Default to ALL MB's in frame |
| else if (ctx->sAirInfo.i32NumAIRSPerFrame < 0) |
| ctx->sAirInfo.i32NumAIRSPerFrame = ui32MaxMBs = ((ui32MBFrameWidth * ui32MBPictureHeight) + 99) / 100; // Default to 1% of MB's in frame (min 1) |
| else |
| ui32MaxMBs = ctx->sAirInfo.i32NumAIRSPerFrame; |
| |
| pSADPointer = (IMG_UINT8 *)pvSADBuffer; |
| |
| if (ctx->sAirInfo.i32SAD_Threshold >= 0) |
| ui32tSAD_Threshold = (IMG_UINT16)ctx->sAirInfo.i32SAD_Threshold; |
| else { |
| // Running auto adjust threshold adjust mode |
| if (ctx->sAirInfo.i32SAD_Threshold == -1) { |
| // This will occur only the first time |
| if (pBestMBDecisionCtrlBuf) { |
| psBestMB_Params=(IMG_BEST_MULTIPASS_MB_PARAMS *) pSADPointer; // Auto seed the threshold with the first value |
| ui32SADParam = psBestMB_Params->ui32SAD_Inter_MBInfo & IMG_BEST_MULTIPASS_SAD_MASK; |
| } else { |
| psFirstMB_Params=(IMG_FIRST_STAGE_MB_PARAMS *) pSADPointer; // Auto seed the threshold with the first value |
| ui32SADParam = (IMG_UINT32) psFirstMB_Params->ui16Ipe0Sad; |
| } |
| ctx->sAirInfo.i32SAD_Threshold = -1 - ui32SADParam; // Negative numbers indicate auto-adjusting threshold |
| } |
| ui32tSAD_Threshold = (IMG_UINT32) - (ctx->sAirInfo.i32SAD_Threshold + 1); |
| } |
| |
| ui32tSAD_ThresholdLo = ui32tSAD_Threshold / 2; |
| ui32tSAD_ThresholdHi = ui32tSAD_Threshold + ui32tSAD_ThresholdLo; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"Th:%u, MaxMbs:%u, Skp:%i\n", (unsigned int)ui32tSAD_Threshold, (unsigned int)ui32MaxMBs, ctx->sAirInfo.i16AIRSkipCnt); |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| if (fp) |
| fp=fopen("SADvals.txt","a"); |
| else |
| fp=fopen("SADvals.txt","w"); |
| |
| if (ctx->sAirInfo.i32SAD_Threshold>=0) |
| if (ctx->sAirInfo.i32NumAIRSPerFrame>0) |
| fprintf(fp, "S_SADThreshold: %i MaxMBs: %i\n", ui32tSAD_Threshold, ui32MaxMBs); |
| else |
| fprintf(fp, "S_SADThreshold: %i MaxMBs: NA\n", ui32tSAD_Threshold, ui32MaxMBs); |
| else |
| fprintf(fp, "V_SADThreshold: %i MaxMBs: %i\n", ui32tSAD_Threshold, ui32MaxMBs); |
| |
| if (pBestMBDecisionCtrlBuf) |
| fprintf(fp, "Using Best Multipass SAD values\n"); |
| else |
| fprintf(fp, "Using Motion Search Data IPE SAD values\n"); |
| #endif |
| |
| // This loop could be optimised to a single counter if necessary, retaining for clarity |
| for (ui32MBy = 0; ui32MBy < ui32MBPictureHeight; ui32MBy++) { |
| for( ui32MBx=0; ui32MBx<ui32MBFrameWidth; ui32MBx++) { |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| IMG_CHAR cMarked; |
| cMarked='_'; |
| #endif |
| // Turn all negative table values to positive (reset 'touched' state of a block that may have been set in APP_SendAIRInpCtrlBuf()) |
| if (ctx->sAirInfo.pi8AIR_Table[ui32MBy * ui32MBFrameWidth + ui32MBx] < 0) |
| ctx->sAirInfo.pi8AIR_Table[ui32MBy * ui32MBFrameWidth + ui32MBx] = -1 - ctx->sAirInfo.pi8AIR_Table[ui32MBy * ui32MBFrameWidth + ui32MBx]; |
| |
| // This will read the SAD value from the buffer (either IPE0 SAD or the superior Best multipass parameter structure SAD value) |
| if (pBestMBDecisionCtrlBuf) { |
| psBestMB_Params = (IMG_BEST_MULTIPASS_MB_PARAMS *) pSADPointer; |
| ui32SADParam = psBestMB_Params->ui32SAD_Inter_MBInfo & IMG_BEST_MULTIPASS_SAD_MASK; |
| |
| if ((psBestMB_Params->ui32SAD_Intra_MBInfo & IMG_BEST_MULTIPASS_MB_TYPE_MASK) >> IMG_BEST_MULTIPASS_MB_TYPE_SHIFT == 1) |
| ui8IsAlreadyIntra = 1; |
| else |
| ui8IsAlreadyIntra = 0; |
| |
| pSADPointer=(IMG_UINT8 *) &(psBestMB_Params[1]); |
| } else { |
| psFirstMB_Params=(IMG_FIRST_STAGE_MB_PARAMS *) pSADPointer; |
| ui32SADParam = (IMG_UINT32) psFirstMB_Params->ui16Ipe0Sad; |
| ui32SADParam += (IMG_UINT32) psFirstMB_Params->ui16Ipe1Sad; |
| ui32SADParam /= 2; |
| ui8IsAlreadyIntra = 0; // We don't have the information to determine this |
| pSADPointer=(IMG_UINT8 *) &(psFirstMB_Params[1]); |
| } |
| |
| if (ui32SADParam >= ui32tSAD_ThresholdLo) { |
| ui32NumMBsOverLo++; |
| |
| if (ui32SADParam >= ui32tSAD_Threshold) { |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| cMarked='i'; |
| #endif |
| |
| // if (!ui8IsAlreadyIntra) // Don't mark this block if it's just been encoded as an Intra block anyway |
| // (results seem better without this condition anyway) |
| { |
| ctx->sAirInfo.pi8AIR_Table[ui32MBy * ui32MBFrameWidth + ui32MBx]++; |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| cMarked='I'; |
| #endif |
| } |
| ui32NumMBsOverThreshold++; |
| if (ui32SADParam >= ui32tSAD_ThresholdHi) |
| ui32NumMBsOverHi++; |
| } |
| } |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| fprintf(fp,"%4x[%i]%c, ",ui32SADParam, ctx->sAirInfo.pi8AIR_Table[ui32MBy * ui32MBFrameWidth + ui32MBx], cMarked); |
| #endif |
| } |
| pSADPointer=(IMG_UINT8 *) ALIGN_64(((IMG_UINT32) pSADPointer)); |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| fprintf(fp,"\n"); |
| #endif |
| } |
| |
| // Test and process running adaptive threshold case |
| if (ctx->sAirInfo.i32SAD_Threshold < 0) { |
| // Adjust our threshold (to indicate it's auto-adjustable store it as a negative value minus 1) |
| if (ui32NumMBsOverLo <= ui32MaxMBs) |
| ctx->sAirInfo.i32SAD_Threshold = (IMG_INT32) - ((IMG_INT32)ui32tSAD_ThresholdLo) - 1; |
| else |
| if (ui32NumMBsOverHi >= ui32MaxMBs) |
| ctx->sAirInfo.i32SAD_Threshold = (IMG_INT32) - ((IMG_INT32)ui32tSAD_ThresholdHi) - 1; |
| else { |
| if (ui32MaxMBs < ui32NumMBsOverThreshold) { |
| ctx->sAirInfo.i32SAD_Threshold = ((IMG_INT32)ui32tSAD_ThresholdHi - (IMG_INT32)ui32tSAD_Threshold); |
| ctx->sAirInfo.i32SAD_Threshold *= ((IMG_INT32)ui32MaxMBs - (IMG_INT32)ui32NumMBsOverThreshold); |
| ctx->sAirInfo.i32SAD_Threshold /= ((IMG_INT32)ui32NumMBsOverHi - (IMG_INT32)ui32NumMBsOverThreshold); |
| ctx->sAirInfo.i32SAD_Threshold += ui32tSAD_Threshold; |
| } else { |
| ctx->sAirInfo.i32SAD_Threshold = ((IMG_INT32)ui32tSAD_Threshold - (IMG_INT32)ui32tSAD_ThresholdLo); |
| ctx->sAirInfo.i32SAD_Threshold *= ((IMG_INT32)ui32MaxMBs - (IMG_INT32)ui32NumMBsOverLo); |
| ctx->sAirInfo.i32SAD_Threshold /= ((IMG_INT32)ui32NumMBsOverThreshold - (IMG_INT32)ui32NumMBsOverLo); |
| ctx->sAirInfo.i32SAD_Threshold += ui32tSAD_ThresholdLo; |
| } |
| ctx->sAirInfo.i32SAD_Threshold = -ctx->sAirInfo.i32SAD_Threshold - 1; |
| } |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| fprintf(fp,"THRESHOLDS ADJUSTMENT\nThrLo:%i ThrMid:%i ThrHi:%i\nMBsLo:%i MBsMid:%i MBsHi:%i\n",ui32tSAD_ThresholdLo, ui32tSAD_Threshold, ui32tSAD_ThresholdHi, ui32NumMBsOverLo, ui32NumMBsOverThreshold, ui32NumMBsOverHi); |
| fprintf(fp,"Target No. MB's:%i\nThreshold adjusted to: %i\n",ui32MaxMBs, -(ctx->sAirInfo.i32SAD_Threshold)); |
| #endif |
| } |
| |
| #ifdef ADAPTIVE_INTRA_REFRESH_DEBUG_OUTPUT |
| fprintf(fp,"\n MBs tagged:%i\n", ui32NumMBsOverThreshold); |
| fclose(fp); |
| #endif |
| drv_debug_msg(VIDEO_DEBUG_GENERAL,"%s: end\n", __FUNCTION__); |
| return; |
| } |
| |
| // Adaptive Intra Refresh (AIR) - Calculate the new AIR values based upon Motion Search feedback |
| // APP_UpdateAdaptiveIntraRefresh_Calc |
| static void tng_update_air_calc(context_ENC_p ctx, IMG_UINT8 ui8SlotNum) |
| { |
| IMG_UINT8 *pFirstPassOutBuf = NULL; |
| IMG_UINT8 *pBestMBDecisionCtrlBuf = NULL; |
| #if 0 |
| // Get pointer to MB Control buffer for current source buffer (if input control is enabled, otherwise buffer is NULL) |
| tng__map_first_pass_out_buf(ctx, ui8SlotNum, &pFirstPassOutBuf); |
| tng__map_best_mb_decision_out_buf(ctx, ui8SlotNum, &pBestMBDecisionCtrlBuf); |
| |
| if(pFirstPassOutBuf || pBestMBDecisionCtrlBuf) |
| tng__calc_air_inp_ctrl_buf (ctx, pFirstPassOutBuf, pBestMBDecisionCtrlBuf); |
| |
| tng__unmap_first_pass_out_buf(ctx, ui8SlotNum, &pFirstPassOutBuf); |
| tng__unmap_best_mb_decision_out_buf(ctx, ui8SlotNum, &pBestMBDecisionCtrlBuf); |
| #endif |
| tng_cmdbuf_insert_command(ctx->obj_context, ctx->ui32StreamID, |
| MTX_CMDID_SW_UPDATE_AIR_CALC, ui8SlotNum, 0, 0); |
| } |
| |
| /*********************************************************************************** |
| * Function Name : |
| * Inputs : |
| * Description : |
| ************************************************************************************/ |
| void tng_air_set_input_control(context_ENC_p ctx, IMG_UINT8 __maybe_unused ui8StreamID) |
| { |
| IMG_UINT8 ui8SlotIndex = ctx->ui8SlotsCoded; |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: slot index = %d\n", __FUNCTION__, ctx->ui8SlotsCoded); |
| //IMG_UINT32 ui32HalfWayBU; |
| //ui32HalfWayBU = tng_fill_slice_map(ctx, ui8SlotIndex, ui8StreamID); |
| |
| ////////////////////////////// INPUT CONTROL |
| // Add input control stuff here |
| tng__fill_input_control(ctx, ui8SlotIndex, ctx->ui32HalfWayBU[ui8SlotIndex]); |
| |
| // Adaptive Intra Refresh (AIR) - send the AIR values to the next buffer |
| if (ctx->bEnableAIR) |
| tng__update_air_send(ctx, ui8SlotIndex); |
| } |
| |
| |
| /*********************************************************************************** |
| * Function Name : |
| * Inputs : |
| * Description : |
| ************************************************************************************/ |
| void tng_air_set_output_control(context_ENC_p ctx, IMG_UINT8 __maybe_unused ui8StreamID) |
| { |
| IMG_UINT8 ui8SlotIndex = ctx->ui8SlotsCoded; |
| |
| drv_debug_msg(VIDEO_DEBUG_GENERAL, "%s: slot index = %d\n", __FUNCTION__, ctx->ui8SlotsCoded); |
| |
| if ((ctx->eFrameType == IMG_INTRA_IDR) || |
| (ctx->eFrameType == IMG_INTRA_FRAME)) |
| tng_air_buf_clear(ctx); |
| else |
| tng_update_air_calc(ctx, ui8SlotIndex); |
| |
| return; |
| } |
