void Canvas::Copy(const Bitmap &src) { Copy(0, 0, src.GetWidth(), src.GetHeight(), src, 0, 0); }
void Coder_ld8a( g729a_encoder_state *state, Word16 ana[] /* output : Analysis parameters */ ) { /* LPC analysis */ Word16 Aq_t[(MP1)*2]; /* A(z) quantized for the 2 subframes */ Word16 Ap_t[(MP1)*2]; /* A(z/gamma) for the 2 subframes */ Word16 *Aq, *Ap; /* Pointer on Aq_t and Ap_t */ /* Other vectors */ Word16 h1[L_SUBFR]; /* Impulse response h1[] */ Word16 xn[L_SUBFR]; /* Target vector for pitch search */ Word16 xn2[L_SUBFR]; /* Target vector for codebook search */ Word16 code[L_SUBFR]; /* Fixed codebook excitation */ Word16 y1[L_SUBFR]; /* Filtered adaptive excitation */ Word16 y2[L_SUBFR]; /* Filtered fixed codebook excitation */ Word16 g_coeff[4]; /* Correlations between xn & y1 */ Word16 g_coeff_cs[5]; Word16 exp_g_coeff_cs[5]; /* Correlations between xn, y1, & y2 <y1,y1>, -2<xn,y1>, <y2,y2>, -2<xn,y2>, 2<y1,y2> */ /* Scalars */ Word16 i, j, k, i_subfr; Word16 T_op, T0, T0_min, T0_max, T0_frac; Word16 gain_pit, gain_code, index; Word16 temp, taming; Word32 L_temp; /*------------------------------------------------------------------------* * - Perform LPC analysis: * * * autocorrelation + lag windowing * * * Levinson-durbin algorithm to find a[] * * * convert a[] to lsp[] * * * quantize and code the LSPs * * * find the interpolated LSPs and convert to a[] for the 2 * * subframes (both quantized and unquantized) * *------------------------------------------------------------------------*/ { /* Temporary vectors */ Word16 r_l[MP1], r_h[MP1]; /* Autocorrelations low and hi */ Word16 rc[M]; /* Reflection coefficients. */ Word16 lsp_new[M], lsp_new_q[M]; /* LSPs at 2th subframe */ /* LP analysis */ Autocorr(state->p_window, M, r_h, r_l); /* Autocorrelations */ Lag_window(M, r_h, r_l); /* Lag windowing */ Levinson(r_h, r_l, Ap_t, rc); /* Levinson Durbin */ Az_lsp(Ap_t, lsp_new, state->lsp_old); /* From A(z) to lsp */ /* LSP quantization */ Qua_lsp(state, lsp_new, lsp_new_q, ana); ana += 2; /* Advance analysis parameters pointer */ /*--------------------------------------------------------------------* * Find interpolated LPC parameters in all subframes * * The interpolated parameters are in array Aq_t[]. * *--------------------------------------------------------------------*/ Int_qlpc(state->lsp_old_q, lsp_new_q, Aq_t); /* Compute A(z/gamma) */ Weight_Az(&Aq_t[0], GAMMA1, M, &Ap_t[0]); Weight_Az(&Aq_t[MP1], GAMMA1, M, &Ap_t[MP1]); /* update the LSPs for the next frame */ Copy(lsp_new, state->lsp_old, M); Copy(lsp_new_q, state->lsp_old_q, M); } /*----------------------------------------------------------------------* * - Find the weighted input speech w_sp[] for the whole speech frame * * - Find the open-loop pitch delay * *----------------------------------------------------------------------*/ Residu(&Aq_t[0], &(state->speech[0]), &(state->exc[0]), L_SUBFR); Residu(&Aq_t[MP1], &(state->speech[L_SUBFR]), &(state->exc[L_SUBFR]), L_SUBFR); { Word16 Ap1[MP1]; Ap = Ap_t; Ap1[0] = 4096; for(i=1; i<=M; i++) /* Ap1[i] = Ap[i] - 0.7 * Ap[i-1]; */ Ap1[i] = sub(Ap[i], mult(Ap[i-1], 22938)); Syn_filt(Ap1, &(state->exc[0]), &(state->wsp[0]), L_SUBFR, state->mem_w, 1); Ap += MP1; for(i=1; i<=M; i++) /* Ap1[i] = Ap[i] - 0.7 * Ap[i-1]; */ Ap1[i] = sub(Ap[i], mult(Ap[i-1], 22938)); Syn_filt(Ap1, &(state->exc[L_SUBFR]), &(state->wsp[L_SUBFR]), L_SUBFR, state->mem_w, 1); } /* Find open loop pitch lag */ T_op = Pitch_ol_fast(state->wsp, PIT_MAX, L_FRAME); /* Range for closed loop pitch search in 1st subframe */ T0_min = T_op - 3; T0_max = T0_min + 6; if (T0_min < PIT_MIN) { T0_min = PIT_MIN; T0_max = PIT_MIN + 6; } else if (T0_max > PIT_MAX) { T0_max = PIT_MAX; T0_min = PIT_MAX - 6; } /*------------------------------------------------------------------------* * Loop for every subframe in the analysis frame * *------------------------------------------------------------------------* * To find the pitch and innovation parameters. The subframe size is * * L_SUBFR and the loop is repeated 2 times. * * - find the weighted LPC coefficients * * - find the LPC residual signal res[] * * - compute the target signal for pitch search * * - compute impulse response of weighted synthesis filter (h1[]) * * - find the closed-loop pitch parameters * * - encode the pitch delay * * - find target vector for codebook search * * - codebook search * * - VQ of pitch and codebook gains * * - update states of weighting filter * *------------------------------------------------------------------------*/ Aq = Aq_t; /* pointer to interpolated quantized LPC parameters */ Ap = Ap_t; /* pointer to weighted LPC coefficients */ for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { /*---------------------------------------------------------------* * Compute impulse response, h1[], of weighted synthesis filter * *---------------------------------------------------------------*/ h1[0] = 4096; Set_zero(&h1[1], L_SUBFR-1); Syn_filt(Ap, h1, h1, L_SUBFR, &h1[1], 0); /*----------------------------------------------------------------------* * Find the target vector for pitch search: * *----------------------------------------------------------------------*/ Syn_filt(Ap, &(state->exc[i_subfr]), xn, L_SUBFR, state->mem_w0, 0); /*---------------------------------------------------------------------* * Closed-loop fractional pitch search * *---------------------------------------------------------------------*/ T0 = Pitch_fr3_fast(&(state->exc[i_subfr]), xn, h1, L_SUBFR, T0_min, T0_max, i_subfr, &T0_frac); index = Enc_lag3(T0, T0_frac, &T0_min, &T0_max,PIT_MIN,PIT_MAX,i_subfr); *ana++ = index; if (i_subfr == 0) { *ana++ = Parity_Pitch(index); } /*-----------------------------------------------------------------* * - find filtered pitch exc * * - compute pitch gain and limit between 0 and 1.2 * * - update target vector for codebook search * *-----------------------------------------------------------------*/ Syn_filt(Ap, &(state->exc[i_subfr]), y1, L_SUBFR, state->mem_zero, 0); gain_pit = G_pitch(xn, y1, g_coeff, L_SUBFR); /* clip pitch gain if taming is necessary */ taming = test_err(state, T0, T0_frac); if( taming == 1){ if (gain_pit > GPCLIP) { gain_pit = GPCLIP; } } /* xn2[i] = xn[i] - y1[i] * gain_pit */ for (i = 0; i < L_SUBFR; i++) { //L_temp = L_mult(y1[i], gain_pit); //L_temp = L_shl(L_temp, 1); /* gain_pit in Q14 */ L_temp = ((Word32)y1[i] * gain_pit) << 2; xn2[i] = sub(xn[i], extract_h(L_temp)); } /*-----------------------------------------------------* * - Innovative codebook search. * *-----------------------------------------------------*/ index = ACELP_Code_A(xn2, h1, T0, state->sharp, code, y2, &i); *ana++ = index; /* Positions index */ *ana++ = i; /* Signs index */ /*-----------------------------------------------------* * - Quantization of gains. * *-----------------------------------------------------*/ g_coeff_cs[0] = g_coeff[0]; /* <y1,y1> */ exp_g_coeff_cs[0] = negate(g_coeff[1]); /* Q-Format:XXX -> JPN */ g_coeff_cs[1] = negate(g_coeff[2]); /* (xn,y1) -> -2<xn,y1> */ exp_g_coeff_cs[1] = negate(add(g_coeff[3], 1)); /* Q-Format:XXX -> JPN */ Corr_xy2( xn, y1, y2, g_coeff_cs, exp_g_coeff_cs ); /* Q0 Q0 Q12 ^Qx ^Q0 */ /* g_coeff_cs[3]:exp_g_coeff_cs[3] = <y2,y2> */ /* g_coeff_cs[4]:exp_g_coeff_cs[4] = -2<xn,y2> */ /* g_coeff_cs[5]:exp_g_coeff_cs[5] = 2<y1,y2> */ *ana++ = Qua_gain(code, g_coeff_cs, exp_g_coeff_cs, L_SUBFR, &gain_pit, &gain_code, taming); /*------------------------------------------------------------* * - Update pitch sharpening "sharp" with quantized gain_pit * *------------------------------------------------------------*/ state->sharp = gain_pit; if (state->sharp > SHARPMAX) { state->sharp = SHARPMAX; } else if (state->sharp < SHARPMIN) { state->sharp = SHARPMIN; } /*------------------------------------------------------* * - Find the total excitation * * - update filters memories for finding the target * * vector in the next subframe * *------------------------------------------------------*/ for (i = 0; i < L_SUBFR; i++) { /* exc[i] = gain_pit*exc[i] + gain_code*code[i]; */ /* exc[i] in Q0 gain_pit in Q14 */ /* code[i] in Q13 gain_cod in Q1 */ //L_temp = L_mult(exc[i+i_subfr], gain_pit); //L_temp = L_mac(L_temp, code[i], gain_code); //L_temp = L_shl(L_temp, 1); L_temp = (Word32)(state->exc[i+i_subfr]) * (Word32)gain_pit + (Word32)code[i] * (Word32)gain_code; L_temp <<= 2; state->exc[i+i_subfr] = g_round(L_temp); } update_exc_err(state, gain_pit, T0); for (i = L_SUBFR-M, j = 0; i < L_SUBFR; i++, j++) { temp = ((Word32)y1[i] * (Word32)gain_pit) >> 14; k = ((Word32)y2[i] * (Word32)gain_code) >> 13; state->mem_w0[j] = sub(xn[i], add(temp, k)); } Aq += MP1; /* interpolated LPC parameters for next subframe */ Ap += MP1; } /*--------------------------------------------------* * Update signal for next frame. * * -> shift to the left by L_FRAME: * * speech[], wsp[] and exc[] * *--------------------------------------------------*/ Copy(&(state->old_speech[L_FRAME]), &(state->old_speech[0]), L_TOTAL-L_FRAME); Copy(&(state->old_wsp[L_FRAME]), &(state->old_wsp[0]), PIT_MAX); Copy(&(state->old_exc[L_FRAME]), &(state->old_exc[0]), PIT_MAX+L_INTERPOL); }
void P12218319_CALL Rename(const std::string& aOldPath, const std::string& aNewPath) { Copy(aOldPath, aNewPath); DeleteFile(aOldPath); }
RefPtr<Type> Type::MakeSharedConst() { RefPtr<Type> type = Copy(); type->Mod = (MOD) (MODconst | MODshared); return type; }
RefPtr<Type> Type::MakeInvariant() { RefPtr<Type> type = Copy(); type->Mod = MODinvariant; return type; }
void CLightmapManager::CreateSpecial (tRgbColorb *texColorP, ushort nLightmap, ubyte nColor) { memset (texColorP, nColor, LM_W * LM_H * sizeof (tRgbColorb)); Copy (texColorP, nLightmap); }
RefPtr<Type> Type::MakeMutable() { RefPtr<Type> type = Copy(); type->Mod = (MOD) (Mod & MODshared); return type; }
static void Rule13Alloc(This *t) { static creal w[][nrules] = { { .00844923090033615, .3213775489050763, .3372900883288987, -.8264123822525677, .6539094339575232 }, { .023771474018994404, -.1767341636743844, -.1644903060344491, .306583861409436, -.2041614154424632}, { .02940016170142405, .07347600537466073, .07707849911634623, .002389292538329435, -.174698151579499 }, { .006644436465817374, -.03638022004364754, -.03804478358506311, -.1343024157997222, .03937939671417803 }, { .0042536044255016, .021252979220987123, .02223559940380806, .08833366840533902, .006974520545933992 }, { 0, .1460984204026913, .1480693879765931, 0, 0 }, { .0040664827465935255, .017476132861520992, 4.467143702185815e-6, .0009786283074168292, .0066677021717782585 }, { .03362231646315497, .1444954045641582, .150894476707413, -.1319227889147519, .05512960621544304 }, { .033200804136503725, .0001307687976001325, 3.6472001075162155e-5, .00799001220015063, .05443846381278608 }, { .014093686924979677, .0005380992313941161, .000577719899901388, .0033917470797606257, .02310903863953934 }, { .000977069770327625, .0001042259576889814, .0001041757313688177, .0022949157182832643, .01506937747477189 }, { .007531996943580376, -.001401152865045733, -.001452822267047819, -.01358584986119197, -.060570216489018905 }, { .02577183086722915, .008041788181514763, .008338339968783704, .04025866859057809, .04225737654686337}, { .015625, -.1420416552759383, -.147279632923196, .003760268580063992, .02561989142123099 } }; static creal g[] = { .12585646717265545, .3506966822267133, .4795480315809981, .4978005239276064, .25, .07972723291487795, .1904495567970094, .3291384627633596, .43807365825146577, .499121592026599, .4895111329084231, .32461421628226944, .43637106005656195, .1791307322940614, .2833333333333333, .1038888888888889 }; enum { nsets = 14, ndim = 2 }; count n, r; Set *first, *last, *s, *x; csize_t setsize = SetSize; Die(first = calloc(nsets, setsize)); last = first; n = last->n = 1; Copy(last->weight, w[0], nrules); NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[1], nrules); last->gen[0] = g[0]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[2], nrules); last->gen[0] = g[1]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[3], nrules); last->gen[0] = g[2]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[4], nrules); last->gen[0] = g[3]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[5], nrules); last->gen[0] = g[4]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[6], nrules); last->gen[0] = g[5]; last->gen[1] = g[5]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[7], nrules); last->gen[0] = g[6]; last->gen[1] = g[6]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[8], nrules); last->gen[0] = g[7]; last->gen[1] = g[7]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[9], nrules); last->gen[0] = g[8]; last->gen[1] = g[8]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[10], nrules); last->gen[0] = g[9]; last->gen[1] = g[9]; NextSet(last); n += last->n = 4*ndim*(ndim - 1); Copy(last->weight, w[11], nrules); last->gen[0] = g[10]; last->gen[1] = g[11]; NextSet(last); n += last->n = 4*ndim*(ndim - 1); Copy(last->weight, w[12], nrules); last->gen[0] = g[12]; last->gen[1] = g[13]; NextSet(last); n += last->n = 4*ndim*(ndim - 1); Copy(last->weight, w[13], nrules); last->gen[0] = g[14]; last->gen[1] = g[15]; t->rule.first = first; t->rule.last = last; t->rule.errcoeff[0] = 10; t->rule.errcoeff[1] = 1; t->rule.errcoeff[2] = 5; t->rule.n = n; for( s = first; s <= last; NextSet(s) ) for( r = 1; r < nrules - 1; ++r ) { creal scale = (s->weight[r] == 0) ? 100 : -s->weight[r + 1]/s->weight[r]; real sum = 0; for( x = first; x <= last; NextSet(x) ) sum += x->n*fabs(x->weight[r + 1] + scale*x->weight[r]); s->scale[r] = scale; s->norm[r] = 1/sum; } }
static void Rule11Alloc(This *t) { static creal w[][nrules] = { { .0009903847688882167, 1.715006248224684, 1.936014978949526, .517082819560576, 2.05440450381852 }, { .0084964717409851, -.3755893815889209, -.3673449403754268, .01445269144914044, .013777599884901202 }, { .00013587331735072814, .1488632145140549, .02929778657898176, -.3601489663995932, -.576806291790441 }, { .022982920777660364, -.2497046640620823, -.1151883520260315, .3628307003418485, .03726835047700328 }, { .004202649722286289, .1792501419135204, .05086658220872218, .007148802650872729, .0068148789397772195 }, { .0012671889041675774, .0034461267589738897, .04453911087786469, -.09222852896022966, .057231697338518496 }, { .0002109560854981544, -.005140483185555825, -.022878282571259, .01719339732471725, -.044930187438112855 }, { .016830857056410086, .006536017839876424, .02908926216345833, -.102141653746035, .027292365738663484 }, { .00021876823557504823, -.00065134549392297, -.002898884350669207, -.007504397861080493, .000354747395055699 }, { .009690420479796819, -.006304672433547204, -.028059634133074954, .01648362537726711, .01571366799739551 }, { .030773311284628138, .01266959399788263, .05638741361145884, .05234610158469334, .049900992192785674 }, { .0084974310856038, -.005454241018647931, -.02427469611942451, .014454323316130661, .0137791555266677 }, { .0017749535291258914, .004826995274768427, .021483070341828822, .003019236275367777, .0028782064230998723 } }; static creal g[] = { .095, .25, .375, .4, .4975, .49936724991757, .38968518428362114, .49998494965443835, .3951318612385894, .22016983438253684, .4774686911397297, .2189239229503431, .4830546566815374, .2288552938881567 }; enum { nsets = 13, ndim = 3 }; count n, r; Set *first, *last, *s, *x; csize_t setsize = SetSize; Die(first = calloc(nsets, setsize)); last = first; n = last->n = 1; Copy(last->weight, w[0], nrules); NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[1], nrules); last->gen[0] = g[0]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[2], nrules); last->gen[0] = g[1]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[3], nrules); last->gen[0] = g[2]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[4], nrules); last->gen[0] = g[3]; NextSet(last); n += last->n = 2*ndim; Copy(last->weight, w[5], nrules); last->gen[0] = g[4]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[6], nrules); last->gen[0] = g[5]; last->gen[1] = g[5]; NextSet(last); n += last->n = 2*ndim*(ndim - 1); Copy(last->weight, w[7], nrules); last->gen[0] = g[6]; last->gen[1] = g[6]; NextSet(last); n += last->n = 4*ndim*(ndim - 1)*(ndim - 2)/3; Copy(last->weight, w[8], nrules); last->gen[0] = g[7]; last->gen[1] = g[7]; last->gen[2] = g[7]; NextSet(last); n += last->n = 4*ndim*(ndim - 1)*(ndim - 2)/3; Copy(last->weight, w[9], nrules); last->gen[0] = g[8]; last->gen[1] = g[8]; last->gen[2] = g[8]; NextSet(last); n += last->n = 4*ndim*(ndim - 1)*(ndim - 2)/3; Copy(last->weight, w[10], nrules); last->gen[0] = g[9]; last->gen[1] = g[9]; last->gen[2] = g[9]; NextSet(last); n += last->n = 4*ndim*(ndim - 1)*(ndim - 2); Copy(last->weight, w[11], nrules); last->gen[0] = g[10]; last->gen[1] = g[11]; last->gen[2] = g[11]; NextSet(last); n += last->n = 4*ndim*(ndim - 1)*(ndim - 2); Copy(last->weight, w[12], nrules); last->gen[0] = g[12]; last->gen[1] = g[12]; last->gen[2] = g[13]; t->rule.first = first; t->rule.last = last; t->rule.errcoeff[0] = 4; t->rule.errcoeff[1] = .5; t->rule.errcoeff[2] = 3; t->rule.n = n; for( s = first; s <= last; NextSet(s) ) for( r = 1; r < nrules - 1; ++r ) { creal scale = (s->weight[r] == 0) ? 100 : -s->weight[r + 1]/s->weight[r]; real sum = 0; for( x = first; x <= last; NextSet(x) ) sum += x->n*fabs(x->weight[r + 1] + scale*x->weight[r]); s->scale[r] = scale; s->norm[r] = 1/sum; } }
void wxTextCtrl::OnCopy( wxCommandEvent& WXUNUSED(rEvent) ) { Copy(); } // end of wxTextCtrl::OnCopy
void IWnd_stc::OnKeyEvent(wxKeyEvent& evt) { int kc = evt.GetRawKeyCode(); if(kc==wxSTC_KEY_TAB) { if(evt.ShiftDown()) { CmdKeyExecute (wxSTC_CMD_BACKTAB); } else { CmdKeyExecute (wxSTC_CMD_TAB); } return; } if(evt.ControlDown()) { switch(kc) { case 'C': { Copy(); } return; case 'X': { Cut(); } return; case 'V': { Paste(); } return; case 'A': { SelectAll(); } return; case 'Z': { Undo(); } return; case 'R': { Redo(); } return; case 'D': { this->Clear(); } return; //case 'F': // if(style.get(STYLE_CAN_FIND)) // { // WndManager::current().evtmgr["Find"].CmdExecuteEx(-1); // evt.Skip(); // return; // } // break; //case 'H': // if(style.get(STYLE_CAN_REPLACE)) // { // WndManager::current().evtmgr["Replace"].CmdExecuteEx(-1); // evt.Skip(); // return; // } // break; }; } evt.Skip(); }
//------------------------------------------------------------------------------ //! Summary: Overloaded assignment operator //! //! Parameters: \li rSource - the object being assigned //! //! Returns: this object //------------------------------------------------------------------------------ const CMLStartFederationResponse& CMLStartFederationResponse::operator = (const CMLStartFederationResponse& rSource) { Copy(rSource); return *this; }
//------------------------------------------------------------------------------ //! Summary: Copy constructor //! //! Parameters: \li rSource - the object to be copied //! //! Returns: None //------------------------------------------------------------------------------ CMLStartFederationResponse::CMLStartFederationResponse(const CMLStartFederationResponse& rSource) { Copy(rSource); }
/* ============= idWinding2D::Split ============= */ int idWinding2D::Split( const idVec3 &plane, const float epsilon, idWinding2D **front, idWinding2D **back ) const { float dists[MAX_POINTS_ON_WINDING_2D]; byte sides[MAX_POINTS_ON_WINDING_2D]; int counts[3]; float dot; int i, j; const idVec2 * p1, *p2; idVec2 mid; idWinding2D * f; idWinding2D * b; int maxpts; counts[0] = counts[1] = counts[2] = 0; // determine sides for each point for ( i = 0; i < numPoints; i++ ) { dists[i] = dot = plane.x * p[i].x + plane.y * p[i].y + plane.z; if ( dot > epsilon ) { sides[i] = SIDE_FRONT; } else if ( dot < -epsilon ) { sides[i] = SIDE_BACK; } else { sides[i] = SIDE_ON; } counts[sides[i]]++; } sides[i] = sides[0]; dists[i] = dists[0]; *front = *back = NULL; // if nothing at the front of the clipping plane if ( !counts[SIDE_FRONT] ) { *back = Copy(); return SIDE_BACK; } // if nothing at the back of the clipping plane if ( !counts[SIDE_BACK] ) { *front = Copy(); return SIDE_FRONT; } maxpts = numPoints+4; // cant use counts[0]+2 because of fp grouping errors *front = f = new idWinding2D; *back = b = new idWinding2D; for ( i = 0; i < numPoints; i++ ) { p1 = &p[i]; if ( sides[i] == SIDE_ON ) { f->p[f->numPoints] = *p1; f->numPoints++; b->p[b->numPoints] = *p1; b->numPoints++; continue; } if ( sides[i] == SIDE_FRONT ) { f->p[f->numPoints] = *p1; f->numPoints++; } if ( sides[i] == SIDE_BACK ) { b->p[b->numPoints] = *p1; b->numPoints++; } if ( sides[i+1] == SIDE_ON || sides[i+1] == sides[i] ) { continue; } // generate a split point p2 = &p[(i+1)%numPoints]; // always calculate the split going from the same side // or minor epsilon issues can happen if ( sides[i] == SIDE_FRONT ) { dot = dists[i] / ( dists[i] - dists[i+1] ); for ( j = 0; j < 2; j++ ) { // avoid round off error when possible if ( plane[j] == 1.0f ) { mid[j] = plane.z; } else if ( plane[j] == -1.0f ) { mid[j] = -plane.z; } else { mid[j] = (*p1)[j] + dot * ((*p2)[j] - (*p1)[j]); } } } else { dot = dists[i+1] / ( dists[i+1] - dists[i] ); for ( j = 0; j < 2; j++ ) { // avoid round off error when possible if ( plane[j] == 1.0f ) { mid[j] = plane.z; } else if ( plane[j] == -1.0f ) { mid[j] = -plane.z; } else { mid[j] = (*p2)[j] + dot * ( (*p1)[j] - (*p2)[j] ); } } } f->p[f->numPoints] = mid; f->numPoints++; b->p[b->numPoints] = mid; b->numPoints++; } return SIDE_CROSS; }
cDMatrix::cDMatrix(const cDMatrix& theMatrix) { Initialize(theMatrix.mvNRow, theMatrix.mvNCol) ; Copy(theMatrix.mvV) ; }
// operators void wxTextAttr::operator= (const wxTextAttr& attr) { Copy(attr); }
cDMatrix::cDMatrix(uint theNRow, uint theNCol, const double* theFlatMat) { Initialize(theNRow, theNCol) ; Copy(theFlatMat) ; }
// Add a local-bridge void AddLocalBridge(CEDAR *c, char *hubname, char *devicename, bool local, bool monitor, bool tapmode, char *tapaddr, bool limit_broadcast) { UINT i; HUB *h = NULL; LOCALBRIDGE *br = NULL; // Validate arguments if (c == NULL || hubname == NULL || devicename == NULL) { return; } if (OS_IS_UNIX(GetOsInfo()->OsType) == false) { tapmode = false; } LockList(c->HubList); { LockList(c->LocalBridgeList); { bool exists = false; // Ensure that the same configuration local-bridge doesn't exist already for (i = 0; i < LIST_NUM(c->LocalBridgeList); i++) { LOCALBRIDGE *br = LIST_DATA(c->LocalBridgeList, i); if (StrCmpi(br->DeviceName, devicename) == 0) { if (StrCmpi(br->HubName, hubname) == 0) { if (br->TapMode == tapmode) { exists = true; } } } } if (exists == false) { // Add configuration br = ZeroMalloc(sizeof(LOCALBRIDGE)); StrCpy(br->HubName, sizeof(br->HubName), hubname); StrCpy(br->DeviceName, sizeof(br->DeviceName), devicename); br->Bridge = NULL; br->Local = local; br->TapMode = tapmode; br->LimitBroadcast = limit_broadcast; br->Monitor = monitor; if (br->TapMode) { if (tapaddr != NULL && IsZero(tapaddr, 6) == false) { Copy(br->TapMacAddress, tapaddr, 6); } else { GenMacAddress(br->TapMacAddress); } } Add(c->LocalBridgeList, br); // Find the hub for (i = 0; i < LIST_NUM(c->HubList); i++) { HUB *hub = LIST_DATA(c->HubList, i); if (StrCmpi(hub->Name, br->HubName) == 0) { h = hub; AddRef(h->ref); break; } } } } UnlockList(c->LocalBridgeList); } UnlockList(c->HubList); // Start the local-bridge immediately if (h != NULL && br != NULL && h->Type != HUB_TYPE_FARM_DYNAMIC) { Lock(h->lock_online); { if (h->Offline == false) { LockList(c->LocalBridgeList); { if (IsInList(c->LocalBridgeList, br)) { if (br->Bridge == NULL) { br->Bridge = BrNewBridge(h, br->DeviceName, NULL, br->Local, br->Monitor, br->TapMode, br->TapMacAddress, br->LimitBroadcast, br); } } } UnlockList(c->LocalBridgeList); } } Unlock(h->lock_online); } ReleaseHub(h); }
void CLightmapManager::BuildAll (int nFace) { CSide* sideP; int nLastFace; int i; float h; int nBlackLightmaps = 0, nWhiteLightmaps = 0; gameStates.render.nState = 0; h = 1.0f / float (LM_W - 1); for (i = 0; i < LM_W; i++) m_data.nOffset [i] = F2X (i * h); InitVertColorData (m_data.vcd); m_data.vcd.vertPosP = &m_data.vcd.vertPos; m_data.vcd.fMatShininess = 4; #if 0 if (gameStates.app.bMultiThreaded) nLastFace = nFace ? gameData.segs.nFaces : gameData.segs.nFaces / 2; else #endif INIT_PROGRESS_LOOP (nFace, nLastFace, gameData.segs.nFaces); if (nFace <= 0) { CreateSpecial (m_data.texColor, 0, 0); CreateSpecial (m_data.texColor, 1, 255); m_list.nLightmaps = 2; } //Next Go through each surface and create a lightmap for it. for (m_data.faceP = FACES.faces + nFace; nFace < nLastFace; nFace++, m_data.faceP++) { #if DBG if ((m_data.faceP->nSegment == nDbgSeg) && ((nDbgSide < 0) || (m_data.faceP->nSide == nDbgSide))) nDbgSeg = nDbgSeg; #endif if (SEGMENTS [m_data.faceP->nSegment].m_nType == SEGMENT_IS_SKYBOX) continue; sideP = SEGMENTS [m_data.faceP->nSegment].m_sides + m_data.faceP->nSide; memcpy (m_data.sideVerts, m_data.faceP->index, sizeof (m_data.sideVerts)); m_data.nType = (sideP->m_nType == SIDE_IS_QUAD) || (sideP->m_nType == SIDE_IS_TRI_02); m_data.vNormal = CFixVector::Avg (sideP->m_normals [0], sideP->m_normals [1]); CFixVector::Normalize (m_data.vNormal); m_data.vcd.vertNorm.Assign (m_data.vNormal); CFloatVector3::Normalize (m_data.vcd.vertNorm); m_data.nColor = 0; memset (m_data.texColor, 0, LM_W * LM_H * sizeof (tRgbColorb)); if (!RunRenderThreads (rtLightmap)) Build (-1); #if DBG if ((m_data.faceP->nSegment == nDbgSeg) && ((nDbgSide < 0) || (m_data.faceP->nSide == nDbgSide))) nDbgSeg = nDbgSeg; #endif if (m_data.nColor == 1) { m_data.faceP->nLightmap = 0; nBlackLightmaps++; } else if (m_data.nColor == 2) { m_data.faceP->nLightmap = 1; nWhiteLightmaps++; } else { Copy (m_data.texColor, m_list.nLightmaps); m_data.faceP->nLightmap = m_list.nLightmaps++; } } }
// Create new local-bridge BRIDGE *BrNewBridge(HUB *h, char *name, POLICY *p, bool local, bool monitor, bool tapmode, char *tapaddr, bool limit_broadcast, LOCALBRIDGE *parent_local_bridge) { BRIDGE *b; POLICY *policy; THREAD *t; // Validate arguments if (h == NULL || name == NULL || parent_local_bridge == NULL) { return NULL; } if (p == NULL) { policy = ClonePolicy(GetDefaultPolicy()); } else { policy = ClonePolicy(p); } b = ZeroMalloc(sizeof(BRIDGE)); b->Cedar = h->Cedar; b->Hub = h; StrCpy(b->Name, sizeof(b->Name), name); b->Policy = policy; b->Local = local; b->Monitor = monitor; b->TapMode = tapmode; b->LimitBroadcast = limit_broadcast; b->ParentLocalBridge = parent_local_bridge; if (b->TapMode) { if (tapaddr != NULL && IsZero(tapaddr, 6) == false) { Copy(b->TapMacAddress, tapaddr, 6); } else { GenMacAddress(b->TapMacAddress); } } if (monitor) { // Enabling monitoring mode policy->MonitorPort = true; } if (b->LimitBroadcast == false) { // Disable broadcast limiter policy->NoBroadcastLimiter = true; } // Start thread t = NewThread(BrBridgeThread, b); WaitThreadInit(t); ReleaseThread(t); return b; }
RefPtr<Type> Type::MakeConst() { RefPtr<Type> type = Copy(); type->Mod = MODconst; return type; }
// Create a Link LINK *NewLink(CEDAR *cedar, HUB *hub, CLIENT_OPTION *option, CLIENT_AUTH *auth, POLICY *policy) { CLIENT_OPTION *o; LINK *k; CLIENT_AUTH *a; // Validate arguments if (cedar == NULL || hub == NULL || option == NULL || auth == NULL || policy == NULL) { return NULL; } if (hub->Halt) { return NULL; } if (LIST_NUM(hub->LinkList) >= MAX_HUB_LINKS) { return NULL; } if (UniIsEmptyStr(option->AccountName)) { return NULL; } // Limitation of authentication method if (auth->AuthType != CLIENT_AUTHTYPE_ANONYMOUS && auth->AuthType != CLIENT_AUTHTYPE_PASSWORD && auth->AuthType != CLIENT_AUTHTYPE_PLAIN_PASSWORD && auth->AuthType != CLIENT_AUTHTYPE_CERT) { // Authentication method other than anonymous authentication, password authentication, plain password, certificate authentication cannot be used return NULL; } // Copy of the client options (for modification) o = ZeroMalloc(sizeof(CLIENT_OPTION)); Copy(o, option, sizeof(CLIENT_OPTION)); StrCpy(o->DeviceName, sizeof(o->DeviceName), LINK_DEVICE_NAME); o->RequireBridgeRoutingMode = true; // Request the bridge mode o->RequireMonitorMode = false; // Not to require the monitor mode o->NumRetry = INFINITE; // Retry the connection infinitely o->RetryInterval = 10; // Retry interval is 10 seconds o->NoRoutingTracking = true; // Stop the routing tracking // Copy the authentication data a = CopyClientAuth(auth); a->SecureSignProc = NULL; a->CheckCertProc = NULL; // Link object k = ZeroMalloc(sizeof(LINK)); k->lock = NewLock(); k->ref = NewRef(); k->Cedar = cedar; k->Option = o; k->Auth = a; k->Hub = hub; // Copy the policy k->Policy = ZeroMalloc(sizeof(POLICY)); Copy(k->Policy, policy, sizeof(POLICY)); // Normalize the policy NormalizeLinkPolicy(k->Policy); // Register in the link list of the HUB LockList(hub->LinkList); { Add(hub->LinkList, k); AddRef(k->ref); } UnlockList(hub->LinkList); return k; }
RefPtr<Type> Type::MakeShared() { RefPtr<Type> type = Copy(); type->Mod = MODshared; return type; }
MAIN_START(argc, argv) { char *pszDriver = nullptr; GDALDriverH hDriver = nullptr; /* Check that we are running against at least GDAL 1.5 */ /* Note to developers : if we use newer API, please change the requirement */ if (atoi(GDALVersionInfo("VERSION_NUM")) < 1500) { fprintf(stderr, "At least, GDAL >= 1.5.0 is required for this version of %s, " "which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME); exit(1); } GDALAllRegister(); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); if( argc < 3 ) Usage(); if( EQUAL(argv[1], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); return 0; } /* -------------------------------------------------------------------- */ /* Do we have a driver specifier? */ /* -------------------------------------------------------------------- */ char **papszRemainingArgv = argv + 2; int nRemainingArgc = argc - 2; if( EQUAL(papszRemainingArgv[0],"-f") && nRemainingArgc > 1 ) { pszDriver = papszRemainingArgv[1]; papszRemainingArgv += 2; nRemainingArgc -= 2; } if( pszDriver != nullptr ) { hDriver = GDALGetDriverByName( pszDriver ); if( hDriver == nullptr ) { fprintf( stderr, "Unable to find driver named '%s'.\n", pszDriver ); exit( 1 ); } } /* -------------------------------------------------------------------- */ /* Split out based on operation. */ /* -------------------------------------------------------------------- */ if( STARTS_WITH_CI(argv[1],"ident" /* identify" */ ) ) Identify( nRemainingArgc, papszRemainingArgv ); else if( EQUAL(argv[1],"copy") ) Copy( hDriver, nRemainingArgc, papszRemainingArgv, "copy" ); else if( EQUAL(argv[1],"rename") ) Copy( hDriver, nRemainingArgc, papszRemainingArgv, "rename" ); else if( EQUAL(argv[1],"delete") ) Delete( hDriver, nRemainingArgc, papszRemainingArgv ); else Usage(); /* -------------------------------------------------------------------- */ /* Cleanup */ /* -------------------------------------------------------------------- */ CSLDestroy( argv ); GDALDestroyDriverManager(); exit( 0 ); }
void TextControl::OnCommandCopy(wxCommandEvent& WXUNUSED(event)) { Copy(); }
CVarDefMap & CVarDefMap::operator = ( const CVarDefMap & array ) { Copy( &array ); return( *this ); }
// Create a tap device int UnixCreateTapDeviceEx(char *name, char *prefix, UCHAR *mac_address) { int fd; struct ifreq ifr; char eth_name[MAX_SIZE]; char instance_name_lower[MAX_SIZE]; struct sockaddr sa; char *tap_name = TAP_FILENAME_1; int s; #ifdef UNIX_MACOS char tap_macos_name[256] = TAP_MACOS_DIR TAP_MACOS_FILENAME; #endif // Validate arguments if (name == NULL) { return -1; } // Generate the device name StrCpy(instance_name_lower, sizeof(instance_name_lower), name); Trim(instance_name_lower); StrLower(instance_name_lower); Format(eth_name, sizeof(eth_name), "%s_%s", prefix, instance_name_lower); eth_name[15] = 0; // Open the tun / tap #ifndef UNIX_MACOS if (GetOsInfo()->OsType == OSTYPE_LINUX) { // Linux if (IsFile(TAP_FILENAME_1) == false) { char tmp[MAX_SIZE]; Format(tmp, sizeof(tmp), "%s c 10 200", TAP_FILENAME_1); Run("mknod", tmp, true, true); Format(tmp, sizeof(tmp), "600 %s", TAP_FILENAME_1); Run("chmod", tmp, true, true); } } // Other than MacOS X fd = open(TAP_FILENAME_1, O_RDWR); if (fd == -1) { // Failure fd = open(TAP_FILENAME_2, O_RDWR); if (fd == -1) { return -1; } tap_name = TAP_FILENAME_2; } #else // UNIX_MACOS { int i; fd = -1; for (i = 0; i < TAP_MACOS_NUMBER; i++) { sprintf(tap_macos_name + strlen(TAP_MACOS_DIR TAP_MACOS_FILENAME), "%d", i); fd = open(tap_macos_name, O_RDWR); if (fd != -1) { tap_name = tap_macos_name; break; } } if (fd == -1) { return -1; } } #endif // UNIX_MACOS #ifdef UNIX_LINUX // Create a tap for Linux // Set the device name Zero(&ifr, sizeof(ifr)); ifr.ifr_flags = IFF_TAP | IFF_NO_PI; StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); if (ioctl(fd, TUNSETIFF, &ifr) == -1) { // Failure close(fd); return -1; } // MAC address setting s = socket(AF_INET, SOCK_DGRAM, 0); if (s != -1) { if (mac_address != NULL) { Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER; Copy(&ifr.ifr_addr.sa_data, mac_address, 6); ioctl(s, SIOCSIFHWADDR, &ifr); } Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), eth_name); ioctl(s, SIOCGIFFLAGS, &ifr); ifr.ifr_flags |= IFF_UP; ioctl(s, SIOCSIFFLAGS, &ifr); close(s); } #else // UNIX_LINUX #ifdef UNIX_MACOS // MAC address setting s = socket(AF_INET, SOCK_DGRAM, 0); if (s != -1) { char *macos_eth_name; macos_eth_name = tap_macos_name + strlen(TAP_MACOS_DIR); if (mac_address != NULL) { Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), macos_eth_name); ifr.ifr_addr.sa_len = ETHER_ADDR_LEN; ifr.ifr_addr.sa_family = AF_LINK; Copy(&ifr.ifr_addr.sa_data, mac_address, ETHER_ADDR_LEN); ioctl(s, SIOCSIFLLADDR, &ifr); } Zero(&ifr, sizeof(ifr)); StrCpy(ifr.ifr_name, sizeof(ifr.ifr_name), macos_eth_name); ioctl(s, SIOCGIFFLAGS, &ifr); ifr.ifr_flags |= IFF_UP; ioctl(s, SIOCSIFFLAGS, &ifr); close(s); } #endif // UNIX_MACOS #ifdef UNIX_SOLARIS // Create a tap for Solaris { int ip_fd; int tun_fd; int ppa; tun_fd = open(tap_name, O_RDWR); if (tun_fd == -1) { // Failure close(fd); return -1; } ip_fd = open("/dev/ip", O_RDWR); if (ip_fd == -1) { // Failure close(tun_fd); close(fd); return -1; } ppa = -1; ppa = ioctl(tun_fd, TUNNEWPPA, ppa); if (ppa == -1) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(fd, I_PUSH, "ip") < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(fd, IF_UNITSEL, (char *)&ppa) < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } if (ioctl(ip_fd, I_LINK, fd) < 0) { // Failure close(tun_fd); close(fd); close(ip_fd); return -1; } close(tun_fd); close(ip_fd); } #endif // UNIX_SOLARIS #endif // UNIX_LINUX return fd; }
void WebRtcG729fix_Decod_ld8a( Decod_ld8a_state *st, int16_t parm[], /* (i) : vector of synthesis parameters parm[0] = bad frame indicator (bfi) */ int16_t synth[], /* (o) : synthesis speech */ int16_t A_t[], /* (o) : decoded LP filter in 2 subframes */ int16_t *T2, /* (o) : decoded pitch lag in 2 subframes */ int16_t *Vad, /* (o) : frame type */ int16_t bad_lsf /* (i) : bad LSF indicator */ ) { int16_t *Az; /* Pointer on A_t */ int16_t lsp_new[M]; /* LSPs */ int16_t code[L_SUBFR]; /* ACELP codevector */ /* Scalars */ int16_t i, j, i_subfr; int16_t T0, T0_frac, index; int16_t bfi; int32_t L_temp; int16_t bad_pitch; /* bad pitch indicator */ /* for G.729B */ int16_t ftyp; int16_t lsfq_mem[MA_NP][M]; int Overflow; /* Test bad frame indicator (bfi) */ bfi = *parm++; /* for G.729B */ ftyp = *parm; if(bfi == 1) { if(st->past_ftyp == 1) { ftyp = 1; parm[4] = 1; /* G.729 maintenance */ } else ftyp = 0; *parm = ftyp; /* modification introduced in version V1.3 */ } *Vad = ftyp; /* Processing non active frames (SID & not transmitted) */ if(ftyp != 1) { WebRtcG729fix_Get_decfreq_prev(st, lsfq_mem); WebRtcG729fix_Dec_cng(st, st->past_ftyp, st->sid_sav, st->sh_sid_sav, parm, st->exc, st->lsp_old, A_t, &st->seed, lsfq_mem); WebRtcG729fix_Update_decfreq_prev(st, lsfq_mem); Az = A_t; for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { Overflow = WebRtcG729fix_Syn_filt(Az, &st->exc[i_subfr], &synth[i_subfr], L_SUBFR, st->mem_syn, 0); if(Overflow != 0) { /* In case of overflow in the synthesis */ /* -> Scale down vector exc[] and redo synthesis */ for (i = 0; i < PIT_MAX + L_INTERPOL + L_FRAME; i++) st->old_exc[i] = shr(st->old_exc[i], 2); WebRtcG729fix_Syn_filt(Az, &st->exc[i_subfr], &synth[i_subfr], L_SUBFR, st->mem_syn, 1); } else WEBRTC_SPL_MEMCPY_W16(st->mem_syn, &synth[i_subfr+L_SUBFR-M], M); Az += MP1; *T2++ = st->old_T0; } st->sharp = SHARPMIN; } /* Processing active frame */ else { st->seed = INIT_SEED; parm++; /* Decode the LSPs */ WebRtcG729fix_D_lsp(st, parm, lsp_new, WebRtcSpl_AddSatW16(bfi, bad_lsf)); parm += 2; /* Note: "bad_lsf" is introduce in case the standard is used with channel protection. */ /* Interpolation of LPC for the 2 subframes */ WebRtcG729fix_Int_qlpc(st->lsp_old, lsp_new, A_t); /* update the LSFs for the next frame */ WEBRTC_SPL_MEMCPY_W16(st->lsp_old, lsp_new, M); /*------------------------------------------------------------------------* * Loop for every subframe in the analysis frame * *------------------------------------------------------------------------* * The subframe size is L_SUBFR and the loop is repeated L_FRAME/L_SUBFR * * times * * - decode the pitch delay * * - decode algebraic code * * - decode pitch and codebook gains * * - find the excitation and compute synthesis speech * *------------------------------------------------------------------------*/ Az = A_t; /* pointer to interpolated LPC parameters */ for (i_subfr = 0; i_subfr < L_FRAME; i_subfr += L_SUBFR) { index = *parm++; /* pitch index */ if(i_subfr == 0) { i = *parm++; /* get parity check result */ bad_pitch = WebRtcSpl_AddSatW16(bfi, i); if( bad_pitch == 0) { WebRtcG729fix_Dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &T0, &T0_frac); st->old_T0 = T0; } else /* Bad frame, or parity error */ { T0 = st->old_T0; T0_frac = 0; st->old_T0 = WebRtcSpl_AddSatW16(st->old_T0, 1); if(st->old_T0 > PIT_MAX) { st->old_T0 = PIT_MAX; } } } else /* second subframe */ { if(bfi == 0) { WebRtcG729fix_Dec_lag3(index, PIT_MIN, PIT_MAX, i_subfr, &T0, &T0_frac); st->old_T0 = T0; } else { T0 = st->old_T0; T0_frac = 0; st->old_T0 = WebRtcSpl_AddSatW16(st->old_T0, 1); if (st->old_T0 > PIT_MAX) { st->old_T0 = PIT_MAX; } } } *T2++ = T0; /*-------------------------------------------------* * - Find the adaptive codebook vector. * *-------------------------------------------------*/ WebRtcG729fix_Pred_lt_3(&st->exc[i_subfr], T0, T0_frac, L_SUBFR); /*-------------------------------------------------------* * - Decode innovative codebook. * * - Add the fixed-gain pitch contribution to code[]. * *-------------------------------------------------------*/ if(bfi != 0) /* Bad frame */ { parm[0] = WebRtcG729fix_Random(&st->seed_fer) & (int16_t)0x1fff; /* 13 bits random */ parm[1] = WebRtcG729fix_Random(&st->seed_fer) & (int16_t)0x000f; /* 4 bits random */ } WebRtcG729fix_Decod_ACELP(parm[1], parm[0], code); parm +=2; j = shl(st->sharp, 1); /* From Q14 to Q15 */ if(T0 < L_SUBFR) { for (i = T0; i < L_SUBFR; i++) { code[i] = WebRtcSpl_AddSatW16(code[i], mult(code[i-T0], j)); } } /*-------------------------------------------------* * - Decode pitch and codebook gains. * *-------------------------------------------------*/ index = *parm++; /* index of energy VQ */ WebRtcG729fix_Dec_gain(st, index, code, L_SUBFR, bfi, &st->gain_pitch, &st->gain_code); /*-------------------------------------------------------------* * - Update pitch sharpening "sharp" with quantized gain_pitch * *-------------------------------------------------------------*/ st->sharp = st->gain_pitch; if (st->sharp > SHARPMAX) { st->sharp = SHARPMAX; } else if (st->sharp < SHARPMIN) { st->sharp = SHARPMIN; } /*-------------------------------------------------------* * - Find the total excitation. * * - Find synthesis speech corresponding to exc[]. * *-------------------------------------------------------*/ for (i = 0; i < L_SUBFR; i++) { /* exc[i] = gain_pitch*exc[i] + gain_code*code[i]; */ /* exc[i] in Q0 gain_pitch in Q14 */ /* code[i] in Q13 gain_codeode in Q1 */ L_temp = L_mult(st->exc[i+i_subfr], st->gain_pitch); L_temp = L_mac(L_temp, code[i], st->gain_code); L_temp = L_shl(L_temp, 1); st->exc[i+i_subfr] = L_round(L_temp); } Overflow = WebRtcG729fix_Syn_filt(Az, &st->exc[i_subfr], &synth[i_subfr], L_SUBFR, st->mem_syn, 0); if(Overflow != 0) { /* In case of overflow in the synthesis */ /* -> Scale down vector exc[] and redo synthesis */ for (i = 0; i < PIT_MAX + L_INTERPOL + L_FRAME; i++) st->old_exc[i] = shr(st->old_exc[i], 2); WebRtcG729fix_Syn_filt(Az, &st->exc[i_subfr], &synth[i_subfr], L_SUBFR, st->mem_syn, 1); } else WEBRTC_SPL_MEMCPY_W16(st->mem_syn, &synth[i_subfr+L_SUBFR-M], M); Az += MP1; /* interpolated LPC parameters for next subframe */ } } /*------------* * For G729b *-----------*/ if(bfi == 0) { L_temp = 0L; for (i = 0; i < L_FRAME; i++) { L_temp = L_mac(L_temp, st->exc[i], st->exc[i]); } /* may overflow => last level of SID quantizer */ st->sh_sid_sav = WebRtcSpl_NormW32(L_temp); st->sid_sav = L_round(L_shl(L_temp, st->sh_sid_sav)); st->sh_sid_sav = WebRtcSpl_SubSatW16(16, st->sh_sid_sav); } /*--------------------------------------------------* * Update signal for next frame. * * -> shift to the left by L_FRAME exc[] * *--------------------------------------------------*/ Copy(&st->old_exc[L_FRAME], &st->old_exc[0], PIT_MAX+L_INTERPOL); /* for G729b */ st->past_ftyp = ftyp; return; }
bool FormatHdd (const std::string &path) { bool f = false; auto hdd = HDD::OpenDisk(path); /* MEMORY mem(SECTOR_SIZE); // Disk to be made BDOS-bootable? if (opt.boot) { // Provide a default boot sector memcpy(mem, abAtomLiteBoot, sizeof(abAtomLiteBoot)); // Boot sector file supplied? if (*opt.boot) { MFILE file; if (!file.Open(opt.boot)) return Error("boot"); else if (msize(&file) != SECTOR_SIZE) { throw util::exception("boot sector must be exactly 512 bytes"); return false; } else mread(mem, mem.size, 1, &file); } } */ if (!hdd) Error("open"); else if (hdd->SafetyCheck() && hdd->Lock()) { BDOS_CAPS bdc; GetBDOSCaps(hdd->total_sectors, bdc); bdc.need_byteswap = !!opt.byteswap; // A quick format stops after the MGT boot sector in record 1 int64_t total_sectors = opt.quick ? bdc.base_sectors + MGT_DIR_TRACKS*MGT_SECTORS + 1 : hdd->total_sectors; // Format the boot sector and record list f = hdd->Copy(nullptr, bdc.base_sectors, 0, 0, total_sectors, "Formatting"); MEMORY mem(MGT_DISK_SIZE); if (!opt.nosig) memcpy(mem + 232, "BDOS", 4); // Format the record data area for (int64_t uPos = bdc.base_sectors; f; uPos += MGT_DISK_SECTORS, f &= !g_fAbort) { // Determine how much to transfer in one go if (uPos > total_sectors) uPos = total_sectors; auto block_size = std::min(static_cast<int>(total_sectors - uPos), MGT_DISK_SECTORS); Message(msgStatus, "Formatting... %u%%", static_cast<unsigned>(uPos * 100 / total_sectors)); if (!block_size) break; // Locate and write the record block if (!hdd->Seek(uPos) || !hdd->Write(mem, block_size, bdc.need_byteswap)) { // If this is a raw format, report the sector offset if (opt.nosig) Message(msgStatus, "Write error at sector %u: %s", uPos, LastError()); else { // Report the record containing the error Message(msgStatus, "Write error in record %u: %s", 1 + (uPos - bdc.base_sectors) / MGT_DISK_SECTORS, LastError()); // Attempt to clear the BDOS signature in the bad record, to prevent its use MEMORY memblank(hdd->sector_size); hdd->Seek(uPos); hdd->Write(memblank, 1); } } } /* if (opt.boot) { UpdateBDOSBootSector(mem, &hdd); if (!hdd->Seek(0) || !hdd->Write(mem, 1, bdc.fNeedSwap)) return Error("boot"); } */ hdd->Unlock(); } return f; }
// Write the certificate object bool WriteSecCert(SECURE *sec, bool private_obj, char *name, X *x) { UINT obj_class = CKO_CERTIFICATE; CK_BBOOL b_true = true, b_false = false, b_private_obj = private_obj; UINT cert_type = CKC_X_509; CK_DATE start_date, end_date; UCHAR subject[MAX_SIZE]; UCHAR issuer[MAX_SIZE]; wchar_t w_subject[MAX_SIZE]; wchar_t w_issuer[MAX_SIZE]; UCHAR serial_number[MAX_SIZE]; UCHAR value[4096]; UINT ret; BUF *b; UINT object; CK_ATTRIBUTE a[] = { {CKA_SUBJECT, subject, 0}, // 0 {CKA_ISSUER, issuer, 0}, // 1 {CKA_SERIAL_NUMBER, serial_number, 0}, // 2 {CKA_VALUE, value, 0}, // 3 {CKA_CLASS, &obj_class, sizeof(obj_class)}, {CKA_TOKEN, &b_true, sizeof(b_true)}, {CKA_PRIVATE, &b_private_obj, sizeof(b_private_obj)}, {CKA_LABEL, name, StrLen(name)}, {CKA_CERTIFICATE_TYPE, &cert_type, sizeof(cert_type)}, #if 0 // Don't use these because some tokens fail {CKA_START_DATE, &start_date, sizeof(start_date)}, {CKA_END_DATE, &end_date, sizeof(end_date)}, #endif }; // Validate arguments if (sec == NULL) { return false; } if (name == NULL) { sec->Error = SEC_ERROR_BAD_PARAMETER; return false; } if (sec->SessionCreated == false) { sec->Error = SEC_ERROR_NO_SESSION; return false; } if (sec->LoginFlag == false && private_obj) { sec->Error = SEC_ERROR_NOT_LOGIN; return false; } // Copy the certificate to the buffer b = XToBuf(x, false); if (b == NULL) { sec->Error = SEC_ERROR_INVALID_CERT; return false; } if (b->Size > sizeof(value)) { // Size is too large FreeBuf(b); sec->Error = SEC_ERROR_DATA_TOO_BIG; return false; } Copy(value, b->Buf, b->Size); A_SIZE(a, 3) = b->Size; FreeBuf(b); // Store the Subject and the Issuer by encoding into UTF-8 GetPrintNameFromName(w_subject, sizeof(w_subject), x->subject_name); UniToUtf8(subject, sizeof(subject), w_subject); A_SIZE(a, 0) = StrLen(subject); if (x->root_cert == false) { GetPrintNameFromName(w_issuer, sizeof(w_issuer), x->issuer_name); UniToUtf8(issuer, sizeof(issuer), w_issuer); A_SIZE(a, 1) = StrLen(issuer); } // Copy the serial number Copy(serial_number, x->serial->data, MIN(x->serial->size, sizeof(serial_number))); A_SIZE(a, 2) = MIN(x->serial->size, sizeof(serial_number)); // Expiration date information UINT64ToCkDate(&start_date, SystemToLocal64(x->notBefore)); UINT64ToCkDate(&end_date, SystemToLocal64(x->notAfter)); // Workaround for Gemalto PKCS#11 API. It rejects a private certificate. if(sec->Dev->Id == 18 || sec->Dev->Id == 19) { b_private_obj = false; } // Remove objects which have the same name if (CheckSecObject(sec, name, SEC_X)) { DeleteSecCert(sec, name); } // Creating if ((ret = sec->Api->C_CreateObject(sec->SessionId, a, sizeof(a) / sizeof(a[0]), &object)) != CKR_OK) { // Failure sec->Error = SEC_ERROR_HARDWARE_ERROR; Debug("Error: 0x%02x\n", ret); return false; } // Clear Cache EraseEnumSecObjectCache(sec); return true; }