From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) by finch.gentoo.org (Postfix) with ESMTP id 2DBFC138D1A for ; Wed, 15 Jul 2015 15:01:56 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 8ACE2E0830; Wed, 15 Jul 2015 15:01:50 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 0EB82E0830 for ; Wed, 15 Jul 2015 15:01:49 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id CFF1D3408F0 for ; Wed, 15 Jul 2015 15:01:48 +0000 (UTC) Received: from localhost.localdomain (localhost [127.0.0.1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 52E20906 for ; Wed, 15 Jul 2015 15:01:47 +0000 (UTC) From: "Anthony G. Basile" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Anthony G. Basile" Message-ID: <1436972637.8cedd5c264d4c49352aa3b058984b913bf893cf1.blueness@gentoo> Subject: [gentoo-commits] proj/musl:master commit in: media-libs/mesa/, media-libs/mesa/files/ X-VCS-Repository: proj/musl X-VCS-Files: media-libs/mesa/Manifest media-libs/mesa/files/mesa-10.3.7-format_utils.c.patch media-libs/mesa/files/mesa-10.5.1-fstat-include.patch media-libs/mesa/mesa-10.3.7-r1.ebuild media-libs/mesa/mesa-10.3.7-r99.ebuild media-libs/mesa/metadata.xml X-VCS-Directories: media-libs/mesa/ media-libs/mesa/files/ X-VCS-Committer: blueness X-VCS-Committer-Name: Anthony G. Basile X-VCS-Revision: 8cedd5c264d4c49352aa3b058984b913bf893cf1 X-VCS-Branch: master Date: Wed, 15 Jul 2015 15:01:47 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Archives-Salt: 3385f77f-bc73-4604-995c-0d0f44fd5424 X-Archives-Hash: 8da030aa524739129c1c174e5d95879d commit: 8cedd5c264d4c49352aa3b058984b913bf893cf1 Author: Anthony G. Basile gentoo org> AuthorDate: Wed Jul 15 15:03:57 2015 +0000 Commit: Anthony G. Basile gentoo 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 +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 +--- + 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 +Date: Wed, 11 Mar 2015 19:12:35 +0000 +Subject: loader: include for non-sysfs builds + +Required by fstat(), otherwise we'll error out due to implicit function +declaration. + +Cc: "10.4 10.5" +Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=89530 +Signed-off-by: Emil Velikov +Reported-by: Vadim Rutkovsky +Tested-by: Vadim Rutkovsky + +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 + */ + ++#include + #include + #include + #include +@@ -80,7 +81,6 @@ + #endif + #endif + #ifdef HAVE_SYSFS +-#include + #include + #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.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 @@ Disable patent-encumbered ARB_texture_float, EXT_texture_shared_exponent, and EXT_packed_float extensions. Build drivers based on the classic architecture. - Enable Direct 3D9 API through Nine state tracker. Can be used together with patched wine. Enable DRI3 support. Enable EGL support. Build drivers based on Gallium3D, the new architecture for 3D graphics drivers. Enable the Graphics Buffer Manager for EGL on KMS. - Enable GLES (both v1 and v2) support. Enable GLESv1 support. Enable GLESv2 support. Enable LLVM backend for Gallium3D. @@ -20,7 +18,6 @@ Build the Mesa library for off-screen rendering. Enable if the user plans to run the package under a pax enabled hardened kernel disable optimized assembly code that is not PIC friendly - Build the LLVM based r600 shader compiler. Enable the VDPAU acceleration interface for the Gallium3D Video Layer. Enable support for dev-libs/wayland Enable the XA (X Acceleration) API for Gallium3D.