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); }