static void rfx_rlgr_code_gr(RFX_BITSTREAM* bs, int* krp, UINT32 val)
{
int kr = *krp >> LSGR;
/* unary part of GR code */
UINT32 vk = (val) >> kr;
OutputBit(vk, 1);
OutputBit(1, 0);
/* remainder part of GR code, if needed */
if (kr)
{
OutputBits(kr, val & ((1 << kr) - 1));
}
/* update krp, only if it is not equal to 1 */
if (vk == 0)
{
UpdateParam(*krp, -2, kr);
}
else if (vk > 1)
{
UpdateParam(*krp, vk, kr);
}
}
static uint32
rfx_rlgr_get_gr_code(RFX_BITSTREAM * bs, int * krp, int * kr)
{
int vk;
uint32 mag;
/* chew up/count leading 1s and escape 0 */
for (vk = 0; GetBits(1) == 1;)
vk++;
/* get next *kr bits, and combine with leading 1s */
mag = (vk << *kr) | GetBits(*kr);
/* adjust krp and kr based on vk */
if (!vk)
{
UpdateParam(*krp, -2, *kr);
}
else if (vk != 1)
{
/* at 1, no change! */
UpdateParam(*krp, vk, *kr);
}
return mag;
}
void gs_shader::UploadParams()
{
vector<uint8_t> constData;
bool upload = false;
constData.reserve(constantSize);
for (size_t i = 0; i < params.size(); i++)
UpdateParam(constData, params[i], upload);
if (constData.size() != constantSize)
throw "Invalid constant data size given to shader";
if (upload) {
D3D11_MAPPED_SUBRESOURCE map;
HRESULT hr;
hr = device->context->Map(constants, 0, D3D11_MAP_WRITE_DISCARD,
0, &map);
if (FAILED(hr))
throw HRError("Could not lock constant buffer", hr);
memcpy(map.pData, constData.data(), constData.size());
device->context->Unmap(constants, 0);
}
}
void CDlgCHJpegParam::OnBtnCopy1()
{
if(!UpdateParam()) return;
int i,tmpch;
CString strmsg;
int sel = ((CComboBox*)GetDlgItem(IDC_COMBO_CHCOPY1))->GetCurSel();
if(sel == -1) return;
if(sel == (m_ch + 1)) return;
tmpch = m_ch;
if(sel == 0) //all channels
{
for(i=0;i<g_SerParam->m_chs;i++)
{
m_ch = i;
OnBtnSet();
}
}
else
{
m_ch = sel - 1;
OnBtnSet();
}
m_ch = tmpch;
strmsg.LoadString(IDS_STRING257);
g_SerParam->m_txtMsginfo.SetWindowText(strmsg);
}
static int UpdateInput(equalizer* p)
{
PCMRelease(p->PCM);
p->PCM = NULL;
BufferClear(&p->Buffer);
if (p->Codec.In.Format.Type == PACKET_AUDIO)
{
if (!p->Enabled || p->Codec.In.Format.Format.Audio.Channels>MAXPLANES)
return ERR_INVALID_PARAM;
PacketFormatPCM(&p->Codec.Out.Format,&p->Codec.In.Format,FIX_FRACBITS+1);
p->Codec.Out.Format.Format.Audio.Bits = sizeof(fix_t)*8;
p->Codec.Out.Format.Format.Audio.Flags = PCM_PLANES;
#ifndef FIXED_POINT
p->Codec.Out.Format.Format.Audio.Flags |= PCM_FLOAT;
#endif
p->PCM = PCMCreate(&p->Codec.Out.Format.Format.Audio,&p->Codec.In.Format.Format.Audio,0,0);
if (!p->PCM)
return ERR_OUT_OF_MEMORY;
p->Scale = FIXC(1);
UpdateParam(p);
Flush(p);
}
return ERR_NONE;
}
void CDlgHumitureParam::OnBtnSet()
{
if(!UpdateParam()) return;
CString strmsg;
g_SerParam->SaveParam(MESSAGE_CMD_SETHUMITUREPRAM,0,&m_humitureparam,NULL,NULL);
strmsg.LoadString(IDS_STRING232);
g_SerParam->m_txtMsginfo.SetWindowText(strmsg);
}
void CDlgCHAudioParam::OnBtnSet()
{
if(!UpdateParam()) return;
CString strmsg;
g_SerParam->SaveParam(MESSAGE_CMD_SETAUDIOPARAM,m_ch,&m_audioparam,NULL,NULL);
strmsg.LoadString(IDS_STRING232);
g_SerParam->m_txtMsginfo.SetWindowText(strmsg);
}
int rfx_rlgr_encode(RLGR_MODE mode, const INT16* data, int data_size, BYTE* buffer, int buffer_size)
{
int k;
int kp;
int krp;
RFX_BITSTREAM* bs;
int processed_size;
bs = (RFX_BITSTREAM*) malloc(sizeof(RFX_BITSTREAM));
ZeroMemory(bs, sizeof(RFX_BITSTREAM));
rfx_bitstream_attach(bs, buffer, buffer_size);
/* initialize the parameters */
k = 1;
kp = 1 << LSGR;
krp = 1 << LSGR;
/* process all the input coefficients */
while (data_size > 0)
{
int input;
if (k)
{
int numZeros;
int runmax;
int mag;
int sign;
/* RUN-LENGTH MODE */
/* collect the run of zeros in the input stream */
numZeros = 0;
GetNextInput(input);
while (input == 0 && data_size > 0)
{
numZeros++;
GetNextInput(input);
}
// emit output zeros
runmax = 1 << k;
while (numZeros >= runmax)
{
OutputBit(1, 0); /* output a zero bit */
numZeros -= runmax;
UpdateParam(kp, UP_GR, k); /* update kp, k */
runmax = 1 << k;
}
/* output a 1 to terminate runs */
OutputBit(1, 1);
/* output the remaining run length using k bits */
OutputBits(k, numZeros);
/* note: when we reach here and the last byte being encoded is 0, we still
need to output the last two bits, otherwise mstsc will crash */
/* encode the nonzero value using GR coding */
mag = (input < 0 ? -input : input); /* absolute value of input coefficient */
sign = (input < 0 ? 1 : 0); /* sign of input coefficient */
OutputBit(1, sign); /* output the sign bit */
CodeGR(&krp, mag ? mag - 1 : 0); /* output GR code for (mag - 1) */
UpdateParam(kp, -DN_GR, k);
}
else
{
/* GOLOMB-RICE MODE */
if (mode == RLGR1)
{
UINT32 twoMs;
/* RLGR1 variant */
/* convert input to (2*magnitude - sign), encode using GR code */
GetNextInput(input);
twoMs = Get2MagSign(input);
CodeGR(&krp, twoMs);
/* update k, kp */
/* NOTE: as of Aug 2011, the algorithm is still wrongly documented
and the update direction is reversed */
if (twoMs)
{
UpdateParam(kp, -DQ_GR, k);
}
else
{
UpdateParam(kp, UQ_GR, k);
}
}
else /* mode == RLGR3 */
{
UINT32 twoMs1;
UINT32 twoMs2;
UINT32 sum2Ms;
UINT32 nIdx;
/* RLGR3 variant */
/* convert the next two input values to (2*magnitude - sign) and */
/* encode their sum using GR code */
GetNextInput(input);
twoMs1 = Get2MagSign(input);
GetNextInput(input);
twoMs2 = Get2MagSign(input);
sum2Ms = twoMs1 + twoMs2;
CodeGR(&krp, sum2Ms);
/* encode binary representation of the first input (twoMs1). */
GetMinBits(sum2Ms, nIdx);
OutputBits(nIdx, twoMs1);
/* update k,kp for the two input values */
if (twoMs1 && twoMs2)
{
UpdateParam(kp, -2 * DQ_GR, k);
}
else if (!twoMs1 && !twoMs2)
{
UpdateParam(kp, 2 * UQ_GR, k);
}
}
}
}
processed_size = rfx_bitstream_get_processed_bytes(bs);
free(bs);
return processed_size;
}
int rfx_rlgr_decode(RLGR_MODE mode, const BYTE* data, int data_size, INT16* buffer, int buffer_size)
{
int k;
int kp;
int kr;
int krp;
UINT16 r;
INT16* dst;
RFX_BITSTREAM* bs;
int vk;
UINT16 mag16;
bs = (RFX_BITSTREAM*) malloc(sizeof(RFX_BITSTREAM));
ZeroMemory(bs, sizeof(RFX_BITSTREAM));
rfx_bitstream_attach(bs, data, data_size);
dst = buffer;
/* initialize the parameters */
k = 1;
kp = k << LSGR;
kr = 1;
krp = kr << LSGR;
while (!rfx_bitstream_eos(bs) && buffer_size > 0)
{
int run;
if (k)
{
int mag;
UINT32 sign;
/* RL MODE */
while (!rfx_bitstream_eos(bs))
{
GetBits(1, r);
if (r)
break;
/* we have an RL escape "0", which translates to a run (1<<k) of zeros */
WriteZeroes(1 << k);
UpdateParam(kp, UP_GR, k); /* raise k and kp up because of zero run */
}
/* next k bits will contain remaining run or zeros */
GetBits(k, run);
WriteZeroes(run);
/* get nonzero value, starting with sign bit and then GRCode for magnitude -1 */
GetBits(1, sign);
/* magnitude - 1 was coded (because it was nonzero) */
GetGRCode(&krp, &kr, vk, mag16)
mag = (int) (mag16 + 1);
WriteValue(sign ? -mag : mag);
UpdateParam(kp, -DN_GR, k); /* lower k and kp because of nonzero term */
}
else
{
UINT32 mag;
UINT32 nIdx;
UINT32 val1;
UINT32 val2;
/* GR (GOLOMB-RICE) MODE */
GetGRCode(&krp, &kr, vk, mag16) /* values coded are 2 * magnitude - sign */
mag = (UINT32) mag16;
if (mode == RLGR1)
{
if (!mag)
{
WriteValue(0);
UpdateParam(kp, UQ_GR, k); /* raise k and kp due to zero */
}
else
{
WriteValue(GetIntFrom2MagSign(mag));
UpdateParam(kp, -DQ_GR, k); /* lower k and kp due to nonzero */
}
}
else /* mode == RLGR3 */
{
/*
* In GR mode FOR RLGR3, we have encoded the
* sum of two (2 * mag - sign) values
*/
/* maximum possible bits for first term */
GetMinBits(mag, nIdx);
/* decode val1 is first term's (2 * mag - sign) value */
GetBits(nIdx, val1);
/* val2 is second term's (2 * mag - sign) value */
val2 = mag - val1;
if (val1 && val2)
{
/* raise k and kp if both terms nonzero */
UpdateParam(kp, -2 * DQ_GR, k);
}
else if (!val1 && !val2)
{
/* lower k and kp if both terms zero */
UpdateParam(kp, 2 * UQ_GR, k);
}
WriteValue(GetIntFrom2MagSign(val1));
WriteValue(GetIntFrom2MagSign(val2));
}
}
}
free(bs);
return (dst - buffer);
}
int
rfx_rlgr1_encode(const sint16* data, int data_size, uint8* buffer, int buffer_size)
{
int k;
int kp;
int krp;
int input;
int numZeros;
int runmax;
int mag;
int sign;
int processed_size;
int lmag;
RFX_BITSTREAM bs;
uint32 twoMs;
rfx_bitstream_attach(bs, buffer, buffer_size);
/* initialize the parameters */
k = 1;
kp = 1 << LSGR;
krp = 1 << LSGR;
/* process all the input coefficients */
while (data_size > 0)
{
if (k)
{
/* RUN-LENGTH MODE */
/* collect the run of zeros in the input stream */
numZeros = 0;
GetNextInput(input);
while (input == 0 && data_size > 0)
{
numZeros++;
GetNextInput(input);
}
/* emit output zeros */
runmax = 1 << k;
while (numZeros >= runmax)
{
OutputBit(1, 0); /* output a zero bit */
numZeros -= runmax;
UpdateParam(kp, UP_GR, k); /* update kp, k */
runmax = 1 << k;
}
/* output a 1 to terminate runs */
OutputBit(1, 1);
/* output the remaining run length using k bits */
OutputBits(k, numZeros);
/* note: when we reach here and the last byte being encoded is 0, we still
need to output the last two bits, otherwise mstsc will crash */
/* encode the nonzero value using GR coding */
mag = (input < 0 ? -input : input); /* absolute value of input coefficient */
sign = (input < 0 ? 1 : 0); /* sign of input coefficient */
OutputBit(1, sign); /* output the sign bit */
lmag = mag ? mag - 1 : 0;
CodeGR(krp, lmag); /* output GR code for (mag - 1) */
UpdateParam(kp, -DN_GR, k);
}
else
{
/* GOLOMB-RICE MODE */
/* RLGR1 variant */
/* convert input to (2*magnitude - sign), encode using GR code */
GetNextInput(input);
twoMs = Get2MagSign(input);
CodeGR(krp, twoMs);
/* update k, kp */
/* NOTE: as of Aug 2011, the algorithm is still wrongly documented
and the update direction is reversed */
if (twoMs)
{
UpdateParam(kp, -DQ_GR, k);
}
else
{
UpdateParam(kp, UQ_GR, k);
}
}
}
processed_size = rfx_bitstream_get_processed_bytes(bs);
return processed_size;
}
void KGValueEdit4PairParamDlg::OnBnClickedButton4()
{
UpdateParam(&m_stringParam_4);
}
