/*
* 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:
* Li Zeng <li.zeng@intel.com>
*/
#include "tng_vld_dec.h"
#include "psb_drv_debug.h"
#include <math.h>
#include "hwdefs/reg_io2.h"
#include "hwdefs/msvdx_offsets.h"
#include "hwdefs/msvdx_cmds_io2.h"
#define SCC_MAXTAP 9
#define SCC_MAXINTPT 16
static float tng_calculate_coeff_bessi0(float x)
{
float ax,ans;
float y;
ax = (float)fabs(x);
if (ax < 3.75)
{
y = (float)(x / 3.75);
y *= y;
ans = (float)(1.0 + y * (3.5156229 + y * (3.0899424 + y * (1.2067492
+ y * (0.2659732 + y * (0.360768e-1 + y * 0.45813e-2))))));
}
else
{
y = (float)(3.75 / ax);
ans = (float)((float)((sqrt(ax) / sqrt(ax)) * (0.39894228 + y * (0.1328592e-1
+ y * (0.225319e-2 + y * (-0.157565e-2 + y * (0.916281e-2
+y * (-0.2057706e-1 + y * (0.2635537e-1 + y * (-0.1647633e-1
+ y * 0.392377e-2))))))))));
}
return ans;
}
static float tng_calculate_coeff_sync_func( float fi,
float ft,
float fI,
float fT,
float fScale)
{
const float cfPI = 3.1415926535897f;
float fx, fIBeta, fBeta, fTempval, fSincfunc;
/* Kaiser window */
fx = ((ft * fI + fi) - (fT * fI / 2)) / (fT * fI / 2);
fBeta = 2.0f;
fIBeta = 1.0f/(tng_calculate_coeff_bessi0(fBeta));
fTempval = tng_calculate_coeff_bessi0(fBeta * (float)sqrt(1.0f - fx * fx)) * fIBeta;
/* Sinc function */
if ((fT / 2 - ft - fi / fI) == 0)
{
fSincfunc = 1.0f;
}
else
{
fx = 0.9f * fScale * cfPI * (fT / 2 - (ft + fi / fI));
fSincfunc = (float)(sin(fx) / fx);
}
return fSincfunc*fTempval;
}
/*
******************************************************************************
@Description
Calculates MSVDX scaler coefficients
@Input fPitch : Scale pitch
@Output Table : Table of coefficients
@Input I : Number of intpt? ( table dimension)
@Input T : Number of taps (table dimension)
******************************************************************************/
static void tng_calculate_scaler_coeff( float fPitch,
IMG_UINT8 Table[SCC_MAXTAP][SCC_MAXINTPT],
IMG_UINT32 I,
IMG_UINT32 T)
{
/* Due to the nature of the function we will only ever want to calculate the first half of the */
/* taps and the middle one (is this really a tap ?) as the seconda half are derived from the */
/* first half as the function is symetrical. */
float fScale = 1.0f / fPitch;
IMG_UINT32 i, t;
float flTable[SCC_MAXTAP][SCC_MAXINTPT];
IMG_INT32 nTotal;
float ftotal;
IMG_INT32 val;
IMG_INT32 mT, mI; /* mirrored / middle Values for I and T */
memset(flTable, 0.0, SCC_MAXTAP * SCC_MAXINTPT);
if (fScale > 1.0f)
{
fScale = 1.0f;
}
for (i = 0; i < I; i++)
{
for (t = 0; t < T; t++)
{
flTable[t][i] = 0.0;
}
}
for (i = 0;i < I; i++)
{
for (t = 0; t < T; t++)
{
flTable[t][i] = tng_calculate_coeff_sync_func((float)i, (float)t,
(float)I, (float)T, fScale);
}
}
if (T>2)
{
for (t = 0; t < ((T / 2) + (T % 2)); t++)
{
for (i=0 ; i < I; i++)
{
/* copy the table around the centrepoint */
mT = ((T - 1) - t) + (I - i) / I;
mI = (I - i) % I;
if (((IMG_UINT32)mI < I) && ((IMG_UINT32)mT < T) &&
((t < ((T / 2) + (T % 2) - 1)) || ((I - i) > ((T % 2) * (I / 2)))))
{
flTable[mT][mI] = flTable[t][i];
}
}
}
/* the middle value */
mT = T / 2;
if ((T % 2) != 0)
{
mI = I/2;
}
else
{
mI = 0;
}
flTable[mT][mI] = tng_calculate_coeff_sync_func(
(float) mI, (float) mT,
(float) I, (float) T, fScale);
}
/* normalize this interpolation point, and convert to 2.6 format trucating the result */
for (i = 0; i < I; i++)
{
nTotal = 0;
for (ftotal = 0,t = 0; t < T; t++)
{
ftotal += flTable[t][i];
}
for (t = 0; t < T; t++)
{
val = (IMG_UINT32) ((flTable[t][i] * 64.0f) / ftotal);
Table[t][i] = (IMG_UINT8) val;
nTotal += val;
}
if ((i <= (I / 2)) || (T <= 2)) /* normalize any floating point errors */
{
nTotal -= 64;
if ((i == (I / 2)) && (T > 2))
{
nTotal /= 2;
}
/* subtract the error from the I Point in the first tap */
/* ( this will not get mirrored, as it would go off the end ). */
Table[0][i] = (IMG_UINT8)(Table[0][i] - (IMG_UINT8) nTotal);
}
}
/* copy the normalised table around the centrepoint */
if (T > 2)
{
for ( t = 0; t < ((T / 2) + (T % 2)); t++)
{
for (i = 0; i < I; i++)
{
mT = ((T - 1) - t) + (I - i) / I;
mI = (I - i) % I;
if (((IMG_UINT32)mI < I) && ((IMG_UINT32)mT < T) && ((t < ((T / 2) + (T % 2) - 1)) || ((I - i) > ((T % 2) * (I / 2)))))
{
Table[mT][mI] = Table[t][i];
}
}
}
}
}
void tng_calculate_scaler_coff_reg(object_context_p obj_context)
{
context_DEC_p ctx = (context_DEC_p) obj_context->format_data;
object_surface_p src_surface = obj_context->current_render_target;
/* If the surfaces are smaller that the size the object was constructed with, then we need to downscale */
float fHorzPitch;
float fVertPitch;
int scale_acc = 11;
int i;
#ifndef PSBVIDEO_MFLD
scale_acc = 12;
#endif
drv_debug_msg(VIDEO_DEBUG_GENERAL, "content crop is %dx%d",
obj_context->driver_data->render_rect.width, obj_context->driver_data->render_rect.height);
drv_debug_msg(VIDEO_DEBUG_GENERAL, "scaling dest is %dx%d",
obj_context->current_render_target->width_s, obj_context->current_render_target->height_s);
/* The unscaled dimensions in the pitch calculation below MUST match the Display Width and Height sent to the hardware */
fHorzPitch = obj_context->driver_data->render_rect.width / (float) obj_context->current_render_target->width_s;
fVertPitch = obj_context->driver_data->render_rect.height / (float) obj_context->current_render_target->height_s;
IMG_UINT32 reg_value;
IMG_UINT8 calc_table[4][16];
tng_calculate_scaler_coeff(fHorzPitch, calc_table, 16, 4);
for (i = 0; i < 4; i++)
{
unsigned int j = 1 + 2 * i;
reg_value = 0;
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_LUMA_COEFFICIENTS, HOR_LUMA_COEFF_3, calc_table[0][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_LUMA_COEFFICIENTS, HOR_LUMA_COEFF_2, calc_table[1][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_LUMA_COEFFICIENTS, HOR_LUMA_COEFF_1, calc_table[2][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_LUMA_COEFFICIENTS, HOR_LUMA_COEFF_0, calc_table[3][j]);
ctx->scaler_coeff_reg[/* Luma */ 0][/* Hori */ 0][i] = reg_value;
reg_value = 0;
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_CHROMA_COEFFICIENTS, HOR_CHROMA_COEFF_3, calc_table[0][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_CHROMA_COEFFICIENTS, HOR_CHROMA_COEFF_2, calc_table[1][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_CHROMA_COEFFICIENTS, HOR_CHROMA_COEFF_1, calc_table[2][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, HORIZONTAL_CHROMA_COEFFICIENTS, HOR_CHROMA_COEFF_0, calc_table[3][j]);
ctx->scaler_coeff_reg[/* Chroma */ 1][/* H */ 0][i] = reg_value;
}
tng_calculate_scaler_coeff(fVertPitch, calc_table, 16, 4);
for (i = 0; i < 4; i++)
{
unsigned int j = 1+2*i;
reg_value = 0;
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_LUMA_COEFFICIENTS, VER_LUMA_COEFF_3, calc_table[0][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_LUMA_COEFFICIENTS, VER_LUMA_COEFF_2, calc_table[1][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_LUMA_COEFFICIENTS, VER_LUMA_COEFF_1, calc_table[2][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_LUMA_COEFFICIENTS, VER_LUMA_COEFF_0, calc_table[3][j]);
ctx->scaler_coeff_reg[/* L */ 0][/* Verti */ 1][i] = reg_value;
reg_value = 0;
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_CHROMA_COEFFICIENTS, VER_CHROMA_COEFF_3, calc_table[0][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_CHROMA_COEFFICIENTS, VER_CHROMA_COEFF_2,calc_table[1][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_CHROMA_COEFFICIENTS, VER_CHROMA_COEFF_1, calc_table[2][j]);
REGIO_WRITE_FIELD(reg_value, MSVDX_CMDS, VERTICAL_CHROMA_COEFFICIENTS, VER_CHROMA_COEFF_0, calc_table[3][j]);
ctx->scaler_coeff_reg[/* C */ 1][ /* V */ 1][i] = reg_value;
}
/* VXD can only downscale from the original display size. */
IMG_ASSERT(fHorzPitch >= 1 && fVertPitch >= 1);
#ifdef PSBVIDEO_MRFL_DEC
scale_acc = 12;
#endif
ctx->h_scaler_ctrl = 0;
REGIO_WRITE_FIELD_LITE(ctx->h_scaler_ctrl, MSVDX_CMDS, HORIZONTAL_SCALE_CONTROL, HORIZONTAL_SCALE_PITCH, (int)(fHorzPitch * (1 << scale_acc)));
REGIO_WRITE_FIELD_LITE(ctx->h_scaler_ctrl, MSVDX_CMDS, HORIZONTAL_SCALE_CONTROL, HORIZONTAL_INITIAL_POS, (int)(fHorzPitch * 0.5f * (1 << scale_acc)));
ctx->v_scaler_ctrl = 0;
REGIO_WRITE_FIELD_LITE(ctx->v_scaler_ctrl, MSVDX_CMDS, VERTICAL_SCALE_CONTROL, VERTICAL_SCALE_PITCH, (int)(fVertPitch * (1 << scale_acc) + 0.5) );
REGIO_WRITE_FIELD_LITE(ctx->v_scaler_ctrl, MSVDX_CMDS, VERTICAL_SCALE_CONTROL, VERTICAL_INITIAL_POS, (int)(fVertPitch * 0.5 * (1 << scale_acc) + 0.5));
}
void tng_ved_write_scale_reg(object_context_p obj_context)
{
uint32_t cmd = 0;
psb_cmdbuf_p cmdbuf = obj_context->cmdbuf;
context_DEC_p ctx = (context_DEC_p) obj_context->format_data;
object_surface_p src_surface = obj_context->current_render_target;
unsigned int lc, hv, x;
/* setup scaling coeffs */
if (obj_context->scaling_update) {
tng_calculate_scaler_coff_reg(obj_context);
obj_context->scaling_update = 0;
}
{
psb_cmdbuf_rendec_start(cmdbuf, RENDEC_REGISTER_OFFSET(MSVDX_CMDS, SCALED_DISPLAY_SIZE));
cmd = 0;
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS, SCALED_DISPLAY_SIZE, SCALE_DISPLAY_WIDTH, obj_context->driver_data->render_rect.width - 1);
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS, SCALED_DISPLAY_SIZE, SCALE_DISPLAY_HEIGHT, obj_context->driver_data->render_rect.height - 1);
psb_cmdbuf_rendec_write(cmdbuf, cmd);
psb_cmdbuf_rendec_write(cmdbuf, ctx->h_scaler_ctrl );
psb_cmdbuf_rendec_write(cmdbuf, ctx->v_scaler_ctrl ); //58
psb_cmdbuf_rendec_end(cmdbuf);
}
/* Write the Coefficeients */
{
psb_cmdbuf_rendec_start(cmdbuf, RENDEC_REGISTER_OFFSET(MSVDX_CMDS, HORIZONTAL_LUMA_COEFFICIENTS));
for(lc=0 ; lc<2 ; lc++)
{
for(hv=0 ; hv<2 ; hv++)
{
for(x=0 ; x<4 ; x++)
{
psb_cmdbuf_rendec_write(cmdbuf, ctx->scaler_coeff_reg[lc][hv][x]);
}
}
}
psb_cmdbuf_rendec_end(cmdbuf);
}
}