commit: 8cedd5c264d4c49352aa3b058984b913bf893cf1 Author: Anthony G. Basile <blueness <AT> gentoo <DOT> org> AuthorDate: Wed Jul 15 15:03:57 2015 +0000 Commit: Anthony G. Basile <blueness <AT> gentoo <DOT> org> CommitDate: Wed Jul 15 15:03:57 2015 +0000 URL: https://gitweb.gentoo.org/proj/musl.git/commit/?id=8cedd5c2
media-libs/mesa: bring in line with main tree. Package-Manager: portage-2.2.18 RepoMan-Options: --force Manifest-Sign-Key: 0xF52D4BBA media-libs/mesa/Manifest | 6 +- .../mesa/files/mesa-10.3.7-format_utils.c.patch | 1089 ++++++++++++++++++++ .../mesa/files/mesa-10.5.1-fstat-include.patch | 37 + ...esa-10.3.7-r1.ebuild => mesa-10.3.7-r99.ebuild} | 16 +- media-libs/mesa/metadata.xml | 3 - 5 files changed, 1137 insertions(+), 14 deletions(-) diff --git a/media-libs/mesa/Manifest b/media-libs/mesa/Manifest index 9f97337..98a9217 100644 --- a/media-libs/mesa/Manifest +++ b/media-libs/mesa/Manifest @@ -4,7 +4,9 @@ AUX glx_ro_text_segm.patch 731 SHA256 e36af5b530fdbe2b0e62a035bf4bf4baef267c3dc5 AUX mesa-10-pthread.patch 695 SHA256 a355933736a39ce9b0e26412ac940377fc6b3eeb25737c53bf8d767fe34c5367 SHA512 7850b543fb8413b9abf65ab884588eb7b15782122253bc9f4baee8735775bfd6bade42c386f295c20c7d43484d9ce82597cf82c8bca97433ccec8816386cc275 WHIRLPOOL ad2b5163a556733f8772ab9bce0ea452ac8373c96dc9be82ab1cf7dd7c59eea9fc7bed90786f1e3237e1639852785ed836f42bcaed78447355a6693501c9560f AUX mesa-10.2-dont-require-llvm-for-r300.patch 547 SHA256 83cfeae33b1e8c84b37ed59c353000eb775978ae3d9035ba8ce4f63a167756fc SHA512 d1cb5a989aa001c99f353d27ab5b28ac05d60050614bbfd76ca5d312e00efcc2b1a2459d30d697b68119310c69512b4195afce6c0ed7f31fb9cf14689a740e27 WHIRLPOOL c06669942d275a9d9f132ec8f51d3ecf23d33cb89cb607ba3a7861f209f283b39a9568513b07e22f0dfcc99339a307d7b2a6b03f261ed583fd4518d3b4d0b464 AUX mesa-10.3.7-dont-use-clrsb.patch 1140 SHA256 23626c6bf1e502f17f4b9236b512063b41bf52be64f56252f0fc5ce456824d58 SHA512 2d9dd9a56c3bab02e8ec1a1ab4d88c2855746d8243548f197cb43de6e980554447c75e53c07dcd270de7e1c282cf7fdf996e5102a24e47b75e484a18f99092e0 WHIRLPOOL 47b222fb61427bbe2a63ac4b738608e9c3491e6373c33e1d68c79198a111d7668b4cafbac9e58820e8cefae55dffca46ab57dbe91ad819feeb734c32f01020f0 +AUX mesa-10.3.7-format_utils.c.patch 34839 SHA256 81ec8d547d798aa5ef5dfc9f0685291af04f95882608f8e9db39a867f44ab431 SHA512 777597b41c37ced0fb375048cc30c4cac701c6020c70bd0f6fbbc2d6f2c1ac9ece0f6d411d81dd042be7f2fbc17e0536176d8230b93f9eed7d7ddf205ac98bb8 WHIRLPOOL 51a213c415d81250a2bc3ad117581b62c4eed13152a9550b2214a9c63f85a6559b1504e013ae0d8e56d5adcaff053c753aa833d7acbe10185d468fdfed5e1b72 +AUX mesa-10.5.1-fstat-include.patch 1008 SHA256 4d44da3882ae9ae7c5d255189e5ca86569337a53d6aece4c65344c753aa588d3 SHA512 6df3167efe198955198b4eb3e1c883f307ebbeb5ebaa63836f8bddf70173382454de6b0d9cb626bb20a5a649fe355a7d25ed5ce27348d5234df27fb9c920b4b4 WHIRLPOOL b05dee0366e35105a7eac143bd4b59e146b0ca369b522e58d2e9a08c8c35b79e929edeacf90154d826dc7ff40ebc7161cc3a6b663e0418388b8f5f5254747066 AUX mesa-9.1.6-fpclassify.patch 618 SHA256 b02df9b6850d46d251dd51213800d6608195487d0bc91aac79df75616b7bd6d4 SHA512 e7f61451bb05caaeecbe19b24d3c44cecd54a3f10d40701973cf061dc5396c7dc0220c19396e73d5f8d8a8febf34789333476cca62566667d827ed5f68155d4b WHIRLPOOL 4df278e552808cf8656c1319518cd8e37ffd3189e482efae6401dfd43febe733a8e57135d1d4886906fc37b495762c92ca24e5a5f98fe7af59df405e54a4b946 DIST MesaLib-10.3.7.tar.bz2 7287153 SHA256 43c6ced15e237cbb21b3082d7c0b42777c50c1f731d0d4b5efb5231063fb6a5b SHA512 bbc027c4146c42aaa160990f5281c71a342d32c10ba56f91da1a60dd4cb7d620ff49b72553d24bc1d87470e2baf9be81b5bdee9abe49d6acc57902fccb9e2e5f WHIRLPOOL 7fa32e70c6aabb84a06f2f852f77eac839aea08726c442742b3d3abdb94a0fd9f033439ab0cb16865f4ee14e1538cb86937856bbdfd1f9090e8e7c43eac52e03 -EBUILD mesa-10.3.7-r1.ebuild 14902 SHA256 45718624b57b37693fad5d1ca41c5a8156f2fe364ed95c9709f3b58db34ef27e SHA512 e22136acb270c7e19e0f0ff82ac4b204d5c437c606943455ff6565a930f3a20052dc84a5e4d45a1ded2c1ca029ef81fb34121ea315f0539ac8e6416b3d0602a0 WHIRLPOOL 8a9ad22fad2e133df122ce4babe42ac3ee8f05187b56a76226e6fbaa414eab2990a09c67c9fea280b82510d6960485bc294d39091f4025795d71667e149e5cd5 -MISC metadata.xml 1937 SHA256 b1c243ea287b20ad89f349d4d6274735d0bee6fd4b3309c6a9a0fbc063633c2e SHA512 445b1923de09a43ee10b6df629e48dd114003a2edf482de865f16816b2011d90b058e7cbc5e81face2ffdbac3cb94443f35aeea5cea93a9213f77a8aa822b459 WHIRLPOOL 56eb282ac574bff06e7dbc0bcb26b364ee1fd7827975327d59e3a94530c1cd7e7f843fe6be0bdab9a5956e34301ea3148c17e30b757fb904434a706ae6889023 +EBUILD mesa-10.3.7-r99.ebuild 14707 SHA256 5d7bc944628f494641d79bb39559d0e459f89770f7b2691d79c2f6420d3b7ab9 SHA512 ed82955c3d2741a73ec3082680e5c93b9708a3c159bb836e01298e88cdfc9028591d0050d8ef76dfeb4304f7c0c53e38aee5c130094bbff5d3b93ab609d26391 WHIRLPOOL 26430225f044f046f0229f62f3c3541f169c87b5141973edbc8ffbd6fa57231ba2479ab0d42be0b61ba4ae9dce140277099c20228da2ead18a7b0fd8d2b54423 +MISC metadata.xml 1674 SHA256 f0f164517f72cd4039af02bfad25eff79fa4d2112a5ea80859283ef825988a9c SHA512 f0964d1023805ad6beee2a6e168d7c1539e0180096397fb075dbcdb66d0b035fead201a8ad7082683c1305b8b53de3803418ef10b56fafdcb0f9af0980110892 WHIRLPOOL 557c7fe953399423774d885f726f446ae9181222f54053d7d282c568b4b4786c6b7332ea381fac664d304bd9257d195ed7fa3da3c4242e0a34bfce8dd99432ef diff --git a/media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch b/media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch new file mode 100644 index 0000000..e1fba03 --- /dev/null +++ b/media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch @@ -0,0 +1,1089 @@ +From cfeb394224f2daeb2139cf4ec489a4dd8297a44d Mon Sep 17 00:00:00 2001 +From: Brian Paul <[email protected]> +Date: Fri, 12 Sep 2014 08:31:15 -0600 +Subject: [PATCH] mesa: break up _mesa_swizzle_and_convert() to reduce compile + time + +This reduces gcc -O3 compile time to 1/4 of what it was on my system. +Reduces MSVC release build time too. + +Reviewed-by: Jason Ekstrand <[email protected]> +--- + src/mesa/main/format_utils.c | 1030 ++++++++++++++++++++++-------------------- + 1 file changed, 550 insertions(+), 480 deletions(-) + +diff --git a/src/mesa/main/format_utils.c b/src/mesa/main/format_utils.c +index 240e3bc..29d779a 100644 +--- a/src/mesa/main/format_utils.c ++++ b/src/mesa/main/format_utils.c +@@ -352,9 +352,14 @@ swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels, + */ + #define SWIZZLE_CONVERT(DST_TYPE, SRC_TYPE, CONV) \ + do { \ ++ const uint8_t swizzle_x = swizzle[0]; \ ++ const uint8_t swizzle_y = swizzle[1]; \ ++ const uint8_t swizzle_z = swizzle[2]; \ ++ const uint8_t swizzle_w = swizzle[3]; \ + const SRC_TYPE *typed_src = void_src; \ + DST_TYPE *typed_dst = void_dst; \ + DST_TYPE tmp[7]; \ ++ int s, j; \ + tmp[4] = 0; \ + tmp[5] = one; \ + switch (num_dst_channels) { \ +@@ -423,7 +428,527 @@ swizzle_convert_try_memcpy(void *dst, GLenum dst_type, int num_dst_channels, + } \ + break; \ + } \ +- } while (0); ++ } while (0) ++ ++ ++static void ++convert_float(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const float one = 1.0f; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ SWIZZLE_CONVERT(float, float, src); ++ break; ++ case GL_HALF_FLOAT: ++ SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src)); ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(float, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(float, int8_t, src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(float, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(float, int16_t, src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(float, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(float, int32_t, src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_half_float(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const uint16_t one = _mesa_float_to_half(1.0f); ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src)); ++ break; ++ case GL_HALF_FLOAT: ++ SWIZZLE_CONVERT(uint16_t, uint16_t, src); ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src)); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src)); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src)); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src)); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src)); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src)); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_ubyte(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const uint8_t one = normalized ? UINT8_MAX : 1; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ SWIZZLE_CONVERT(uint8_t, uint8_t, src); ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_byte(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const int8_t one = normalized ? INT8_MAX : 1; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, float, src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8)); ++ } else { ++ SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8)); ++ } else { ++ SWIZZLE_CONVERT(int8_t, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ SWIZZLE_CONVERT(int8_t, int8_t, src); ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8)); ++ } else { ++ SWIZZLE_CONVERT(int8_t, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8)); ++ } else { ++ SWIZZLE_CONVERT(int8_t, int16_t, src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8)); ++ } else { ++ SWIZZLE_CONVERT(int8_t, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8)); ++ } else { ++ SWIZZLE_CONVERT(int8_t, int32_t, src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_ushort(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const uint16_t one = normalized ? UINT16_MAX : 1; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ SWIZZLE_CONVERT(uint16_t, uint16_t, src); ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_short(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const int16_t one = normalized ? INT16_MAX : 1; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, float, src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16)); ++ } else { ++ SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16)); ++ } else { ++ SWIZZLE_CONVERT(int16_t, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16)); ++ } else { ++ SWIZZLE_CONVERT(int16_t, int8_t, src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16, 16)); ++ } else { ++ SWIZZLE_CONVERT(int16_t, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ SWIZZLE_CONVERT(int16_t, int16_t, src); ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32, 16)); ++ } else { ++ SWIZZLE_CONVERT(int16_t, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32, 16)); ++ } else { ++ SWIZZLE_CONVERT(int16_t, int32_t, src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++static void ++convert_uint(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const uint32_t one = normalized ? UINT32_MAX : 1; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ SWIZZLE_CONVERT(uint32_t, uint32_t, src); ++ break; ++ case GL_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src); ++ } ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ ++ ++static void ++convert_int(void *void_dst, int num_dst_channels, ++ const void *void_src, GLenum src_type, int num_src_channels, ++ const uint8_t swizzle[4], bool normalized, int count) ++{ ++ const int32_t one = normalized ? INT32_MAX : 12; ++ ++ switch (src_type) { ++ case GL_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, float, src); ++ } ++ break; ++ case GL_HALF_FLOAT: ++ if (normalized) { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32)); ++ } else { ++ SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src)); ++ } ++ break; ++ case GL_UNSIGNED_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32)); ++ } else { ++ SWIZZLE_CONVERT(int32_t, uint8_t, src); ++ } ++ break; ++ case GL_BYTE: ++ if (normalized) { ++ SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32)); ++ } else { ++ SWIZZLE_CONVERT(int32_t, int8_t, src); ++ } ++ break; ++ case GL_UNSIGNED_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16, 32)); ++ } else { ++ SWIZZLE_CONVERT(int32_t, uint16_t, src); ++ } ++ break; ++ case GL_SHORT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16, 32)); ++ } else { ++ SWIZZLE_CONVERT(int32_t, int16_t, src); ++ } ++ break; ++ case GL_UNSIGNED_INT: ++ if (normalized) { ++ SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32, 32)); ++ } else { ++ SWIZZLE_CONVERT(int32_t, uint32_t, src); ++ } ++ break; ++ case GL_INT: ++ SWIZZLE_CONVERT(int32_t, int32_t, src); ++ break; ++ default: ++ assert(!"Invalid channel type combination"); ++ } ++} ++ + + /** + * Convert between array-based color formats. +@@ -478,499 +1003,44 @@ _mesa_swizzle_and_convert(void *void_dst, GLenum dst_type, int num_dst_channels, + const void *void_src, GLenum src_type, int num_src_channels, + const uint8_t swizzle[4], bool normalized, int count) + { +- int s, j; +- register uint8_t swizzle_x, swizzle_y, swizzle_z, swizzle_w; +- + if (swizzle_convert_try_memcpy(void_dst, dst_type, num_dst_channels, + void_src, src_type, num_src_channels, + swizzle, normalized, count)) + return; + +- swizzle_x = swizzle[0]; +- swizzle_y = swizzle[1]; +- swizzle_z = swizzle[2]; +- swizzle_w = swizzle[3]; +- + switch (dst_type) { + case GL_FLOAT: +- { +- const float one = 1.0f; +- switch (src_type) { +- case GL_FLOAT: +- SWIZZLE_CONVERT(float, float, src) +- break; +- case GL_HALF_FLOAT: +- SWIZZLE_CONVERT(float, uint16_t, _mesa_half_to_float(src)) +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(float, uint8_t, unorm_to_float(src, 8)) +- } else { +- SWIZZLE_CONVERT(float, uint8_t, src) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(float, int8_t, snorm_to_float(src, 8)) +- } else { +- SWIZZLE_CONVERT(float, int8_t, src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(float, uint16_t, unorm_to_float(src, 16)) +- } else { +- SWIZZLE_CONVERT(float, uint16_t, src) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(float, int16_t, snorm_to_float(src, 16)) +- } else { +- SWIZZLE_CONVERT(float, int16_t, src) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(float, uint32_t, unorm_to_float(src, 32)) +- } else { +- SWIZZLE_CONVERT(float, uint32_t, src) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(float, int32_t, snorm_to_float(src, 32)) +- } else { +- SWIZZLE_CONVERT(float, int32_t, src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_float(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_HALF_FLOAT: +- { +- const uint16_t one = _mesa_float_to_half(1.0f); +- switch (src_type) { +- case GL_FLOAT: +- SWIZZLE_CONVERT(uint16_t, float, _mesa_float_to_half(src)) +- break; +- case GL_HALF_FLOAT: +- SWIZZLE_CONVERT(uint16_t, uint16_t, src) +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_half(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint8_t, _mesa_float_to_half(src)) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_half(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int8_t, _mesa_float_to_half(src)) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint16_t, unorm_to_half(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_float_to_half(src)) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_half(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int16_t, _mesa_float_to_half(src)) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_half(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint32_t, _mesa_float_to_half(src)) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_half(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int32_t, _mesa_float_to_half(src)) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_half_float(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_UNSIGNED_BYTE: +- { +- const uint8_t one = normalized ? UINT8_MAX : 1; +- switch (src_type) { +- case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, float, float_to_unorm(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, float, (src < 0) ? 0 : src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_unorm(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_uint(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- SWIZZLE_CONVERT(uint8_t, uint8_t, src) +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, int8_t, snorm_to_unorm(src, 8, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, int8_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, uint16_t, unorm_to_unorm(src, 16, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, uint16_t, src) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, int16_t, snorm_to_unorm(src, 16, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, int16_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, uint32_t, unorm_to_unorm(src, 32, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, uint32_t, src) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, int32_t, snorm_to_unorm(src, 32, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, int32_t, (src < 0) ? 0 : src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_ubyte(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_BYTE: +- { +- const int8_t one = normalized ? INT8_MAX : 1; +- switch (src_type) { +- case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, float, float_to_snorm(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, float, src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint8_t, uint16_t, half_to_snorm(src, 8)) +- } else { +- SWIZZLE_CONVERT(uint8_t, uint16_t, _mesa_half_to_float(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(int8_t, uint8_t, unorm_to_snorm(src, 8, 8)) +- } else { +- SWIZZLE_CONVERT(int8_t, uint8_t, src) +- } +- break; +- case GL_BYTE: +- SWIZZLE_CONVERT(int8_t, int8_t, src) +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(int8_t, uint16_t, unorm_to_snorm(src, 16, 8)) +- } else { +- SWIZZLE_CONVERT(int8_t, uint16_t, src) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(int8_t, int16_t, snorm_to_snorm(src, 16, 8)) +- } else { +- SWIZZLE_CONVERT(int8_t, int16_t, src) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(int8_t, uint32_t, unorm_to_snorm(src, 32, 8)) +- } else { +- SWIZZLE_CONVERT(int8_t, uint32_t, src) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(int8_t, int32_t, snorm_to_snorm(src, 32, 8)) +- } else { +- SWIZZLE_CONVERT(int8_t, int32_t, src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_byte(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_UNSIGNED_SHORT: +- { +- const uint16_t one = normalized ? UINT16_MAX : 1; +- switch (src_type) { +- case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, float, float_to_unorm(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, float, (src < 0) ? 0 : src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_unorm(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_uint(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint8_t, unorm_to_unorm(src, 8, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint8_t, src) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int8_t, snorm_to_unorm(src, 8, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int8_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- SWIZZLE_CONVERT(uint16_t, uint16_t, src) +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int16_t, snorm_to_unorm(src, 16, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int16_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint32_t, unorm_to_unorm(src, 32, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint32_t, src) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, int32_t, snorm_to_unorm(src, 32, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, int32_t, (src < 0) ? 0 : src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_ushort(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_SHORT: +- { +- const int16_t one = normalized ? INT16_MAX : 1; +- switch (src_type) { +- case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, float, float_to_snorm(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, float, src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint16_t, uint16_t, half_to_snorm(src, 16)) +- } else { +- SWIZZLE_CONVERT(uint16_t, uint16_t, _mesa_half_to_float(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(int16_t, uint8_t, unorm_to_snorm(src, 8, 16)) +- } else { +- SWIZZLE_CONVERT(int16_t, uint8_t, src) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(int16_t, int8_t, snorm_to_snorm(src, 8, 16)) +- } else { +- SWIZZLE_CONVERT(int16_t, int8_t, src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(int16_t, uint16_t, unorm_to_snorm(src, 16, 16)) +- } else { +- SWIZZLE_CONVERT(int16_t, uint16_t, src) +- } +- break; +- case GL_SHORT: +- SWIZZLE_CONVERT(int16_t, int16_t, src) +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(int16_t, uint32_t, unorm_to_snorm(src, 32, 16)) +- } else { +- SWIZZLE_CONVERT(int16_t, uint32_t, src) +- } +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(int16_t, int32_t, snorm_to_snorm(src, 32, 16)) +- } else { +- SWIZZLE_CONVERT(int16_t, int32_t, src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_short(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_UNSIGNED_INT: +- { +- const uint32_t one = normalized ? UINT32_MAX : 1; +- switch (src_type) { case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, float, float_to_unorm(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, float, (src < 0) ? 0 : src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_unorm(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_uint(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, uint8_t, unorm_to_unorm(src, 8, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, uint8_t, src) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, int8_t, snorm_to_unorm(src, 8, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, int8_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, uint16_t, unorm_to_unorm(src, 16, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, uint16_t, src) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, int16_t, snorm_to_unorm(src, 16, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, int16_t, (src < 0) ? 0 : src) +- } +- break; +- case GL_UNSIGNED_INT: +- SWIZZLE_CONVERT(uint32_t, uint32_t, src) +- break; +- case GL_INT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, int32_t, snorm_to_unorm(src, 32, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, int32_t, (src < 0) ? 0 : src) +- } +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_uint(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + case GL_INT: +- { +- const int32_t one = normalized ? INT32_MAX : 1; +- switch (src_type) { +- case GL_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, float, float_to_snorm(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, float, src) +- } +- break; +- case GL_HALF_FLOAT: +- if (normalized) { +- SWIZZLE_CONVERT(uint32_t, uint16_t, half_to_snorm(src, 32)) +- } else { +- SWIZZLE_CONVERT(uint32_t, uint16_t, _mesa_half_to_float(src)) +- } +- break; +- case GL_UNSIGNED_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(int32_t, uint8_t, unorm_to_snorm(src, 8, 32)) +- } else { +- SWIZZLE_CONVERT(int32_t, uint8_t, src) +- } +- break; +- case GL_BYTE: +- if (normalized) { +- SWIZZLE_CONVERT(int32_t, int8_t, snorm_to_snorm(src, 8, 32)) +- } else { +- SWIZZLE_CONVERT(int32_t, int8_t, src) +- } +- break; +- case GL_UNSIGNED_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(int32_t, uint16_t, unorm_to_snorm(src, 16, 32)) +- } else { +- SWIZZLE_CONVERT(int32_t, uint16_t, src) +- } +- break; +- case GL_SHORT: +- if (normalized) { +- SWIZZLE_CONVERT(int32_t, int16_t, snorm_to_snorm(src, 16, 32)) +- } else { +- SWIZZLE_CONVERT(int32_t, int16_t, src) +- } +- break; +- case GL_UNSIGNED_INT: +- if (normalized) { +- SWIZZLE_CONVERT(int32_t, uint32_t, unorm_to_snorm(src, 32, 32)) +- } else { +- SWIZZLE_CONVERT(int32_t, uint32_t, src) +- } +- break; +- case GL_INT: +- SWIZZLE_CONVERT(int32_t, int32_t, src) +- break; +- default: +- assert(!"Invalid channel type combination"); +- } +- } +- break; ++ convert_int(void_dst, num_dst_channels, void_src, src_type, ++ num_src_channels, swizzle, normalized, count); ++ break; + default: + assert(!"Invalid channel type"); + } +-- +2.0.5 + diff --git a/media-libs/mesa/files/mesa-10.5.1-fstat-include.patch b/media-libs/mesa/files/mesa-10.5.1-fstat-include.patch new file mode 100644 index 0000000..212d00d --- /dev/null +++ b/media-libs/mesa/files/mesa-10.5.1-fstat-include.patch @@ -0,0 +1,37 @@ +From 771cd266b9d00bdcf2cf7acaa3c8363c358d7478 Mon Sep 17 00:00:00 2001 +From: Emil Velikov <[email protected]> +Date: Wed, 11 Mar 2015 19:12:35 +0000 +Subject: loader: include <sys/stat.h> for non-sysfs builds + +Required by fstat(), otherwise we'll error out due to implicit function +declaration. + +Cc: "10.4 10.5" <[email protected]> +Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=89530 +Signed-off-by: Emil Velikov <[email protected]> +Reported-by: Vadim Rutkovsky <[email protected]> +Tested-by: Vadim Rutkovsky <[email protected]> + +diff --git a/src/loader/loader.c b/src/loader/loader.c +index 9ff5115..17bf133 100644 +--- a/src/loader/loader.c ++++ b/src/loader/loader.c +@@ -64,6 +64,7 @@ + * Rob Clark <[email protected]> + */ + ++#include <sys/stat.h> + #include <stdarg.h> + #include <stdio.h> + #include <string.h> +@@ -80,7 +81,6 @@ + #endif + #endif + #ifdef HAVE_SYSFS +-#include <sys/stat.h> + #include <sys/types.h> + #endif + #include "loader.h" +-- +cgit v0.10.2 + diff --git a/media-libs/mesa/mesa-10.3.7-r1.ebuild b/media-libs/mesa/mesa-10.3.7-r99.ebuild similarity index 96% rename from media-libs/mesa/mesa-10.3.7-r1.ebuild rename to media-libs/mesa/mesa-10.3.7-r99.ebuild index 5417c73..8581f62 100644 --- a/media-libs/mesa/mesa-10.3.7-r1.ebuild +++ b/media-libs/mesa/mesa-10.3.7-r99.ebuild @@ -11,7 +11,7 @@ if [[ ${PV} = 9999* ]]; then EXPERIMENTAL="true" fi -PYTHON_COMPAT=( python{2_6,2_7} ) +PYTHON_COMPAT=( python2_7 ) inherit base autotools multilib multilib-minimal flag-o-matic \ python-any-r1 toolchain-funcs pax-utils ${GIT_ECLASS} @@ -40,6 +40,7 @@ fi LICENSE="MIT SGI-B-2.0" SLOT="0" KEYWORDS="amd64 arm ~mips ppc x86" +RESTRICT="!bindist? ( bindist )" INTEL_CARDS="i915 i965 ilo intel" RADEON_CARDS="r100 r200 r300 r600 radeon radeonsi" @@ -50,7 +51,7 @@ done IUSE="${IUSE_VIDEO_CARDS} bindist +classic debug +dri3 +egl +gallium +gbm gles1 gles2 +llvm +nptl - opencl openvg osmesa pax_kernel openmax pic r600-llvm-compiler selinux + opencl openvg osmesa pax_kernel openmax pic selinux +udev vdpau wayland xvmc xa kernel_FreeBSD kernel_linux" REQUIRED_USE=" @@ -59,14 +60,10 @@ REQUIRED_USE=" opencl? ( gallium llvm - video_cards_r600? ( r600-llvm-compiler ) - video_cards_radeon? ( r600-llvm-compiler ) - video_cards_radeonsi? ( r600-llvm-compiler ) ) openmax? ( gallium ) gles1? ( egl ) gles2? ( egl ) - r600-llvm-compiler? ( gallium llvm || ( video_cards_r600 video_cards_radeonsi video_cards_radeon ) ) wayland? ( egl gbm ) xa? ( gallium ) video_cards_freedreno? ( gallium ) @@ -119,6 +116,7 @@ RDEPEND=" ) ) ) >=sys-devel/llvm-3.3-r3:=[${MULTILIB_USEDEP}] + <sys-devel/llvm-3.6 video_cards_radeonsi? ( >=sys-devel/llvm-3.4.2:=[${MULTILIB_USEDEP}] ) ) opencl? ( @@ -146,7 +144,6 @@ done DEPEND="${RDEPEND} ${PYTHON_DEPS} llvm? ( - r600-llvm-compiler? ( sys-devel/llvm[video_cards_radeon] ) video_cards_radeonsi? ( sys-devel/llvm[video_cards_radeon] ) ) opencl? ( @@ -207,6 +204,8 @@ src_prepare() { fi epatch "${FILESDIR}"/${PN}-10.3.7-dont-use-clrsb.patch + epatch "${FILESDIR}"/${PN}-10.3.7-format_utils.c.patch + epatch "${FILESDIR}"/${PN}-10.5.1-fstat-include.patch # relax the requirement that r300 must have llvm, bug 380303 epatch "${FILESDIR}"/${PN}-10.2-dont-require-llvm-for-r300.patch @@ -266,7 +265,6 @@ multilib_src_configure() { $(use_enable openvg) $(use_enable openvg gallium-egl) $(use_enable openmax omx) - $(use_enable r600-llvm-compiler) $(use_enable vdpau) $(use_enable xa) $(use_enable xvmc) @@ -307,7 +305,7 @@ multilib_src_configure() { " fi - # on abi_x86_32 hardened we need to have asm disable + # on abi_x86_32 hardened we need to have asm disable if [[ ${ABI} == x86* ]] && use pic; then myconf+=" --disable-asm" fi diff --git a/media-libs/mesa/metadata.xml b/media-libs/mesa/metadata.xml index fe098a4..d5ef123 100644 --- a/media-libs/mesa/metadata.xml +++ b/media-libs/mesa/metadata.xml @@ -5,12 +5,10 @@ <use> <flag name='bindist'>Disable patent-encumbered ARB_texture_float, EXT_texture_shared_exponent, and EXT_packed_float extensions.</flag> <flag name='classic'>Build drivers based on the classic architecture.</flag> - <flag name='d3d9'>Enable Direct 3D9 API through Nine state tracker. Can be used together with patched wine.</flag> <flag name='dri3'>Enable DRI3 support.</flag> <flag name='egl'>Enable EGL support.</flag> <flag name='gallium'>Build drivers based on Gallium3D, the new architecture for 3D graphics drivers.</flag> <flag name='gbm'>Enable the Graphics Buffer Manager for EGL on KMS.</flag> - <flag name='gles'>Enable GLES (both v1 and v2) support.</flag> <flag name='gles1'>Enable GLESv1 support.</flag> <flag name='gles2'>Enable GLESv2 support.</flag> <flag name='llvm'>Enable LLVM backend for Gallium3D.</flag> @@ -20,7 +18,6 @@ <flag name='osmesa'>Build the Mesa library for off-screen rendering.</flag> <flag name='pax_kernel'>Enable if the user plans to run the package under a pax enabled hardened kernel</flag> <flag name='pic'>disable optimized assembly code that is not PIC friendly</flag> - <flag name='r600-llvm-compiler'>Build the LLVM based r600 shader compiler.</flag> <flag name='vdpau'>Enable the VDPAU acceleration interface for the Gallium3D Video Layer.</flag> <flag name='wayland'>Enable support for dev-libs/wayland</flag> <flag name='xa'>Enable the XA (X Acceleration) API for Gallium3D.</flag>
