« back to all changes in this revision
Viewing changes to test/utils.c
- browse files at revision 28
- compare with another revision
- download diff
- download tarball
- view history from revision 28
- Committer: Package Import Robot
- Author(s): Julien Cristau, Andreas Boll, intrigeri
- Date: 2015-09-12 13:08:02 UTC
- mfrom: (1.1.29)
- Revision ID: package-import@ubuntu.com-20150912130802-0egoj4agog1fsobn
Tags: 0.33.2-1
[ Andreas Boll ]
* New upstream release candidate.
* Enable vmx on ppc64el (closes: #786345).
* Update Vcs-* fields.
* Add upstream url.
* Drop XC- prefix from Package-Type field.
* Bump standards version to 3.9.6.
[ intrigeri ]
* Simplify hardening build flags handling (closes: #760100).
Thanks to Simon Ruderich <simon@ruderich.org> for the patch.
* Enable all hardening build flags. Thanks to Simon Ruderich too.
* New upstream release candidate.
* Enable vmx on ppc64el (closes: #786345).
* Update Vcs-* fields.
* Add upstream url.
* Drop XC- prefix from Package-Type field.
* Bump standards version to 3.9.6.
[ intrigeri ]
* Simplify hardening build flags handling (closes: #760100).
Thanks to Simon Ruderich <simon@ruderich.org> for the patch.
* Enable all hardening build flags. Thanks to Simon Ruderich too.
- files added:
- compile
- files removed:
- debian/patches/ppc64el.diff
- files modified:
- ChangeLog
added
removed
test/utils.c
4
4
#include <math.h>
5
5
#include <signal.h>
6
6
#include <stdlib.h>
7
#include <float.h>
8
#include <ctype.h>
7
9
8
10
#ifdef HAVE_GETTIMEOFDAY
9
11
#include <sys/time.h>
848
850
#endif
849
851
}
850
852
853
void
854
enable_invalid_exceptions (void)
855
{
856
#ifdef HAVE_FENV_H
857
#ifdef HAVE_FEENABLEEXCEPT
858
feenableexcept (FE_INVALID);
859
#endif
860
#endif
861
}
862
851
863
void *
852
864
aligned_malloc (size_t align, size_t size)
853
865
{
937
949
}
938
950
}
939
951
940
const char *
941
operator_name (pixman_op_t op)
942
{
943
switch (op)
944
{
945
case PIXMAN_OP_CLEAR: return "PIXMAN_OP_CLEAR";
946
case PIXMAN_OP_SRC: return "PIXMAN_OP_SRC";
947
case PIXMAN_OP_DST: return "PIXMAN_OP_DST";
948
case PIXMAN_OP_OVER: return "PIXMAN_OP_OVER";
949
case PIXMAN_OP_OVER_REVERSE: return "PIXMAN_OP_OVER_REVERSE";
950
case PIXMAN_OP_IN: return "PIXMAN_OP_IN";
951
case PIXMAN_OP_IN_REVERSE: return "PIXMAN_OP_IN_REVERSE";
952
case PIXMAN_OP_OUT: return "PIXMAN_OP_OUT";
953
case PIXMAN_OP_OUT_REVERSE: return "PIXMAN_OP_OUT_REVERSE";
954
case PIXMAN_OP_ATOP: return "PIXMAN_OP_ATOP";
955
case PIXMAN_OP_ATOP_REVERSE: return "PIXMAN_OP_ATOP_REVERSE";
956
case PIXMAN_OP_XOR: return "PIXMAN_OP_XOR";
957
case PIXMAN_OP_ADD: return "PIXMAN_OP_ADD";
958
case PIXMAN_OP_SATURATE: return "PIXMAN_OP_SATURATE";
959
960
case PIXMAN_OP_DISJOINT_CLEAR: return "PIXMAN_OP_DISJOINT_CLEAR";
961
case PIXMAN_OP_DISJOINT_SRC: return "PIXMAN_OP_DISJOINT_SRC";
962
case PIXMAN_OP_DISJOINT_DST: return "PIXMAN_OP_DISJOINT_DST";
963
case PIXMAN_OP_DISJOINT_OVER: return "PIXMAN_OP_DISJOINT_OVER";
964
case PIXMAN_OP_DISJOINT_OVER_REVERSE: return "PIXMAN_OP_DISJOINT_OVER_REVERSE";
965
case PIXMAN_OP_DISJOINT_IN: return "PIXMAN_OP_DISJOINT_IN";
966
case PIXMAN_OP_DISJOINT_IN_REVERSE: return "PIXMAN_OP_DISJOINT_IN_REVERSE";
967
case PIXMAN_OP_DISJOINT_OUT: return "PIXMAN_OP_DISJOINT_OUT";
968
case PIXMAN_OP_DISJOINT_OUT_REVERSE: return "PIXMAN_OP_DISJOINT_OUT_REVERSE";
969
case PIXMAN_OP_DISJOINT_ATOP: return "PIXMAN_OP_DISJOINT_ATOP";
970
case PIXMAN_OP_DISJOINT_ATOP_REVERSE: return "PIXMAN_OP_DISJOINT_ATOP_REVERSE";
971
case PIXMAN_OP_DISJOINT_XOR: return "PIXMAN_OP_DISJOINT_XOR";
972
973
case PIXMAN_OP_CONJOINT_CLEAR: return "PIXMAN_OP_CONJOINT_CLEAR";
974
case PIXMAN_OP_CONJOINT_SRC: return "PIXMAN_OP_CONJOINT_SRC";
975
case PIXMAN_OP_CONJOINT_DST: return "PIXMAN_OP_CONJOINT_DST";
976
case PIXMAN_OP_CONJOINT_OVER: return "PIXMAN_OP_CONJOINT_OVER";
977
case PIXMAN_OP_CONJOINT_OVER_REVERSE: return "PIXMAN_OP_CONJOINT_OVER_REVERSE";
978
case PIXMAN_OP_CONJOINT_IN: return "PIXMAN_OP_CONJOINT_IN";
979
case PIXMAN_OP_CONJOINT_IN_REVERSE: return "PIXMAN_OP_CONJOINT_IN_REVERSE";
980
case PIXMAN_OP_CONJOINT_OUT: return "PIXMAN_OP_CONJOINT_OUT";
981
case PIXMAN_OP_CONJOINT_OUT_REVERSE: return "PIXMAN_OP_CONJOINT_OUT_REVERSE";
982
case PIXMAN_OP_CONJOINT_ATOP: return "PIXMAN_OP_CONJOINT_ATOP";
983
case PIXMAN_OP_CONJOINT_ATOP_REVERSE: return "PIXMAN_OP_CONJOINT_ATOP_REVERSE";
984
case PIXMAN_OP_CONJOINT_XOR: return "PIXMAN_OP_CONJOINT_XOR";
985
986
case PIXMAN_OP_MULTIPLY: return "PIXMAN_OP_MULTIPLY";
987
case PIXMAN_OP_SCREEN: return "PIXMAN_OP_SCREEN";
988
case PIXMAN_OP_OVERLAY: return "PIXMAN_OP_OVERLAY";
989
case PIXMAN_OP_DARKEN: return "PIXMAN_OP_DARKEN";
990
case PIXMAN_OP_LIGHTEN: return "PIXMAN_OP_LIGHTEN";
991
case PIXMAN_OP_COLOR_DODGE: return "PIXMAN_OP_COLOR_DODGE";
992
case PIXMAN_OP_COLOR_BURN: return "PIXMAN_OP_COLOR_BURN";
993
case PIXMAN_OP_HARD_LIGHT: return "PIXMAN_OP_HARD_LIGHT";
994
case PIXMAN_OP_SOFT_LIGHT: return "PIXMAN_OP_SOFT_LIGHT";
995
case PIXMAN_OP_DIFFERENCE: return "PIXMAN_OP_DIFFERENCE";
996
case PIXMAN_OP_EXCLUSION: return "PIXMAN_OP_EXCLUSION";
997
case PIXMAN_OP_HSL_HUE: return "PIXMAN_OP_HSL_HUE";
998
case PIXMAN_OP_HSL_SATURATION: return "PIXMAN_OP_HSL_SATURATION";
999
case PIXMAN_OP_HSL_COLOR: return "PIXMAN_OP_HSL_COLOR";
1000
case PIXMAN_OP_HSL_LUMINOSITY: return "PIXMAN_OP_HSL_LUMINOSITY";
1001
1002
case PIXMAN_OP_NONE:
1003
return "<invalid operator 'none'>";
1004
};
1005
1006
return "<unknown operator>";
1007
}
1008
1009
const char *
1010
format_name (pixman_format_code_t format)
1011
{
1012
switch (format)
1013
{
952
struct operator_entry {
953
pixman_op_t op;
954
const char *name;
955
pixman_bool_t is_alias;
956
};
957
958
typedef struct operator_entry operator_entry_t;
959
960
static const operator_entry_t op_list[] =
961
{
962
#define ENTRY(op) \
963
{ PIXMAN_OP_##op, "PIXMAN_OP_" #op, FALSE }
964
#define ALIAS(op, nam) \
965
{ PIXMAN_OP_##op, nam, TRUE }
966
967
/* operator_name () will return the first hit in this table,
968
* so keep the list properly ordered between entries and aliases.
969
* Aliases are not listed by list_operators ().
970
*/
971
972
ENTRY (CLEAR),
973
ENTRY (SRC),
974
ENTRY (DST),
975
ENTRY (OVER),
976
ENTRY (OVER_REVERSE),
977
ALIAS (OVER_REVERSE, "overrev"),
978
ENTRY (IN),
979
ENTRY (IN_REVERSE),
980
ALIAS (IN_REVERSE, "inrev"),
981
ENTRY (OUT),
982
ENTRY (OUT_REVERSE),
983
ALIAS (OUT_REVERSE, "outrev"),
984
ENTRY (ATOP),
985
ENTRY (ATOP_REVERSE),
986
ALIAS (ATOP_REVERSE, "atoprev"),
987
ENTRY (XOR),
988
ENTRY (ADD),
989
ENTRY (SATURATE),
990
991
ENTRY (DISJOINT_CLEAR),
992
ENTRY (DISJOINT_SRC),
993
ENTRY (DISJOINT_DST),
994
ENTRY (DISJOINT_OVER),
995
ENTRY (DISJOINT_OVER_REVERSE),
996
ENTRY (DISJOINT_IN),
997
ENTRY (DISJOINT_IN_REVERSE),
998
ENTRY (DISJOINT_OUT),
999
ENTRY (DISJOINT_OUT_REVERSE),
1000
ENTRY (DISJOINT_ATOP),
1001
ENTRY (DISJOINT_ATOP_REVERSE),
1002
ENTRY (DISJOINT_XOR),
1003
1004
ENTRY (CONJOINT_CLEAR),
1005
ENTRY (CONJOINT_SRC),
1006
ENTRY (CONJOINT_DST),
1007
ENTRY (CONJOINT_OVER),
1008
ENTRY (CONJOINT_OVER_REVERSE),
1009
ENTRY (CONJOINT_IN),
1010
ENTRY (CONJOINT_IN_REVERSE),
1011
ENTRY (CONJOINT_OUT),
1012
ENTRY (CONJOINT_OUT_REVERSE),
1013
ENTRY (CONJOINT_ATOP),
1014
ENTRY (CONJOINT_ATOP_REVERSE),
1015
ENTRY (CONJOINT_XOR),
1016
1017
ENTRY (MULTIPLY),
1018
ENTRY (SCREEN),
1019
ENTRY (OVERLAY),
1020
ENTRY (DARKEN),
1021
ENTRY (LIGHTEN),
1022
ENTRY (COLOR_DODGE),
1023
ENTRY (COLOR_BURN),
1024
ENTRY (HARD_LIGHT),
1025
ENTRY (SOFT_LIGHT),
1026
ENTRY (DIFFERENCE),
1027
ENTRY (EXCLUSION),
1028
ENTRY (HSL_HUE),
1029
ENTRY (HSL_SATURATION),
1030
ENTRY (HSL_COLOR),
1031
ENTRY (HSL_LUMINOSITY),
1032
1033
ALIAS (NONE, "<invalid operator 'none'>")
1034
1035
#undef ENTRY
1036
#undef ALIAS
1037
};
1038
1039
struct format_entry
1040
{
1041
pixman_format_code_t format;
1042
const char *name;
1043
pixman_bool_t is_alias;
1044
};
1045
1046
typedef struct format_entry format_entry_t;
1047
1048
static const format_entry_t format_list[] =
1049
{
1050
#define ENTRY(f) \
1051
{ PIXMAN_##f, #f, FALSE }
1052
#define ALIAS(f, nam) \
1053
{ PIXMAN_##f, nam, TRUE }
1054
1055
/* format_name () will return the first hit in this table,
1056
* so keep the list properly ordered between entries and aliases.
1057
* Aliases are not listed by list_formats ().
1058
*/
1059
1014
1060
/* 32bpp formats */
1015
case PIXMAN_a8r8g8b8: return "a8r8g8b8";
1016
case PIXMAN_x8r8g8b8: return "x8r8g8b8";
1017
case PIXMAN_a8b8g8r8: return "a8b8g8r8";
1018
case PIXMAN_x8b8g8r8: return "x8b8g8r8";
1019
case PIXMAN_b8g8r8a8: return "b8g8r8a8";
1020
case PIXMAN_b8g8r8x8: return "b8g8r8x8";
1021
case PIXMAN_r8g8b8a8: return "r8g8b8a8";
1022
case PIXMAN_r8g8b8x8: return "r8g8b8x8";
1023
case PIXMAN_x14r6g6b6: return "x14r6g6b6";
1024
case PIXMAN_x2r10g10b10: return "x2r10g10b10";
1025
case PIXMAN_a2r10g10b10: return "a2r10g10b10";
1026
case PIXMAN_x2b10g10r10: return "x2b10g10r10";
1027
case PIXMAN_a2b10g10r10: return "a2b10g10r10";
1061
ENTRY (a8r8g8b8),
1062
ALIAS (a8r8g8b8, "8888"),
1063
ENTRY (x8r8g8b8),
1064
ALIAS (x8r8g8b8, "x888"),
1065
ENTRY (a8b8g8r8),
1066
ENTRY (x8b8g8r8),
1067
ENTRY (b8g8r8a8),
1068
ENTRY (b8g8r8x8),
1069
ENTRY (r8g8b8a8),
1070
ENTRY (r8g8b8x8),
1071
ENTRY (x14r6g6b6),
1072
ENTRY (x2r10g10b10),
1073
ALIAS (x2r10g10b10, "2x10"),
1074
ENTRY (a2r10g10b10),
1075
ALIAS (a2r10g10b10, "2a10"),
1076
ENTRY (x2b10g10r10),
1077
ENTRY (a2b10g10r10),
1028
1078
1029
1079
/* sRGB formats */
1030
case PIXMAN_a8r8g8b8_sRGB: return "a8r8g8b8_sRGB";
1080
ENTRY (a8r8g8b8_sRGB),
1031
1081
1032
1082
/* 24bpp formats */
1033
case PIXMAN_r8g8b8: return "r8g8b8";
1034
case PIXMAN_b8g8r8: return "b8g8r8";
1035
1036
/* 16bpp formats */
1037
case PIXMAN_r5g6b5: return "r5g6b5";
1038
case PIXMAN_b5g6r5: return "b5g6r5";
1039
1040
case PIXMAN_a1r5g5b5: return "a1r5g5b5";
1041
case PIXMAN_x1r5g5b5: return "x1r5g5b5";
1042
case PIXMAN_a1b5g5r5: return "a1b5g5r5";
1043
case PIXMAN_x1b5g5r5: return "x1b5g5r5";
1044
case PIXMAN_a4r4g4b4: return "a4r4g4b4";
1045
case PIXMAN_x4r4g4b4: return "x4r4g4b4";
1046
case PIXMAN_a4b4g4r4: return "a4b4g4r4";
1047
case PIXMAN_x4b4g4r4: return "x4b4g4r4";
1083
ENTRY (r8g8b8),
1084
ALIAS (r8g8b8, "0888"),
1085
ENTRY (b8g8r8),
1086
1087
/* 16 bpp formats */
1088
ENTRY (r5g6b5),
1089
ALIAS (r5g6b5, "0565"),
1090
ENTRY (b5g6r5),
1091
1092
ENTRY (a1r5g5b5),
1093
ALIAS (a1r5g5b5, "1555"),
1094
ENTRY (x1r5g5b5),
1095
ENTRY (a1b5g5r5),
1096
ENTRY (x1b5g5r5),
1097
ENTRY (a4r4g4b4),
1098
ALIAS (a4r4g4b4, "4444"),
1099
ENTRY (x4r4g4b4),
1100
ENTRY (a4b4g4r4),
1101
ENTRY (x4b4g4r4),
1048
1102
1049
1103
/* 8bpp formats */
1050
case PIXMAN_a8: return "a8";
1051
case PIXMAN_r3g3b2: return "r3g3b2";
1052
case PIXMAN_b2g3r3: return "b2g3r3";
1053
case PIXMAN_a2r2g2b2: return "a2r2g2b2";
1054
case PIXMAN_a2b2g2r2: return "a2b2g2r2";
1055
1056
#if 0
1057
case PIXMAN_x4c4: return "x4c4";
1058
case PIXMAN_g8: return "g8";
1059
#endif
1060
case PIXMAN_c8: return "x4c4 / c8";
1061
case PIXMAN_x4g4: return "x4g4 / g8";
1062
1063
case PIXMAN_x4a4: return "x4a4";
1064
1065
/* 4bpp formats */
1066
case PIXMAN_a4: return "a4";
1067
case PIXMAN_r1g2b1: return "r1g2b1";
1068
case PIXMAN_b1g2r1: return "b1g2r1";
1069
case PIXMAN_a1r1g1b1: return "a1r1g1b1";
1070
case PIXMAN_a1b1g1r1: return "a1b1g1r1";
1071
1072
case PIXMAN_c4: return "c4";
1073
case PIXMAN_g4: return "g4";
1104
ENTRY (a8),
1105
ALIAS (a8, "8"),
1106
ENTRY (r3g3b2),
1107
ENTRY (b2g3r3),
1108
ENTRY (a2r2g2b2),
1109
ALIAS (a2r2g2b2, "2222"),
1110
ENTRY (a2b2g2r2),
1111
1112
ALIAS (c8, "x4c4 / c8"),
1113
/* ENTRY (c8), */
1114
ALIAS (g8, "x4g4 / g8"),
1115
/* ENTRY (g8), */
1116
1117
ENTRY (x4a4),
1118
1119
/* These format codes are identical to c8 and g8, respectively. */
1120
/* ENTRY (x4c4), */
1121
/* ENTRY (x4g4), */
1122
1123
/* 4 bpp formats */
1124
ENTRY (a4),
1125
ENTRY (r1g2b1),
1126
ENTRY (b1g2r1),
1127
ENTRY (a1r1g1b1),
1128
ENTRY (a1b1g1r1),
1129
1130
ALIAS (c4, "c4"),
1131
/* ENTRY (c4), */
1132
ALIAS (g4, "g4"),
1133
/* ENTRY (g4), */
1074
1134
1075
1135
/* 1bpp formats */
1076
case PIXMAN_a1: return "a1";
1136
ENTRY (a1),
1077
1137
1078
case PIXMAN_g1: return "g1";
1138
ALIAS (g1, "g1"),
1139
/* ENTRY (g1), */
1079
1140
1080
1141
/* YUV formats */
1081
case PIXMAN_yuy2: return "yuy2";
1082
case PIXMAN_yv12: return "yv12";
1083
};
1084
1085
/* Fake formats.
1086
*
1087
* This is separate switch to prevent GCC from complaining
1088
* that the values are not in the pixman_format_code_t enum.
1089
*/
1090
switch ((uint32_t)format)
1091
{
1092
case PIXMAN_null: return "null";
1093
case PIXMAN_solid: return "solid";
1094
case PIXMAN_pixbuf: return "pixbuf";
1095
case PIXMAN_rpixbuf: return "rpixbuf";
1096
case PIXMAN_unknown: return "unknown";
1097
};
1142
ALIAS (yuy2, "yuy2"),
1143
/* ENTRY (yuy2), */
1144
ALIAS (yv12, "yv12"),
1145
/* ENTRY (yv12), */
1146
1147
/* Fake formats, not in pixman_format_code_t enum */
1148
ALIAS (null, "null"),
1149
ALIAS (solid, "solid"),
1150
ALIAS (solid, "n"),
1151
ALIAS (pixbuf, "pixbuf"),
1152
ALIAS (rpixbuf, "rpixbuf"),
1153
ALIAS (unknown, "unknown"),
1154
1155
#undef ENTRY
1156
#undef ALIAS
1157
};
1158
1159
pixman_format_code_t
1160
format_from_string (const char *s)
1161
{
1162
int i;
1163
1164
for (i = 0; i < ARRAY_LENGTH (format_list); ++i)
1165
{
1166
const format_entry_t *ent = &format_list[i];
1167
1168
if (strcasecmp (ent->name, s) == 0)
1169
return ent->format;
1170
}
1171
1172
return PIXMAN_null;
1173
}
1174
1175
static void
1176
emit (const char *s, int *n_chars)
1177
{
1178
*n_chars += printf ("%s,", s);
1179
if (*n_chars > 60)
1180
{
1181
printf ("\n ");
1182
*n_chars = 0;
1183
}
1184
else
1185
{
1186
printf (" ");
1187
(*n_chars)++;
1188
}
1189
}
1190
1191
void
1192
list_formats (void)
1193
{
1194
int n_chars;
1195
int i;
1196
1197
printf ("Formats:\n ");
1198
1199
n_chars = 0;
1200
for (i = 0; i < ARRAY_LENGTH (format_list); ++i)
1201
{
1202
const format_entry_t *ent = &format_list[i];
1203
1204
if (ent->is_alias)
1205
continue;
1206
1207
emit (ent->name, &n_chars);
1208
}
1209
1210
printf ("\n\n");
1211
}
1212
1213
void
1214
list_operators (void)
1215
{
1216
char short_name [128] = { 0 };
1217
int i, n_chars;
1218
1219
printf ("Operators:\n ");
1220
1221
n_chars = 0;
1222
for (i = 0; i < ARRAY_LENGTH (op_list); ++i)
1223
{
1224
const operator_entry_t *ent = &op_list[i];
1225
int j;
1226
1227
if (ent->is_alias)
1228
continue;
1229
1230
snprintf (short_name, sizeof (short_name) - 1, "%s",
1231
ent->name + strlen ("PIXMAN_OP_"));
1232
1233
for (j = 0; short_name[j] != '\0'; ++j)
1234
short_name[j] = tolower (short_name[j]);
1235
1236
emit (short_name, &n_chars);
1237
}
1238
1239
printf ("\n\n");
1240
}
1241
1242
pixman_op_t
1243
operator_from_string (const char *s)
1244
{
1245
int i;
1246
1247
for (i = 0; i < ARRAY_LENGTH (op_list); ++i)
1248
{
1249
const operator_entry_t *ent = &op_list[i];
1250
1251
if (ent->is_alias)
1252
{
1253
if (strcasecmp (ent->name, s) == 0)
1254
return ent->op;
1255
}
1256
else
1257
{
1258
if (strcasecmp (ent->name + strlen ("PIXMAN_OP_"), s) == 0)
1259
return ent->op;
1260
}
1261
}
1262
1263
return PIXMAN_OP_NONE;
1264
}
1265
1266
const char *
1267
operator_name (pixman_op_t op)
1268
{
1269
int i;
1270
1271
for (i = 0; i < ARRAY_LENGTH (op_list); ++i)
1272
{
1273
const operator_entry_t *ent = &op_list[i];
1274
1275
if (ent->op == op)
1276
return ent->name;
1277
}
1278
1279
return "<unknown operator>";
1280
}
1281
1282
const char *
1283
format_name (pixman_format_code_t format)
1284
{
1285
int i;
1286
1287
for (i = 0; i < ARRAY_LENGTH (format_list); ++i)
1288
{
1289
const format_entry_t *ent = &format_list[i];
1290
1291
if (ent->format == format)
1292
return ent->name;
1293
}
1098
1294
1099
1295
return "<unknown format>";
1100
1296
};
1101
1297
1298
#define IS_ZERO(f) (-DBL_MIN < (f) && (f) < DBL_MIN)
1299
1300
typedef double (* blend_func_t) (double as, double s, double ad, double d);
1301
1302
static force_inline double
1303
blend_multiply (double sa, double s, double da, double d)
1304
{
1305
return d * s;
1306
}
1307
1308
static force_inline double
1309
blend_screen (double sa, double s, double da, double d)
1310
{
1311
return d * sa + s * da - s * d;
1312
}
1313
1314
static force_inline double
1315
blend_overlay (double sa, double s, double da, double d)
1316
{
1317
if (2 * d < da)
1318
return 2 * s * d;
1319
else
1320
return sa * da - 2 * (da - d) * (sa - s);
1321
}
1322
1323
static force_inline double
1324
blend_darken (double sa, double s, double da, double d)
1325
{
1326
s = s * da;
1327
d = d * sa;
1328
1329
if (s > d)
1330
return d;
1331
else
1332
return s;
1333
}
1334
1335
static force_inline double
1336
blend_lighten (double sa, double s, double da, double d)
1337
{
1338
s = s * da;
1339
d = d * sa;
1340
1341
if (s > d)
1342
return s;
1343
else
1344
return d;
1345
}
1346
1347
static force_inline double
1348
blend_color_dodge (double sa, double s, double da, double d)
1349
{
1350
if (IS_ZERO (d))
1351
return 0.0f;
1352
else if (d * sa >= sa * da - s * da)
1353
return sa * da;
1354
else if (IS_ZERO (sa - s))
1355
return sa * da;
1356
else
1357
return sa * sa * d / (sa - s);
1358
}
1359
1360
static force_inline double
1361
blend_color_burn (double sa, double s, double da, double d)
1362
{
1363
if (d >= da)
1364
return sa * da;
1365
else if (sa * (da - d) >= s * da)
1366
return 0.0f;
1367
else if (IS_ZERO (s))
1368
return 0.0f;
1369
else
1370
return sa * (da - sa * (da - d) / s);
1371
}
1372
1373
static force_inline double
1374
blend_hard_light (double sa, double s, double da, double d)
1375
{
1376
if (2 * s < sa)
1377
return 2 * s * d;
1378
else
1379
return sa * da - 2 * (da - d) * (sa - s);
1380
}
1381
1382
static force_inline double
1383
blend_soft_light (double sa, double s, double da, double d)
1384
{
1385
if (2 * s <= sa)
1386
{
1387
if (IS_ZERO (da))
1388
return d * sa;
1389
else
1390
return d * sa - d * (da - d) * (sa - 2 * s) / da;
1391
}
1392
else
1393
{
1394
if (IS_ZERO (da))
1395
{
1396
return d * sa;
1397
}
1398
else
1399
{
1400
if (4 * d <= da)
1401
return d * sa + (2 * s - sa) * d * ((16 * d / da - 12) * d / da + 3);
1402
else
1403
return d * sa + (sqrt (d * da) - d) * (2 * s - sa);
1404
}
1405
}
1406
}
1407
1408
static force_inline double
1409
blend_difference (double sa, double s, double da, double d)
1410
{
1411
double dsa = d * sa;
1412
double sda = s * da;
1413
1414
if (sda < dsa)
1415
return dsa - sda;
1416
else
1417
return sda - dsa;
1418
}
1419
1420
static force_inline double
1421
blend_exclusion (double sa, double s, double da, double d)
1422
{
1423
return s * da + d * sa - 2 * d * s;
1424
}
1425
1426
static double
1427
clamp (double d)
1428
{
1429
if (d > 1.0)
1430
return 1.0;
1431
else if (d < 0.0)
1432
return 0.0;
1433
else
1434
return d;
1435
}
1436
1437
static double
1438
blend_channel (double as, double s, double ad, double d,
1439
blend_func_t blend)
1440
{
1441
return clamp ((1 - ad) * s + (1 - as) * d + blend (as, s, ad, d));
1442
}
1443
1102
1444
static double
1103
1445
calc_op (pixman_op_t op, double src, double dst, double srca, double dsta)
1104
1446
{
1336
1678
{
1337
1679
color_t srcval, srcalpha;
1338
1680
1681
static const blend_func_t blend_funcs[] =
1682
{
1683
blend_multiply,
1684
blend_screen,
1685
blend_overlay,
1686
blend_darken,
1687
blend_lighten,
1688
blend_color_dodge,
1689
blend_color_burn,
1690
blend_hard_light,
1691
blend_soft_light,
1692
blend_difference,
1693
blend_exclusion,
1694
};
1695
1339
1696
if (mask == NULL)
1340
1697
{
1341
1698
srcval = *src;
1370
1727
srcalpha.a = src->a * mask->a;
1371
1728
}
1372
1729
1373
result->r = calc_op (op, srcval.r, dst->r, srcalpha.r, dst->a);
1374
result->g = calc_op (op, srcval.g, dst->g, srcalpha.g, dst->a);
1375
result->b = calc_op (op, srcval.b, dst->b, srcalpha.b, dst->a);
1376
result->a = calc_op (op, srcval.a, dst->a, srcalpha.a, dst->a);
1730
if (op >= PIXMAN_OP_MULTIPLY)
1731
{
1732
blend_func_t func = blend_funcs[op - PIXMAN_OP_MULTIPLY];
1733
1734
result->a = srcalpha.a + dst->a - srcalpha.a * dst->a;
1735
result->r = blend_channel (srcalpha.r, srcval.r, dst->a, dst->r, func);
1736
result->g = blend_channel (srcalpha.g, srcval.g, dst->a, dst->g, func);
1737
result->b = blend_channel (srcalpha.b, srcval.b, dst->a, dst->b, func);
1738
}
1739
else
1740
{
1741
result->r = calc_op (op, srcval.r, dst->r, srcalpha.r, dst->a);
1742
result->g = calc_op (op, srcval.g, dst->g, srcalpha.g, dst->a);
1743
result->b = calc_op (op, srcval.b, dst->b, srcalpha.b, dst->a);
1744
result->a = calc_op (op, srcval.a, dst->a, srcalpha.a, dst->a);
1745
}
1377
1746
}
1378
1747
1379
1748
static double
1580
1949
1581
1950
/* The acceptable deviation in units of [0.0, 1.0]
1582
1951
*/
1583
#define DEVIATION (0.0064)
1952
#define DEVIATION (0.0128)
1584
1953
1585
1954
void
1586
1955
pixel_checker_get_max (const pixel_checker_t *checker, color_t *color,
Loggerhead is a web-based interface for Breezy
Version: 2.0.1