| /external/google-tv-pairing-protocol/cpp/src/polo/pairing/ |
| polochallengeresponse.h | 27 typedef std::vector<uint8_t> Alpha, Gamma, Nonce;
43 // Computes the gamma value based on the given nonce.
44 virtual Gamma* GetGamma(const Nonce& nonce) const;
46 // Extracts the nonce from the given gamma value.
47 virtual Nonce* ExtractNonce(const Gamma& gamma) const;
49 // Verifies that the given gamma value is correct.
50 virtual bool CheckGamma(const Gamma& gamma) const;
|
| /external/google-tv-pairing-protocol/cpp/tests/polo/pairing/ |
| mocks.h | 29 MOCK_CONST_METHOD1(GetGamma, Gamma*(const Nonce& nonce));
30 MOCK_CONST_METHOD1(ExtractNonce, Nonce*(const Gamma& gamma));
31 MOCK_CONST_METHOD1(CheckGamma, bool(const Gamma& gammma));
39 MOCK_METHOD1(OnPerformOutputDeviceRole, void(const Gamma& gamma));
|
| pairingsessiontest.cc | 157 EXPECT_CALL(challenge_, GetGamma(_)).WillOnce(Return(new Gamma(10, 0x5)));
158 EXPECT_CALL(listener_, OnPerformOutputDeviceRole(Gamma(10, 0x5)));
202 Gamma gamma(5, 0x1);
206 EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true));
207 EXPECT_CALL(challenge_, ExtractNonce(gamma))
215 session_.SetSecret(gamma);
232 Gamma gamma(5, 0x1);
236 EXPECT_CALL(challenge_, CheckGamma(gamma)).WillOnce(Return(true))
[all...] |
| /frameworks/base/tests/HwAccelerationTest/src/com/android/test/hwui/ |
| TextGammaActivity.java | 40 final GammaTextView gamma = new GammaTextView(this); local
41 layout.addView(gamma, new LinearLayout.LayoutParams(
49 Bitmap b = Bitmap.createBitmap(gamma.getWidth(), gamma.getHeight(),
53 gamma.draw(c);
91 final GammaTextView gamma = new GammaTextView(this); local
96 layout.addView(gamma, lp);
|
| /external/google-tv-pairing-protocol/java/src/com/google/polo/pairing/ |
| PoloChallengeResponse.java | 141 * Returns the gamma value to be used in pairing, i.e. the concatenation
161 * Extracts and returns the nonce portion of a given gamma value.
163 public byte[] extractNonce(byte[] gamma) {
164 if ((gamma.length < 2) || (gamma.length % 2 != 0)) {
167 int nonceLength = gamma.length / 2;
169 System.arraycopy(gamma, nonceLength, nonce, 0, nonceLength);
174 * Returns {@code true} if the gamma value matches the locally computed value.
177 * gamma value.
181 public boolean checkGamma(byte[] gamma) throws PoloException
[all...] |
| PairingListener.java | 56 void onPerformOutputDeviceRole(PairingSession session, byte[] gamma)
|
| /external/skia/bench/ |
| ColorCodecBench.cpp | 72 SkColorSpaceTransferFn gamma; local
73 gamma.fA = 1.0f;
74 gamma.fB = gamma.fC = gamma.fD = gamma.fE = gamma.fF = 0.0f;
75 gamma.fG = 4.0f;
78 fDstSpace = SkColorSpace::MakeRGB(gamma, matrix);
|
| /external/apache-commons-math/src/main/java/org/apache/commons/math/optimization/direct/ |
| MultiDirectional.java | 40 private final double gamma; field in class:MultiDirectional
43 * <p>The default values are 2.0 for khi and 0.5 for gamma.</p>
47 this.gamma = 0.5;
52 * @param gamma contraction coefficient
54 public MultiDirectional(final double khi, final double gamma) {
56 this.gamma = gamma;
90 final RealPointValuePair contracted = evaluateNewSimplex(original, gamma, comparator);
|
| NelderMead.java | 42 private final double gamma; field in class:NelderMead
49 * for both gamma and sigma.</p>
54 this.gamma = 0.5;
61 * @param gamma contraction coefficient
65 final double gamma, final double sigma) {
68 this.gamma = gamma;
139 xC[j] = centroid[j] + gamma * (xR[j] - centroid[j]);
154 xC[j] = centroid[j] - gamma * (centroid[j] - xWorst[j]);
|
| /cts/apps/CameraITS/tests/scene1/ |
| test_auto_vs_manual.py | 79 gamma = sum([[i/63.0,math.pow(i/63.0,1/2.2)] for i in xrange(64)],[])
81 req["android.tonemap.curveRed"] = gamma
82 req["android.tonemap.curveGreen"] = gamma
83 req["android.tonemap.curveBlue"] = gamma
|
| /external/pdfium/core/fxcodec/codec/ |
| icodec_pngmodule.h | 26 double* gamma) = 0;
|
| ccodec_pngmodule.cpp | 123 double gamma = 1.0; local
138 &color_type, &gamma)) {
143 png_set_gamma(png_ptr, gamma, 0.45455);
147 png_set_gamma(png_ptr, gamma, image_gamma);
149 png_set_gamma(png_ptr, gamma, 0.45455);
|
| /external/skia/src/core/ |
| SkMaskGamma.h | 28 virtual SkScalar toLuma(SkScalar gamma, SkScalar luminance) const = 0;
30 virtual SkScalar fromLuma(SkScalar gamma, SkScalar luma) const = 0;
33 static U8CPU computeLuminance(SkScalar gamma, SkColor c) {
34 const SkColorSpaceLuminance& luminance = Fetch(gamma);
35 SkScalar r = luminance.toLuma(gamma, SkIntToScalar(SkColorGetR(c)) / 255);
36 SkScalar g = luminance.toLuma(gamma, SkIntToScalar(SkColorGetG(c)) / 255);
37 SkScalar b = luminance.toLuma(gamma, SkIntToScalar(SkColorGetB(c)) / 255);
42 return SkScalarRoundToInt(luminance.fromLuma(gamma, luma) * 255);
45 /** Retrieves the SkColorSpaceLuminance for the given gamma. */
46 static const SkColorSpaceLuminance& Fetch(SkScalar gamma);
[all...] |
| /external/ImageMagick/coders/ |
| hdr.c | 148 gamma;
308 if (LocaleCompare(keyword,"gamma") == 0)
310 image->gamma=StringToDouble(value,(char **) NULL);
491 gamma=pow(2.0,pixel[3]-(128.0+8.0));
492 SetPixelRed(image,ClampToQuantum(QuantumRange*gamma*pixel[0]),q);
493 SetPixelGreen(image,ClampToQuantum(QuantumRange*gamma*pixel[1]),q);
494 SetPixelBlue(image,ClampToQuantum(QuantumRange*gamma*pixel[2]),q);
731 if (image->gamma != 0.0)
733 count=FormatLocaleString(header,MagickPathExtent,"GAMMA=%g\n",
734 image->gamma);
144 gamma; local
769 gamma; local
[all...] |
| /external/skia/include/core/ |
| SkColorSpace.h | 68 * Colorspace with the sRGB primaries, but a linear (1.0) gamma. Commonly used for
96 static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, Gamut gamut);
97 static sk_sp<SkColorSpace> MakeRGB(RenderTargetGamma gamma, const SkMatrix44& toXYZD50);
108 * Returns true if the color space gamma is near enough to be approximated as sRGB.
115 * Returns true if the color space gamma is linear.
|
| /external/eigen/unsupported/Eigen/src/EulerAngles/ |
| EulerAngles.h | 31 * - then, rotate the axes system over the gamma axis(which was rotated in the two stages above) in angle gamma
137 /** \returns the axis vector of the third (gamma) rotation */
149 /** Constructs and initialize Euler angles(\p alpha, \p beta, \p gamma). */
150 EulerAngles(const Scalar& alpha, const Scalar& beta, const Scalar& gamma) :
151 m_angles(alpha, beta, gamma) {}
169 * \param positiveRangeGamma If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
199 * \param positiveRangeGamma If true, gamma will be in [0, 2*PI]. Otherwise, in [-PI, +PI].
211 /** \returns The angle values stored in a vector (alpha, beta, gamma). */
213 /** \returns A read-write reference to the angle values stored in a vector (alpha, beta, gamma). *
227 Scalar gamma() const { return m_angles[2]; } function in class:Eigen::EulerAngles
229 Scalar& gamma() { return m_angles[2]; } function in class:Eigen::EulerAngles
[all...] |
| /prebuilts/misc/windows/sdl2/test/ |
| testautomation_pixels.c | 404 const char *expectedError1 = "Parameter 'gamma' is invalid";
407 float gamma; local
419 /* Make call with different gamma values */
422 /* gamma = 0 all black */
424 gamma = 0.0f;
426 /* gamma = 1 identity */
428 gamma = 1.0f;
430 /* gamma = [0.2,0.8] normal range */
432 gamma = 0.2f + 0.8f * SDLTest_RandomUnitFloat();
434 /* gamma = >1.1 non-standard range *
[all...] |
| /cts/tests/tests/uirendering/src/android/uirendering/cts/bitmapcomparers/ |
| MSSIMComparer.java | 150 * The prime symbols dictate a gamma correction of 1.
153 final double gamma = 1; local
155 l += (0.21f * Math.pow(Color.red(pixel) / 255f, gamma));
156 l += (0.72f * Math.pow(Color.green(pixel) / 255f, gamma));
157 l += (0.07f * Math.pow(Color.blue(pixel) / 255f, gamma));
|
| /external/libpng/contrib/gregbook/ |
| readpng2.c | 222 double gamma; local
224 png_fixed_point gamma; local
335 * such images have a file gamma of 0.45455, which corresponds to a PC-like
341 * "gamma" value for the entire display system, i.e., the product of
345 if (png_get_gAMA(png_ptr, info_ptr, &gamma))
346 png_set_gamma(png_ptr, mainprog_ptr->display_exponent, gamma);
350 if (png_get_gAMA_fixed(png_ptr, info_ptr, &gamma))
352 (png_fixed_point)(100000*mainprog_ptr->display_exponent+.5), gamma);
|
| readpng.c | 210 double gamma; local
252 * this file may have come from--so if it doesn't have a file gamma, don't
255 if (png_get_gAMA(png_ptr, info_ptr, &gamma))
256 png_set_gamma(png_ptr, display_exponent, gamma);
|
| /external/webrtc/webrtc/modules/remote_bitrate_estimator/test/estimators/ |
| nada.cc | 248 float gamma = local
252 bitrate_kbps_ = static_cast<int>((1.0f + gamma) * fb.receiving_rate() + 0.5f);
257 float gamma = 3.0f * kMaxCongestionSignalMs / local
259 gamma = std::min(gamma, kGamma0);
260 bitrate_kbps_ = gamma * fb.receiving_rate() + 0.5f;
|
| /frameworks/native/libs/ui/ |
| ColorSpace.cpp | 71 static ColorSpace::transfer_function toOETF(float gamma) {
72 if (gamma == 1.0f) {
75 return std::bind(safePow, _1, 1.0f / gamma);
78 static ColorSpace::transfer_function toEOTF(float gamma) {
79 if (gamma == 1.0f) {
82 return std::bind(safePow, _1, gamma);
135 float gamma,
140 , mParameters({gamma, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f})
141 , mOETF(toOETF(gamma))
142 , mEOTF(toEOTF(gamma))
[all...] |
| /external/pdfium/third_party/libtiff/ |
| tif_color.c | 129 double gamma; local
136 gamma = 1.0 / cielab->display.d_gammaR ;
141 * ((float)pow((double)i / cielab->range, gamma));
145 gamma = 1.0 / cielab->display.d_gammaG ;
150 * ((float)pow((double)i / cielab->range, gamma));
154 gamma = 1.0 / cielab->display.d_gammaB ;
159 * ((float)pow((double)i / cielab->range, gamma));
|
| /external/ImageMagick/MagickCore/ |
| composite.c | 153 Da' in in the follow formula as 'gamma' The resulting alpla value.
157 gamma = Sa+Da-Sa*Da;
158 gamma = 1 - QuantiumScale*alpha * QuantiumScale*beta;
159 opacity = QuantiumScale*alpha*beta; // over blend, optimized 1-Gamma
383 gamma,
449 gamma=Sa+Da-Sa*Da;
450 gamma=PerceptibleReciprocal(gamma);
487 ClampPixel(gamma*QuantumRange*(Sca+Dca*(1.0-Sa))) :
488 ClampToQuantum(gamma*QuantumRange*(Sca+Dca*(1.0-Sa)))
381 gamma, local
1281 gamma; local
[all...] |
| pixel.c | 4511 gamma; local
4575 gamma, local
5002 gamma, local
5567 gamma; local
[all...] |
