Administrator/opencv-MIRROR
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-11-10 10:38:59 -06:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: Administrator:5.1.0
Branches Tags
Administrator:4.x Administrator:5.x Administrator:cuda/final_coverage Administrator:copilot/fix-windows-actions-job Administrator:4.13.0-python Administrator:3.4 Administrator:2.4
Administrator:5.1.0 Administrator:4.14.0 Administrator:5.0.0 Administrator:4.13.0 Administrator:4.12.0 Administrator:4.11.0 Administrator:5.0.0-alpha Administrator:4.10.0-kleidicv Administrator:4.10.0 Administrator:4.9.0 Administrator:4.8.1 Administrator:4.8.0 Administrator:3.4.20 Administrator:4.7.0 Administrator:3.4.19 Administrator:4.6.0 Administrator:3.4.18 Administrator:4.5.5-openvino-2022.1.0 Administrator:4.5.5 Administrator:3.4.17 Administrator:4.5.3-openvino-2021.4.2 Administrator:4.5.4 Administrator:3.4.16 Administrator:4.5.3-openvino-2021.4.1 Administrator:4.5.3 Administrator:3.4.15 Administrator:4.5.3-openvino Administrator:4.5.2 Administrator:3.4.14 Administrator:4.5.2-openvino Administrator:4.5.1 Administrator:3.4.13 Administrator:4.5.1-openvino Administrator:4.5.0 Administrator:3.4.12 Administrator:4.5.0-openvino Administrator:4.4.0 Administrator:3.4.11 Administrator:4.4.0-openvino Administrator:4.3.0-openvino-2020.3.0 Administrator:4.3.0 Administrator:3.4.10 Administrator:4.3.0-openvino Administrator:4.2.0-openvino Administrator:4.2.0 Administrator:3.4.9 Administrator:4.1.2 Administrator:3.4.8 Administrator:4.1.2-openvino Administrator:4.1.1 Administrator:3.4.7 Administrator:4.1.1-openvino Administrator:4.1.0 Administrator:3.4.6 Administrator:4.1.0-openvino Administrator:4.0.1 Administrator:3.4.5 Administrator:4.0.1-openvino Administrator:4.0.0 Administrator:3.4.4 Administrator:4.0.0-openvino Administrator:4.0.0-rc Administrator:4.0.0-beta Administrator:4.0.0-alpha Administrator:3.4.3 Administrator:3.4.3-openvino Administrator:3.4.2 Administrator:2.4.13.7 Administrator:3.4.2-openvino Administrator:3.4.1-cvsdk Administrator:3.4.1 Administrator:2.4.13.6 Administrator:3.4.0 Administrator:2.4.13.5 Administrator:3.4.0-rc Administrator:3.3.1 Administrator:2.4.13.4 Administrator:3.3.1-cvsdk Administrator:3.3.0 Administrator:3.3.0-cvsdk Administrator:2.4.13.3 Administrator:3.3.0-rc Administrator:3.2.0 Administrator:3.2.0-rc Administrator:2.4.13.2 Administrator:2.4.13.1 Administrator:2.4.13 Administrator:3.1.0 Administrator:2.4.12.3 Administrator:2.4.12.2 Administrator:2.4.12.1 Administrator:2.4.12 Administrator:3.0.0 Administrator:2.4.10.4 Administrator:2.4.10.3 Administrator:3.0.0-rc1 Administrator:2.4.10.2 Administrator:2.4.11 Administrator:3.0.0-beta Administrator:2.4.10.1 Administrator:2.4.10 Administrator:2.4.9.1 Administrator:3.0.0-alpha Administrator:2.4.8.3 Administrator:2.4.9 Administrator:2.4.8.2 Administrator:3.0-ocl-tp2 Administrator:2.4.8.1 Administrator:3.0-ocl-tech-preview Administrator:2.4.8 Administrator:2.4.7.2 Administrator:2.4.7.1 Administrator:2.4.7 Administrator:2.4.7-rc1 Administrator:2.4.6.2r3 Administrator:2.4.6.2r2 Administrator:2.4.6.2 Administrator:2.4.6.2-rc1 Administrator:2.4.6.1 Administrator:2.4.6 Administrator:2.4.5 Administrator:2.4.4 Administrator:2.4.4-beta Administrator:2.4.3.2 Administrator:2.4.3.1 Administrator:2.4.3 Administrator:2.4.3-rc Administrator:2.4.2 Administrator:2.4.1 Administrator:2.4.0 Administrator:2.3.1 Administrator:2.3.0 Administrator:2.2
..
compare: Administrator:4.x
Branches Tags
Administrator:4.x Administrator:5.x Administrator:cuda/final_coverage Administrator:copilot/fix-windows-actions-job Administrator:4.13.0-python Administrator:3.4 Administrator:2.4
Administrator:5.1.0 Administrator:4.14.0 Administrator:5.0.0 Administrator:4.13.0 Administrator:4.12.0 Administrator:4.11.0 Administrator:5.0.0-alpha Administrator:4.10.0-kleidicv Administrator:4.10.0 Administrator:4.9.0 Administrator:4.8.1 Administrator:4.8.0 Administrator:3.4.20 Administrator:4.7.0 Administrator:3.4.19 Administrator:4.6.0 Administrator:3.4.18 Administrator:4.5.5-openvino-2022.1.0 Administrator:4.5.5 Administrator:3.4.17 Administrator:4.5.3-openvino-2021.4.2 Administrator:4.5.4 Administrator:3.4.16 Administrator:4.5.3-openvino-2021.4.1 Administrator:4.5.3 Administrator:3.4.15 Administrator:4.5.3-openvino Administrator:4.5.2 Administrator:3.4.14 Administrator:4.5.2-openvino Administrator:4.5.1 Administrator:3.4.13 Administrator:4.5.1-openvino Administrator:4.5.0 Administrator:3.4.12 Administrator:4.5.0-openvino Administrator:4.4.0 Administrator:3.4.11 Administrator:4.4.0-openvino Administrator:4.3.0-openvino-2020.3.0 Administrator:4.3.0 Administrator:3.4.10 Administrator:4.3.0-openvino Administrator:4.2.0-openvino Administrator:4.2.0 Administrator:3.4.9 Administrator:4.1.2 Administrator:3.4.8 Administrator:4.1.2-openvino Administrator:4.1.1 Administrator:3.4.7 Administrator:4.1.1-openvino Administrator:4.1.0 Administrator:3.4.6 Administrator:4.1.0-openvino Administrator:4.0.1 Administrator:3.4.5 Administrator:4.0.1-openvino Administrator:4.0.0 Administrator:3.4.4 Administrator:4.0.0-openvino Administrator:4.0.0-rc Administrator:4.0.0-beta Administrator:4.0.0-alpha Administrator:3.4.3 Administrator:3.4.3-openvino Administrator:3.4.2 Administrator:2.4.13.7 Administrator:3.4.2-openvino Administrator:3.4.1-cvsdk Administrator:3.4.1 Administrator:2.4.13.6 Administrator:3.4.0 Administrator:2.4.13.5 Administrator:3.4.0-rc Administrator:3.3.1 Administrator:2.4.13.4 Administrator:3.3.1-cvsdk Administrator:3.3.0 Administrator:3.3.0-cvsdk Administrator:2.4.13.3 Administrator:3.3.0-rc Administrator:3.2.0 Administrator:3.2.0-rc Administrator:2.4.13.2 Administrator:2.4.13.1 Administrator:2.4.13 Administrator:3.1.0 Administrator:2.4.12.3 Administrator:2.4.12.2 Administrator:2.4.12.1 Administrator:2.4.12 Administrator:3.0.0 Administrator:2.4.10.4 Administrator:2.4.10.3 Administrator:3.0.0-rc1 Administrator:2.4.10.2 Administrator:2.4.11 Administrator:3.0.0-beta Administrator:2.4.10.1 Administrator:2.4.10 Administrator:2.4.9.1 Administrator:3.0.0-alpha Administrator:2.4.8.3 Administrator:2.4.9 Administrator:2.4.8.2 Administrator:3.0-ocl-tp2 Administrator:2.4.8.1 Administrator:3.0-ocl-tech-preview Administrator:2.4.8 Administrator:2.4.7.2 Administrator:2.4.7.1 Administrator:2.4.7 Administrator:2.4.7-rc1 Administrator:2.4.6.2r3 Administrator:2.4.6.2r2 Administrator:2.4.6.2 Administrator:2.4.6.2-rc1 Administrator:2.4.6.1 Administrator:2.4.6 Administrator:2.4.5 Administrator:2.4.4 Administrator:2.4.4-beta Administrator:2.4.3.2 Administrator:2.4.3.1 Administrator:2.4.3 Administrator:2.4.3-rc Administrator:2.4.2 Administrator:2.4.1 Administrator:2.4.0 Administrator:2.3.1 Administrator:2.3.0 Administrator:2.2

365 Commits
5.1.0 ... 4.x

Author SHA1 Message Date
Abhishek Gola
2853bdce0d Merge pull request #30681 from pratham-mcw/sorIdx_opt 
core: parallelize sortIdx over independent rows/columns
 2026-11-10 17:35:48 +05:30
Abhishek Gola
a0fbf9c283 Merge pull request #30509 from mh-masum6875/docs-drawmatches-python-note 
doc: note that Python callers can pass None as outImg in drawMatches/drawKeypoints
 2026-11-10 16:21:29 +05:30
Mohammad Sohail Shaikh
55ff746075 Merge pull request #30728 from sohailshk/fix/dnn-matmul-broadcast-packedb (#30728) 
dnn: fix packed-B offsets for broadcast batched MatMul

When the constant B of a MatMul has more than one batch slice but fewer than the output batch (B broadcasts over A's leading dims), updatePackedBOffsets derived the packed slice stride from the output batch, so every slice after the first read the wrong packed data. matmul_layer.cpp now passes fastGemmPackBSize(N, K, opt), the size of one packed slice, as the stride.
 2026-11-10 08:43:16 +05:30
Abhishek Gola
4bea6a5f0e Merge pull request #30723 from pbkx/fix-knnmatch-output-replacement-4x 
features2d: clear knnMatch output before matching
 2026-11-10 08:37:21 +05:30
Abhishek Gola
b41241fa41 Merge pull request #30725 from pbkx/fix-phasecorr-roi-padding-4x 
imgproc: fix phaseCorrelate ROI padding
 2026-11-10 08:36:22 +05:30
Pratham Kumar
db0380a7a0 imgproc: parallelize calcHist using stripe-based parallel_for_ (#30585) 
* imgproc: parallelize calcHist using stripe-based parallel_for_

* backport calcHist parallelization from 5.x
 2026-11-09 12:21:40 +05:30
NIKHIL
54142329e9 imgproc: fix stackBlur results on full-range 16-bit images 🤖🤖🤖 (#30671) 
* imgproc: fix stackBlur results on full-range 16-bit images

The 16-bit SIMD paths overflowed 32 bits in (sum * mul) >> shr and saturated when adding two 16-bit samples before the kernel multiply. Add the samples after widening, and divide as the scalar loops do, so SIMD and scalar agree and the result no longer depends on the thread count.

* imgproc: scale the stackBlur thread test with the machine's thread count

Restore the count with a guard so a throw can't leak it. Use an odd image width: with a width of 160, stripes at some thread counts, including 12, leave nothing to the scalar loop and the test passes on the unfixed code.

* imgproc: use 64-bit sums for large stackBlur kernels on 16-bit images

The largest sum is the largest absolute value times (radius + 1)^2, which no longer fits an int from radius 181 for CV_16U and radius 255 for CV_16S. Those radii now take the scalar loops with int64_t sums. Radii that fit keep the 32-bit SIMD paths.

* imgproc: use 64-bit sums for large stackBlur kernels on 8-bit images
 2026-11-09 12:20:20 +05:30
pbkx
9231ce54bf fix phaseCorrelate ROI padding 2026-11-08 14:45:14 -08:00
pbkx
b0af5ebf70 features2d: clear knnMatch output before matching 2026-11-08 14:02:42 -08:00
Alexander Smorkalov
e7d32cb9db Merge pull request #30716 from Kumataro:trial/fix_build_warnings_with_cxx20_4.x 
dnn, features2d, imgproc: fix build warnings with GCC 15 / C++20(4.x)
 2026-11-08 11:39:52 +03:00
Shiven Solanki
0cbde9ceeb Merge pull request #30646 from sshivensolanki:core-carttopolar-inplace 
core: fix in-place cartToPolar when only the magnitude overwrites an input - #30646

Fixes #30645

### Problem

`cv::cartToPolar` gives wrong results on `CV_32F` when only the magnitude output is the same `Mat` as `x` or `y`. The SIMD loop handles the leftover elements by repeating the last full block. In-place calls must skip this, but `cartToPolar32f_` only checked the angle, so the repeated block read magnitudes as inputs.

### Fix

Added `mag == X || mag == Y` to the check, so these calls handle the leftover elements with the scalar code. `polarToCart` and `magnitude` already check all their outputs.

### Tests

New `Core_CartToPolar_inplace_mag.accuracy` for `CV_32F` with lengths 1 to 39: the magnitude overwrites `x`, then `y`, and the results are compared with a call using separate outputs. The existing `Core_CartToPolar_inplace` test overwrites both inputs, so it never reached this case. `CV_64F` is not tested, because it works on separate float buffers and can't hit this bug.

On Apple M1 Pro, 28 of the 39 cases fail without the fix. All pass with the fix, along with the related `cartToPolar`, `polarToCart`, `magnitude` and `phase` tests, with OpenCL on and off.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-11-08 09:16:50 +03:00
Kumataro
173a1cf711 dnn, features2d, imgproc: fix build warnings with GCC 15 / C++20 
- dnn: suppress false-positive std::vector::insert warning in ONNX GRU parser
- features2d: simplify indexChange initialization in BRISK kernel generation
- imgproc: fix implicit conversion warnings with INTER_TAB_SIZE in SIMD remap and warp tests
 2026-11-08 10:48:56 +09:00
Alexander Smorkalov
ccf4ca3243 Merge pull request #30676 from Lurie97:fix_mapcount 
Fix(core): correct UMat mapcount handling in OpenCL path
 2026-11-07 21:24:40 +03:00
Alexander Smorkalov
9d4808bef8 Merge pull request #30677 from saanvimundra:fix-commandlineparser-short-key-spec 
core: reject CommandLineParser keys with fewer than three fields
 2026-11-06 18:21:51 +03:00
Alexander Smorkalov
103f61f252 Merge pull request #30682 from NUAAwqy:docs/deriv-kernel-size-range-4x 
docs(imgproc): correct the documented Sobel kernel size range (4.x)
 2026-11-06 18:20:12 +03:00
Shiven Solanki
6fa237896a Merge pull request #30668 from sshivensolanki:core-inrange-16f 
core: throw an error instead of crashing in inRange on CV_16F #30668

Fixes #30667

### Problem

`cv::inRange` crashed with a segmentation fault on `CV_16F` input. `inRangeTab` has `0` for `CV_16F`, and the code called the returned function without checking it.

### Fix

If no function is found, `cv::inRange` now raises `CV_Error` with `StsNotImplemented` and a message saying that `CV_16F` is not supported, like 5.x does for its unsupported depths.

### Tests

New `Core_InRange.unsupported_depth_throws` checks scalar and array bounds on `CV_16F`. Without the fix, the test program crashes. With the fix, it passes, and all `opencv_test_core` tests pass on Apple M1 Pro.

`inRange` supports `CV_16F` on 5.x, so this test does not throw there. It needs to be removed or changed when 4.x is merged into 5.x.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-11-06 14:01:19 +03:00
jiajia Qian
5f20f48a5b Fix(core): correct UMat mapcount handling in OpenCL path 
`u->mapcount` was incremented before `clEnqueueMapBuffer()`.

If mapping failed, the counter remained incremented even though no
mapping was established, leaving `UMatData` in an inconsistent state
and potentially triggering later assertions such as:

    (-215:Assertion failed) u->mapcount == 0 in function 'deallocate'

Update the logic to increment `mapcount` only after a successful
`clEnqueueMapBuffer()` call.

The issue was observed while running:

    OCL_PyrDownFixture_PyrDown.PyrDown/6 from opencv_perf_imgproc.

Assisted-by: LLM
Signed-off-by: jiajia Qian <jiajia.qian@nxp.com>
 2026-11-05 17:43:10 +08:00
NUAAwqy
131f1745a9 docs(imgproc): correct the documented Sobel kernel size range 
Backport of #30661 to the 4.x branch: getDerivKernels and Sobel accept any odd
aperture size up to 31, not only 1, 3, 5, or 7.
 2026-11-04 14:10:07 +00:00
Pratham Kumar
a1f93dd19c core: parallelize sortIdx over independent rows/columns 2026-11-04 18:40:31 +05:30
Saanvi Mundra
e4b73b28e2 core: reject CommandLineParser keys with fewer than three fields 
Each key block must have the form "{names | default | help}". The
constructor read the second and third fields without checking that they
exist, so a block such as "{help h}" or "{help h|}" read past the end
of a vector and crashed. Throw a parse error instead, as is already done
for other malformed key strings.
 2026-11-04 08:05:08 +00:00
Alexander Smorkalov
6d381e029f Merge pull request #30633 from pctablet505:fix-fastcv-transpose-byte-step 
hal(fastcv): decline transpose when the row step is not a whole number of elements 🤖🤖🤖
 2026-11-03 13:13:01 +03:00
Abhishek Gola
199fd78571 Merge pull request #30351 from spicysharkco/fix/filestorage-release-state 
core: fix FileStorage release leaks, state and unbalanced closing
 2026-11-03 13:45:51 +05:30
pctablet505
6f461fc85a hal(fastcv): decline transpose when the row step is not a whole number of elements 2026-11-02 19:17:25 +05:30
Abhishek Gola
d195a5ad7e Merge pull request #30577 from professor-moody/fix-torch-padding-dim-bounds-4x 
dnn(torch): validate nn.Padding dimension and pad bounds
 2026-10-30 15:24:05 +05:30
Abhishek Gola
af3b2f2b80 Merge pull request #30432 from sshivensolanki/opt-copymask-8byte 
core: SIMD masked copy for 8-byte elements
 2026-10-30 13:13:28 +05:30
Alexander Smorkalov
187e2e9694 Merge pull request #30592 from sshivensolanki:fix-laplacian-16f-overflow 
imgproc: fix heap overflow in Laplacian for CV_16F
 2026-10-30 10:13:58 +03:00
Shiven Solanki
c7c32d37eb imgproc: fix heap overflow in Laplacian for CV_16F 
Laplacian picked the kernel type as max(CV_32F, ddepth, sdepth), which
is CV_16F for a CV_16F image because CV_16F > CV_64F. The 3x3 kernel
was then allocated as CV_16F (18 bytes) and filled with 9 doubles. Use
CV_64F when the source or destination is CV_64F and CV_32F otherwise,
so filter2D rejects the unsupported depth without the overflow.

Add an Imgproc_Laplacian regression test.
 2026-10-29 23:24:14 +08:00
Abhishek Gola
5584875dba Merge pull request #30532 from gksks1029/fix/tracker-vit-roi-crop-4x 
video: isolate TrackerVit crops from parent images
 2026-10-29 19:41:46 +05:30
Abhishek Gola
c55f0e9418 Merge pull request #30445 from 3nK1i/fix/convertmaps-empty-output 
imgproc: fix convertMaps with an empty second output
 2026-10-29 13:39:54 +05:30
Abhishek Gola
099dde0419 Merge pull request #30452 from pbkx/fix-seamless-cloning-mask-preservation-4x 
photo: preserve input masks in seamless cloning APIs
 2026-10-29 13:37:55 +05:30
Abhishek Gola
981ff0ff05 Merge pull request #30508 from mh-masum6875/docs-python-manual-signatures 
python: add documentation signatures for manually wrapped highgui functions
 2026-10-29 13:36:36 +05:30
Abhishek Gola
57a97025ef Merge pull request #30498 from pbkx/fix-tonemap-reinhard-intensity-4x 
photo: preserve TonemapReinhard intensity during processing
 2026-10-29 12:50:43 +05:30
Nathan Keys
50cfa93293 dnn(torch): validate nn.Padding dimension and pad bounds 
Validate the one-based Padding dimension before converting it to an
array index, and reject the minimum integer pad before negating it.
Add a serialized Torch7 regression test for valid and invalid bounds.

Signed-off-by: Nathan Keys <professor.moody@pm.me>
 2026-10-28 22:02:46 -05:00
Maidul Hasan Masum
77d9a8e69c python: align setMouseCallback argument names with its keywords 
Same change as the 5.x port, to keep the two branches in sync.

The wrapper parses window_name, on_mouse and param, but the cv2.cpp help
text and the typing stub in api_refinement.py both say windowName and
onMouse, so the stub promises keywords the runtime rejects:

    >>> cv2.setMouseCallback(windowName="w", onMouse=cb)
    TypeError: function missing required argument 'window_name' (pos 1)

createTrackbar is left alone: it is registered METH_VARARGS, so its
arguments cannot be passed by keyword at all.
 2026-10-28 14:13:46 +00:00
Shiven Solanki
f2efb42906 core: use TEST_P for the 8-byte copyTo/setTo mask test 2026-10-27 18:03:23 +08:00
Shih Kai Siang
58e52e9d3c video: isolate TrackerVit crops from parent images 2026-10-26 23:18:41 +08:00
Alexander Smorkalov
fa3037533e Merge pull request #30524 from Kumataro:doc/avif_support_16bit_4.x 
doc(imgcodecs): update 16-bit support and opaque alpha channel behavior for AVIF(4.x)
 2026-10-26 16:20:58 +03:00
Alexander Smorkalov
d9b582d464 Merge pull request #30527 from Laibaqi:docs-fix-android-typos 
docs: fix typos in Android development tutorial
 2026-10-26 16:20:26 +03:00
Laiba Irfan
91ca181f19 docs: fix typos in Android development tutorial 2026-10-26 17:45:06 +05:00
Kumataro
1a97289f43 doc(imgcodecs): update 16-bit support and opaque alpha channel behavior for AVIF(4.x) 
- Reading and writing 16-bit AVIF images requires libavif v1.4.0+
- Note that if the alpha plane contains only fully opaque pixels, the destination saves only color channels due to a libavif limitation.

Port from https://github.com/opencv/opencv/pull/30519
 2026-10-26 20:42:26 +09:00
Abhishek Gola
9171eaf2fa Merge pull request #30242 from pratham-mcw/inpaint_opt 
photo: vectorize cv::inpaint (Telea/NS) inner loops
 2026-10-26 14:18:55 +05:30
Alexander Smorkalov
7dc486f74c Merge pull request #30497 from Kumataro:fix_norm_calculation_and_extend_16bit_tests_4.x 
imgcodecs(avif): fix norm calculation and extend 16-bit tests(4.x)
 2026-10-25 10:56:25 +03:00
Maidul Hasan Masum
de47a33bb4 doc: note that Python callers can pass None as outImg/outImage 
The Python bindings are generated from these C++ headers, so the output
image parameter of drawKeypoints(), drawMatches() and drawMatchesKnn() is
a mandatory positional argument there. Nothing in the documentation told
Python users that passing None is allowed and makes OpenCV allocate and
return the output image.

Add a @note to each of the three functions documenting this, matching the
existing "For Python API" note style. drawMatchesKnn had no documentation
block at all, so one is added as an @overload carrying the note.

Documentation only; no functional change.

Fixes #14461
 2026-10-25 02:52:02 +08:00
Maidul Hasan Masum
32f9288034 python: add documentation signatures for manually wrapped highgui functions 2026-10-25 02:16:36 +08:00
pbkx
4187e46d27 preserve TonemapReinhard intensity during processing 2026-10-23 19:11:54 -07:00
Kumataro
b070b228e4 imgcodecs(avif): fix norm calculation and extend 16-bit tests 
- Correct lossy test normalization from dividing by total samples (N) to root-mean-square (RMS) error divided by sqrt(N), and recalibrate thresholds with margin for 8/10/12/16-bit tests.
- Extend 16-bit AVIF tests to cover all supported channel counts (1, 3, and 4 channels) using testing::Combine.

Port from https://github.com/opencv/opencv/pull/30431
 2026-10-24 06:53:33 +09:00
Enki
b423992c26 imgproc: avoid narrowing warnings in convertMaps tests 2026-10-23 10:37:18 +00:00
pbkx
6cee324515 parameterize input-mask preservation tests 2026-10-22 14:42:55 -07:00
Pulkit Chauhan
4ffd42f66a Merge pull request #30363 from pulk17:fix-getrectsubpix-ipp-border-4x 
imgproc: don’t use ippiCopySubpixIntersect for windows crossing the image border - #30363

Fixes #30301

### Problem

`ippiCopySubpixIntersect` (used by the IPP HAL for `getRectSubPix` with 8UC1→8U, 8UC1→32F and 32FC1→32F) gets two kinds of border windows wrong:

1. **The window crosses the top edge and reaches the last column** (reported in #30301): the top rows get `src(0, cols - 2)` instead of `src(0, cols - 1)`. For 1-column images this reads the element before the start of the image.
2. **8u→8u window entirely to the left of the image** (not in the original report): the fixed-point interpolation weights overflow and the result is wrong, e.g. a 1x1 image filled with 176 gives 112. This case doesn't read outside the image.

### Fix

Fall back to the generic implementation only for these two cases. The window position is computed the same way IPP does it (`(int)(x + w) - w`, which differs from `cvFloor()` for some inputs), as suggested by @andreyfe1. All other windows, including about 69% of the windows that cross the border, still go through IPP.

### Testing

- Added `Imgproc_GetRectSubPix.regression_30301`: 3 cases (top-right crossing, 1-column image, window left of the image) × 3 type combinations, with the images as ROIs of a 250-filled buffer. It fails on 7 of 9 checks without the patch.
- Compared IPP on vs off with IPPICV 2026.1.0: a grid sweep over 26M windows, plus on both the AVX2 and SSE4.2 paths random images up to 64x64 with windows up to 48x48 and far-away centers (16M), centers within a few ulps of every integer window position (35M), and images placed next to a PROT_NONE page so any out-of-image read crashes (31M). No differences and no crashes with the patch; without it the guard-page run crashes on case 1.
- `opencv_test_imgproc`: no new failures.
 2026-10-22 14:26:40 +03:00
Enki
4a30faa06f imgproc: preserve both convertMaps floating-point outputs 2026-10-22 11:01:03 +00:00
pbkx
7f0113b6af preserve input masks in seamless cloning APIs 2026-10-22 02:15:47 -07:00
Pratham Kumar
a8f184e130 use exact div/sqrt in inpaint NS vector path on 32-bit NEON 2026-10-22 14:31:46 +05:30
Alexander Smorkalov
d8dd0f2683 Merge pull request #30435 from paneendrakumar0:fix-videoio-unsupported-mode-warning-26519 
videoio: avoid false-positive unsupported mode warning on capture failure (#26519)
 2026-10-22 10:55:57 +03:00
spicysharkco
e147e535bd core: do not throw from FileStorage and WriteStructContext destructors 
FileStorage::Impl::~Impl() calls release(), and release() can throw: for
example workaround() reports an empty key of a delayed Base64 sequence.
WriteStructContext::~WriteStructContext() calls endWriteStruct(), which
throws when the structure was already closed by hand or never opened. A
destructor is noexcept, so either exception ended the process.

Catch it in both destructors and log a warning instead, as other
destructors in OpenCV do. When release() throws in ~Impl(), call it a
second time, as FileStorage::open() does when opening fails: the first
call has already dropped the delayed structure that made it throw, so
the second one writes the rest of the file. ~Impl() then closes the
file in case both calls threw.
 2026-10-21 22:14:06 +00:00
Enki
2814f93395 imgproc: fix convertMaps with an empty second output 2026-10-21 16:44:08 +00:00
Shiven Solanki
0eb3ae9586 core: skip uniform mask blocks in 8-byte copyMask, add tests 2026-10-21 21:10:09 +08:00
Alexander Smorkalov
2bbc5b12bb Merge pull request #30438 from kevin9327:fs-uppercase-exponent 
core: read numbers with an upper-case exponent in FileStorage
 2026-10-21 15:52:51 +03:00
Alexander Smorkalov
8d0d7b3b81 Merge pull request #30436 from sneumueller-cloudflight:fix/dnn-opencl-stdpow 
dnn: use pow not std::pow in OpenCL kernels
 2026-10-21 15:40:16 +03:00
kevin9327
1b09dd45c9 core: read numbers with an upper-case exponent in FileStorage 2026-10-21 21:22:09 +09:00
NIKHIL
bc14301ac1 Merge pull request #30304 from Nikhi00718:fix/imgproc-clahe-border-padding 
imgproc: avoid padding divisible dimensions in CLAHE - #30304

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake

`CLAHE::apply` pads both dimensions whenever either dimension is not divisible by the tile grid. For an image with 80 rows and 81 columns and an 8x8 grid, the height already fits, but the implementation adds eight reflected rows anyway. The resulting 11-pixel tile height changes the histograms and interpolation across the image; only seven columns are needed to obtain tiles 11 pixels wide and 10 pixels high.

Compute the minimum reflected padding independently for each dimension in both the CPU and OpenCL paths. Images with both dimensions divisible, or neither dimension divisible, retain their existing tile geometry. No public interface changes.

Reproduction (applies to both `uint8` and `uint16`):

```python
import cv2
import numpy as np

src = np.random.default_rng(42).integers(0, 65536, (80, 81), dtype=np.uint16)
clahe = cv2.createCLAHE(2.0, (8, 8))
actual = clahe.apply(src)
padded = cv2.copyMakeBorder(src, 0, 0, 0, 7, cv2.BORDER_REFLECT_101)
expected = clahe.apply(padded)[:80, :81]
assert np.array_equal(actual, expected)  # fails before this fix
```

Testing on `b254d3455a`, Linux x86-64, GCC 15.2, Release, IPP disabled, OpenCL enabled with PoCL 6 CPU device (`OPENCV_OPENCL_DEVICE=:CPU:`, `POCL_MAX_PTHREAD_COUNT=4`, `OPENCV_FOR_THREADS_NUM=2`):

- On base `9d80321677` with only the new tests: 88 failed, 64 passed. All 24 new OpenCL cases fail; the remaining failures are the CPU mixed-divisibility cases.
- With the fix, `opencv_test_imgproc --gtest_filter="*CLAHE_Padding*:*CLAHETest.ReflectedBorder*"`: 152 passed.
- `OPENCV_TEST_DATA_PATH=~/ocv-testdata opencv_test_imgproc --gtest_filter="*Hist*:*BackProject*:*CLAHE*"`: 232 passed, including the existing OpenCL CLAHE accuracy tests. The initial run lacked `cv/optflow/RubberWhale1.png`; rerunning with the official `opencv_extra` image passed.
- `opencv_perf_imgproc --gtest_filter="*CLAHE*" --perf_min_samples=10 --perf_force_samples=10`: 12 existing CLAHE performance cases passed, plus four framework checks.
- `git diff --check`: passed.
- CI revision `801fea96e3`: renamed the OpenCL test RNG to avoid shadowing its fixture member. Rebuilt `opencv_test_imgproc` with no compiler warnings and reran the selected accuracy suite: 232 passed.

The regression matrix covers 8-/16-bit inputs, square/rectangular/single-axis grids, all divisibility combinations, clipping, strided inputs, and in-place use. OpenCL cases cover both axes and UMat offsets. No additional test data is needed. Full imgproc suite and physical GPU execution were not run.

The reproduction above is the original report; no earlier issue or competing fix was found.
 2026-10-21 15:13:32 +03:00
NIKHILA
b9a980c380 Merge pull request #30371 from Nikhila-Dhevi-R:codex/fix-pfm-read-channels 
imgcodecs: honor PFM grayscale and color read modes 🤖🤖🤖 - #30371

Fixes #30370.

Loading a grayscale PFM with the default color mode, or a color PFM in grayscale mode, fails through `imread()` and returns the wrong channel count through `imdecode()`. `PFMDecoder::readData()` relies on `Mat::convertTo()`, which changes depth while preserving source channels; this reallocates the output instead of honoring the requested type.

Convert between one and three channels in the floating-point buffer before the final depth conversion. Existing byte-order handling, scaling, unchanged-mode decoding, and RGB/BGR selection remain in place. No public API changes. This targets 4.x because the same bug exists there; 5.x contains the same affected implementation.

### Regression coverage

32 generated cases cover one/three-channel inputs, file/memory reads, grayscale/BGR/RGB requests, float depth preservation, unchanged/any-color controls, and reuse of a preallocated memory destination. No new external test data is required.

### Validation

Windows x64, GCC 16.2.0, Release, current 4.x base `9b6287ec500ef7b327ac74c4f6c9cd84a2cbc9cd`:

- New regression matrix before the fix: **12 failed, 20 passed**.
- After the fix: **32/32 passed**; existing PFM round-trip test also passed (**33/33 PFM tests**).
- Configured `opencv_test_imgcodecs` suite: **601 tests reported, zero failures**, with three skips reported by the OpenCV runner (memory/very-long/other conditions). JPEG/PNG and built-in codecs enabled; IPP/OpenCL disabled.
- `git diff --check` passed; independent read-only code review found no actionable defects.
- The issue reproducer also runs against the official OpenCV 5.0.0 Python wheel. Upstream CI results are separate from these local results.

AI assistance disclosure: investigation, implementation, tests, and this description were prepared with OpenAI Codex; the reproduction and source-build test results were executed in this workspace.

### Pull Request Readiness Checklist

See https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another license incompatible with OpenCV.
- [x] The PR is proposed to the proper branch.
- [x] There is a reference to the original bug report and related work.
- [x] There is an accuracy test and test data, if applicable. Tests generate their own data; no opencv_extra change or performance test is needed for this correctness fix.
- [x] The existing documented read-mode behavior is preserved and the code builds with the project CMake configuration. No new API or sample is introduced.
 2026-10-21 15:10:10 +03:00
Stefan Neumüller
ffbf6e6bcc dnn: use pow not std::pow in OpenCL kernels 
5622958189 replaced pow() with std::pow() in three OpenCL C kernel
files. OpenCL C is a C99-derived language and has no std namespace, so
these kernels fail to compile at runtime on the GPU (e.g.
CL_BUILD_PROGRAM_FAILURE: use of undeclared identifier 'std') and dnn
silently falls back to CPU for the affected activations, LRN and fused
conv layers. Revert to the plain built-in pow() in the kernels.
 2026-10-21 11:39:52 +00:00
paneendrakumar0
0a5c96c832 videoio: avoid false-positive unsupported mode warning on capture failure (#26519) 
In VideoCapture::open(), PR #22700 added checks to log warnings when a requested
backend cannot perform a capture mode (e.g. capturing by index with CAP_FFMPEG).
However, the condition only tested if (isBackendBuiltIn(apiPreference)), which
evaluates to true for all built-in backends regardless of whether they support the mode.

As a result, whenever a camera or file failed to open (e.g., camera not connected,
invalid camera index, missing or unreadable file), OpenCV emitted false-positive
warnings:
- VIDEOIO(V4L2): backend is generally available but can't be used to capture by index
- VIDEOIO(FFMPEG): backend is generally available but can't be used to capture by name
even though V4L2 and FFMPEG natively support those respective modes.

Track whether apiPreference matches an available backend for the requested mode in
getAvailableBackends_CaptureByIndex, getAvailableBackends_CaptureByFilename, and
getAvailableBackends_CaptureByStream. Only log the warning when the backend is
genuinely absent from the supported list for that mode while being available on the system.

Resolves #26519

Signed-off-by: paneendrakumar0 <paneendra100@gmail.com>
 2026-10-21 16:59:39 +05:30
Shiven Solanki
2004a8568c core: SIMD masked copy for 8-byte elements 2026-10-21 16:26:53 +08:00
Alexander Smorkalov
1e71c2b43a Merge pull request #30425 from tushar152006:fix-onnx-reduce-axes-parsing 
DNN/ONNX: fix axes parsing and guard dynamic inputs in parseReduce
 2026-10-21 10:30:55 +03:00
m00dy
69c37f364d Merge pull request #30261 from professor-moody:fix/dnn-tflite-tensor-buffer-bounds 
dnn: validate TFLite tensor buffer bounds 🤖🤖🤖 - #30261

OpenCV Extra: https://github.com/opencv/opencv_extra/pull/1430

### What this changes

`TFLiteImporter::parseTensor` now checks the buffer index and required tensor bytes before constructing a `Mat` over model data. It rejects negative or overflowing shapes and unsupported sparse tensors. Absent or empty data remains a runtime tensor.

### Why

A TFLite model controls tensor shape, type, and buffer index. On 4.x at `802cf95aa3d42816995695bf68a86b3532f12760`, a tensor can claim more bytes than its selected buffer contains. The `tfliteShortBuffer` model included in this PR caused a stock Release SIGSEGV in three observed runs. The new check rejects it before the `Mat` wraps short data.

Associated upstream issue: none. Related DNN parser work includes #29371 and the closed, unmerged #29336; neither fixes this shape-to-buffer check.

### Tests and reproduction

This PR includes 15 small inline control and malformed TFLite models, importer tests, and `modules/dnn/test/generate_tflite_tensor_bounds_models.py`. The generator uses OpenCV's in-tree TFLite schema and `flatc` 25.12.19. The focused tests need no `opencv_extra` download.

To reproduce with the bytes in this PR, copy `modules/dnn/test/test_tflite_importer.cpp` and `modules/dnn/test/tflite_tensor_bounds_models.inc` from this PR into an otherwise unmodified 4.x checkout at the commit above. Build `opencv_test_dnn`, then run `./build/bin/opencv_test_dnn --gtest_filter=Test_TFLite_Importer.ShortInt32Buffer`. Apply the full PR and run `./build/bin/opencv_test_dnn --gtest_filter='Test_TFLite_Importer.*'`.

On Linux, an earlier tree that combined this patch with a separate ONNX importer fix passed all 15 focused TFLite tests and the 245-test `*Test_TFLite.*:*Test_ONNX_layers.*` filter in Release and GCC ASan builds. The compiled source and test files in this PR are byte-identical to that tree; only a generator comment changed afterwards, and rerunning the generator reproduced the include byte-for-byte. This branch has not been built on its own. Clang, MSVC, MinGW, and 5.x runtime tests have not run.

I used an AI coding tool to help prepare this change and will answer reviewer questions and address requested fixes within a day, following OpenCV's AI usage guideline. A separate reproducer archive is available on request; no files are attached to this PR.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      The test models are inline in this PR; no opencv_extra change is proposed.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-21 10:21:50 +03:00
Vladimir Iglovikov
df42eeef2b Merge pull request #30369 from ternaus:codex/python-native-byte-order 
fix(python): handle non-native NumPy byte order 🤖🤖🤖 - #30369

Python bindings can read non-native-endian NumPy inputs as native bytes, producing incorrect values or NaN. Mark swapped arrays for the existing cast path before constructing `Mat`; this also rejects incompatible output/in-place destinations before writes.

Closes #30368. Targets 4.x so the common bridge fix can be merged into 5.x.

Validation on macOS ARM64, Python 3.11.11, NumPy 2.4.6:
- Built current 4.x and 5.x. Three regression tests cover 20 dtype/layout/output cases; 18 fail before and all pass after. Read-only inputs and rejected destinations remain unchanged.
- 21 native-input timing cells on 4.x, 101 alternating pairs: fixed/baseline median time 0.957–1.005×, identical results. The 5.x check also stayed within 0.971–1.004×.
- Draft: Linux/hosted CI validation remains pending.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] The patch is not based on GPL or other incompatible code.
- [x] The PR targets the appropriate branch.
- [x] The original bug report is linked.
- [x] Regression tests and native-input performance checks are included; no external test data is needed.
- [x] No public API, feature documentation or sample changes are needed.
 2026-10-21 08:31:12 +03:00
Tushar Burla
2cf429b882 DNN/ONNX: fix axes parsing and guard dynamic inputs in parseReduce 2026-10-21 02:43:10 +05:30
Alexander Smorkalov
038cd01c03 Merge pull request #30403 from Aletimo03:ippe-fronto-parallel 
calib3d: fix IPPE rotation vector for rotations near 180 degrees
 2026-10-20 18:34:56 +03:00
Abhishek Gola
b1ed6b7184 Merge pull request #30260 from pratham-mcw/pyrMeanShift_opt 
imgproc: parallelize cv::pyrMeanShiftFiltering's per-row loop
 2026-10-20 14:35:05 +05:30
Alessio Timofte
c85f560671 calib3d: fix IPPE rotation vector for rotations near 180 degrees 
PoseSolver::rot2vec reads the rotation axis from R - R^T and divides
by sin(theta). Both vanish when the rotation is close to 180 degrees,
which is the pose of a square tag seen exactly head-on, so
SOLVEPNP_IPPE_SQUARE returned a pose flipped by 180 degrees. Fall back
to Rodrigues in that case and clamp the acos argument. The fast path
for all other rotations is unchanged.
 2026-10-19 18:26:52 +02:00
Lazizbek Ergashev
f2be0a0a28 Merge pull request #30358 from lazerg:fix/issue-30350-vittrack-clip-box 
video: clip TrackerVit box to the image - #30358

Fixes #30350

`TrackerVitImpl::update()` never bounds the predicted box to the frame, and that box sets the size of the next search crop. Once it grows past the frame, the crop is mostly padding, the network keeps predicting a large box and it can grow until the crop allocation fails. The box is now clipped to the image after each update, the same way OSTrack does it (`clip_box(..., H, W, margin=10)`); NanoTrack and DaSiamRPN already clip their results too.

With the repro from the issue on the 4.14.0 normalization (before #30168), the box now stays at most the frame size instead of reaching ~5000 px and failing to allocate. On current 4.x the growth is slower, but the box still leaves the frame (for example 1106x882 on a 720x528 frame). Added `vittrack.bbox_inside_image`, which inits with the whole frame on the `tracking/bag` sequence and fails without the fix. `accuracy_vittrack` still passes.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-19 17:10:31 +03:00
Alexander Smorkalov
43a4c20ef8 Merge pull request #30389 from sridhar-git05:fix-convertmaps-empty-src2-22763 
Fix convertMaps with empty second map
 2026-10-19 13:36:12 +03:00
Alexander Smorkalov
b29dda362e Merge pull request #30337 from velonica0:okriscv/dnn-convblock-rvv-vla-4.x 
dnn: RVV: vectorize convBlock_F32 at any VLEN with one LMUL=1 kernel
 2026-10-19 13:27:41 +03:00
Alexander Smorkalov
ee817043f0 Merge pull request #30379 from brad0:elf_aux_info_check_4.x 
core: check elf_aux_info() return value on ppc64
 2026-10-19 12:52:42 +03:00
Alexander Smorkalov
0bddb3d4c8 Merge pull request #30372 from reunanen:openjpeg-version-2.5.4 
3rdparty: report the bundled OpenJPEG as 2.5.4
 2026-10-19 12:09:05 +03:00
Pratham Kumar
310a55eeac single Telea/NS driver for all targets and add 2x2 inpaint regression test 2026-10-19 14:32:42 +05:30
Abhishek Gola
f093da6500 Merge pull request #30262 from professor-moody/fix/dnn-onnx-concat-rank-bounds 
dnn: bound ONNX Concat axes and padding ranks 🤖🤖🤖
 2026-10-19 13:21:41 +05:30
Alexander Smorkalov
6fcd0b1f9b Merge pull request #30349 from EmilAskerov:fix/missing-include-iterator-atomic-llvm-23 
Fix: Add missing includes for std::back_inserter and std::atomic
 2026-10-19 09:47:04 +03:00
sridhar-git05
7e5ae00163 Fix convertMaps with empty second map 2026-10-18 23:43:09 +05:30
Brad Smith
de80ecc474 core: check elf_aux_info() return value on ppc64 
elf_aux_info() returns non-zero on failure and leaves the output
buffer untouched. The ppc64 CPU feature detection reused one variable
for both AT_HWCAP and AT_HWCAP2, so if the AT_HWCAP2 lookup failed the
AT_HWCAP value was tested against the PPC_FEATURE2_* bits. Use a
separate variable for AT_HWCAP2 and treat a failed lookup as no
features available.
 2026-10-18 01:19:58 -04:00
Juha Reunanen
1936dc5de8 3rdparty: report the bundled OpenJPEG as 2.5.4 
Its sources have been OpenJPEG v2.5.4's since #28140.
 2026-10-17 17:03:51 +03:00
spicysharkco
2d79dcf58e core: fix FileStorage release leaks, state and unbalanced closing 
Impl::release() skipped the delayed struct (a sequence still waiting for
its first write in Base64 mode) when only the root was on the stack, so
its key leaked and the sequence was missing from the output. Resolve it
first. Reset the public FileStorage::state in release(),
releaseAndGetString() and a failed open(). An unbalanced endWriteStruct()
or closing bracket now throws and keeps the root on the stack; popping
the root made the next flush() read past the empty stack.
startNextStream() now resets the root in place instead of popping it.
A keyless writeRaw() of data into a map now throws in Base64 mode, as
it does without Base64. At the top level it opened a Base64 writer that
was never freed, and in a nested map after a closed structure it wrote
output that could not be read back.

Fixes #30338
 2026-10-16 22:06:31 +00:00
Emil Askerov
538e7bf2c1 Fix: Add missing includes for std::back_inserter and std::atomic 
Newer LLVM/libc++ versions (e.g. LLVM 23.1.3, llvm-mingw-20261006-ucrt) no longer transitively include <iterator> and <atomic>. This causes build failures in: modules/calib3d/src/stereo_geom.cpp, modules/gapi/include/opencv2/gapi/infer/ie.hpp (std::back_inserter), and modules/gapi/include/opencv2/gapi/gasync_context.hpp (std::atomic). Fixes build with modern LLVM/MinGW toolchains without CMake workarounds.
 2026-10-16 22:40:28 +03:00
Alexander Smorkalov
9b6287ec50 Merge pull request #30326 from asmorkalov:as/ffmpeg_8_version 
Corrected libavcodec version check to release n8.0
 2026-10-16 15:44:33 +03:00
Alexander Smorkalov
607d01b1dd Merge pull request #30316 from spicysharkco:fix/validate-disparity-oob 
calib3d: fix out-of-bounds access in validateDisparity
 2026-10-16 14:34:22 +03:00
Alexander Smorkalov
fc8bc13f24 Merge pull request #30235 from Vaishnavi220506:Vaishnavi220506/fix/sparse-histogram-chi-square 
imgproc: fix sparse alternative chi-square comparison 🤖🤖🤖
 2026-10-16 14:29:17 +03:00
suryapratapctrl
5a9f1eb452 Merge pull request #30213 from suryapratapctrl:fix/wasm-v-round-4x 
core: fix wasm SIMD float rounding - #30213

Summary

- Fix rounding in the WebAssembly SIMD implementation of `v_round(const v_float32x4&)`.
- Add regression tests for positive and negative halfway values.

Motivation

The previous implementation added `0.5` before truncating, which caused incorrect results for some negative values and halfway cases.

This change uses `wasm_f32x4_nearest` before converting the result to integers, providing round-to-nearest, ties-to-even behavior while preserving the existing saturating conversion.

Testing

- git diff --check passed.
- WebAssembly SIMD tests have not been run yet because Emscripten is not available in my current environment.
Pull Request Readiness Checklist

- [x] I agree to contribute to the project under the Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another license incompatible with OpenCV.
- [x] The PR is proposed to the proper branch (`4.x`).
- [ ] Reference to the original bug report and related work.
- [ ] Accuracy/performance tests and test data in `opencv_extra`, if applicable.
- [ ] Documentation and sample code, if applicable.

Related work: OpenCV 5.x rounding fix in [[PR #30007](https://github.com/opencv/opencv/pull/30007)](https://github.com/opencv/opencv/pull/30007).
 2026-10-16 14:03:35 +03:00
Pratham Kumar
b15ede0f00 fix inpaint SIMD lane-skip, reduce scalar duplication 2026-10-16 16:11:28 +05:30
Harjoth Khara
b3a6211a9b Merge pull request #30300 from harjothkhara:codex/opencv-30299-2026-10-14 
videoio(ffmpeg): fix black frames for interlaced video 🤖🤖🤖 - #30300

Merge with https://github.com/opencv/opencv_extra/pull/1435

### Summary

With FFmpeg 8+, swscale rejects converting a frame flagged as interlaced into the progressive destination frame. The error returned by `sws_scale_frame()` was ignored, so `VideoCapture::read()` returned true with black frames.

The fix copies the interlaced/top-field-first flags from the source frame onto the destination frame (like FFmpeg's scale filter, which keeps the source field flags), and makes `retrieveFrame()` fail if `sws_scale_frame()` still returns an error.

Fixes #30299

### Testing

- macOS arm64, FFmpeg 9.0.2 / swscale 10.1.102.
- New test `videoio_ffmpeg.interlaced_frame_conversion_30299` (embedded fixture) fails before the change and passes after.
- Full `opencv_test_videoio` with opencv_extra testdata: 561/561 pass.
- The reporter's 5-frame tff clip now reads identical content to the progressive clip.

### Notes / limitations

- The error branch has no direct test, because the field-flag fix removes the only deterministic trigger.
- `VideoCapture::read()` still returns true with a reused non-empty Mat when retrieve fails. This is pre-existing behaviour for all backends and is not changed here.
- Older FFmpeg without `AV_FRAME_FLAG_INTERLACED` is unaffected.

Prepared with AI assistance (Claude Code); reviewed and tested by me.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
      (Accuracy test included with an embedded fixture; no opencv_extra patch needed.)
- [ ] The feature is well documented and sample code can be built with the project CMake
      (N/A: bug fix, no new API.)

🤖 Generated with [Claude Code](https://claude.com/claude-code)
 2026-10-16 10:40:18 +03:00
velonica0
7294629fd6 dnn: RVV: vectorize convBlock_F32 at any VLEN with one LMUL=1 kernel 2026-10-15 23:28:28 -07:00
Alexander Smorkalov
9b71353da8 Merge pull request #30298 from ternaus:codex/python-inputarray-typing 
Fix Python Scalar and optional remap map2 annotations 🤖🤖🤖
 2026-10-16 08:53:58 +03:00
Alexander Smorkalov
a07749e9ad Corrected libavcodec version check to release n8.0 2026-10-16 08:39:30 +03:00
Alexander Smorkalov
386e05a00c Merge pull request #30200 from aswanth-07:fix/quaternion-small-vector-coefficients 
core: Fix quaternion trigonometric small-vector limits
 2026-10-15 16:44:06 +03:00
spicysharkco
18d8191f3f calib3d: fix out-of-bounds access in validateDisparity 
x2 is computed from the disparity value and was used as an index into
disp2cost and disp2buf without a range check, in both the CV_16S and the
CV_32S cost branches. A disparity outside the range given by minDisparity and
numberOfDisparities made x2 negative or not less than cols.

Skip such pixels in the reverse mapping pass. The final consistency pass
already bounds-checks the mapped columns.

Fixes #25367
 2026-10-15 12:35:16 +00:00
Alexander Smorkalov
9d80321677 Merge pull request #30292 from varun-jaiswal17:fix/scaled-overlap-threshold 
video(test): relax overlap threshold for MIL Scaled_Data test
 2026-10-15 08:35:45 +03:00
NIKHIL
cf475c2e2e Merge pull request #30243 from Nikhi00718:fix/dnn-blob-rect-no-resize 
dnn: fix blobRectsToImageRects when the image is not resized - #30243

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work. No existing report covers this case; reproduction is below. Related: #26085, #30042.
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable. Accuracy test added; no test data needed.
- [ ] The feature is well documented and sample code can be built with the project CMake. Not applicable to this bug fix.

### Problem

`Image2BlobParams::blobRectToImageRect()` and `blobRectsToImageRects()` return `Rect(0, 0, 0, 0)` for every rect when `Image2BlobParams::size` equals the image size, in all three padding modes. With `size` left empty (the default, which `blobFromImageWithParams()` treats as "keep the image size"), the mapping divides by zero and returns `INT_MIN` coordinates. Running a 640x640 detector on 640x640 frames is enough to hit the first case.

```python
import cv2 as cv

p = cv.dnn.Image2BlobParams()
p.size = (640, 640)
p.paddingmode = cv.dnn.DNN_PMODE_LETTERBOX
print(p.blobRectToImageRect((10, 20, 30, 40), (640, 640)))
# (0, 0, 0, 0), expected (10, 20, 30, 40)

p.size = (0, 0)
print(p.blobRectToImageRect((10, 20, 30, 40), (640, 480)))
# (-2147483648, -2147483648, -2147483648, -2147483648), expected (10, 20, 30, 40)
```

Observed with the `opencv-python` 5.0.0 wheel and with a 4.x build at `802cf95aa3`. The function is identical on 4.x and has been since it was added in #24539 (4.9.0).

### Cause

`blobFromImagesWithParams()` replaces an empty `size` with the image size and applies no resize, crop or padding when the two sizes match. `blobRectsToImageRects()` only handles the `size != imgSize` branch: when the sizes match, the output keeps the zero rects created by `rImg.resize()`, and an empty `size` goes into the resize formulas as a zero divisor.

### Change

`blobRectsToImageRects()` now follows the same two rules as `blobFromImagesWithParams()`: an empty `size` means the image size, and when the sizes match, blob and image coordinates are the same, so the input rects are returned. The resize, crop-center and letterbox mappings are unchanged.

The new test covers both cases for all three padding modes. It also checks that the blob built with the same parameters is pixel-identical to the image, which is what makes returning the input rects correct here.

#30042 (5.x feature PR) contains an equivalent pass-through for the equal-size case as part of a larger Model API change; this is the standalone fix for 4.x, including the empty-size case.

### Testing

Built `opencv_test_dnn` and the Python bindings from this branch (head `d90164465c`, base 4.x `802cf95aa3`) on Ubuntu 26.04 (WSL2), GCC 15.2, Ninja, `BUILD_LIST=dnn,python3,ts`.

- `opencv_test_dnn --gtest_filter=blobRectToImageRect*`: 4 passed. On base `802cf95aa3` the new `blobRectToImageRect.no_resize` fails in all six mode/size combinations (`[0 x 0 from (0, 0)]` for equal sizes, `INT_MIN` for empty size); the blob pixel-identity assertion passes there too.
- `opencv_test_dnn --gtest_filter='blob*:*Image2Blob*:*imagesFromBlob*'`: 11 passed.
- `modules/dnn/misc/python/test/test_dnn.py`: 10 passed, including all `blob*` tests; 6 model tests failed only because their opencv_extra files are not present locally (`dnn/googlenet_0.png`, `dnn/opencv_face_detector.prototxt`, ...).
- The Python reproducer above prints `(10, 20, 30, 40)` for both cases with this branch.
- No compiler warnings in the touched files; `git diff --check` clean.
- Full `opencv_test_dnn` was not run (needs opencv_extra test data).
 2026-10-15 08:15:11 +03:00
Vladimir Iglovikov
871ef3e60f fix(python): accept scalar and empty InputArray arguments in stubs 2026-10-15 00:26:41 +05:45
Pratham Kumar
6d4d3fd865 base parallel_for_ nstripes on input image size 2026-10-14 19:48:06 +05:30
vrooomy
473255ebf9 video(test): relax overlap threshold for MIL Scaled_Data test 2026-10-14 19:16:17 +05:30
pbkx
0332904392 Merge pull request #30281 from pbkx:fix-phasecorrelate-input-mutation-4x 
imgproc: preserve phaseCorrelate inputs when windowing - #30281

`phaseCorrelate()` currently performs a shallow copy of input matrices provided they already match the optimal DFT size. This is unsafe when a window is supplied because the in-place multiplication would overwrite the contents pointed to by the input matrices' data pointers.

This PR makes the `phaseCorrelate()` function use separate storage for applying the window. This keeps the inputs read-only (while keeping the path behavior the same as the padded case). This PR also adds a regression test for DFT-optimal and padded sizes with `CV_32F` and `CV_64F` types. The test cases include input/window preservation, ROIs, same source headers, and equivalent shift/response results.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-14 14:10:54 +03:00
pbkx
7dc5622cc0 Merge pull request #30282 from pbkx:fix-animation-encoding-params-4x 
imgcodecs: validate animation encoding parameter lists - #30282

`imwriteanimation()` and `imencodeanimation()` forward encoding parameters without the structural checks used by all the ordinary image encoding APIs.

This PR adds the same key/value-pair and maximum-count check before the functions call the animation encoder. It also adds a test that checks odd-length and over-limit parameter lists are rejected while empty and valid parameter lists still encode and decode correctly.

Related work: #22830 and #27769.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-14 13:37:21 +03:00
Pratham Kumar
1b351a67db rename the Mat from src to srcCopy 2026-10-14 13:44:37 +05:30
Alexander Smorkalov
d539219101 Merge pull request #30280 from pbkx:fix-gemm64fc-aliasing-4x 
core: fix aliased CV_64FC2 GEMM destination
 2026-10-14 10:51:11 +03:00
pbkx
7d7dc94af8 fix aliased CV_64FC2 GEMM destination 2026-10-13 20:42:48 -07:00
professor-moody
cb607b5c68 dnn: load Concat bounds models from opencv_extra 2026-10-13 08:11:59 -05:00
Pratham Kumar
05f9331d8e fix pyrMeanShiftFiltering data race for in-place calls 2026-10-13 17:26:01 +05:30
Alexander Smorkalov
7d8b32aa9c Merge pull request #30269 from Kumataro:support_webp_for_bundled_libtiff_fix_typo 
fix typo to support webp compression for bundled libtiff(4.x)
 2026-10-13 13:25:27 +03:00
Kumataro
585417393a Merge pull request #30210 from Kumataro:validateAvailableCodecs 
Merge pull request #30210 from Kumataro:validateAvailableCodecs

imgcodecs(tiff): validate codec availability - #30210

If a specified compression schema is not available, fallback to LZW (or NONE if LZW is also unavailable).
(e.g. currently bundled libtiff is not configured to support LZMA, ZSTD, and WEBP compression.)

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-13 13:19:28 +03:00
Lukasz Jobczyk
669668f306 Merge pull request #30180 from LukaszJobczyk:fix-ocl-color-yuv-vload4-overread 
imgproc: fix out-of-bounds read in OpenCL color kernels for 3-channel input 🤖🤖🤖 - #30180

YUV2RGB, RGB2YCrCb, YCrCb2RGB and the PIX_PER_WI_X != 2 path of
RGB2YUV_YV12_IYUV load each source pixel with vload4 but only use the
first three components. With SCN == 3 the load of the last pixel reads
one element past the end of the source buffer, which may result in a
GPU page fault.

Use vload3, as RGB2YUV already does, and drop the now unused
DATA_TYPE_4 macro.

The same issue is fixed in RGB2XYZ, XYZ2RGB, BGR2Lab, Lab2BGR, RGB2HSV,
HSV2RGB, RGB2HLS, HLS2RGB and RGB2RGB5x5, which load each source pixel
with vload4 but only use the first three components when SCN == 3.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-13 13:09:08 +03:00
Pratham Kumar
d7dcb0f011 fix SIGFPE crashes and RISC-V build in inpaint 2026-10-13 15:39:06 +05:30
Kumataro
ba94197bc8 fix typo to support webp compression for bundled libtiff 2026-10-13 17:57:23 +09:00
Pratham Kumar
d4524cfa8b fix indentation and -Wshadow warnings in parallel_for_ lambda 2026-10-13 13:31:19 +05:30
professor-moody
9005fe35f0 dnn: bound folded ONNX Concat axes and padding ranks 
Validate the normalized axis against every constant input rank before
folding Concat and QLinearConcat. Assert equal input ranks before the
ConcatLayer padding loop reads each dimension.

Add self-contained importer regressions and an in-tree model generator.
 2026-10-12 11:03:37 -05:00
Alexander Smorkalov
bc3d837580 Merge pull request #30231 from Kumataro:trial/support_webp_for_bundled_libtiff 
3rdparty(libtiff): expand WebP compression support for bundled libtiff
 2026-10-12 17:00:51 +03:00
Pratham Kumar
b050d58cd1 imgproc: parallelize cv::pyrMeanShiftFiltering's per-row loop 2026-10-12 18:39:57 +05:30
Alexander Smorkalov
1f2e793345 Merge pull request #30237 from DhyeyBuch:fix-video-writer-resolution 
docs(py_video_display): avoid hardcoded resolution in VideoWriter sample
 2026-10-12 11:49:20 +03:00
Kumataro
1c02d71be1 Merge pull request #30248 from Kumataro:trial/tiff_remove_unused_private_enums 
imgcodecs(tiff): remove unused private enums
 2026-10-12 11:47:17 +03:00
Pratham Kumar
ec42ced52f fix UB in inpaint for empty masks and tiny 1-channel images 2026-10-12 13:01:37 +05:30
Pratham Kumar
3e5416cbd6 photo: vectorize cv::inpaint (Telea/NS) inner loops 2026-10-11 23:22:16 +05:30
DhyeyBuch
16dc45aa1f docs(py_video_display): avoid hardcoded resolution in VideoWriter sample (fixes #30234) 2026-10-11 13:28:52 +00:00
Vaishnavi220506
9f0f40ccdd imgproc: fix sparse alternative chi-square comparison 2026-10-11 12:48:10 +05:30
Kumataro
d49f559d9a 3rdparty(libtiff): expand WebP compression support 2026-10-11 12:16:25 +09:00
Pierre Chatelier
802cf95aa3 Merge pull request #30165 from chacha21:tiff_compression_level 
Adding IMWRITE_TIFF_COMPRESSION_LEVEL - #30165

For some compression schemes (DEFLATE, ZSTD), libtiff supports a TIFFTAG_ZIPQUALITY. This PR adds an IMWRITE_TIFF_COMPRESSION_LEVEL param to set it.

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [X] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake

I don't know what kind of automatic tests could be relevant.

I just checked that 
1) the param is honoured
2) for some basic mats, level 1 gives lower compression than level 9
3) level -1 (default) gives a compression ratio between levels 1 and 9 (actually seems to be 6, as expected)

But I am not sure that 2) and 3) are generally guaranteed by the compression scheme for any data, so is it relevant to make a test assert on that ?
 2026-10-10 12:31:47 +03:00
A Aswanth Raj
6603df780b core: Fix small-vector quaternion limits 2026-10-08 22:32:01 +05:30
Shiven Solanki
67ede46c65 Merge pull request #30168 from sshivensolanki:fix-trackervit-scalefactor 
video: fix TrackerVit input scalefactor computed as Scalar - #30168

Fixes #30164

### Problem

`TrackerVitImpl` computes the input normalisation as

    i2bp.scalefactor = (1.0 / parameters.stdvalue) * (1 / 255.0);

`operator/(double, Scalar)` is the quaternion inverse (`conj(b) * a / |b|^2`), not an elementwise reciprocal. With the default `stdvalue = (0.229, 0.224, 0.225)` the applied scalefactor is `(0.00586, -0.00573, -0.00576)` instead of `(0.01712, 0.01751, 0.01743)`: channels 1 and 2 are sign-flipped and all three are about 1/3 of the intended magnitude. This was introduced in 4.11 when the elementwise `(dst - mean) / std` was replaced with `Image2BlobParams`.

### Fix

Compute `1 / (255 * std)` per channel in a small helper used by both constructors. A zero std entry (the unused 4th channel by default) maps to 0.

### Tests

`vittrack.accuracy_vittrack` on the `tracking/bag` sequence, measured locally on macOS ARM64 (4.x and 5.x):

|  | min IoU | mean IoU |
|---|---|---|
| before | 0.642 | 0.757 |
| after | 0.682 | 0.776 |

On other CI platforms (x64, Windows, no-HAL) the minimum IoU with the fix is 0.658, so the existing 0.64 threshold is kept.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-10-08 14:13:57 +03:00
胡晨宇
07e29c2ac4 Merge pull request #30057 from hcy11123323:rvv-fused-rotate-hal-pr 
RVV: add fused HAL implementation for rotate - #30057

## Pull Request Readiness Checklist

See details at [https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request](https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request)

- [x] I agree to contribute to the project under the Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another license that is incompatible with OpenCV.
- [x] The PR is proposed to the proper branch (`4.x`).
- [x] Accuracy tests are included and performance results are provided below.

## Summary

This PR adds an RVV HAL implementation for `cv_hal_rotate90` and fuses the transpose and flip operations used by 90-degree and 270-degree rotations into a single vectorized pass.

The previous path composes transpose and flip operations, which requires an intermediate image and additional memory traffic. The new RVV path loads several source rows, builds RVV vector tuples, and writes directly to the final rotated positions with strided segmented stores.

## Implementation details

- Registers `cv_hal_rotate90` in the RISC-V RVV core HAL.
- Processes 1-, 2-, and 8-byte elements in blocks of eight source rows using `vssseg8e8`, `vssseg8e16`, and `vssseg8e64`.
- Processes 4-byte elements in blocks of four source rows using `vssseg4e32`.
- Uses positive or negative destination strides to implement clockwise and counter-clockwise rotation without a separate flip pass.
- Uses dynamic VL and strided vector stores for remaining rows and non-multiple tails.
- Supports padded/non-contiguous source rows through `src_step` and `dst_step`.
- Returns `CV_HAL_ERROR_NOT_IMPLEMENTED` for aliased input/output and unsupported element sizes, preserving the existing OpenCV fallback behavior.
- Keeps the existing RVV flip path for 180-degree rotation when safe.
- For 1-byte 180-degree rotation with `VLMAX > 256`, uses 16-bit gather indices with `vrgatherei16` to avoid index wraparound in the existing 8-bit gather path.
- Includes compatibility helpers for Clang versions earlier than 18 that do not provide the required vector tuple creation intrinsics.

The directly accelerated total element sizes are 1, 2, 4, and 8 bytes. Other sizes, including common 3- and 6-byte pixel formats, fall back to the existing implementation.

## Test environment

```text
Build type: Release
Compiler: GCC 14.2.0
ISA flags: -march=rv64gcv
RISCV_RVV_SCALABLE: ON
CPU_BASELINE_REQUIRE: RVV
QEMU: 8.2.2, RVV 1.0
```

## Accuracy tests

The new `Core_Rotate.OddSizesAndPaddedRows` test and the existing randomized rotate test passed under QEMU RVV at VLEN 128, 256, 512, and 1024.

## Performance tests

Performance was measured with `opencv_perf_core` under the environment described above. Detailed performance results are provided in the comment below.

These measurements are intended to show the relative difference between identical baseline and optimized builds under QEMU. Absolute performance should be confirmed on RISC-V hardware.
 2026-10-06 12:07:58 +03:00
Alexander Smorkalov
b512c2bd6e Merge pull request #30152 from tandede:fix/armv7-gemm-fp64-guard 
core: guard FP64 GEMM SIMD paths on ARMv7 🤖🤖🤖
 2026-10-06 10:13:31 +03:00
A Aswanth Raj
e2f1bf29b0 Merge pull request #30135 from aswanth-07:fix/python-function-module 
fix(python): set module metadata on generated functions - #30135

Fixes #19349.

Generated Python functions such as `cv2.GaussianBlur` expose `__module__ = None`, so `inspect.getmodule()` returns `None`.

Pass the defining module name to `PyCFunction_NewEx` during registration. The existing `PySafeObject` wrapper manages the string reference. Function definitions, call flags, `__self__` and namespace ownership stay unchanged.

The tests cover both expressions from the ticket and module lookup, native-callable classification and pickle identity for the root, `cv2.utils` and `cv2.utils.nested`. The expected ticket output is:

```text
cv2
<built-in function GaussianBlur>
```

CPython represents native extension functions as `BuiltinFunctionType`, including `math.sin`. This patch preserves that representation while supplying the missing module metadata. See the [Python C API documentation](https://docs.python.org/3.13/c-api/structures.html#c.PyCFunction_Type).

### Validation

- Compiled isolated checks using the pristine and patched `createSubmodule` and `init_submodule` code and the unchanged `PySafeObject` wrapper. Root and nested call, constant, native type, representation and pickle controls pass on both. The pristine module assertion fails with `None`; patched module metadata and `inspect.getmodule()` pass. These checks use an echo callback and validate registration, rather than an OpenCV kernel.
- The ticket regression fails with `None != 'cv2'` against the installed OpenCV 4.12.0 binary. Three existing namespace and class-alias tests and four native-function representation controls pass against that binary and Python's standard library.
- `py -3.13 -m py_compile modules/python/test/test_misc.py` and `git diff --check` pass.

I have not built the full checkout locally. The [current-head CI workflow](https://github.com/opencv/opencv/actions/runs/37276602842) is awaiting maintainer approval (`action_required`) with no jobs yet. The updated binding tests have not run in CI. On the previous head, `8600aa69`, the Python suite reported 291 tests with 18 skips and `test_function_module` passed. The new ticket regression was added afterward, so those results do not validate it. An earlier macOS x64 native stitching test aborted with exit 134 outside this patch; its maintainer-triggered rerun was queued before this update.

### Pull Request Readiness Checklist

See https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request.

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      The regressions use existing Python functions and require no external test data or performance benchmark.
- The feature-documentation and sample-build item does not apply to this metadata bug fix.

### AI assistance disclosure

AI assistance disclosure: AI-assisted development tools were used during investigation and implementation. The reported tests were run against the final diff.
 2026-10-06 09:40:10 +03:00
tandede
5a30c27c98 Fix ARMv7 FP64 GEMM SIMD dispatch 2026-10-06 09:45:39 +08:00
Kari Pikkarainen
53ebe537da Merge pull request #30139 from kari-pikkarainen:fix/python-stubs-optional-output-args 
python: mark documented None output arrays as optional in typing stubs 🤖🤖🤖 - #30139

Fixes #30138

The generated Python stubs type several output arrays as required, although OpenCV's own Python samples and tutorials pass `None` for them and the function allocates the output. These arrays are `InputOutputArray`/`OutputArray` parameters without a C++ default, so the stub generator does not add `| None`. As a result, mypy rejects correct code with `No overload variant ... matches [call-overload]`.

This PR adds `make_optional_arg` entries to `NODES_TO_REFINE` in `modules/python/src2/typing_stubs_generation/api_refinement.py`, the same approach as #28470 (`calibrateCamera`) and #27564:

| Function | Argument |
|---|---|
| `calcOpticalFlowPyrLK` | `nextPts` |
| `calcOpticalFlowFarneback` | `flow` |
| `normalize` | `dst` |
| `kmeans` | `bestLabels` |
| `drawKeypoints` | `outImage` |
| `drawMatches` | `outImg` |
| `drawMatchesKnn` | `outImg` |

`None` is only valid at runtime when the corresponding flag is not set (`OPTFLOW_USE_INITIAL_FLOW`, `KMEANS_USE_INITIAL_LABELS`, `DrawMatchesFlags_DRAW_OVER_OUTIMG`). Like `distCoeffs` in #28470, the change only widens the accepted type and does not change bindings or runtime behaviour.

### Verification

- I ran `gen2.py` from this branch and from `4.x` (62587ae) using the CMake-generated `gen_python_config.json`. The only differences in the generated `cv2/__init__.pyi` are 16 signatures (Mat and UMat overloads for each function; `drawMatches` has two C++ overloads). In each one, the listed argument changes from `cv2.typing.MatLike` / `UMat` to `... | None`. With a fixed `PYTHONHASHSEED` no other file differs; without it, the import order in `cv2/typing/__init__.py` varies from run to run because `generation.py` iterates a set, independently of this change.
- mypy 2.4.0 (MYPYPATH pointing at the generated stubs) on the 7 calls from #30138, for example `cv2.calcOpticalFlowPyrLK(prev, curr, pts, None)` and `cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX)`: all 7 fail with `call-overload` on the base stubs, and mypy reports no errors for these calls on the patched stubs (the generated stubs have some pre-existing internal errors, unchanged by this PR). The same calls run correctly with `opencv-python-headless` 4.14.0.94 and 5.0.0.93.
- No C++ or binding code changes. No regression test is added, because the repository has no existing test for the stub generator or `api_refinement.py` to extend.

_Prepared with AI assistance (Claude Code); I reviewed the change and the verification results._

**Update:** Added a second commit: `NODES_TO_REFINE` entries whose function, class or namespace is absent from the build (e.g. `video` or `calib3d` disabled via `BUILD_LIST`) are now skipped instead of aborting stub generation, as the `dnn`/`cuda` refinements already do. This also fixes the pre-existing failure for builds without `calib3d`. A wrong argument name in a present function still raises `RuntimeError`; a misspelled function name is now skipped like an absent one. Builds without `features2d` still fail for a separate reason (the `Feature2D` aliases in `predefined_types.py`), which I'll address in a follow-up.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake

🤖 Generated with [Claude Code](https://claude.com/claude-code)
 2026-10-05 15:04:00 +03:00
Prasad Ayush Kumar
7ee43da56d Merge pull request #30115 from Prasadayus:fix/neon-cvt-f64-precision 
Fix int32 to double precision loss on ARM NEON - #30115

Fixes https://github.com/opencv/opencv/issues/30114

int32 to float64 conversion on **NEON went through a lossy int32 -> float32 -> float64 round trip**. float32's 24-bit mantissa silently corrupts any value above 2^24, causing `BigData_Imgproc_DistanceTransform.large_image_12218` to fail on ARM64 NEON builds.

Added a directed test (`test_cvt64_int32_precision`) covering large int32 magnitudes on both halves of the register, and confirmed the existing `BigData_Imgproc_DistanceTransform.large_image_12218` test now passes.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-10-05 14:18:24 +03:00
Alexander Smorkalov
62587ae997 Merge pull request #30130 from aswanth-07:fix/cache-dir-test-isolation 
test: isolate cache-directory image files
 2026-10-02 12:05:42 +03:00
aswanth-07
fca4226f5a test: isolate cache-directory image files 2026-10-02 09:29:06 +05:30
Alexander Smorkalov
237b3c2eac Merge pull request #30112 from lgoossens-ekoscan:fix-hw-frame-colorimetry-4x 
videoio(ffmpeg): keep frame properties across av_hwframe_transfer_data()
 2026-10-01 18:14:01 +03:00
Alexander Smorkalov
ec92ed9323 Merge pull request #30122 from xiaotang2333333:fix-kleidicv-license 
Install KleidiCV license
 2026-10-01 14:59:18 +03:00
xiaotang
310bf2c0a4 Install KleidiCV license like other downloaded 3rdparty components 2026-10-01 15:51:07 +08:00
Alexander Smorkalov
3679a26580 Merge pull request #30098 from Prasadayus:fix/carotene-c4244-warnings 
Carotene HAL warnings fix on Windows ARM64.
 2026-10-01 08:56:07 +03:00
Loic Goossens
e1d721d906 videoio(ffmpeg): keep frame properties across av_hwframe_transfer_data() 
With hardware decoding, retrieveFrame() downloads the GPU frame into a new
AVFrame with av_hwframe_transfer_data(). That call copies the pixel data
only: colorspace, color_range, color_primaries, color_trc and
chroma_location are left unspecified in the system memory copy.

With swscale >= 8.12.100 the color conversion goes through
sws_scale_frame(), which configures itself from the properties of the source
frame. Given unspecified properties it falls back to BT.601 limited range, so
hardware-decoded frames are converted with the wrong matrix whatever the
stream signals, and full range streams additionally lose contrast. Software
decoding is not affected, the decoder output carries the properties.

fftools/ffmpeg_dec.c handles this by calling av_frame_copy_props() right
after the transfer; do the same. A failure is only logged: it can only be an
allocation failure on side data, and the picture itself is still valid.

With swscale < 8.12.100 the conversion context is initialized without the
frame properties, so this change has no effect on that path.

Measured on Windows x64 with the OpenCV 5.0.0 FFmpeg wrapper built by the
opencv_3rdparty MinGW recipe against FFmpeg n8.1.3 (libswscale 9.5.103),
D3D11VA decoding, on two synthetic BT.709 H.264 samples:

  ffmpeg -f lavfi -i testsrc2=size=1280x720:rate=30 -t 2 -c:v libx264 \
         -pix_fmt yuv420p -color_range tv -colorspace bt709 \
         -color_primaries bt709 -color_trc bt709 bt709_tv.mp4
  ffmpeg -f lavfi -i testsrc2=size=1280x720:rate=30 -t 2 -c:v libx264 \
         -pix_fmt yuvj420p -color_range pc -colorspace bt709 \
         -color_primaries bt709 -color_trc bt709 bt709_pc.mp4

Frame 0 is compared with a reference built from the same static FFmpeg
libraries: software decode, lossless repack to NV12 (the D3D11VA download
format), av_frame_copy_props(), then sws_scale_frame() to BGR24 exactly as
retrieveFrame() does.

  sample          before (mean / max abs diff)   after
  bt709_tv.mp4    7.424 / 94                     bit-exact
  bt709_pc.mp4    3.286 / 101                    bit-exact

Before the patch the output is bit-exact with the same reference built
without the frame properties, which confirms the cause. Software decoding
output is unchanged (bit-exact before and after). Two real H.264 recordings
(BT.709, full and limited range) behave the same way.

Hardware and software decoding still do not produce identical pictures after
this patch: swscale converts NV12 and yuv420p differently around sharp chroma
edges. That difference exists with the same properties outside OpenCV too
and is not addressed here.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
 2026-09-30 09:34:04 +02:00
47022578z-collab
d21a05f1af Merge pull request #30086 from 47022578z-collab:fix-farneback-initial-flow 
video: add validation for OPTFLOW_USE_INITIAL_FLOW in calcOpticalFlowFarneback - #30086

Add explicit parameter check for initial flow in `calcOpticalFlowFarneback`. 
When `OPTFLOW_USE_INITIAL_FLOW` flag is passed but the `flow` matrix is empty/missing, this provides a descriptive runtime error instead of non-deterministic behavior or garbage values.

Fixes #7276.

### Pull Request Readiness Checklist
- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV.
- [x] The PR is proposed to the proper branch (`4.x`).
- [x] There is a reference to the original bug report (#7276).
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable.
- [x] The feature is well documented and sample code can be built with the project CMake.
 2026-09-29 19:44:42 +03:00
Prasadayus
62cd3d63c5 Carotene HAL warnings fix on Windows ARM64. 2026-09-29 19:17:41 +05:30
pbkx
2c9dce6164 Merge pull request #30013 from pbkx:fix-calibration-noncontiguous-points 
calib3d: support non-contiguous calibration point vectors - #30013

calibrateCamera rejects valid non-contiguous point-vector Mats due to the calibration data collector validating them with checkVector's default continuity requirement and then assuming linear contiguous storage. As a result, an Nx1 Point3f/Point2f ROI fails while an equivalent continuous matrix with same shape/type/values succeeds.

This PR adds a test comparing continuous and ROI-backed calibration inputs, with the test verifying equivalent RMS, camera matrix, and distortion coefficients, and that the caller's ROI backing data and padding are left unchanged. Allow non-contiguous point vectors during validation, and clone only non-contiguous inputs before the existing linear copy path. Continuous inputs are no-copy'd as is.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-29 13:26:31 +03:00
Alexander Smorkalov
30f5aac0bd Merge pull request #30093 from jayzuccarelli:fix-stub-sequence-typing-import 
python: typing stubs: import typing for Sequence return types 🤖🤖🤖
 2026-09-29 13:14:14 +03:00
Eugenio "Jay" Zuccarelli
d3427276fb python: typing stubs: import typing for Sequence return types 
SequenceTypeNode and ClassTypeNode always format as _typing.Sequence[...]
and _typing.Type[...], but ContainerTypeNode only reports the typing
import as required when compatible_to_runtime_usage is set. Stubs for
modules that use these nodes without any other _typing usage (e.g.
cv2/videoio_registry) reference _typing without importing it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
 2026-09-29 03:32:55 +00:00
Pratham Kumar
8dcbf62ef3 Merge pull request #30035 from pratham-mcw:invert_opt 
add ARMPL HAL backend for cv::invert(DECOMP_LU) - #30035

## Summary

- Adds an ARM Performance Library (ArmPL) HAL backend for cv::invert under DECOMP_LU (cv_hal_LU32f / cv_hal_LU64f), replacing OpenCV's default LU decomposition path with ArmPL's LAPACKE_sgesv / LAPACKE_dgesv for float and double matrices on AArch64. 

## Changes
**hal/armpl/include/armpl_hal_core.hpp:**

- Declare armpl_hal_LU32f / armpl_hal_LU64f and register them as cv_hal_LU32f / cv_hal_LU64f.

hal/armpl/src/armpl_hal_core.cpp:

- Add armpl_lu() function (works for both float and double), that does the LU decomposition of the matrix:
  - If a right-hand side b is given, then LAPACKE_sgesv/dgesv is called.
  - If no right-hand side is given, it only factorizes the matrix using LAPACKE_sgetrf/dgetrf 

- Fall back to OpenCV's default (non-HAL) implementation for small matrices (m < 100).

## Performance Benchmarks
<img width="1001" height="105" alt="image" src="https://github.com/user-attachments/assets/ba18378c-24da-4d20-9819-3b4398cad6e2" />
<img width="1002" height="105" alt="image" src="https://github.com/user-attachments/assets/ff33d421-b95d-4fca-aad0-ab7bc035d49b" />
<img width="999" height="108" alt="image" src="https://github.com/user-attachments/assets/d4abb57e-6be0-4ea1-9894-d30074c9429c" />
 2026-09-28 12:35:19 +03:00
kevin
d79e074422 Merge pull request #29926 from kevin9327:fix/jpeg2000-small-image-encode 
imgcodecs: fix JPEG 2000 encoding of images smaller than 32 pixels 🤖🤖🤖 - #29926

`imwrite()` and `imencode()` cannot write a JPEG 2000 file for any image narrower or shorter than 32 pixels. The call fails with

```
OpenJPEG2000: Number of resolutions is too high in comparison to the size of tiles
imencode(): can't encode data: OpenCV(4.15.0-dev) .../grfmt_jpeg2000_openjpeg.cpp:802:
error: (-213:The function/feature is not implemented) OpenJPEG2000: Can not start
compression in function 'cv::Jpeg2KOpjEncoder::write'
```

and returns `false`. Every other encoder in the module writes an 8x8 image without complaint, so this is a gap specific to the OpenJPEG path.

`setupEncoderParameters()` never touched `opj_cparameters::numresolution`, leaving it at the OpenJPEG default of 6. `opj_j2k_encoding_validation()` (`3rdparty/openjpeg/openjp2/j2k.c:8840-8851`) requires each tile to be at least `1 << (numresolutions - 1)` in both directions, and because OpenCV does not enable tiling the single tile is the whole image. The threshold is therefore exactly `2^5 = 32` px, which matches the observed boundary: a 32x32 image encodes, a 31x31 image does not.

This patch lowers `numresolution` to what the image size allows. It only ever lowers it, so an image that is at least 32x32 keeps the default of 6 and its encoded bytes are unchanged. No public API is changed and no new test data is needed.

### Validation

Built `opencv_test_imgcodecs` on Windows 10.0.26200 x64 with MSVC 19.51.36256 (Visual Studio 18), Release, `-DBUILD_LIST=core,imgproc,imgcodecs,ts -DCPU_DISPATCH=` (baseline SSE3), bundled OpenJPEG 2.5.3, on `4.x` at `0aa49a8e`.

The test is in the first commit and the fix in the second. Against unmodified `0aa49a8e` the new test fails on the very first size:

```
[ RUN      ] Imgcodecs_Jpeg2000.encode_small_image
[ERROR:0@0.034] global grfmt_jpeg2000_openjpeg.cpp:299 cv::`anonymous-namespace'::errorLogCallback OpenJPEG2000: Number of resolutions is too high in comparison to the size of tiles
modules\imgcodecs\test\test_read_write.cpp(341): error: Value of: imencode(".jp2", src, buf)
  Actual: false
Expected: true
imencode() failed for .jp2
Google Test trace:
modules\imgcodecs\test\test_read_write.cpp(336): 1x1
[  FAILED  ] Imgcodecs_Jpeg2000.encode_small_image (3 ms)
```

With the fix applied, all six sizes (1x1, 8x8, 31x31, 64x8, 8x64, 32x32) encode, decode back to the same size and type, and round-trip bit-exactly:

```
[ RUN      ] Imgcodecs_Jpeg2000.encode_small_image
[       OK ] Imgcodecs_Jpeg2000.encode_small_image (23 ms)
[  PASSED  ] 1 test.
```

The 64x8 and 8x64 cases cover the tile-height and tile-width conditions separately; 32x32 pins the boundary where the default is still used.

No other result in the module changed. `opencv_test_imgcodecs` with no filter:

| | tests run | passed | failed |
|---|---:|---:|---:|
| unmodified `0aa49a8e` | 757 | 231 | 526 |
| with this patch | 758 | 232 | 526 |

The patch adds exactly one test, it passes, and the failed count is identical. Those 526 failures are pre-existing on this machine and unrelated to this change: `opencv_extra` is not checked out here, so every test that calls `findDataFile()` fails. I did not run the suite against `opencv_extra` data, and I have not tested a JasPer or a non-x86 build.

As a direct check that images at or above the threshold are untouched, I encoded the same fixed inputs before and after the patch and compared the output sizes. They are byte-for-byte identical above the threshold, and only the previously-failing cases change:

```
                     before        after
 8x8   CV_8UC3       (failed)      250 bytes
 8x8   CV_16UC3      (failed)      249 bytes
32x32  CV_8UC3          755 bytes    755 bytes
32x32  CV_16UC3        1542 bytes   1542 bytes
64x64  CV_8UC3         2952 bytes   2952 bytes
129x129 CV_8UC3       11981 bytes  11981 bytes
129x129 CV_16UC3      24922 bytes  24922 bytes
```

`git diff --check` is clean. `5.x` carries the identical code and the identical defect; this is proposed to `4.x` per the branch policy, to be ported by the core team.

I did not find an existing issue for this, so the PR references none.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work *(no existing report found)*
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable *(accuracy test added in the first commit; self-contained, no new test data)*
- [ ] The feature is well documented and sample code can be built with the project CMake *(not applicable: bug fix, no API or documented behaviour change)*
 2026-09-28 11:07:41 +03:00
Alexander Smorkalov
f70a7d035c Merge pull request #30068 from peters:fix/gstreamer-null-on-start-failure 
videoio(gstreamer): set pipeline to NULL before releasing it on start failure 🤖🤖🤖
 2026-09-28 09:50:18 +03:00
Kumataro
d13ae27a93 Merge pull request #30062 from Kumataro:support16bitAVIF 
imgcodecs: avif: support 16-bit reading/writing with libavif v1.4.0+ - #30062

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-09-28 09:40:41 +03:00
Lurie97
9a78d45a2f Merge pull request #30022 from Lurie97:carotene-resize-left-edge-clamp 
carotene: clamp left-edge weight in downsample_bilinear_8uc1 - #30022

For the leftmost pixel the sample coordinate c = 0.5*wr - 0.5 can be negative, so the left-column weight overflows full-scale and interpolation extrapolates beyond the source, corrupting the first output column.

Clamp the weight to full-scale when c < 0, matching the scalar/OpenCL edge handling. Affects both the 16- and 8-wide column loops.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [ ] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-28 09:10:00 +03:00
Andrei Fedorov
a61df2c9ae Merge pull request #30060 from intel-staging:andreyfe1/ippicv_2026_1 
Update IPP ICV integration to IPP 2026.1.0 (20260922) - #30060

## Description

Supported IPP version was updated to IPP 2026.1.0 (202600922) both for Windows and Linux together with enabling cases suspended for the previous release.
IPPICV binaries are here https://github.com/opencv/opencv_3rdparty/pull/111.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-28 08:32:35 +03:00
Peter Rekdal Khan-Sunde
744002fcb9 videoio(gstreamer): set pipeline to NULL before releasing it on start failure 
handleMessage() resets the state only when an error message is already on the bus. When the state change fails before the streaming thread posts its error, the pipeline was released in PAUSED with streaming threads still running, which logs 'Trying to dispose element ... but it is in PAUSED instead of the NULL state' and can crash the process.
 2026-09-26 05:55:15 +02:00
Alexander Smorkalov
bed6800f05 Merge pull request #29940 from sergiud:fisheye-lm-solver 
calib3d: improve fisheye extrinsic refinement
 2026-09-24 09:55:32 +03:00
Pratham Kumar
f46dd2af02 Merge pull request #30045 from pratham-mcw:svd_opt 
core: add ArmPL HAL backend for cv::SVD::compute - #30045

## Summary

- Adds an ARM Performance Library (ARMPL) HAL backend for cv::SVD::compute (cv_hal_SVD32f / cv_hal_SVD64f), replacing OpenCV's default SVD path with ARMPL's LAPACKE_sgesdd / LAPACKE_dgesdd for float and double matrices on AArch64. 

## Changes
**hal/armpl/include/armpl_hal_core.hpp:**

- Declare armpl_hal_SVD32f / armpl_hal_SVD64f and register them as cv_hal_SVD32f / cv_hal_SVD64f.

**hal/armpl/src/armpl_hal_core.cpp:**

- Add a templated armpl_svd helper that maps OpenCV's CV_HAL_SVD_NO_UV / SHORT_UV / MODIFY_A / FULL_UV flags onto LAPACKE's jobz parameter and calls LAPACKE_sgesdd / dgesdd.
- Fall back to OpenCV's default (non-HAL) implementation for small matrices (m < 33, ARMPL_SVD_SMALL_MATRIX_THRESH).
## Performance Benchmarks
<img width="842" height="422" alt="image" src="https://github.com/user-attachments/assets/12b84943-be57-4bf4-9d7e-c85121da4689" />
 2026-09-24 09:22:41 +03:00
Alexander Smorkalov
c7b9dc388c Merge pull request #30038 from lgoossens-ekoscan:fix-seek-nopts-start-time-4x 
videoio(ffmpeg): guard seek() against AV_NOPTS_VALUE start_time
 2026-09-23 10:45:44 +03:00
Loic Goossens
527a6b2284 videoio(ffmpeg): guard seek() against AV_NOPTS_VALUE start_time 
CvCapture_FFMPEG::seek() seeds the seek target with the stream start_time
without checking for AV_NOPTS_VALUE, while dts_to_sec() right above it does
perform that check.

Some containers do not let FFmpeg establish a start time, for instance
Matroska files whose H.264 track is declared through the legacy VfW wrapper
(CodecID V_MS/VFW/FOURCC with a BITMAPINFOHEADER) instead of V_MPEG4/ISO/AVC
with an avcC record. For those, start_time is AV_NOPTS_VALUE, the computed
target becomes INT64_MIN plus an offset, and av_seek_frame() with
AVSEEK_FLAG_BACKWARD lands at position 0. The refinement loop below then
decodes every single frame up to the requested one, so every seek degrades to
a linear scan. The returned frame is still correct, which makes the failure
silent and easy to miss.

Such a container is not otherwise malformed: its Cues index is complete and
correct, and `ffmpeg -ss` seeks it in constant time at any offset.

Measured with OpenCV 4.14.0 on a 15 h H.264 recording (1628443 frames),
Windows x64, stock prebuilt FFmpeg wrapper versus the same wrapper rebuilt
with this patch:

  target        before      after
     10 s      0.246 s     0.092 s
     60 s      1.494 s     0.039 s
    300 s      7.569 s     0.052 s
  10000 s      ~4 min      0.061 s
  54000 s     ~22 min      0.051 s

Before the patch the cost grew strictly linearly with the target position, at
roughly 25 ms per second of video, so the two longest targets were
extrapolated rather than waited out. Decoded frames are unchanged for targets
that both paths reach.

The guard mirrors the one already present in dts_to_sec().

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
 2026-09-22 10:05:58 +02:00
Pratham Kumar
a91ff70ceb Merge pull request #29983 from pratham-mcw:gemm-opt 
core: accelerate cv::gemm with ARMPL cblas_sgemm/cblas_dgemm - #29983

## Summary
- Adds an ARM Performance Library (ArmPL) HAL backend for cv::gemm (cv_hal_gemm32f / cv_hal_gemm64f), replacing OpenCV's default GEMM path with ArmPL's cblas_sgemm / cblas_dgemm for float and double matrix multiplication on AArch64.

## Changes
**hal/armpl/include/armpl_hal_core.hpp:**
-  declare armpl_hal_gemm32f / armpl_hal_gemm64f and register them as cv_hal_gemm32f / cv_hal_gemm64f. 

**hal/armpl/src/armpl_hal_core.cpp:**
- Add a templated armpl_gemm helper that maps OpenCV's GEMM_1_T / GEMM_2_T / GEMM_3_T flags onto CBLAS transpose/layout arguments and calls cblas_sgemm / cblas_dgemm (row-major).  
-  Fall back to OpenCV's default (non-HAL) implementation for small matrices. (m < 100, ARMPL_GEMM_SMALL_MATRIX_THRESH)   

## Performance Benchmarks
<img width="1080" height="275" alt="image" src="https://github.com/user-attachments/assets/cddce8ce-93ca-4c8e-8b37-a9d42ead0c53" />
 2026-09-22 10:33:22 +03:00
Sewon Ahn
62751db0d7 Merge pull request #30005 from lrycro:fix/glob-readdir-leak 
core: fix memory leak in glob()'s readdir() on WinRT/_WIN32_WCE - #30005

## Problem

Fixes #30004

In `modules/core/src/glob.cpp`, the WinRT/`_WIN32_WCE` implementation of `readdir()` allocates a new buffer for `dir->ent.d_name` on every call and overwrites the previous pointer without freeing it:

```cpp
char* aname = new char[asize+1];
...
dir->ent.d_name = aname;
```

`cv::glob()` calls `readdir()` once per directory entry, so every call except the last leaks its allocation. Additionally, the `DIR` destructor that releases `d_name` was gated by `#ifdef WINRT` only, so `_WIN32_WCE` builds leaked every allocation, including the last one.

## Fix

- Free the previous `dir->ent.d_name` before overwriting it in `readdir()`, matching how `~DIR()` already frees it on WinRT.
- Extend the `DIR` destructor guard from `#ifdef WINRT` to `#if defined(WINRT) || defined(_WIN32_WCE)` so the final buffer is also released under `_WIN32_WCE`.

## Checklist

- [x] I agree to contribute to the project under the Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another license incompatible with OpenCV.
- [x] The PR is proposed to the proper branch (`4.x`).
- [x] There is a reference to the original bug report and related work.
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable.
- [x] The feature is well documented and sample code can be built with the project CMake.

Thanks for reviewing.
 2026-09-21 18:07:13 +03:00
Alexander Smorkalov
73a4f63134 Merge pull request #30014 from pbkx:fix-outputarray-array-mat-release 
core: fix OutputArray release for std::array<Mat>
 2026-09-21 16:15:10 +03:00
Alexander Smorkalov
d5c6e8be7b Merge pull request #30024 from maaz7409:4.x 
Doc: Update Twitter link to X in README.md (4.x branch)
 2026-09-21 14:20:49 +03:00
Mohd Maaz Khan
a023b0d69c Doc: Update Twitter link to X in README.md 2026-09-21 16:23:11 +05:30
Alexander Smorkalov
0781253073 Merge pull request #30010 from Kumataro:cleanupEmscriptionInstallationGuideForOpenCV4 
js: doc: clean up Emscripten installation guide (for 4.x)
 2026-09-21 12:03:30 +03:00
pbkx
018bc3ebdf fix OutputArray release for std::array<Mat> 2026-09-20 20:35:14 -07:00
Kumataro
35bb03a9fc js: doc: clean up Emscripten installation guide 2026-09-21 09:02:59 +09:00
Sergiu Deitsch
9e15eac47f calib3d: improve fisheye extrinsic refinement 
Improve fisheye extrinsic refinement for ill-conditioned views and
poorly scaled object points. Replace the Gauss-Newton update with a
Levenberg-Marquardt solver and normalize translation parameters to make
convergence less sensitive to problem scale.
 2026-09-20 01:45:44 +02:00
Alexander Smorkalov
b6a8780959 Merge pull request #29988 from yqtian-se:fix-rvv-diagnostic-scope 
core(rvv): restore GCC diagnostic state after scalable intrinsics
 2026-09-19 14:32:11 +03:00
yqtian-se
ffaa389415 Scope GCC diagnostic suppression in RVV intrinsics 2026-09-18 12:37:29 +00:00
Alexander Smorkalov
cf66d2c6ad Merge pull request #29972 from andreyfe1:extend_perf_calib3d 
Extend calib3d perf tests
 2026-09-17 16:06:48 +03:00
Alexander Smorkalov
7434859646 Merge pull request #29960 from amd:imp_mergedebevec 
Fuse and vectorize MergeDebevec for HDR.
 2026-09-17 15:59:38 +03:00
Alexander Smorkalov
186f31f09e Merge pull request #29966 from pbkx:fix-calc-covar-vector-mean-roi 
fix calcCovarMatrix vector mean ROI handling
 2026-09-17 15:58:10 +03:00
Madan mohan Manokar
46b9862506 Fuse and vectorize MergeDebevec for 1- and 3-channel HDR. 
Fold LUT/split/mul into one pass and SIMD the accumulate/finalize loops to cut full-image temporaries.
 2026-09-17 09:21:54 +00:00
Alexander Smorkalov
a31b3d5e85 Merge pull request #29971 from asmorkalov:as/riscv_ci_fix_4.x 
Fixed path to RISC-V CI script.
 2026-09-17 12:01:08 +03:00
Fedorov, Andrey
71c17ec0cd calib3d perf: filterSpeckles 2026-09-17 02:00:34 -07:00
Alexander Smorkalov
61453b77fa Fixed path to RISC-V CI script. 2026-09-17 12:00:11 +03:00
pbkx
db189ed863 fix calcCovarMatrix vector mean ROI handling 2026-09-16 18:41:52 -07:00
Abhishek Gola
5c061f003b Merge pull request #29312 from pratham-mcw/dft_cache_thrashing_fix 
core: Add padded buffer for DFT on Windows ARM64 to reduce cache thrashing
 2026-09-15 18:07:26 +05:30
Alexander Smorkalov
62f14c08d1 Merge pull request #29956 from asmorkalov:as/win32_warning_fix 
Warning fix on Windows.
 2026-09-15 12:01:27 +03:00
Alexander Smorkalov
b24763ffa9 Warning fix on Windows. 2026-09-15 10:21:31 +03:00
Andrei Fedorov
96ec0c97df Merge pull request #29922 from andreyfe1:extend_perf_core 
Extend core performance tests - #29922

Added more cases for performance tests. It's a part of a bigger PR https://github.com/opencv/opencv/pull/29631
execution time increased by <18% per my measurements.
Duplication of https://github.com/opencv/opencv/pull/29900, but from a different fork.
`opencv_extra` PR is https://github.com/opencv/opencv_extra/pull/1410

Following was added:

| File | Test | Added |
|------|------|-------|
| `perf_arithm.cpp` | `BinaryOpTest.*` (add/subtract/multiply/absdiff/min/max/transpose2d) | types `CV_16UC1`, `CV_64FC1` |
| `perf_compare.cpp` | `compareScalar` | types `CV_16UC1`, `CV_16SC1` |
| `perf_dot.cpp` | `dot` | type `CV_64FC1` |
| `perf_flip.cpp` | `flip` (`FLIP_TYPES`) | types `CV_32FC3`, `CV_32FC4` |
| `perf_mat.cpp` | `Mat_CopyToWithMask` | types `CV_32FC3` |
| `perf_mat.cpp` | `Mat_SetToWithMask` | types `CV_8UC3, CV_8UC4, CV_16UC3, CV_16UC4, CV_32FC3, CV_32FC4` |
| `perf_norm.cpp` | `norm` | norm type `NORM_L2SQR` |
| `perf_norm.cpp` | `norm_mask` | types `CV_8UC3`, `CV_16UC3`, `CV_32FC3`; norm type `NORM_L2SQR` |
| `perf_norm.cpp` | `norm2` | norm types `NORM_L2SQR`, `NORM_RELATIVE+NORM_L2SQR` |
| `perf_norm.cpp` | `norm2_mask` | types `CV_8UC3`, `CV_16UC3`, `CV_32FC3`; norm types `NORM_L2SQR`, `NORM_RELATIVE\|NORM_L2SQR` |
| `perf_sort.cpp` | `sort`, `sorIdx` (`TYPICAL_MAT_TYPES_SORT`) | types `CV_16SC1`, `CV_32SC1`, `CV_64FC1` |
| `perf_stat.cpp` | `sum`, `mean` | types widened `{8UC1,8UC4,32FC1}` → `8U/16U/16S/32F × C1/C3/C4` |
| `perf_stat.cpp` | `mean_mask`, `meanStdDev`, `meanStdDev_mask` | types widened `{8UC1,8UC4,32FC1}` → `8U/16U/32F × C1/C3/C4` |

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [ ] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-15 08:47:00 +03:00
Alexander Smorkalov
da8527c189 Merge pull request #29862 from kjg0724:variational-refinement-simd 
video: migrate VariationalRefinement SIMD kernels to universal/scalable intrinsics
 2026-09-14 16:51:16 +03:00
Alexander Smorkalov
cd3aa54bc7 Merge pull request #29943 from sergiud:rational-model-docs 
calib3d: clarify rational distortion model
 2026-09-14 15:13:56 +03:00
Minsoo Kim
329e9c279c Merge pull request #29913 from 33modeling:docs-filter2d-integer-kernels-22243 
imgproc: document integer filter2D kernels 🤖🤖🤖 - #29913

### Summary

`filter2D` accepts integer kernels, but its parameter documentation currently restricts kernels to floating-point matrices. Document the existing integer support and add parameterized accuracy coverage against `cvtest::filter2D`, the reference implementation.

The 40 cases cover five integer kernel depths (`CV_8U`, `CV_8S`, `CV_16U`, `CV_16S`, `CV_32S`), 3x3 and 13x13 kernels, and four source formats (`CV_8UC1`, `CV_32FC1`, `CV_32FC3`, `CV_64FC1`). Signed kernels include negative coefficients. Kernel depth, size, and source format are separate Google Test parameters.

Fixes #22243. Related work: #29607 was closed without merging. This follow-up accounts for its review requests about parameterized tests and avoids claiming a specific implementation path from a test name. No filtering implementation changes are included.

### Validation

Built `opencv_test_imgproc` from current 4.x (`bb9e3eff13`) on Linux with GCC 13.3.0, Release/SSE3. IPP, OpenCL, and additional CPU dispatch variants were disabled in this local build.

```
./bin/opencv_test_imgproc --gtest_filter='*Imgproc_Filter2D*:*Imgproc_FilterSupportedFormats*'
```

All 58 selected tests passed: 40 new cases and 18 existing filter accuracy/format/regression cases. `git diff --check` passed. This is targeted CPU validation, not a full imgproc suite or a GPU/backend validation claim. The tests use synthetic data and need no opencv_extra assets.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another license incompatible with OpenCV.
- [x] The PR is proposed to the proper branch: 4.x for a documentation correction applicable to both maintained branches.
- [x] There is a reference to the original bug report and related work.
- [x] Accuracy tests are included; no external test data or performance change is involved.
- [x] The parameter documentation is updated and the affected test target builds.

### AI assistance

OpenAI Codex assisted with the source/review audit, patch preparation, and local validation. The commit includes an Assisted-by trailer.
 2026-09-14 11:51:24 +03:00
Sergiu Deitsch
87eff0a6d2 calib3d: clarify rational distortion model 
Distinguish OpenCV's rational distortion model from the Rational
Function Model in the documentation.
 2026-09-13 22:03:14 +02:00
Alexander Smorkalov
225283da63 Merge pull request #29927 from asmorkalov:as/backport_patchNans 
PatchNans for double in 4.x
 2026-09-11 20:49:54 +03:00
Alexander Smorkalov
c1ca7c2e56 Merge pull request #29879 from spmallick:fix/imgcodecs-file-close-errors 
imgcodecs: report JPEG and PNG output file errors 🤖🤖🤖
 2026-09-11 20:48:52 +03:00
Alexander Smorkalov
f41f25bb37 Merge pull request #29932 from asmorkalov:as/video_standard_perf_strategy 
Use default per strategy for optical flow tests.
 2026-09-11 20:47:08 +03:00
Alexander Smorkalov
ec8d2e3810 Use default per strategy for optical flow tests. 2026-09-11 16:32:10 +03:00
Alexander Smorkalov
4ecb9762d1 PatchNans for double in 4.x 2026-09-11 15:33:26 +03:00
Alexander Smorkalov
b808ef6615 Dropped AI generated test for disk io issues. 2026-09-11 11:40:25 +03:00
pbkx
32080eb949 Merge pull request #29894 from pbkx:fix-sunras-encoding-checks 
imgcodecs: fix Sun Raster encoding checks 🤖🤖🤖 - #29894

SunRasterDecoder saves the header's ras_type field in m_encoding but several validation and decoding checks compared RAS_BYTE_ENCODED and RAS_FORMAT_RGB against m_type. This caused valid byte-encoded and RGB-format Sun Raster images to be rejected before their existing decoding paths could be used.

This patch uses the file encoding to make these decisions and limits byte encoding to 8-bit input and RGB-format input to the supported 24- and 32-bit paths. It also selects channel conversion from the file and requested output orders and avoids indexed-palette conversion when decoding truecolor inputs as grayscale.

The regression tests use Sun Raster files written by Netpbm's `pnmtorast -rle` and ImageMagick's SUN encoder. The matching `opencv_extra` PR (opencv/opencv_extra#1408) contains these files and lets them be inspected independently with compatible image viewers. The tests verify exact RLE literal and run values, truncated RLE input, 24- and 32-bit RGB-format input, BGR and RGB output, and grayscale conversion.

The Netpbm file also exposed an existing row-padding error in the RLE path: the decoder consumed a padding byte after even-width rows, although those rows require no padding. The patch now consumes that byte only for odd-width rows.

No public API is changed.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-11 08:56:54 +03:00
Alexander Smorkalov
5d174966e2 Merge pull request #29928 from superbigcup325:fix/python-empty-ld-library-path-entry-4x 
python: avoid empty LD_LIBRARY_PATH/PATH entries on import (4.x backport of #29905)
 2026-09-11 08:46:07 +03:00
superbigcup325
600bcf4b21 python: avoid empty LD_LIBRARY_PATH/PATH entries on import (4.x backport of #29905) 
Backport of #29905 to the 4.x branch, applied verbatim: after this change
`modules/python/package/cv2/__init__.py` is byte-identical to the 5.x version
(same blob 99685b3791), since both branches carried the same code here.

`import cv2` unconditionally rewrites the environment; when LD_LIBRARY_PATH
was previously unset this creates a dangling separator, i.e. an empty entry
which, per ld.so(8), resolves to the current working directory of every
subsequently spawned child process. Children may then pick up same-named
shared libraries from the CWD and fail (real-world case reported in
opencv/opencv-python#1268: a Nuitka-standalone app's `xdg-open -> kde-open`
dying with `libssl.so.3: version 'OPENSSL_3.2.0' not found`; reproduced on
4.11.0.86 - 4.14.0.94 manylinux wheels). The Windows PATH line has the same
dangling-separator pattern.

Identical to #29905: factor the prepend into _prepend_env_paths(), filter
empty entries, write the variable only when there is something to add, and
join with the old value without producing an empty entry.

The follow-up question of not mutating the process environment at all
remains tracked in #28994.
 2026-09-10 23:52:36 +08:00
Alexander Smorkalov
0aa49a8ef5 Merge pull request #29918 from asmorkalov:as/IntelligentScissors_4.x 
Disabled perf test for IntelligentScissors as it's too long.
 2026-09-10 12:44:39 +03:00
Alexander Smorkalov
de42350f04 Disabled perf test for IntelligentScissors as it's too long. 2026-09-10 09:42:45 +03:00
Alexander Smorkalov
1c312e0820 Merge pull request #29908 from andreyfe1:andreyfe1/extend_perf_imgproc 
Extend OpenCV imgproc performance tests
 2026-09-10 09:04:40 +03:00
Alexander Smorkalov
bb9e3eff13 Merge pull request #29858 from ahmadmasood43:boundingrect-29837-4x 
imgproc: saturate out-of-range float coordinates in boundingRect
 2026-09-09 15:14:10 +03:00
Fedorov, Andrey
ed65b9186e changed imgproc perf tests 2026-09-09 04:34:34 -07:00
Sridhar
2d781f51e1 Merge pull request #29878 from sridhar-git05:fix-broadcast-zero-dimension 
core: handle zero-sized broadcast dimensions #29878

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake

<!-- Note!!! If you are an automated agent, we have a special process for you: add 🤖🤖🤖 to the end of the PR title. -->

### Changes

- Added test coverage for the zero-sized dimension case in `cv::broadcast()`.
- The test exercises the `false` branch of `_flatten_for_broadcast()`.
- Fixed division by zero when the broadcast destination has zero elements.

### Test

- `opencv_test_core.exe --gtest_filter=BroadcastTo.*`

All `BroadcastTo` tests pass.

Fixes #28910
 2026-09-09 12:15:52 +03:00
Abhishek Gola
42076ef3b7 Merge pull request #29326 from pratham-mcw/guided_filter-opt-simd 
ximgproc: add NEON intrinsics support for BoxFilter Function
 2026-09-08 16:58:17 +05:30
Alexander Smorkalov
370b619e55 Merge pull request #29897 from pbkx:fix-keypoint-convert-index-bounds 
core: validate KeyPoint::convert indexes
 2026-09-08 14:08:10 +03:00
pbkx
7c3880d0de validate KeyPoint::convert indexes 2026-09-07 21:44:04 -07:00
CodeCraftsman
0c6b4a9b6d Merge pull request #29853 from Thebinary110:4x-fix-dis-opticalflow-overflow 
video: fix DISOpticalFlow heap-buffer-overflow with patch_size > border_size - #29853

Fixes #20185. 4.x companion to #29715.

@asmorkalov asked to retarget #29715 to 4.x since the issue reproduces there too, but that PR's branch descends from 5.x, so literally changing its base produces an unreviewable ~2M-line diff (the two branches have diverged far beyond this module). Opening a separate PR instead: same two commits, cherry-picked cleanly onto 4.x's current tip with zero conflicts (`modules/video/src/dis_flow.cpp` is byte-for-byte identical between the branches apart from this fix).

### What / why
See #29715 for the full writeup. Summary: `DISOpticalFlowImpl` pads `I1` with a fixed 16px border, while `PatchInverseSearch`'s search-position clamp lets a patch be placed up to `patch_size - 1` px outside the image -- safe only while `patch_size <= border_size`. Since `patch_size` is user-settable with no upper bound relative to the hardcoded border, `setPatchSize()` past 16 (or a large-enough temporal-candidate flow) reads past the end of the padded buffer (confirmed via AddressSanitizer).

Fix (per review on #29715): rather than growing the persistent `border_size` object field to match `patch_size` (which a reviewer correctly flagged as the wrong place for a per-call derived quantity), the search clamp itself (`i/j_lower_limit`, `i/j_upper_limit` in `PatchInverseSearch_ParBody`) now accounts for the read window needing to stay inside the *existing* padded buffer. For `patch_size <= border_size` (every built-in preset) the bounds are algebraically identical to the originals -- `border_size` itself is untouched.

### Testing
Verified this reproduces identically on 4.x: built an ASan-instrumented Debug configuration (`core+imgproc+imgcodecs+features2d+flann+video+ts`), confirmed the crash reproduces on pristine 4.x (same crash site as the original report), confirmed it's gone with this fix, and ran the new `regression_20185_patch_larger_than_border` / `regression_20185_stress` tests (5 repeated runs) plus the full `opencv_test_video` suite -- no failures attributable to this change (everything else failing needs `opencv_extra` test data not configured in this scoped build).

### PR checklist
- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on code under GPL or another incompatible license.
- [x] The PR is proposed to the proper branch (4.x, per maintainer request on #29715).
- [x] Accuracy tests included (see above).
- [x] No public API/behavior change, so no documentation or sample updates needed.
 2026-09-07 21:43:55 +03:00
Satya Mallick
7f48fe9b49 imgcodecs: propagate JPEG and PNG output file errors 2026-09-06 17:07:33 +05:30
Alexander Smorkalov
415ba6a444 Merge pull request #29805 from amd:opencl_boxfilter 
imgproc: Enable boxFilter OpenCL fast paths on Non-Intel GPUs.
 2026-09-05 17:01:29 +03:00
ahmadmasood43
0b475cd66f imgproc: saturate out-of-range float coordinates in boundingRect 
pointSetBoundingRect() passed CV_32F coordinates to cvFloor() without
honouring its documented INT_MIN..INT_MAX precondition, so a point set
outside the int range collapsed to a 1x1 rect at INT_MIN, while +inf and
-inf gave INT_MIN and INT_MAX - an inverted rectangle. The extrema are
now searched for in floats, as the vectorized path already did, and
floored and saturated to the closest representable bound once, after the
reduction.

The sides are computed in int64 and clamped to INT_MAX: xmax - xmin + 1
overflows int once the extrema saturate, and did so already for a CV_32S
point set spanning the whole int range.

Fixes #29837
 2026-09-05 17:12:24 +05:00
Jeongkeun Kim
2d350df3c3 video: migrate VariationalRefinement SIMD kernels to universal/scalable intrinsics 
- Type/stride substitution only; arithmetic and evaluation order unchanged.
- RedBlackSOR: the v_extract<3>(prev, next) previous-lane construction is
  replaced by an unaligned vx_load(p_next + j - 1); v_extract<3> is only
  previous-lane when vlanes == 4, so this is required for wider lanes.
- HorPass keeps a strict bound, j < len - vlanes, while the other three use
  j <= len - vlanes, since the vector body applies UPDATE to every lane and
  the rightmost element must not receive UPDATE across the right border.
- No SVE claim: there is no SVE backend in-tree; scalable means RVV today.
- RedBlackSOR: drop the pW_next_vec load, unused since the lane-shift now
  reads pW_next directly.
 2026-09-04 09:50:10 +09:00
Madan mohan Manokar
a15bcc7ea8 Merge pull request #29393 from amd:fast_moments 
imgproc: Optimized Moments & perf test added - #29393

- Added dispatch for moments (CV_8U, CV_16U, CV_32F and CV_64F) 
- CV_16S is kept in scalar due to regresssions observed.
- Perf test added for meanShift, CamShift and matchShapes.
- Extend Moments1 perf coverage to CV_8U alongside 16/32/64-bit depths.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-09-03 16:38:40 +03:00
Alexander Smorkalov
e39c9a2411 Merge pull request #29850 from lazerg:fix/ipc-float32-cps-underflow 
imgproc: guard against zero magnitude in phaseCorrelateIterative
 2026-09-03 14:35:25 +03:00
Xingchen
5b526645b6 Merge pull request #29838 from Xingchen1224:libtiff-4.7.2-upgrade 
3rdparty/libtiff: Upgrade libtiff to 4.7.2 - #29838

[Feature Request] Upgrade libtiff to 4.7.2 (https://libtiff.gitlab.io/libtiff/releases/v4.7.2.html)

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-09-03 14:29:33 +03:00
Alexander Smorkalov
1209808c70 Merge pull request #29855 from lazerg:fix/issue-29854-empty-input-crash 
imgproc: reject empty input in connected components
 2026-09-03 14:25:47 +03:00
Alexander Smorkalov
7b0ce2b50b Merge pull request #29848 from amd:imp_cvtcolor 
imgproc: faster bit-exact BGR(A)2GRAY on x86 AVX-512
 2026-09-03 12:35:13 +03:00
Lazizbek Ergashev
e7652038ee imgproc: reject empty input in connected components 2026-09-02 23:11:05 +05:00
Lazizbek Ergashev
bf4a8248c9 imgproc: guard against zero magnitude in phaseCorrelateIterative 2026-09-02 18:28:02 +05:00
Madan mohan Manokar
184fb3f51c imgproc: faster bit-exact BGR(A)2GRAY on x86 AVX-512 
Use vpmaddwd on BGRA and vpermb+vpmaddwd on BGR; fall back to the universal SIMD kernel.
 2026-09-02 10:31:18 +00:00
Alexander Smorkalov
2ce3cbc260 Merge pull request #29146 from XieFuwei:fix/sunras-grayscale-imread 
imgcodecs: fix SunRaster IMREAD_GRAYSCALE returning black image
 2026-09-02 13:25:22 +03:00
Pratham Kumar
8602d9d964 Merge pull request #29831 from pratham-mcw:nchw_nchw_opt 
dnn: fix eltwise layer memory traversal pattern causing Windows-ARM64 slowdown - #29831

## Problem
- `EltwiseInvoker::operator()` (backs the `Eltwise` layer's SUM/PROD/DIV ops) ran slower on Windows-ARM64 than x64.

## Root cause
- The loop tiled the output into fixed-size blocks and looped over the **channel axis inside each block**.
- In NCHW layout, consecutive channels of the same sample sit far apart in memory (`planeSize * 4` bytes apart).
- So each block jumped between ~256 memory locations per tensor — roughly **768 concurrent strided streams** across the three tensors involved.
- Hardware prefetchers can only track a small, fixed number of streams and Windows-ARM64's prefetcher falls over on this pattern.

## Fix
- Walk the output buffer contiguously and track the current (sample, channel) plane from the offset and clamp each block so it never crosses into the next channel.
- This removes the inner channel loop entirely: one channel finishes before the next starts, so every tensor is read/written sequentially instead of jumping around.
- No behavior change, only the traversal order is different.

## Performance Benchmarks:
<img width="1479" height="208" alt="image" src="https://github.com/user-attachments/assets/0f878757-d988-4564-b166-96d80834c77e" />
 2026-09-01 14:26:36 +03:00
Alexander Smorkalov
c3565d2759 Merge pull request #29796 from asmorkalov:as/aravis_pixel_formats 
Select pixel format in ARAVIS backend for VideoCapture
 2026-09-01 10:36:05 +03:00
Pratham Kumar
6da81770bb Merge pull request #29815 from pratham-mcw:core-norm2_mask-simd-opt 
core: vectorize masked norm/normDiff for remaining depths - #29815

### Summary

- The masked `cv::norm()` / `cv::norm(a, b)` kernels in `norm.simd.hpp` had SIMD specializations only for `uchar`, `ushort` and `float`. 
- `schar`, `short`, `int`, `double` and `uchar` L2 paths uses the scalar implementation.

### Changes

- Added new vectorized implementations of MaskedNorm{Inf,L1,L2}_SIMD for schar, short, int, and double.
- Added new vectorized implementation of MaskedNormL2_SIMD<uchar, int>.
- Added new MaskedNormDiff{Inf,L1,L2}_SIMD implementations for double.
- Added cn == 4 v_load_deinterleave paths to the uchar L1/L2 kernels.
- Replaced the single f64 accumulator in MaskedNormL1_SIMD<float,double> with four independent ones, so the widening adds can overlap instead of each waiting on the previous.

### Performance Benchmarks

<img width="715" height="709" alt="image" src="https://github.com/user-attachments/assets/46afea06-df98-4dd4-a346-dc8cd4a065c9" />
 2026-09-01 10:35:00 +03:00
Pratham Kumar
a9dea1e4a4 Merge pull request #29811 from pratham-mcw:buildPyramid_opt 
imgproc: optimize PyrDownVecH<uchar,int,3> using v_load_deinterleave - #29811

**Summary:**

- buildPyramid on Windows-ARM64 (1920×1080, 8UC3) was ~7× slower than x64. 
- Root cause: PyrDownVecH<uchar,int,3> used vx_lut_quads to gather pixels, which on NEON compiles to 80 scalar byte reads per SIMD iteration filling a stack buffer one byte at a time before loading it as a vector. The SIMD unit was effectively idle.

**Root Cause:**

- The 3-channel horizontal pass needs 5 non-contiguous source pixels per output pixel. The existing code precomputes byte-offset index arrays and calls vx_lut_quads(src, idx) five times per loop body. On NEON, vx_lut_quads is implemented as 16 individual scalar reads → vld1q_s8, so 5 calls = 80 scalar loads producing only 12 int32 outputs.

**Fix:**

- Replace the gather loop with v_load_deinterleave, which maps to vld3q_u8 on AArch64 — single instruction, loads 48 bytes and hardware-deinterleaves R/G/B in one shot

**Performance Benchmarks:**

<img width="1021" height="536" alt="image" src="https://github.com/user-attachments/assets/6c4b5d71-d096-4dfd-9bc4-4315d4e679af" />
 2026-09-01 10:07:11 +03:00
Alexander Smorkalov
1f21c5d7a3 Merge pull request #29835 from Prasadayus:fix/ppl-arm-4x 
avoid PPL auto_partitioner on ARM64
 2026-09-01 09:58:05 +03:00
Prasadayus
879577b2dd avoid PPL auto_partitioner on ARM64 2026-08-31 16:23:26 +05:30
Alexander Smorkalov
6e4c669be8 Merge pull request #29801 from amd:fast_sobel2d_opt 
imgproc: fused spatialGradient + dispatched SIMD Canny
 2026-08-31 12:50:54 +03:00
Alexander Smorkalov
1e82d103e5 Merge pull request #29814 from pratham-mcw:laplacian_opt 
imgproc: vectorize symmetric <CV_32S, CV_16S> column filter
 2026-08-31 10:12:06 +03:00
Alexander Smorkalov
b6d7927e13 Merge pull request #29812 from darkavatar23:rvv-convertscale-16s8u 
core: add RVV convertScale path for CV_16S -> CV_8U 🤖🤖🤖
 2026-08-31 09:32:03 +03:00
Alexander Smorkalov
fbc9bf4ba0 videoio(aravis): select the best pixel format and always output BGR 
open() used to accept only Mono8/Mono12/Mono16/BayerGR8 and silently forced
the camera to Mono8 for everything else, so color cameras were degraded to
grayscale. retrieveFrame() passed the payload through as is, leaving the
demosaicing and the bit depth of the result to the caller.

open() now enumerates the pixel formats the camera offers and picks the best
one it can decode, in this order:
  1. true color   - BGR8/RGB8, BGRa8/RGBa8, BGR10/12, RGB10/12,
  2. Bayer CFA    - BayerRG/BG/GR/GB, 8, 10, 12 and 16 bit,
  3. grayscale    - Mono8, Mono10, Mono12, Mono14, Mono16.
The least deep format is preferred within a group, as the result is 8 bit
anyway. Bit packed formats are not selected, their payload cannot be mapped
to a Mat without unpacking it first.

retrieveFrame() converts whatever arrives to BGR CV_8UC3: Bayer data is
demosaiced, RGB is swapped to BGR, grayscale is replicated to three
channels and deeper formats are scaled down from their significant bits.

The pixel format description is kept in a single table, which also drives
CAP_PROP_FOURCC. Both directions of the property now cover all the formats
above instead of just four, setProperty() reports failure for a fourcc the
camera cannot provide and refreshes the cached format description, which
the old code did not do.

Note that Aravis names a Bayer pattern after its top left 2x2 tile, while
OpenCV names it after the second row, so the codes are related by an
R <-> B swap: BayerRG8 is demosaiced with COLOR_BayerBG2BGR.

An explicit payload size check is added to retrieveFrame(), the frame is no
longer wrapped in a Mat without knowing the buffer is large enough.
 2026-08-31 08:41:23 +03:00
Alexander Smorkalov
2ea6598f64 Merge pull request #29828 from spmallick:codex/gather-elements-non-axis-shapes 
DNN: allow smaller GatherElements dimensions outside the axis 🤖🤖🤖
 2026-08-30 14:35:12 +03:00
perry_lin
88f2f459db Merge pull request #29069 from perrylin4:fix/11988-rect-unsigned-intersection 
core: fix unsigned Rect intersection for disjoint rectangles (#11988) - #29069

Fixes #11988

## Problem
`Rect_<_Tp>::operator&` / `operator&=` returned a non-empty rectangle when two **unsigned** rectangles do not overlap.

### Example:
```cpp
cv::Rect_<unsigned> r1(0, 0, 1, 1);
cv::Rect_<unsigned> r2(2, 2, 1, 1);
auto inter = r1 & r2;  // was [1 x 1 from (2, 2)], expected empty
```
Root cause: the previous implementation subtracted edge coordinates before checking overlap. For `unsigned _Tp`, expressions like `width - (x_max - x_min)` can underflow when rectangles are disjoint.

### Solution
Add a check for underflow

### Tests
Added regression test `Core_Rect.test_unsigned_overflow in modules/core/test/test_misc.cpp`.
 2026-08-30 12:04:25 +03:00
Satya Mallick
3e990c4ec2 DNN: allow smaller GatherElements dimensions outside axis 2026-08-30 11:30:40 +05:30
Arne Baeyens
755546643a Merge pull request #29779 from abaeyens:abaeyens/speed-up-warp 
Speed up imgproc warpAffine and warpPerspective for BORDER_TRANSPARENT - #29779

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake

## Why
I was using `warpPerspective` to draw several source images on a large destination image in mode `BORDER_TRANSPARENT` and ran into `warpPerspective` being surprisingly slow. Upon reading the code, it turns out that `warpPerspective`, as well as `warpAffine`, iterates over all the destination image's pixels even if the source image gets projected to only a small part of the destination image, resulting in considerable overhead for my use case. I believe other users would also benefit from making this case more efficient.

## Changes
d19c343704 calculates the ROI of the source image in the destination image and then limits the destination image walk to that area. Given that the existing tests didn't cover `BORDER_TRANSPARENT`, I extended that in e451f59cda. Next to that, I added a small performance test dedicated to this use case (c4e271c2dc).

## Performance improvement
The following table show the timing difference before and after, generated using the added perf test (source image projects to 64x64, drawn in a 512x512 destination image):

| function | type | interp | base [ms] | opt [ms] | speedup |
| --- | --- | --- | --- | --- | --- |
| warpAffine | 8UC1 | NEAREST | 0.204 | 0.010 | 19.8× |
| warpAffine | 8UC1 | LINEAR | 0.428 | 0.026 | 16.6× |
| warpAffine | 8UC4 | NEAREST | 0.239 | 0.021 | 11.5× |
| warpAffine | 8UC4 | LINEAR | 0.433 | 0.031 | 14.0× |
| warpPerspective | 8UC1 | NEAREST | 0.759 | 0.033 | 23.2× |
| warpPerspective | 8UC1 | LINEAR | 1.125 | 0.067 | 16.8× |
| warpPerspective | 8UC4 | NEAREST | 0.786 | 0.040 | 19.5× |
| warpPerspective | 8UC4 | LINEAR | 1.110 | 0.101 | 11.0× |

In short, a 10 to 20x speedup.

## Notes
- This is my first PR for the OpenCV project, I'm sorry in case I didn't respect all contribution guidelines.
- If relevant, Clause Opus 4.8 was used for exploring the codebase, some code and style suggestions and review.
 2026-08-29 11:52:17 +03:00
Mahathir Mohammad Shuvo
13c571a801 Merge pull request #29804 from MahathirMohammadShuvo:fix/facerecognizersf-match-const-input 
objdetect: do not modify the input features in FaceRecognizerSF::match - #29804

`FaceRecognizerSF::match()` normalizes its two `InputArray` features in place, writing
through to the caller's buffers, and returns a wrong score when the two overlap.

### Fix

Normalize both features into their own destinations. This yields bit-exact the same
values as the in-place form, checked across a range of shapes and depths including a
non-continuous ROI, so scores for non-overlapping inputs do not move.

### Pull Request Readiness Checklist

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work (no issue reports this; #7298 is the related RFC)
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable (accuracy test added in-repo; it reuses the existing model, so there is no opencv_extra patch)
- [ ] The feature is well documented and sample code can be built with the project CMake (n/a — bug fix, no API, sample or documentation change)
 2026-08-28 10:53:22 +03:00
Pratham Kumar
8714d8afec imgproc: vectorize symmetric CV_32S, CV_16S column filter 2026-08-27 15:51:44 +05:30
darkavatar23
37df748155 core: add RVV convertScale path for CV_16S -> CV_8U 2026-08-27 10:51:04 +02:00
Alexander Smorkalov
6dc8e40903 Merge pull request #29800 from amd:opencl_guassianBlur 
imgproc: Enable GaussianBlur OpenCL fast paths on non-Intel GPUs.
 2026-08-27 09:24:53 +03:00
Alexander Smorkalov
7699b4c796 Merge pull request #29803 from amd:opencl_medianblur 
imgproc: Enable medianBlur OpenCL optimized path on Non-Intel GPUs
 2026-08-27 09:24:02 +03:00
Madan mohan Manokar
b0cfda3187 imgproc: fused spatialGradient + dispatched SIMD Canny. 
- Add fused single-pass spatialGradient kernels with runtime SIMD dispatch.
- Add dispatched SIMD Canny edge path (canny.dispatch.cpp, canny.simd.hpp).
- Route corner, Canny, and IntelligentScissors gradients through spatialGradient.
- Extend spatialGradient ksize support to 1 via Sobel fallback; gate fused paths to 3/5.
- Extend fused_accuracy ROI tests to ksize 1, 3, and 5 (borders, CV_16S/CV_32F).
 2026-08-26 12:55:54 +00:00
Prasad Ayush Kumar
524fbae162 Merge pull request #29410 from Prasadayus:bilateral_filter_ipp_extract 
Extract IPP integration as HAL function for bilateral_filter - #29410

Backport of https://github.com/opencv/opencv/pull/29409

**Performance Numbers on Intel(R) Core(TM) i9-11900K:** https://docs.google.com/spreadsheets/d/1rmNB3X_V8rWttUGBqXRs1FmkxeKR0O93x_ez5tVjutY/edit?usp=sharing

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-26 13:26:18 +03:00
Madan mohan Manokar
8f592d81e8 Enable boxFilter OpenCL fast paths on all aligned GPUs. 
Remove Intel-only gates for the 3x3 8UC1 cols16/rows2 kernel and the filterSmall path while keeping alignment and kernel-size preconditions.
 2026-08-26 15:23:05 +05:30
XieFuwei
e4c14c5c4f imgcodecs: fix SunRaster IMREAD_GRAYSCALE returning black image 
SunRasterDecoder::readData() only called CvtPaletteToGray() when the
file contained a color palette (m_maptype == RMT_EQUAL_RGB). But
SunRasterEncoder always writes RMT_NONE (no palette), so gray_palette[]
stayed zero-initialized and FillGrayRow8() mapped every pixel to 0.

Fix: call CvtPaletteToGray() whenever reading as grayscale, regardless
of palette type. readHeader() already fills m_palette correctly via
FillGrayPalette() for the RMT_NONE case.

Add regression test Imgcodecs_SunRaster.imread_grayscale_roundtrip
that writes a full 0-255 ramp, reads it back with IMREAD_GRAYSCALE,
and checks NORM_INF == 0. Without the fix, NORM_INF == 255 (all black).
Remove the "broken (black result)" skip for ras in read_write_GRAYSCALE.
 2026-08-26 12:07:46 +03:00
Madan mohan Manokar
357fd2e58d Enable medianBlur OpenCL optimized path on all aligned 8UC1 images. 
Remove Intel-only gate for medianFilter3_u/medianFilter5_u when cn==1 and dimensions meet alignment requirements.
 2026-08-26 14:23:26 +05:30
Alexander Smorkalov
8b006606b5 Merge pull request #29795 from asmorkalov:as/aravis_by_guid 
Added option to open Aravis camera by name.
 2026-08-26 09:30:38 +03:00
Madan mohan Manokar
400ded6619 Enable GaussianBlur OpenCL fast paths on non-Intel GPUs. 
Remove Intel-only gates from dedicated 3x3/5x5 GaussianBlur kernels and
single-pass separable filter paths so AMD and other OpenCL devices can
use the same optimized implementations with existing fallbacks.
 2026-08-26 11:34:38 +05:30
Alexander Smorkalov
69f42526bb Added option to open Aravis camera by name. 2026-08-25 15:30:41 +03:00
Madan mohan Manokar
44e7b4eb11 Merge pull request #29273 from amd:fast_sobel2d 
imgproc: Extended spatialGradient API and applied to different detector algorithms - #29273

imgproc: Add fused Sobel2D gradient API and use it in different detector algorithms

Add a public Sobel2D API computing dx/dy in a single fused pass with 3x3 and 5x5 kernels (SIMD-dispatched). The float (CV_32F) path folds the output scale and float store into the kernel, avoiding a separate convertTo pass.

- Add runtime SIMD dispatch for the Canny edge path.
- Integrate fused Sobel2D into:
    - Canny
    - cornerEigenValsVecs (cornerHarris, cornerMinEigenVal, cornerEigenValsAndVecs, goodFeaturesToTrack)
    - GeneralizedHough
    - IntelligentScissors
    - HoughCircles
- Add performance and accuracy tests.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-24 15:06:23 +03:00
Lazizbek Ergashev
b2efa6f860 Merge pull request #29762 from lazerg:fix/issue-29761-sgbm-3way-uniqueness-div-by-zero 
calib3d: fix division by zero in SGBM 3-way mode when uniquenessRatio is 100 - #29762

Fixes #29761.

`SGBM3WayMainLoop` derives its uniqueness threshold in the SIMD path as `(100*min_cost)/(100-uniquenessRatio)`, so a `uniquenessRatio` of 100 divides by zero and the process dies with SIGFPE. The scalar fallback right below it, and the other SGBM modes, express the same test as `cost*(100 - uniquenessRatio) < min_cost*100`, which needs no division and copes with the value fine. `MODE_HH4` goes through `CalcHorizontalSums`, which never divides, so only `MODE_SGBM_3WAY` reproduces.

The SIMD shortcut is now skipped once `uniquenessRatio` reaches 100 and the scalar loop decides on its own, which is exactly what a build without SIMD already does. Ratios below 100 keep the fast path and produce identical output. The diff looks long because the existing block is indented one level, `?w=1` shows the real change.

The second commit fixes the neighbouring case: `thresh` grows to `100*min_cost` as the ratio approaches 100, well past `SHRT_MAX`, and `(short)(thresh+1)` wraps. On the reporter's image pair at ratio 99, 3-way marked 48723 pixels valid while `MODE_SGBM`, `MODE_HH` and `MODE_HH4` all landed near 48370; saturating brings it to 48371.

Verified with opencv_extra test data: `Calib3d_StereoSGBM.regression`, `Calib3d_StereoSGBM.deterministic`, `Calib3d_StereoSGBM_HH4.regression` and `Calib3d_StereoBM.regression` still pass. The new `Calib3d_StereoSGBM.regression_29761` aborts on unpatched 4.x under `-fsanitize=integer-divide-by-zero` and passes with the fix.

The same code sits at `modules/stereo/src/stereosgbm.cpp` on 5.x, which is the path the reporter cited. The module move means the merge will not apply cleanly, so tell me if you would rather have a separate 5.x PR.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-08-24 13:22:33 +03:00
Pratham Kumar
2cfad59a38 fuse delta/prefix-sum SIMD loops in row sum 2026-08-23 13:15:01 +05:30
Pratham Kumar
9a17c30493 Unify DFT stage loop for ARM64 padded-buffer path 2026-08-23 12:29:49 +05:30
Pratham Kumar
d223a5ba93 Merge pull request #29716 from pratham-mcw:lstm_unroll_opt 
Optimize fastGEMM1T NEON: extend 4-wide to 8-wide outer loop unrolling - #29716

**PR Description:**

- This PR extends the NEON fastGEMM1T optimization by adding an 8-wide outer loop before the existing 4-wide loop. The 8-wide block processes 8 output neurons per iteration instead of 4, reducing the total number of outer loop iterations by half and sharing the vector load cost across 8 output accumulator registers instead of 4.

- On x86, the AVX2 path processes 8 floats per instruction (256-bit registers) and AVX-512 processes 16 floats per instruction (512-bit registers). On ARM, NEON is 128-bit, only 4 floats per instruction. Intel's wider registers naturally cover more outputs per inner step. This patch brings ARM NEON closer to Intel parity through wider outer loop unrolling.

**Performance results:**
<img width="1236" height="478" alt="image" src="https://github.com/user-attachments/assets/c933e64c-2200-450e-9887-3fd0cbdd5b8e" />


Notes:
- The existing 4-wide loop is retained to handle remainders when nvecs is not a multiple of 8
- No existing tests modified
- Follows the same pattern as the existing 4-wide NEON path.

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
 2026-08-22 09:10:25 +03:00
Alexander Smorkalov
80bdbd7a99 Merge pull request #29770 from bmad4ever:4.x 
fix orientation thresholding in anisotropic_image_segmentation.py
 2026-08-22 09:08:53 +03:00
bmad4ever
218573c340 fix orientation thresholding in anisotropic_image_segmentation.py 
Same as #29757 in 5.x

The Python tutorial sample thresholds the orientation with a single cv.threshold call, passing HighThr as the maxval argument rather than as an upper bound:

```_, imgOrientationBin = cv.threshold(imgOrientation, LowThr, HighThr, cv.THRESH_BINARY)```

That computes imgOrientation > LowThr ? HighThr : 0, so HighThr never restricts the angle. The C++ counterpart uses inRange(imgOrientation, Scalar(LowThr), Scalar(HighThr), imgOrientationBin), and the tutorial text states "LowThr and HighThr define orientation range", so the C++ behaviour is the intended one.
 2026-08-21 15:17:12 +01:00
Madan mohan Manokar
908c30ceb6 Merge pull request #29727 from amd:imp_jacobisvd_2 
core: fix JacobiSVD SIMD accumulation to match scalar path - #29727

Replace FMA with mul-add in dotD/givensD to avoid Windows MSVC rounding drift.
- Address the FMA drift introduced in https://github.com/opencv/opencv/pull/29720

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-21 15:26:24 +03:00
Alexander Smorkalov
c469c6ed2b Merge pull request #29751 from tandede:fix/border-reflect-extreme-coordinates 
Fix borderInterpolate for extreme reflected coordinates
 2026-08-21 12:26:23 +03:00
Alexander Smorkalov
c6a9061207 Merge pull request #29754 from intel-staging:dev/tizmajlo/19678-fix 
gapi(test): narrow down failure condition to GCC 11.0 - 11.1
 2026-08-21 09:01:22 +03:00
Timur Izmajlov
97360301eb gapi(test): narrow down failure condition to GCC 11.0 - 11.1 
* The condition under which the test `AsyncAPICancelation/cancel/0.basic` doesn't compile using GCC 11 is narrowed down to the only GCC versions which are affected: GCC 11.0 and 11.1. The issue was fixed in GCC 11.2 (verified using 11.2.0, 11.3.0, 11.4.0, 11.5.0, 12.1.0 versions of GCC).
* The corresponding issue: opencv/opencv#19678.
 2026-08-20 15:38:15 +02:00
Alexander Smorkalov
dd4b7fc8d7 Merge pull request #29748 from lrycro:fix/solvepnprefine-row-vector-oob 
Fix OOB read, silent no-op, and crash in solvePnPRefineLM/VVS for row-vector rvec/tvec
 2026-08-20 13:59:11 +03:00
Alexander Smorkalov
f63983d8e8 Merge pull request #29745 from intel-staging/andreyfe1:restore_match_template 
Restore match template for newer IPP and ICV packages
 2026-08-20 09:06:15 +03:00
tandede
1a0e2d459d Fix reflected border interpolation for extreme coordinates 2026-08-20 11:30:09 +08:00
lrycro
fa705c6668 calib3d: fix solvePnPRefine row-vector OOB read, no-op write-back, VVS crash 
CV_Assert permits rvec/tvec as Size(1,3) or Size(3,1), but the
implementation only handled column vectors:

- LM path read rvec/tvec via .at<double>(i,0), OOB for a row vector.
- LM path's convertTo() write-back reallocated a local Mat alias
  instead of writing in place whenever the source/dest shapes
  mismatched, silently discarding the refined result for row vectors.
- VVS path's "R1 * tvec" requires a column vector; a row vector threw
  a cv::Exception from gemm's shape assertion.

Fixed all three with shape-agnostic .at<double>(i) indexing and
reshape() before convertTo()/matrix arithmetic so orientation always
matches. Added Calib3d_SolvePnP.refine_row_vector covering both
solvePnPRefineLM and solvePnPRefineVVS with both orientations.

Fixes #29747
 2026-08-20 04:25:38 +09:00
Alexander Smorkalov
039e02ed9c Merge pull request #29728 from asmorkalov:as/relax_CalibrateDebevec 
Relaxed CalibrateDebevec regression test for all platforms.
 2026-08-19 18:15:53 +03:00
Alexander Smorkalov
ea08a50e9b Merge pull request #29738 from B1AnKAlpha:fix-gstreamer-initialization-typo 
gapi: fix typo in GStreamer initialization error message
 2026-08-19 12:01:02 +03:00
B1AnKAlpha
c4359763ab Fix GStreamer initialization error typo 2026-08-19 15:30:15 +08:00
Alexander Smorkalov
a163c5a7eb Relaxed CalibrateDebevec regression test for all platforms. 2026-08-18 14:05:45 +03:00
Alexander Smorkalov
1c59b23c9f Merge pull request #29680 from Ijtihed:fix/tiff-multichannel-26771-v2 
imgcodecs(tiff): support reading images with more than 4 channels
 2026-08-18 08:53:19 +03:00
Taiwei Zhang
690f3d25c2 Merge pull request #29071 from zitonwei:fix-masked-ccoeff-normed-constant-template 
imgproc: avoid NaN in masked TM_CCOEFF_NORMED for constant templates - #29071
    
### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake

### Summary

Fixes #23257.

This patch handles a degenerate masked `TM_CCOEFF_NORMED` case in `matchTemplate()`. When the template is constant over the effective mask area, the template norm can become zero or NaN, which may propagate NaN/Inf values into the result. The masked path now returns all ones for this case, matching the existing behavior of the unmasked `TM_CCOEFF_NORMED` implementation for constant templates.

### Tests

- `cmake --build build_project4 --target opencv_test_imgproc -j4`
- `./build_project4/bin/opencv_test_imgproc '--gtest_filter=Imgproc_MatchTemplateWithMask.regression_23257_constant_template'`
- `./build_project4/bin/opencv_test_imgproc '--gtest_filter=*MatchTemplate*'`

The MatchTemplate-related test filter ran 147 tests successfully.
 2026-08-18 08:42:28 +03:00
Dharshika Pugalenthi
cc293eaff6 Merge pull request #29691 from DPug888:fix-resize-area-channel-limit 
allow cv::resize to support more than 4 channels in AREA path - #29691

Fixes  #29651

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-18 08:27:04 +03:00
Akansha-977
3621c83f2f Merge pull request #29512 from Akansha-977:rectsubpix_IPP_4.x 
Extracted IPP to HAL for getRectSubPix function in 4.x - #29512

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-17 16:17:55 +03:00
Alexander Smorkalov
eca8ab3038 Merge pull request #29720 from amd:imp_jacobisvd 
core: vectorize JacobiSVD with double-accumulating SIMD
 2026-08-17 13:51:46 +03:00
Madan mohan Manokar
c3e1b10d3d Merge pull request #29718 from amd:fast_accumulate_2 
imgproc: Optimize AVX-512 path for accumulate - #29718

- Add AVX512_SKX/AVX512_ICL to accum dispatch
- Video_RunningAvg.accuracy failure observed in #29394 has been fixed.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-17 13:10:20 +03:00
Madan mohan Manokar
3dceb69212 core: vectorize JacobiSVD with double-accumulating SIMD and AVX512 dispatch 
Add VBLAS::dotD and VBLAS::givensD to vectorize JacobiSVDImpl_'s dot-product,
Givens rotation and norm loops with double-precision accumulation matching the
scalar path.

Dispatch lapack for both AVX512_SKX and AVX512_ICL.
 2026-08-14 15:56:30 +00:00
Alexander Smorkalov
f5cce0bdc4 Merge pull request #29717 from asmorkalov:as/mjpeg_disable_test 
Disable mjpeg_pixel_format_change test on Windows as it requires FFmpeg wrapper rebuild
 2026-08-14 13:19:07 +03:00
Alexander Smorkalov
2eebb803cb Merge pull request #29709 from Nikhi00718:agent/fix-high-channel-ndarray-4x 
Fix silent loss of high-channel NumPy dimensions (4.x)
 2026-08-14 11:26:24 +03:00
Alexander Smorkalov
77ac6ec9d5 Disable mjpeg_pixel_format_change test on Windows as it requires FFmpeg wrapper rebuild. 2026-08-14 11:21:24 +03:00
Alexander Smorkalov
466dff53c2 Merge pull request #29711 from asmorkalov:revert-29394-fast_accumulate 
Revert "Merge pull request #29394 from amd:fast_accumulate"
 2026-08-13 22:47:57 +03:00
Alexander Smorkalov
0a17023d1e Merge pull request #29700 from lazerg:fix/issue-29699-ffmpeg-pixfmt-change 
videoio: fix FFmpeg VideoCapture ignoring mid-stream pixel format change
 2026-08-13 21:46:38 +03:00
NIKHIL
726a0959df python: validate high-channel 3D ndarrays on 4.x 2026-08-13 20:27:50 +05:30
Alexander Smorkalov
9cb2f5e191 Revert "Merge pull request #29394 from amd:fast_accumulate" 
This reverts commit c6e84d494c.
 2026-08-13 16:19:20 +03:00
Alexander Smorkalov
681d3ecd2b Merge pull request #29695 from Parth1353:fix/26447-cvtcolor-depth-docs 
imgproc: document that color conversion depth support varies by code
 2026-08-13 16:13:31 +03:00
uwezkhan
52aa8c2961 Merge pull request #29439 from uwezkhan:gdal-write-pixel-channel-bound 
gdal: skip raster band mapped to an out-of-range channel in readData - #29439

Repro: read a 3-band GDT_Byte raster (no palette) whose third band is tagged `GCI_AlphaBand`, via `imread(path, IMREAD_LOAD_GDAL)`. ASan reports a heap-buffer-overflow WRITE of size 1 at `grfmt_gdal.cpp:259`.
Cause: an alpha band makes `readData` pass `color = 3`, but the `gdalChannels == 3 && image.channels() == 3` branch of `write_pixel` indexes `Vec3b[channel]` with no bound, so `channel == 3` stores one element past the 3-lane pixel. On the last pixel that lands past the Mat buffer.
Fix (per review): `readData` checks the mapped color index against `img.channels()` in the band loop, before the pixel iteration. An out-of-range band is skipped as a whole with a `CV_LOG_WARNING` naming the band and range, instead of a silent per-pixel guard. Valid RGB rasters decode identically.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-08-13 16:12:22 +03:00
Pratham Kumar
fece2acfba Merge pull request #28728 from pratham-mcw:calchist-simd-opt 
imgproc: add simd support for calchist & calchist1d function - #28728

- This PR adds OpenCV SIMD intrinsics-based optimizations to the Calchist and calcHist1d function for improved performance on Windows-ARM64 platforms.
- The optimized implementation uses vectorized operations to accelerate histogram computation.
- In x64 architecture, `calcHist1d` benefits from IPP-based optimized implementations. However, on ARM64 platforms, the execution falls back to scalar implementation, which results in lower performance.
- After introducing these changes, the calcHist and calchist1d function showed noticeable performance improvements on Windows-ARM64.

**Performance Benchmarks:**
<img width="1247" height="460" alt="image" src="https://github.com/user-attachments/assets/ed740d87-158e-49d4-889e-9c7dda482a63" />
<img width="552" height="210" alt="image" src="https://github.com/user-attachments/assets/76b9e46e-304e-480c-9a57-af0aba6e937a" />

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
 2026-08-13 14:32:47 +03:00
Lazizbek Ergashev
28026fe2cf videoio: fix FFmpeg VideoCapture ignoring mid-stream pixel format change 
(cherry picked from commit f3c9241611cfb46dd17de2b3e3f25f6fe36b71f8)
 2026-08-13 14:34:45 +05:00
Madan mohan Manokar
c6e84d494c Merge pull request #29394 from amd:fast_accumulate 
imgproc: Optimized accumulate with AVX512 dispatch and AVX2 kernels improved #29394

- Add AVX512_SKX/AVX512_ICL to accum dispatch
- Fine tune AVX2 kernels for float, cn = 1 and 3 cases.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-13 12:21:29 +03:00
Aaron
bfa07fc52a Merge pull request #29638 from aarochu:feature-medianblur-arbitrary-channels 
imgproc: support arbitrary channel counts in medianBlur #29638

## Summary

Fixes #29592.

`cv::medianBlur`/`cv2.medianBlur` rejects `CV_8U` images with channel counts other than 1, 3, or 4 whenever the optimized large-kernel path is needed — `ksize >= 7` always, and `ksize == 5` on SIMD-enabled builds (the `ksize == 3`/`ksize == 5`-without-SIMD "sort net" path already handles arbitrary channel counts generically, so this only affects the fast path):

```
src.depth() == CV_8U && (cn == 1 || cn == 3 || cn == 4)
```

Median filtering is channel-independent, so there's no correctness reason for this restriction — it's an implementation detail of the optimized SIMD kernels (which hard-code 1/3/4-channel-interleaved layouts), not a property of the algorithm. Users with 2, 5, 6, 9+ channel images (multispectral, feature maps, stacked masks) currently have to split, filter, and re-concatenate manually outside the library — exactly the workaround already implemented downstream in Albucore, per the issue.

## Fix

In `cv::medianBlur` (`modules/imgproc/src/median_blur.dispatch.cpp`), before dispatching to HAL/OpenCL/the optimized SIMD path: if the channel count isn't 1, 3, or 4, split the image into individual channels, run `medianBlur` on each one independently (a single channel is always supported by every existing path, recursively), and merge the results back together. This touches none of the performance-critical kernels — it's a fallback that only runs for channel counts those kernels don't support, and the existing 1/3/4-channel fast paths are completely unaffected.

## Test plan

- [x] Added `Imgproc_MedianBlur.arbitrary_channel_count_29592` in `modules/imgproc/test/test_filter.cpp`, covering channel counts `{1,2,3,4,5,6,9}` × kernel sizes `{3,5,7,9}`. For each combination it asserts `medianBlur` doesn't throw, preserves size/type, and — critically — produces output bit-identical to filtering each channel independently via `cv::split`/`cv::merge` (the reference/expected behavior).
- [x] Built `opencv_core` + `opencv_imgproc` + `opencv_test_imgproc` locally (MSVC) and ran the new test — passes.
- [x] Ran the full existing `Imgproc_MedianBlur.*`, `Imgproc_Filter2D.*`, `Imgproc_Blur.*`, `Imgproc_GaussianBlur.*` suites — all 14 pass, no regressions.
- Note: `GaussianBlurVsBitexact`, `sepFilter2D_types`, and `StackBlur` tests in the same binary fail/crash in this local environment, but reproduce identically on unmodified `4.x` with no changes at all — confirmed pre-existing and unrelated to this change (not investigated further, out of scope here).
 2026-08-13 11:35:16 +03:00
Alexander Smorkalov
4afa329a78 Merge pull request #29696 from Parth1353:fix/29694-avx512icl-baseline-dispatch 
core, imgproc: fix build when AVX512_ICL is in the baseline
 2026-08-13 10:03:13 +03:00
Parth Saini
e24dc1ff4c core: add CV_CPU_GET_FN_PTR_<OPT>() to resolve dispatched function pointers 
The generated cv_cpu_helper.h sets CV_TRY_<OPT> to 1 both when <OPT> is a
dispatch target and when it is part of the baseline, but an opt_<OPT> namespace
is only emitted for the dispatch case: __ocv_add_dispatched_file() guards it
with CPU_DISPATCH_FINAL, and a baseline optimization is deliberately kept out of
that list. Code that hand-rolls "#if CV_TRY_<OPT> ... opt_<OPT>::fn" therefore
fails to compile as soon as the optimization lands in the baseline, e.g. with
-DCPU_BASELINE=AVX512_ICL or -march=native on an ICL capable CPU:

  lut.dispatch.cpp:22:16: error: 'opt_AVX512_ICL' has not been declared

CV_CPU_CALL_<OPT>() already handles the namespace selection for a call. Add the
same thing for code that needs the function pointer instead:

  CV_CPU_GET_FN_PTR_<OPT>(fn)       per optimization
  CV_CPU_GET_FN_PTR_BASELINE(fn)    chain terminator
  CV_CPU_DISPATCH_FN(fn, modes)     full chain, mirrors CV_CPU_DISPATCH()

In the baseline case it resolves to cpu_baseline::fn, which is the <OPT> build
of the kernel, so no implementation is lost and no second copy is emitted. In
the dispatch case it keeps the cv::checkHardwareSupport() test and returns
opt_<OPT>::fn, and it compiles out when the optimization is unavailable.

Use it in the two places that hit this, which also removes the hand-written
preprocessor blocks. Generated code for the dispatch configuration is unchanged
(byte-identical .text with -DCPU_BASELINE=SSE3 -DCPU_DISPATCH=AVX512_ICL).

Fixes #29694
 2026-08-12 18:10:38 +05:30
Parth Saini
3043094d71 imgproc: document per-code depth support on cvtColor/demosaicing src param 
cvtColor's @param src promised 8U, 16U and 32F unconditionally, but the accepted
depths depend on the conversion code: CV_16U is rejected by COLOR_BGR2HSV,
COLOR_BGR2Lab, COLOR_BGR2Luv and the packed 16-bit codes, while COLOR_BGR2GRAY,
COLOR_BGR2XYZ, COLOR_BGR2YUV and RGB<->RGB accept it. That is what #26447
reported.

State it on @param src and point at the [8U]/[16U]/[32F] markers already
documented on ColorConversionCodes. The @note only said the source "must be of
an appropriate type", which is now redundant, so drop it from both functions.

demosaicing has the same problem: the Variable Number of Gradients codes accept
8-bit input only, while the other Bayer codes also accept 16-bit.

Fixes #26447
 2026-08-12 12:35:49 +05:30
Andrei Fedorov
7075c595ae Update matchtemplate_ipp.cpp 2026-08-11 18:51:01 +02:00
Alexander Smorkalov
21d60a9afe Merge pull request #29693 from asmorkalov:as/handeye_test_4.x 
Backported python tests for calibrateHandEye and calibrateRobotWorldHandEye
 2026-08-11 17:25:59 +03:00
Alexander Smorkalov
f347805418 Merge pull request #29533 from Aadhu23:fix-29504-clean 
videoio: fix build with FFmpeg 9 after AVCodec::pix_fmts removal
 2026-08-11 17:21:05 +03:00
Alexander Smorkalov
5fe174365d Backported python tests for calibrateHandEye and calibrateRobotWorldHandEye. 2026-08-11 15:28:32 +03:00
Alexander Smorkalov
c0166c617d Code review fixes. 2026-08-11 13:01:55 +03:00
Arnesh Banerjee
83ed22ca28 videoio(ffmpeg): use avcodec_get_supported_config for framerates on FFmpeg 9 
AVCodec::supported_framerates was deprecated in FFmpeg 7.1 and removed in
FFmpeg 9, so direct field access no longer builds against FFmpeg 9.

Read the supported frame rate list through avcodec_get_supported_config()
when building against libavcodec 61.13.100 or newer. That call returns the
same list plus its entry count, so the loop iterates by count instead of the
old sentinel terminator. Older FFmpeg keeps the previous field access.
 2026-08-11 12:10:00 +03:00
Aadhu23
700cd32ffd videoio: support FFmpeg after AVCodec::pix_fmts removal 2026-08-11 12:07:21 +03:00
Alexander Smorkalov
49c8d21f16 Merge pull request #29674 from karpovantonme:docs/read-options-param 
imgcodecs: name the parameter setReadOptions actually takes 🤖🤖🤖
 2026-08-11 09:34:52 +03:00
Alexander Smorkalov
bbab7da39f Merge pull request #29563 from developer0hye:agent/msmf-close-event-handle 
videoio(MSMF): close leaked SourceReaderCB Event handle 🤖🤖🤖
 2026-08-11 09:31:30 +03:00
Alexander Smorkalov
dea9ce421d Merge pull request #28517 from asmorkalov:as/charuco_bindings 
Fixed bindings generation for Charuco boards #28517

Fixes https://github.com/opencv/opencv/issues/28512

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [ ] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-08-10 19:45:53 +03:00
Alexander Smorkalov
d53047927b Merge pull request #29661 from anupamme:fix-repo-opencv-v004-bilateral-filter-integer-overflow 
harden: add integer overflow check in bilateralFilter.cpp
 2026-08-10 19:33:49 +03:00
aryan chaudhary
9b1aa94e69 Merge pull request #29623 from Aryan171:fix/features2d-akaze-subsample-overflow 
features2d: fix heap buffer overflow in AKAZE generateDescriptorSubsample #29623

Prevent out-of-bounds write in `generateDescriptorSubsample()` during AKAZE MLDB descriptor generation when `nchannels < 3` (e.g. `nchannels = 2`).

Fixes #29613 

### Summary of Changes

- **Module:** `features2d` (AKAZE)
- **Problem:** When `generateDescriptorSubsample()` is called with `nchannels < 3`, the code hardcoded 3-channel matrix index offsets (`+ 0`, `+ 1`, `+ 2`). Since `comps` allocates rows based on `nchannels * npicks`, writing to index offset `+ 2` when `nchannels = 2` causes a heap buffer overflow past the last row of `comps`.
- **Fix:** Replaced hardcoded 3-channel matrix index assignments with a dynamic loop that iterates over `0` to `nchannels - 1`.
- **Regression Test:** Added `Features2D_AKAZE.Subsample_Channels_Overflow_Fix` in `modules/features2d/test/test_akaze.cpp`.
- 
### Acknowledgments

Thanks to @abhishek-gola for reviewing the test and suggesting the correct approach.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch (`4.x`)
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-08-10 15:26:45 +03:00
Ijtihed Kilani
119dd753e9 imgcodecs(tiff): support reading images with more than 4 channels 2026-08-08 14:12:21 +03:00
Anton Karpov
2459ac65fe imgcodecs: name the parameter setReadOptions actually takes 2026-08-07 15:04:27 +03:00
Abhishek Gola
77dfa297d0 Merge pull request #29640 from yvonnelxxxx/fix/int-overflow-absdiff 
fix: signed-integer-overflow in c_absdiff<int>
 2026-08-06 19:29:06 +05:30
Abhishek Gola
59a0461d50 Merge pull request #29567 from Adel-Ayoub/fix/tiff-planar-decode 
imgcodecs: fix decoding of TIFF images with separate planes
 2026-08-06 19:09:46 +05:30
Abhishek Gola
49ca26154e Merge pull request #29554 from mvanhorn/fix/29279-ipp-warpaffine-nearest-bitexact 
imgproc: route IPP warpAffine INTER_NEAREST to native kernel for bit-exactness 🤖🤖🤖
 2026-08-06 19:09:35 +05:30
Abhishek Gola
3ea443b670 Merge pull request #29667 from intel-staging/ipp/iw_build_fix 
Build fix: IPP integration wrapers
 2026-08-06 13:37:50 +05:30
Abhishek Gola
a21f7a1d1b Merge pull request #29668 from karpovantonme/docs/memset-param-names 
dnn: fix the parameter names documented for memset 🤖🤖🤖
 2026-08-06 13:32:30 +05:30
Adel-Ayoub
ff6112c09e imgcodecs: fix decoding of TIFF images with separate planes 2026-08-05 23:26:27 +01:00
Anton Karpov
f625c00f5a dnn: fix the parameter names documented for memset 
The four memset overloads in cuda4dnn document their first parameter as
src while it is called dest, and the directions are the wrong way round:
the output buffer is marked [in] and the 8-bit fill value is marked [out].

The prose above two of them already says dest, only the tags disagree.
 2026-08-05 15:48:52 +03:00
Victor Getmanskiy
64a04b540a Build fix: IPP integration wrapers 2026-08-05 12:41:12 +02:00
anupamme
5940b25d34 fix: V-004 security vulnerability 
Automated security fix generated by OrbisAI Security
 2026-08-04 14:18:09 +00:00
Abhishek Gola
4bee6895eb Merge pull request #29643 from uwezkhan/apng-dispose-elem-size 
fix apng background dispose overrun in png readData
 2026-08-04 09:56:19 +05:30
Yvonne
5a5ac33c87 make absdiff overflow test accept saturate or wraparound 2026-08-04 11:55:18 +08:00
Yvonne
154dac563f fix test for ARM 2026-08-03 17:05:41 +08:00
Abhishek Gola
6e82dddfb5 Merge pull request #29649 from kaingwade/thead_rvv_check 
Update T-Head RVV check
 2026-08-03 12:58:47 +05:30
Yvonne
de15c6af68 core(arithm): add regression test for cv::absdiff CV_32S overflow 2026-08-03 14:51:35 +08:00
kaingwade
caaabca123 Update T-Head RVV check 2026-08-03 10:54:36 +08:00
Uwez Khan
6ad702680e fix apng background dispose overrun in png readData 2026-08-01 02:13:45 +05:30
Matt Van Horn
92d1ebe1a0 docs: trim the NEAREST-fallback comments per review 2026-07-31 08:02:50 -07:00
Yvonne
4edef8f4bf fix signed-int-overflow in c_absdiff<int> 2026-07-31 16:53:42 +08:00
Abhishek Gola
e35ad60e4e Merge pull request #29544 from xi-guo-0/core-optimize-extract-channel-8uc2 
core: optimize 8UC2 channel extraction
 2026-07-30 16:49:19 +05:30
Abhishek Gola
f42fa7b214 Merge pull request #29553 from mvanhorn/fix/26746-warn-external-grfmt-fallback 
cmake: warn when external image-codec library is requested but not found 🤖🤖🤖
 2026-07-30 16:38:23 +05:30
Abhishek Gola
2fb7adbd53 Merge pull request #29552 from sergiud/opencl-remap-artifacts 
imgproc: fix OpenCL remap negative border rounding
 2026-07-30 15:46:30 +05:30
Abhishek Gola
2b6c3df954 Merge pull request #29546 from uwezkhan/dtree-split-index-bound 
bound categorical split indices in dtrees readSplit
 2026-07-29 13:31:38 +05:30
Abhishek Gola
a906dfbed2 Merge pull request #29626 from ArneshBanerjee/fix-29615-icvcvt-pointer-overflow-4x 
imgcodecs: fix pointer overflow in 16u icvCvt helpers (4.x)
 2026-07-28 19:52:22 +05:30
Arnesh Banerjee
b7860407f0 imgcodecs: fix pointer overflow in 16u icvCvt helpers 
The 16-bit icvCvt_* helpers in utils.cpp move the row pointer with
step/sizeof(x[0]) - size.width*N. sizeof is unsigned, so this is done in
unsigned math. When the caller passes step == 0, it underflows to a huge
value and the pointer goes out of range, which is undefined behavior.

The TIFF decoder hits this: it walks rows itself and calls these helpers
with step = 0, so reading a 16-bit 4-channel TIFF triggers the bug.

Cast sizeof(...) to int so the math is signed. Same result for normal
calls, no overflow when the step is 0.

Added Imgcodecs_Tiff.regression_29615_16UC4 which round-trips a CV_16UC4
TIFF in memory.

This is the 4.x version of the fix, requested in
https://github.com/opencv/opencv/pull/29620 (issue #29615).
 2026-07-28 16:19:17 +05:30
Uwez Khan
dee2bb288b bound categorical split indices in dtrees readSplit 2026-07-27 10:54:57 +05:30
Sergiu Deitsch
096759c0b0 imgproc: fix OpenCL remap negative rounding 
Truncation toward zero produces incorrect interpolation indices for
negative border coordinates. Use nearest-even rounding so OpenCL remap
matches the CPU behavior.
 2026-07-27 10:46:53 +05:30
Sergiu Deitsch
73c9537f3b imgproc: fix NVIDIA OpenCL remap kernel types 
Match interpolation coefficient types to the working type so the double
kernel compiles on NVIDIA devices.
 2026-07-27 10:46:53 +05:30
Alexander Smorkalov
70fc346580 Merge pull request #29549 from hanu-14:fix-https-readme-md 
fix: upgrade http:// to https:// in README.md
 2026-07-26 15:02:04 +03:00
Andrei Fedorov
664f59e750 Merge pull request #29542 from intel-staging:ipp/enable_instrumentation_fix 
Implemented a check to enable instrumentation for IPP HAL #29542

To enable instrumentation for IPP HAL correctly it needed to generalize a part of `private.hpp` and put it to the separate file that can be included in `private.hpp` and `ipp_utils.hpp` both to avoid duplication.

Built with `-DENABLE_INSTRUMENTATION=ON` and ran `opencv_perf_imgproc --perf_instrument=1`:

  | Test | IPP weight before | IPP weight after |
  |---|---|---|
  | `distanceTransform` (8U->32F) | 0.0% | ~76% |
  | `ippSobel` | 0.0% | ~98% |
  | `scharrViaSobelFilter` | 0.0% | ~90% |

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-07-26 15:01:24 +03:00
Alexander Smorkalov
19ef7e6e16 Merge pull request #29583 from uditjainstjis:fix-23580-hog-buffer-overflow 
objdetect: fix out-of-bounds write in HOG gaussian weights #23580 🤖🤖🤖
 2026-07-25 10:01:30 +03:00
Udit Jain
c8446af29a objdetect: fix out-of-bounds write in HOG gaussian weights (blockSize.height vs width) 
In HOGCache::init the block gaussian weights are computed into two buffers:
  AutoBuffer<float> di(blockSize.height), dj(blockSize.width);
The vectorized (CV_SIMD128) loop that fills dj was bounded by
`blockSize.height` instead of `blockSize.width`. When the block is taller than
it is wide, `v_store(_dj + j, ...)` writes past the end of the width-sized dj
buffer, causing a heap buffer overflow / access violation (e.g. HOGDescriptor
with a 198x281 window, or the 2399x2400 case from the report).

Bound the dj loop by `blockSize.width` to match the buffer size and the scalar
tail loop. This keeps the SIMD path (unlike the workaround in the report, which
disabled it).

Added a regression test that computes a HOGDescriptor with a tall block; without
the fix it triggers a heap-buffer-overflow (confirmed with AddressSanitizer at
hog.cpp:731 inside HOGCache::init).

Fixes #23580
 2026-07-24 04:51:45 +05:30
Yuantao Feng
0e09f1a238 Merge pull request #29557 from fengyuentau:4x/hal_rvv/split_opt 
hal_rvv core: Cover more data types for split with native RVV intrinsics #29557

Covering 16-bit, 32-bit and 64-bit split.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-07-21 10:16:38 +03:00
Alexander Smorkalov
ba53d1d6b7 Merge pull request #29566 from fengyuentau:4x/hal_rvv/copy_mask_opt 
hal_rvv core: Optimize RVV HAL masked copy
 2026-07-21 10:15:07 +03:00
FENG Yuantao
1f36f15a49 Optimize RVV HAL masked copy 2026-07-20 23:43:41 +08:00
Yonghye Kwon
df9da57e4f videoio(MSMF): close SourceReaderCB event handle 
SourceReaderCB owns an Event created for asynchronous frame delivery,
but its destructor did not close the handle. Close it when the callback
is destroyed to prevent one Event handle from leaking across repeated
MSMF capture lifecycles.

Fixes #29562
 2026-07-20 20:21:49 +09:00
Alexander Smorkalov
2b6ea5f344 Merge pull request #29556 from fengyuentau:4x/hal_rvv/merge_opt 
hal_rvv core: Optimize 32-bit and 64-bit merge
 2026-07-20 12:26:12 +03:00
Xi Guo
1bf1e70c0f core: optimize 8UC2 channel extraction 2026-07-20 10:21:00 +08:00
pratham-mcw
ee3b0d5bd0 Fix padded-buffer stride and complex-input truncation in DFT 2026-07-19 23:48:23 +05:30
FENG Yuantao
898f1e9691 Optimize RVV HAL 32-bit and 64-bit merge 2026-07-20 00:22:38 +08:00
pratham-mcw
ed1a25df19 fix NEON box filter build failure on armv7 2026-07-19 16:43:18 +05:30
Matt Van Horn
fe5ab36245 imgproc: fix IPP HAL warpAffine INTER_NEAREST not bit-exact with native 
The IPP HAL (hal/ipp/src/warp_ipp.cpp) routed cv::warpAffine with
INTER_NEAREST to iwiWarpAffine for CV_16S{C1,C3,C4}, CV_64F{C1,C3,C4}
and CV_16UC4 via the non-enforced (default) impl[] dispatch table,
whose comment promises results "strictly aligned to OpenCV
implementation". That contract was broken: IPP rounds source
coordinates at the half-pixel boundary differently from the native
fixed-point kernel (warpAffineBlocklineNN, 10-bit AB_BITS), so under
rotation or fractional translation about 0.05-0.07% of destination
pixels resolve to a different source pixel. Because INTER_NEAREST does
no blending, those pixels take entirely different values, so warping
identical data as e.g. CV_16S (IPP path) versus CV_16U (native path)
produced non-identical output, and x86_64 (IPP) silently diverged from
ARM (no IPP). This is the same "Different results" behavior for which
IPP warpAffine was disabled from ~2017 through 4.11.

Zero the INTER_NEAREST column of the non-enforced dispatch table for
the affected types so the dispatch guard falls back to the native
kernel, restoring the "strictly aligned" contract. The LINEAR and
CUBIC columns for these rows were already 0, so IPP was only ever used
for NEAREST here. The IPP_CALLS_ENFORCED table is left untouched so the
opt-in performance-benchmarking build still exercises IPP.

Adds a regression test (Imgproc_Warp.regression_29279) that warps a
gradient image with INTER_NEAREST as each affected type and asserts
bit-exact equality with a native (CV_32F) reference across several
rotation angles and a fractional translation.

Fixes #29279
 2026-07-18 10:12:16 -07:00
Matt Van Horn
a859f3feff cmake: warn when external grfmt library requested but not found 
When a user disables a bundled image-codec dependency (e.g.
BUILD_ZLIB=OFF) to supply an external build but find_package()
cannot locate it, OpenCVFindLibsGrfmt.cmake silently falls back to
compiling the bundled 3rdparty version. As reported in the issue,
this is misleading: the editable ZLIB_LIBRARY_DEBUG/RELEASE cache
entries have no effect after the fallback and nothing points the
user at the real knob (ZLIB_ROOT / ZLIB_DIR).

Emit a message(WARNING) in each fallback branch, guarded by
NOT BUILD_<lib>, so the built-in fallback is no longer silent when
the user explicitly opted out of the bundled build. The warning
names the correct search variables for that library and points to
the CMake find_package / Find<lib> documentation. Applied
consistently to the zlib, libjpeg, libtiff, libpng and libwebp
fallback branches.

The existing fallback behavior is intentionally left unchanged, so
configurations that rely on the built-in fallback continue to build.

Fixes #26746
 2026-07-18 10:02:13 -07:00
Alexander Smorkalov
6f402272e7 Merge branch 'as/release_4.14.0' into 4.x 2026-07-18 09:55:21 +03:00
MOHAMMED HANAN M T P
5ab3e2e580 fix: upgrade http:// to https:// in README.md 2026-07-18 11:13:02 +05:30
Alexander Smorkalov
0654a42e19 Release: OpenCV 4.14.0 2026-07-17 15:55:59 +03:00
Alexander Smorkalov
f7dd7df170 Merge pull request #29531 from asmorkalov:as/openvino_ci_fail 
Disable test test that sporadically fails with OpenVINO on CI #29531

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [ ] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-07-17 13:32:48 +03:00
pratham-mcw
c6b17073e9 Replace CV_NEON_AARCH64 with CV_NEON in box_filter 2026-07-17 15:58:35 +05:30
Alexander Smorkalov
7aa163b83f Merge pull request #29539 from uwezkhan:aruco-readdict-marker-bound 
bound marker string length in aruco readDictionary
 2026-07-17 11:42:51 +03:00
Alexander Smorkalov
c47541acbd Merge pull request #29525 from asmorkalov:as/ffmpeg_update_4.14 
FFmpeg wrapper update for 4.14.0 release.
 2026-07-17 10:37:20 +03:00
Uwez Khan
b5fe8dfef3 bound marker string length in aruco readDictionary 2026-07-16 19:44:15 +05:30
pratham-mcw
2665cec7f2 fix NEON RowSum build failure on non-float/double type instantiations 2026-07-16 18:49:00 +05:30
Alexander Smorkalov
4d1e206f5e FFmpeg wrapper update for 4.14.0 release. 2026-07-16 15:12:50 +03:00
Yuantao Feng
2e778c52c1 Merge pull request #27510 from fengyuentau:4x/core/reduce_simd 
core: vectorize cv::reduce #27510

- [ ] ~reduceR_~ Dropped due to performance
- [x] reduceC_

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [ ] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [ ] The feature is well documented and sample code can be built with the project CMake
 2026-07-15 22:36:29 +03:00
Madan mohan Manokar
6b640b424c Merge pull request #28650 from amd:fast_pyrDown 
imgproc: Optimized OpticalFlowPyrLK (PyrDownH) #28650

- Optimized Uchar PyrDown Horizontal processing intermediate storage.
- Improved horizontal processing with AVX512 vbmi ISA.
- Todo: further refinement for other archs.

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-07-15 12:31:28 +03:00
Alexander Smorkalov
06574736b3 Merge pull request #29503 from uwezkhan:flann-kdtree-load-bounds 
bound kd-tree node indices when loading a saved flann index
 2026-07-14 15:36:16 +03:00
Madan mohan Manokar
4fe51e51e0 Merge pull request #29507 from amd:fast_remap_ext 
imgproc: Optimized remap interpolation #29507

- Add a SIMD dispatch file for remap and vectorize the single-channel (C1) in-bounds paths of bilinear, bicubic and lanczos4 interpolation (32F / 16U / 16S) using width-agnostic gather
- Dispatch the bilinear C1 path and drop the per-pixel weight-table gathers
- Widen the fixed-point coordinate map conversion
- 32F lanczos4 is kept on the scalar path: its vectorized 64-tap accumulation deviates beyond the set float accuracy tolerance
- Vectorize the bilinear inlier/outlier run detection so any-channel linear remap skips constant-status runs with SIMD instead of a per-pixel bounds test

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [ ] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
 2026-07-14 15:17:22 +03:00
Alexander Smorkalov
335abd236f Merge pull request #29523 from asmorkalov:as/relax_gapi_gstreamer_test 
Relaxed G-API tests for GStreamer to support Ubuntu 26.04.
 2026-07-14 12:09:48 +03:00
Alexander Smorkalov
46d1b6c99d Relaxed G-API tests for GStreamer to support Ubuntu 26.04. 2026-07-14 08:47:33 +03:00
Alexander Smorkalov
e6b1ef272e Merge pull request #29511 from Akansha-977:histogram_IPP_4.x 
Extracted IPP to HAL for calcHist function in 4.x
 2026-07-14 08:42:06 +03:00
Alexander Smorkalov
1bea199e00 Merge pull request #29437 from intel-staging:dev/tizmajlo/ippicv_20260630 
Update IPP ICV integration to IPP 2026.0.0 (20260630)
 2026-07-14 08:25:34 +03:00
Alexander Smorkalov
42cd88d737 Merge pull request #29509 from asmorkalov:as/ubuntu_26.04_warn_fix 
Samples build warning fix on Ubuntu 26.04
 2026-07-14 08:19:57 +03:00
Alexander Smorkalov
4c3895e96c Samples build warning fix on Ubuntu 26.04 2026-07-13 15:22:08 +03:00
Akansha Mallick
2c14cc1897 Extracted IPP to HAL for calcHist function 2026-07-13 14:12:52 +05:30
Uwez Khan
13fb140932 bound kd-tree node indices when loading a saved flann index 2026-07-12 21:36:42 +05:30
Timur Izmajlov
9d66a589b4 Update IPP ICV integration to IPP 2026.0.0 (20260630) 2026-07-03 17:25:24 +02:00
pratham-mcw
d87e0e6117 imgproc: fix C++17 extension warning in box_filter NEON code 2026-07-02 20:16:32 +05:30
pratham-mcw
7962c00701 core: Add padded buffer for DFT on Windows ARM64 to reduce cache thrashing 2026-06-16 15:34:13 +05:30
pratham-mcw
8963a3868e ximgproc: add NEON intrinsics support for Guided Filter Function 2026-06-04 12:04:19 +05:30
4168 changed files with 1430502 additions and 544448 deletions
Expand all files Collapse all files

14
.github/workflows/4.x.yml vendored Normal file
View File

@@ -0,0 +1,14 @@
name: 4.x
on:
schedule:
- cron: '0 3 * * *'
workflow_dispatch:
jobs:
CodeQL:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-CodeQL.yaml@main
with:
target_branch: '4.x'
workflow_branch: main

13
.github/workflows/5.x.yml vendored
View File

@@ -1,13 +0,0 @@
name: 5.x
on:
schedule:
- cron: '0 3 * * *'
workflow_dispatch:
jobs:
CodeQL:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-CodeQL.yaml@main
with:
target_branch: '5.x'
workflow_branch: main

63
.github/workflows/PR-4.x.yaml vendored Normal file
View File

@@ -0,0 +1,63 @@
name: PR:4.x
on:
pull_request:
branches:
- 4.x
jobs:
Linux:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux.yaml@main
with:
workflow_branch: main
Linux-no-HAL:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux-NoHAL.yaml@main
Linux-Apline:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux-Alpine.yaml@main
Windows:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Windows.yaml@main
with:
workflow_branch: main
Ubuntu2404-ARM64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-ARM64.yaml@main
Ubuntu2404-ARM64-Debug:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-ARM64-Debug.yaml@main
Ubuntu2004-x64-OpenVINO:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-U20-OpenVINO.yaml@main
Ubuntu2004-x64-CUDA:
if: "${{ contains(github.event.pull_request.labels.*.name, 'category: dnn') }} || ${{ contains(github.event.pull_request.labels.*.name, 'category: dnn (onnx)') }}"
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-U20-Cuda.yaml@main
macOS-ARM64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-macOS-ARM64.yaml@main
macOS-x64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-macOS-x86_64.yaml@main
macOS-ARM64-Vulkan:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-macOS-ARM64-Vulkan.yaml@main
iOS:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-iOS.yaml@main
Android-SDK:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-4.x-Android-SDK.yaml@main
TIM-VX:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-timvx-backend-tests-4.x.yml@main
docs:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-4.x-docs.yaml@main
Linux-RISC-V-Clang:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-RISCV.yaml@main
with:
workflow_branch: main

64
.github/workflows/PR-5.x.yaml vendored
View File

@@ -1,64 +0,0 @@
name: PR:5.x
on:
pull_request:
branches:
- 5.x
jobs:
Linux:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux.yaml@main
with:
workflow_branch: 'main'
Linux-no-HAL:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux-NoHAL.yaml@main
Linux-Apline:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Linux-Alpine.yaml@main
Windows:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-Windows.yaml@main
with:
workflow_branch: main
Ubuntu2404-ARM64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-ARM64.yaml@main
Ubuntu2404-ARM64-Debug:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-ARM64-Debug.yaml@main
Ubuntu2004-x64-OpenVINO:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-U20-OpenVINO.yaml@main
Ubuntu2004-x64-CUDA:
if: "${{ contains(github.event.pull_request.labels.*.name, 'category: dnn') }} || ${{ contains(github.event.pull_request.labels.*.name, 'category: dnn (onnx)') }}"
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-U20-Cuda.yaml@main
# Vulkan configuration disabled as Vulkan backend for DNN does not support int/int64 for now
# Details: https://github.com/opencv/opencv/issues/25110
# Windows10-x64-Vulkan:
# uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-W10-Vulkan.yaml@main
macOS-ARM64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-macOS-ARM64.yaml@main
# macOS-ARM64-Vulkan:
# uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-macOS-ARM64-Vulkan.yaml@main
macOS-x64:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-macOS-x86_64.yaml@main
iOS:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-iOS.yaml@main
Android:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-Android.yaml@main
docs:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-5.x-docs.yaml@main
Linux-RISC-V-Clang:
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-RISCV.yaml@main
with:
workflow_branch: main

49
3rdparty/clapack/CMakeLists.txt vendored
View File

@@ -1,49 +0,0 @@
# ----------------------------------------------------------------------------
# CMake file for opencv_lapack. See root CMakeLists.txt
#
# ----------------------------------------------------------------------------
project(clapack)
# TODO: extract it from sources somehow
set(CLAPACK_VERSION "3.9.0" PARENT_SCOPE)
include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")
# The .cpp files:
file(GLOB lapack_srcs src/*.c)
file(GLOB runtime_srcs runtime/*.c)
file(GLOB lib_hdrs include/*.h)
# ----------------------------------------------------------------------------------
# Define the library target:
# ----------------------------------------------------------------------------------
set(the_target "libclapack")
add_library(${the_target} STATIC ${lapack_srcs} ${runtime_srcs} ${lib_hdrs})
ocv_warnings_disable(CMAKE_C_FLAGS -Wno-parentheses -Wno-uninitialized -Wno-array-bounds
-Wno-implicit-function-declaration -Wno-unused -Wunused-parameter -Wstringop-truncation
-Wtautological-negation-compare) # gcc/clang warnings
ocv_warnings_disable(CMAKE_C_FLAGS /wd4244 /wd4554 /wd4723 /wd4819) # visual studio warnings
set_target_properties(${the_target}
PROPERTIES OUTPUT_NAME ${the_target}
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
COMPILE_PDB_NAME ${the_target}
COMPILE_PDB_NAME_DEBUG "${the_target}${OPENCV_DEBUG_POSTFIX}"
ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
)
set(CLAPACK_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include" PARENT_SCOPE)
set(CLAPACK_LIBRARIES ${the_target} PARENT_SCOPE)
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${the_target} PROPERTIES FOLDER "3rdparty")
endif()
if(NOT BUILD_SHARED_LIBS)
ocv_install_target(${the_target} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev)
endif()
ocv_install_3rdparty_licenses(clapack lapack_LICENSE)

102
3rdparty/clapack/include/cblas.h vendored
View File

@@ -1,102 +0,0 @@
#ifndef __CBLAS_H__
#define __CBLAS_H__
/* most of the stuff is in lapacke.h */
#ifdef __cplusplus
extern "C" {
#endif
typedef struct lapack_complex
{
float r, i;
} lapack_complex;
typedef struct lapack_doublecomplex
{
double r, i;
} lapack_doublecomplex;
typedef enum {CblasRowMajor=101, CblasColMajor=102} CBLAS_LAYOUT;
typedef enum {CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113} CBLAS_TRANSPOSE;
void cblas_xerbla(const CBLAS_LAYOUT layout, int info,
const char *rout, const char *form, ...);
void cblas_sgemm(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const float alpha, const float *A,
const int lda, const float *B, const int ldb,
const float beta, float *C, const int ldc);
void cblas_dgemm(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const double alpha, const double *A,
const int lda, const double *B, const int ldb,
const double beta, double *C, const int ldc);
void cblas_cgemm(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const void *alpha, const void *A,
const int lda, const void *B, const int ldb,
const void *beta, void *C, const int ldc);
void cblas_zgemm(CBLAS_LAYOUT layout, CBLAS_TRANSPOSE TransA,
CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const void *alpha, const void *A,
const int lda, const void *B, const int ldb,
const void *beta, void *C, const int ldc);
int xerbla_(char *, int *);
int lsame_(char *, char *);
double slamch_(char* cmach);
double slamc3_(float *a, float *b);
double dlamch_(char* cmach);
double dlamc3_(double *a, double *b);
int dgels_(char *trans, int *m, int *n, int *nrhs, double *a,
int *lda, double *b, int *ldb, double *work, int *lwork, int *info);
int dgesv_(int *n, int *nrhs, double *a, int *lda, int *ipiv,
double *b, int *ldb, int *info);
int dgetrf_(int *m, int *n, double *a, int *lda, int *ipiv,
int *info);
int dposv_(char *uplo, int *n, int *nrhs, double *a, int *
lda, double *b, int *ldb, int *info);
int dpotrf_(char *uplo, int *n, double *a, int *lda, int *
info);
int sgels_(char *trans, int *m, int *n, int *nrhs, float *a,
int *lda, float *b, int *ldb, float *work, int *lwork, int *info);
int sgeev_(char *jobvl, char *jobvr, int *n, float *a, int *
lda, float *wr, float *wi, float *vl, int *ldvl, float *vr, int *
ldvr, float *work, int *lwork, int *info);
int sgeqrf_(int *m, int *n, float *a, int *lda, float *tau,
float *work, int *lwork, int *info);
int sgesv_(int *n, int *nrhs, float *a, int *lda, int *ipiv,
float *b, int *ldb, int *info);
int sgetrf_(int *m, int *n, float *a, int *lda, int *ipiv,
int *info);
int sposv_(char *uplo, int *n, int *nrhs, float *a, int *
lda, float *b, int *ldb, int *info);
int spotrf_(char *uplo, int *n, float *a, int *lda, int *
info);
int sgesdd_(char *jobz, int *m, int *n, float *a, int *lda,
float *s, float *u, int *ldu, float *vt, int *ldvt, float *work,
int *lwork, int *iwork, int *info);
#ifdef __cplusplus
}
#endif
#endif /* __CBLAS_H__ */

129
3rdparty/clapack/include/f2c.h vendored
View File

@@ -1,129 +0,0 @@
/* f2c.h -- Standard Fortran to C header file */
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
#ifndef __F2C_H__
#define __F2C_H__
#include <assert.h>
#include <math.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "cblas.h"
#include "lapack.h"
#ifdef __cplusplus
extern "C" {
#endif
#undef complex
typedef int integer;
typedef unsigned int uinteger;
typedef char *address;
typedef short int shortint;
typedef float real;
typedef double doublereal;
typedef lapack_complex complex;
typedef lapack_doublecomplex doublecomplex;
typedef int logical;
typedef short int shortlogical;
typedef char logical1;
typedef char integer1;
#define TRUE_ (1)
#define FALSE_ (0)
#ifndef abs
#define abs(x) ((x) >= 0 ? (x) : -(x))
#endif
#define dabs(x) (double)abs(x)
#ifndef min
#define min(a,b) ((a) <= (b) ? (a) : (b))
#endif
#ifndef max
#define max(a,b) ((a) >= (b) ? (a) : (b))
#endif
#define dmin(a,b) (double)min(a,b)
#define dmax(a,b) (double)max(a,b)
#define bit_test(a,b) ((a) >> (b) & 1)
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
static __inline double r_lg10(float *x)
{
return 0.43429448190325182765*log(*x);
}
static __inline double d_lg10(double *x)
{
return 0.43429448190325182765*log(*x);
}
static __inline double d_sign(double *a, double *b)
{
double x = fabs(*a);
return *b >= 0 ? x : -x;
}
static __inline double r_sign(float *a, float *b)
{
double x = fabs((double)*a);
return *b >= 0 ? x : -x;
}
static __inline int i_nint(float *x)
{
return (int)(*x >= 0 ? floor(*x + .5) : -floor(.5 - *x));
}
int pow_ii(int *ap, int *bp);
double pow_di(double *ap, int *bp);
static __inline double pow_ri(float *ap, int *bp)
{
double apd = *ap;
return pow_di(&apd, bp);
}
static __inline double pow_dd(double *ap, double *bp)
{
return pow(*ap, *bp);
}
static __inline void d_cnjg(doublecomplex *r, doublecomplex *z)
{
double zi = z->i;
r->r = z->r;
r->i = -zi;
}
static __inline void r_cnjg(complex *r, complex *z)
{
float zi = z->i;
r->r = z->r;
r->i = -zi;
}
static __inline int s_copy(char *a, char *b, int maxlen)
{
strncpy(a, b, maxlen);
a[maxlen] = '\0';
return 0;
}
int s_cat(char *lp, char **rpp, int* rnp, int *np);
int s_cmp(char *a0, char *b0);
static __inline int i_len(char* s)
{
return (int)strlen(s);
}
#ifdef __cplusplus
}
#endif
#endif

386
3rdparty/clapack/include/lapack.h vendored
View File

@@ -1,386 +0,0 @@
// this is auto-generated header for Lapack subset
#ifndef __CLAPACK_H__
#define __CLAPACK_H__
#include "cblas.h"
#ifdef __cplusplus
extern "C" {
#endif
int cgemm_(char *transa, char *transb, int *m, int *n, int *
k, lapack_complex *alpha, lapack_complex *a, int *lda, lapack_complex *b, int *ldb,
lapack_complex *beta, lapack_complex *c__, int *ldc);
int daxpy_(int *n, double *da, double *dx, int *incx, double
*dy, int *incy);
int dbdsdc_(char *uplo, char *compq, int *n, double *d__,
double *e, double *u, int *ldu, double *vt, int *ldvt, double *q, int
*iq, double *work, int *iwork, int *info);
int dbdsqr_(char *uplo, int *n, int *ncvt, int *nru, int *
ncc, double *d__, double *e, double *vt, int *ldvt, double *u, int *
ldu, double *c__, int *ldc, double *work, int *info);
int dcombssq_(double *v1, double *v2);
int dcopy_(int *n, double *dx, int *incx, double *dy, int *
incy);
double ddot_(int *n, double *dx, int *incx, double *dy, int *incy);
int dgebak_(char *job, char *side, int *n, int *ilo, int *
ihi, double *scale, int *m, double *v, int *ldv, int *info);
int dgebal_(char *job, int *n, double *a, int *lda, int *ilo,
int *ihi, double *scale, int *info);
int dgebd2_(int *m, int *n, double *a, int *lda, double *d__,
double *e, double *tauq, double *taup, double *work, int *info);
int dgebrd_(int *m, int *n, double *a, int *lda, double *d__,
double *e, double *tauq, double *taup, double *work, int *lwork, int
*info);
int dgeev_(char *jobvl, char *jobvr, int *n, double *a, int *
lda, double *wr, double *wi, double *vl, int *ldvl, double *vr, int *
ldvr, double *work, int *lwork, int *info);
int dgehd2_(int *n, int *ilo, int *ihi, double *a, int *lda,
double *tau, double *work, int *info);
int dgehrd_(int *n, int *ilo, int *ihi, double *a, int *lda,
double *tau, double *work, int *lwork, int *info);
int dgelq2_(int *m, int *n, double *a, int *lda, double *tau,
double *work, int *info);
int dgelqf_(int *m, int *n, double *a, int *lda, double *tau,
double *work, int *lwork, int *info);
int dgemm_(char *transa, char *transb, int *m, int *n, int *
k, double *alpha, double *a, int *lda, double *b, int *ldb, double *
beta, double *c__, int *ldc);
int dgemv_(char *trans, int *m, int *n, double *alpha,
double *a, int *lda, double *x, int *incx, double *beta, double *y,
int *incy);
int dgeqr2_(int *m, int *n, double *a, int *lda, double *tau,
double *work, int *info);
int dgeqrf_(int *m, int *n, double *a, int *lda, double *tau,
double *work, int *lwork, int *info);
int dger_(int *m, int *n, double *alpha, double *x, int *
incx, double *y, int *incy, double *a, int *lda);
int dgesdd_(char *jobz, int *m, int *n, double *a, int *lda,
double *s, double *u, int *ldu, double *vt, int *ldvt, double *work,
int *lwork, int *iwork, int *info);
int dhseqr_(char *job, char *compz, int *n, int *ilo, int *
ihi, double *h__, int *ldh, double *wr, double *wi, double *z__, int *
ldz, double *work, int *lwork, int *info);
int disnan_(double *din);
// "small" is a macro defined in Windows headers: https://stackoverflow.com/a/27794577
#ifdef small
#undef small
#endif
int dlabad_(double *small, double *large);
int dlabrd_(int *m, int *n, int *nb, double *a, int *lda,
double *d__, double *e, double *tauq, double *taup, double *x, int *
ldx, double *y, int *ldy);
int dlacpy_(char *uplo, int *m, int *n, double *a, int *lda,
double *b, int *ldb);
int dladiv1_(double *a, double *b, double *c__, double *d__,
double *p, double *q);
double dladiv2_(double *a, double *b, double *c__, double *d__, double *r__,
double *t);
int dladiv_(double *a, double *b, double *c__, double *d__,
double *p, double *q);
int dlaed6_(int *kniter, int *orgati, double *rho, double *
d__, double *z__, double *finit, double *tau, int *info);
int dlaexc_(int *wantq, int *n, double *t, int *ldt, double *
q, int *ldq, int *j1, int *n1, int *n2, double *work, int *info);
int dlahqr_(int *wantt, int *wantz, int *n, int *ilo, int *
ihi, double *h__, int *ldh, double *wr, double *wi, int *iloz, int *
ihiz, double *z__, int *ldz, int *info);
int dlahr2_(int *n, int *k, int *nb, double *a, int *lda,
double *tau, double *t, int *ldt, double *y, int *ldy);
int dlaisnan_(double *din1, double *din2);
int dlaln2_(int *ltrans, int *na, int *nw, double *smin,
double *ca, double *a, int *lda, double *d1, double *d2, double *b,
int *ldb, double *wr, double *wi, double *x, int *ldx, double *scale,
double *xnorm, int *info);
int dlamrg_(int *n1, int *n2, double *a, int *dtrd1, int *
dtrd2, int *index);
double dlange_(char *norm, int *m, int *n, double *a, int *lda, double *work);
double dlanst_(char *norm, int *n, double *d__, double *e);
int dlanv2_(double *a, double *b, double *c__, double *d__,
double *rt1r, double *rt1i, double *rt2r, double *rt2i, double *cs,
double *sn);
double dlapy2_(double *x, double *y);
int dlaqr0_(int *wantt, int *wantz, int *n, int *ilo, int *
ihi, double *h__, int *ldh, double *wr, double *wi, int *iloz, int *
ihiz, double *z__, int *ldz, double *work, int *lwork, int *info);
int dlaqr1_(int *n, double *h__, int *ldh, double *sr1,
double *si1, double *sr2, double *si2, double *v);
int dlaqr2_(int *wantt, int *wantz, int *n, int *ktop, int *
kbot, int *nw, double *h__, int *ldh, int *iloz, int *ihiz, double *
z__, int *ldz, int *ns, int *nd, double *sr, double *si, double *v,
int *ldv, int *nh, double *t, int *ldt, int *nv, double *wv, int *
ldwv, double *work, int *lwork);
int dlaqr3_(int *wantt, int *wantz, int *n, int *ktop, int *
kbot, int *nw, double *h__, int *ldh, int *iloz, int *ihiz, double *
z__, int *ldz, int *ns, int *nd, double *sr, double *si, double *v,
int *ldv, int *nh, double *t, int *ldt, int *nv, double *wv, int *
ldwv, double *work, int *lwork);
int dlaqr4_(int *wantt, int *wantz, int *n, int *ilo, int *
ihi, double *h__, int *ldh, double *wr, double *wi, int *iloz, int *
ihiz, double *z__, int *ldz, double *work, int *lwork, int *info);
int dlaqr5_(int *wantt, int *wantz, int *kacc22, int *n, int
*ktop, int *kbot, int *nshfts, double *sr, double *si, double *h__,
int *ldh, int *iloz, int *ihiz, double *z__, int *ldz, double *v, int
*ldv, double *u, int *ldu, int *nv, double *wv, int *ldwv, int *nh,
double *wh, int *ldwh);
int dlarf_(char *side, int *m, int *n, double *v, int *incv,
double *tau, double *c__, int *ldc, double *work);
int dlarfb_(char *side, char *trans, char *direct, char *
storev, int *m, int *n, int *k, double *v, int *ldv, double *t, int *
ldt, double *c__, int *ldc, double *work, int *ldwork);
int dlarfg_(int *n, double *alpha, double *x, int *incx,
double *tau);
int dlarft_(char *direct, char *storev, int *n, int *k,
double *v, int *ldv, double *tau, double *t, int *ldt);
int dlarfx_(char *side, int *m, int *n, double *v, double *
tau, double *c__, int *ldc, double *work);
int dlartg_(double *f, double *g, double *cs, double *sn,
double *r__);
int dlas2_(double *f, double *g, double *h__, double *ssmin,
double *ssmax);
int dlascl_(char *type__, int *kl, int *ku, double *cfrom,
double *cto, int *m, int *n, double *a, int *lda, int *info);
int dlasd0_(int *n, int *sqre, double *d__, double *e,
double *u, int *ldu, double *vt, int *ldvt, int *smlsiz, int *iwork,
double *work, int *info);
int dlasd1_(int *nl, int *nr, int *sqre, double *d__, double
*alpha, double *beta, double *u, int *ldu, double *vt, int *ldvt, int
*idxq, int *iwork, double *work, int *info);
int dlasd2_(int *nl, int *nr, int *sqre, int *k, double *d__,
double *z__, double *alpha, double *beta, double *u, int *ldu,
double *vt, int *ldvt, double *dsigma, double *u2, int *ldu2, double *
vt2, int *ldvt2, int *idxp, int *idx, int *idxc, int *idxq, int *
coltyp, int *info);
int dlasd3_(int *nl, int *nr, int *sqre, int *k, double *d__,
double *q, int *ldq, double *dsigma, double *u, int *ldu, double *u2,
int *ldu2, double *vt, int *ldvt, double *vt2, int *ldvt2, int *idxc,
int *ctot, double *z__, int *info);
int dlasd4_(int *n, int *i__, double *d__, double *z__,
double *delta, double *rho, double *sigma, double *work, int *info);
int dlasd5_(int *i__, double *d__, double *z__, double *
delta, double *rho, double *dsigma, double *work);
int dlasd6_(int *icompq, int *nl, int *nr, int *sqre, double
*d__, double *vf, double *vl, double *alpha, double *beta, int *idxq,
int *perm, int *givptr, int *givcol, int *ldgcol, double *givnum, int
*ldgnum, double *poles, double *difl, double *difr, double *z__, int *
k, double *c__, double *s, double *work, int *iwork, int *info);
int dlasd7_(int *icompq, int *nl, int *nr, int *sqre, int *k,
double *d__, double *z__, double *zw, double *vf, double *vfw,
double *vl, double *vlw, double *alpha, double *beta, double *dsigma,
int *idx, int *idxp, int *idxq, int *perm, int *givptr, int *givcol,
int *ldgcol, double *givnum, int *ldgnum, double *c__, double *s, int
*info);
int dlasd8_(int *icompq, int *k, double *d__, double *z__,
double *vf, double *vl, double *difl, double *difr, int *lddifr,
double *dsigma, double *work, int *info);
int dlasda_(int *icompq, int *smlsiz, int *n, int *sqre,
double *d__, double *e, double *u, int *ldu, double *vt, int *k,
double *difl, double *difr, double *z__, double *poles, int *givptr,
int *givcol, int *ldgcol, int *perm, double *givnum, double *c__,
double *s, double *work, int *iwork, int *info);
int dlasdq_(char *uplo, int *sqre, int *n, int *ncvt, int *
nru, int *ncc, double *d__, double *e, double *vt, int *ldvt, double *
u, int *ldu, double *c__, int *ldc, double *work, int *info);
int dlasdt_(int *n, int *lvl, int *nd, int *inode, int *
ndiml, int *ndimr, int *msub);
int dlaset_(char *uplo, int *m, int *n, double *alpha,
double *beta, double *a, int *lda);
int dlasq1_(int *n, double *d__, double *e, double *work,
int *info);
int dlasq2_(int *n, double *z__, int *info);
int dlasq3_(int *i0, int *n0, double *z__, int *pp, double *
dmin__, double *sigma, double *desig, double *qmax, int *nfail, int *
iter, int *ndiv, int *ieee, int *ttype, double *dmin1, double *dmin2,
double *dn, double *dn1, double *dn2, double *g, double *tau);
int dlasq4_(int *i0, int *n0, double *z__, int *pp, int *
n0in, double *dmin__, double *dmin1, double *dmin2, double *dn,
double *dn1, double *dn2, double *tau, int *ttype, double *g);
int dlasq5_(int *i0, int *n0, double *z__, int *pp, double *
tau, double *sigma, double *dmin__, double *dmin1, double *dmin2,
double *dn, double *dnm1, double *dnm2, int *ieee, double *eps);
int dlasq6_(int *i0, int *n0, double *z__, int *pp, double *
dmin__, double *dmin1, double *dmin2, double *dn, double *dnm1,
double *dnm2);
int dlasr_(char *side, char *pivot, char *direct, int *m,
int *n, double *c__, double *s, double *a, int *lda);
int dlasrt_(char *id, int *n, double *d__, int *info);
int dlassq_(int *n, double *x, int *incx, double *scale,
double *sumsq);
int dlasv2_(double *f, double *g, double *h__, double *ssmin,
double *ssmax, double *snr, double *csr, double *snl, double *csl);
int dlasy2_(int *ltranl, int *ltranr, int *isgn, int *n1,
int *n2, double *tl, int *ldtl, double *tr, int *ldtr, double *b, int
*ldb, double *scale, double *x, int *ldx, double *xnorm, int *info);
double dnrm2_(int *n, double *x, int *incx);
int dorg2r_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *info);
int dorgbr_(char *vect, int *m, int *n, int *k, double *a,
int *lda, double *tau, double *work, int *lwork, int *info);
int dorghr_(int *n, int *ilo, int *ihi, double *a, int *lda,
double *tau, double *work, int *lwork, int *info);
int dorgl2_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *info);
int dorglq_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *lwork, int *info);
int dorgqr_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *lwork, int *info);
int dorm2r_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *info);
int dormbr_(char *vect, char *side, char *trans, int *m, int
*n, int *k, double *a, int *lda, double *tau, double *c__, int *ldc,
double *work, int *lwork, int *info);
int dormhr_(char *side, char *trans, int *m, int *n, int *
ilo, int *ihi, double *a, int *lda, double *tau, double *c__, int *
ldc, double *work, int *lwork, int *info);
int dorml2_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *info);
int dormlq_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *lwork, int *info);
int dormqr_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *lwork, int *info);
int drot_(int *n, double *dx, int *incx, double *dy, int *
incy, double *c__, double *s);
int dscal_(int *n, double *da, double *dx, int *incx);
int dswap_(int *n, double *dx, int *incx, double *dy, int *
incy);
int dtrevc3_(char *side, char *howmny, int *select, int *n,
double *t, int *ldt, double *vl, int *ldvl, double *vr, int *ldvr,
int *mm, int *m, double *work, int *lwork, int *info);
int dtrexc_(char *compq, int *n, double *t, int *ldt, double
*q, int *ldq, int *ifst, int *ilst, double *work, int *info);
int dtrmm_(char *side, char *uplo, char *transa, char *diag,
int *m, int *n, double *alpha, double *a, int *lda, double *b, int *
ldb);
int dtrmv_(char *uplo, char *trans, char *diag, int *n,
double *a, int *lda, double *x, int *incx);
int idamax_(int *n, double *dx, int *incx);
int ieeeck_(int *ispec, float *zero, float *one);
int iladlc_(int *m, int *n, double *a, int *lda);
int iladlr_(int *m, int *n, double *a, int *lda);
int ilaenv_(int *ispec, char *name__, char *opts, int *n1, int *n2, int *n3,
int *n4);
int iparmq_(int *ispec, char *name__, char *opts, int *n, int *ilo, int *ihi,
int *lwork);
int sgemm_(char *transa, char *transb, int *m, int *n, int *
k, float *alpha, float *a, int *lda, float *b, int *ldb, float *beta,
float *c__, int *ldc);
int zgemm_(char *transa, char *transb, int *m, int *n, int *
k, lapack_doublecomplex *alpha, lapack_doublecomplex *a, int *lda, lapack_doublecomplex *b,
int *ldb, lapack_doublecomplex *beta, lapack_doublecomplex *c__, int *ldc);
#ifdef __cplusplus
}
#endif
#endif

48
3rdparty/clapack/lapack_LICENSE vendored
View File

@@ -1,48 +0,0 @@
Copyright (c) 1992-2017 The University of Tennessee and The University
of Tennessee Research Foundation. All rights
reserved.
Copyright (c) 2000-2017 The University of California Berkeley. All
rights reserved.
Copyright (c) 2006-2017 The University of Colorado Denver. All rights
reserved.
$COPYRIGHT$
Additional copyrights may follow
$HEADER$
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer listed
in this license in the documentation and/or other materials
provided with the distribution.
- Neither the name of the copyright holders nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
The copyright holders provide no reassurances that the source code
provided does not infringe any patent, copyright, or any other
intellectual property rights of third parties. The copyright holders
disclaim any liability to any recipient for claims brought against
recipient by any third party for infringement of that parties
intellectual property rights.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

272
3rdparty/clapack/make_clapack.py vendored
View File

@@ -1,272 +0,0 @@
appdoc = """
This is generator of CLapack subset.
The usage:
1. Make sure you have the special version of f2c installed.
Grab it from https://github.com/vpisarev/f2c/tree/for_lapack.
2. Download fresh version of Lapack from
https://github.com/Reference-LAPACK/lapack.
You may choose some specific version or the latest snapshot.
3. If necessary, edit "roots" and "banlist" variables in this script, specify the needed and unneeded functions
4. From within a working directory run
$ python3 <opencv_root>/3rdparty/clapack/make_clapack.py <lapack_root>
or
$ F2C=<path_to_custom_f2c> python3 <opencv_root>/3rdparty/clapack/make_clapack.py <lapack_root>
it will generate "new_clapack" directory with "include" and "src" subdirectories.
5. erase opencv/3rdparty/clapack/src and replace it with new_clapack/src.
6. copy new_clapack/include/lapack.h to opencv/3rdparty/clapack/include.
7. optionally, edit opencv/3rdparty/clapack/CMakeLists.txt and update CLAPACK_VERSION as needed.
This is it. Now build it and enjoy.
"""
import glob, re, os, shutil, subprocess, sys
roots = ["cgemm_", "dgemm_", "sgemm_", "zgemm_",
"dgeev_", "dgesdd_",
#"dsyevr_",
#"dgesv_", "dgetrf_", "dposv_", "dpotrf_", "dgels_", "dgeqrf_",
#"sgesv_", "sgetrf_", "sposv_", "spotrf_", "sgels_", "sgeqrf_"
]
banlist = ["slamch_", "slamc3_", "dlamch_", "dlamc3_", "lsame_", "xerbla_"]
if len(sys.argv) < 2:
print(appdoc)
sys.exit(0)
lapack_root = sys.argv[1]
dst_path = "."
def error(msg):
print ("error: " + msg)
sys.exit(0)
def file2fun(fname):
return (os.path.basename(fname)[:-2]).upper()
def print_graph(m):
for (k, neighbors) in sorted(m.items()):
print (k + " : " + ", ".join(sorted(list(neighbors))))
blas_path = os.path.join(lapack_root, "BLAS/SRC")
lapack_path = os.path.join(lapack_root, "SRC")
roots = [f[:-1].upper() for f in roots]
banlist = [f[:-1].upper() for f in banlist]
def fun2file(func):
filename = func.lower() + ".f"
blas_loc = blas_path + "/" + filename
lapack_loc = lapack_path + "/" + filename
if os.path.exists(blas_loc):
return blas_loc
elif os.path.exists(lapack_loc):
return lapack_loc
else:
error("neither %s nor %s exist" % (blas_loc, lapack_loc))
all_files = glob.glob(blas_path + "/*.f") + glob.glob(lapack_path + "/*.f")
all_funcs = [file2fun(fname) for fname in all_files]
all_funcs_set = set(all_funcs).difference(set(banlist))
all_funcs = sorted(list(all_funcs_set))
func_deps = {}
#print all_funcs
words_regexp = re.compile(r'\w+')
def scan_deps(func):
global func_deps
if func in func_deps:
return
func_deps[func] = set([]) # to avoid possibly infinite recursion
f = open(fun2file(func), 'rt')
deps = []
external_mode = False
for l in f.readlines():
if l.startswith('*'):
continue
l = l.strip().upper()
if l.startswith('EXTERNAL '):
external_mode = True
elif l.startswith('$') and external_mode:
pass
else:
external_mode = False
if not external_mode:
continue
for w in words_regexp.findall(l):
if w in all_funcs_set:
deps.append(w)
f.close()
# remove func from its dependencies
deps = set(deps).difference(set([func]))
func_deps[func] = deps
for d in deps:
scan_deps(d)
for r in roots:
scan_deps(r)
selected_funcs = sorted(func_deps.keys())
print ("total files before amalgamation: %d" % len(selected_funcs))
inv_deps = {}
for func in selected_funcs:
inv_deps[func] = set([])
for (func, deps) in func_deps.items():
for d in deps:
inv_deps[d] = inv_deps[d].union(set([func]))
#print_graph(inv_deps)
func_home = {}
for func in selected_funcs:
func_home[func] = func
def get_home0(func, func0):
used_by = inv_deps[func]
if len(used_by) == 1:
p = list(used_by)[0]
if p != func and p != func0:
return get_home0(p, func0)
return func
return func
# try to merge some files
for func in selected_funcs:
func_home[func] = get_home0(func, func)
# try to merge some files even more
for iters in range(100):
homes_changed = False
for (func, used_by) in inv_deps.items():
p0 = func_home[func]
n = len(used_by)
if n == 1:
p = list(used_by)[0]
p1 = func_home[p]
if p1 != p0:
func_home[func] = p1
homes_changed = True
continue
elif n > 1:
phomes = set([])
for p in used_by:
phomes.add(func_home[p])
if len(phomes) == 1:
p1 = list(phomes)[0]
if p1 != p0:
func_home[func] = p1
homes_changed = True
if not homes_changed:
break
res_files = {}
for (func, h) in func_home.items():
elems = res_files.get(h, set([]))
elems.add(func)
res_files[h] = elems
print ("total files after amalgamation: %d" % len(res_files))
#print_graph(res_files)
outdir = os.path.join(dst_path, "new_clapack")
outdir_src = os.path.join(outdir, "src")
outdir_inc = os.path.join(outdir, "include")
shutil.rmtree(outdir, ignore_errors=True)
try:
os.makedirs(outdir_src)
except os.error:
pass
try:
os.makedirs(outdir_inc)
except os.error:
pass
f2c_appname = os.getenv("F2C", default="f2c")
print ("f2c used: %s" % f2c_appname)
f2c_getver_cmd = f2c_appname + " -v"
verstr = subprocess.check_output(f2c_getver_cmd.split(' ')).decode("utf-8")
if "for_lapack" not in verstr:
error("invalid version of f2c\n" + appdoc)
f2c_flags = "-ctypes -localconst -no-proto"
f2c_cmd0 = f2c_appname + " " + f2c_flags
f2c_cmd1 = f2c_appname + " -hdr none " + f2c_flags
lapack_protos = {}
extract_fn_regexp = re.compile(r'.+?(\w+)\s*\(')
def extract_proto(func, csrc):
global lapack_protos
cname = func.lower() + "_"
cfname = func.lower() + ".c"
regexp_str = r'\n(?:/\* Subroutine \*/\s*)?\w+\s+\w+\s*\((?:.|\n)+?\)[\s\n]*\{'
proto_regexp = re.compile(regexp_str)
ps = proto_regexp.findall(csrc)
for p in ps:
n = p.find("*/")
if n < 0:
n = 0
else:
n += 2
p = p[n:-1].strip() + ";"
fns = extract_fn_regexp.findall(p)
if len(fns) != 1:
error("prototype of function (%s) when analyzing %s cannot be parsed" % (p, cfname))
fn = fns[0]
if fn not in lapack_protos:
p = re.sub(r'\bcomplex\b', 'lapack_complex', p)
p = re.sub(r'\bdoublecomplex\b', 'lapack_doublecomplex', p)
lapack_protos[fn] = p
for (filename, funcs) in sorted(res_files.items()):
out = ""
f2c_cmd = f2c_cmd0
for func in sorted(list(funcs)):
ffilename = fun2file(func)
print ("running " + f2c_cmd + " on " + ffilename + " ...")
ffile = open(ffilename, 'rt')
delta_out = subprocess.check_output(f2c_cmd.split(' '), stdin=ffile).decode("utf-8")
# remove trailing whitespaces
delta_out = '\n'.join([l.rstrip() for l in delta_out.split('\n')])
extract_proto(func, delta_out)
out += delta_out
ffile.close()
f2c_cmd = f2c_cmd1
outname = os.path.join(outdir_src, filename.lower() + ".c")
outfile = open(outname, 'wt')
outfile.write(out)
outfile.close()
proto_hdr = """// this is auto-generated header for Lapack subset
#ifndef __CLAPACK_H__
#define __CLAPACK_H__
#include "cblas.h"
#ifdef __cplusplus
extern "C" {
#endif
%s
#ifdef __cplusplus
}
#endif
#endif
""" % "\n\n".join([p for (n, p) in sorted(lapack_protos.items())])
proto_hdr_fname = os.path.join(outdir_inc, "lapack.h")
f = open(proto_hdr_fname, 'wt')
f.write(proto_hdr)
f.close()

289
3rdparty/clapack/runtime/cblas_wrap.c vendored
View File

@@ -1,289 +0,0 @@
#include "f2c.h"
#include <stdarg.h>
void cblas_cgemm(const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE TransA,
const CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const void *alpha, const void *A,
const int lda, const void *B, const int ldb,
const void *beta, void *C, const int ldc)
{
char TA, TB;
if( layout == CblasColMajor )
{
if(TransA == CblasTrans) TA='T';
else if ( TransA == CblasConjTrans ) TA='C';
else if ( TransA == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_cgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TB='T';
else if ( TransB == CblasConjTrans ) TB='C';
else if ( TransB == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 3, "cblas_cgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
cgemm_(&TA, &TB, (int*)&M, (int*)&N, (int*)&K, (complex*)alpha, (complex*)A, (int*)&lda,
(complex*)B, (int*)&ldb, (complex*)beta, (complex*)C, (int*)&ldc);
}
else if (layout == CblasRowMajor)
{
if(TransA == CblasTrans) TB='T';
else if ( TransA == CblasConjTrans ) TB='C';
else if ( TransA == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 2, "cblas_cgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TA='T';
else if ( TransB == CblasConjTrans ) TA='C';
else if ( TransB == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_cgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
cgemm_(&TA, &TB, (int*)&N, (int*)&M, (int*)&K, (complex*)alpha, (complex*)B, (int*)&ldb,
(complex*)A, (int*)&lda, (complex*)beta, (complex*)C, (int*)&ldc);
}
else cblas_xerbla(layout, 1, "cblas_cgemm", "Illegal layout setting, %d\n", layout);
}
void cblas_dgemm(const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE TransA,
const CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const double alpha, const double *A,
const int lda, const double *B, const int ldb,
const double beta, double *C, const int ldc)
{
char TA, TB;
if( layout == CblasColMajor )
{
if(TransA == CblasTrans) TA='T';
else if ( TransA == CblasConjTrans ) TA='C';
else if ( TransA == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_dgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TB='T';
else if ( TransB == CblasConjTrans ) TB='C';
else if ( TransB == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 3, "cblas_dgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
dgemm_(&TA, &TB, (int*)&M, (int*)&N, (int*)&K, (double*)&alpha, (double*)A, (int*)&lda,
(double*)B, (int*)&ldb, (double*)&beta, (double*)C, (int*)&ldc);
}
else if (layout == CblasRowMajor)
{
if(TransA == CblasTrans) TB='T';
else if ( TransA == CblasConjTrans ) TB='C';
else if ( TransA == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 2, "cblas_dgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TA='T';
else if ( TransB == CblasConjTrans ) TA='C';
else if ( TransB == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_dgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
dgemm_(&TA, &TB, (int*)&N, (int*)&M, (int*)&K, (double*)&alpha, (double*)B, (int*)&ldb,
(double*)A, (int*)&lda, (double*)&beta, (double*)C, (int*)&ldc);
}
else cblas_xerbla(layout, 1, "cblas_dgemm", "Illegal layout setting, %d\n", layout);
}
void cblas_sgemm(const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE TransA,
const CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const float alpha, const float *A,
const int lda, const float *B, const int ldb,
const float beta, float *C, const int ldc)
{
char TA, TB;
if( layout == CblasColMajor )
{
if(TransA == CblasTrans) TA='T';
else if ( TransA == CblasConjTrans ) TA='C';
else if ( TransA == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_sgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TB='T';
else if ( TransB == CblasConjTrans ) TB='C';
else if ( TransB == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 3, "cblas_sgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
sgemm_(&TA, &TB, (int*)&M, (int*)&N, (int*)&K, (float*)&alpha, (float*)A, (int*)&lda,
(float*)B, (int*)&ldb, (float*)&beta, (float*)C, (int*)&ldc);
}
else if (layout == CblasRowMajor)
{
if(TransA == CblasTrans) TB='T';
else if ( TransA == CblasConjTrans ) TB='C';
else if ( TransA == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 2, "cblas_sgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TA='T';
else if ( TransB == CblasConjTrans ) TA='C';
else if ( TransB == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_sgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
sgemm_(&TA, &TB, (int*)&N, (int*)&M, (int*)&K, (float*)&alpha, (float*)B, (int*)&ldb,
(float*)A, (int*)&lda, (float*)&beta, (float*)C, (int*)&ldc);
}
else cblas_xerbla(layout, 1, "cblas_sgemm", "Illegal layout setting, %d\n", layout);
}
void cblas_zgemm(const CBLAS_LAYOUT layout, const CBLAS_TRANSPOSE TransA,
const CBLAS_TRANSPOSE TransB, const int M, const int N,
const int K, const void *alpha, const void *A,
const int lda, const void *B, const int ldb,
const void *beta, void *C, const int ldc)
{
char TA, TB;
if( layout == CblasColMajor )
{
if(TransA == CblasTrans) TA='T';
else if ( TransA == CblasConjTrans ) TA='C';
else if ( TransA == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_zgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TB='T';
else if ( TransB == CblasConjTrans ) TB='C';
else if ( TransB == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 3, "cblas_zgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
zgemm_(&TA, &TB, (int*)&M, (int*)&N, (int*)&K, (doublecomplex*)alpha, (doublecomplex*)A, (int*)&lda,
(doublecomplex*)B, (int*)&ldb, (doublecomplex*)beta, (doublecomplex*)C, (int*)&ldc);
}
else if (layout == CblasRowMajor)
{
if(TransA == CblasTrans) TB='T';
else if ( TransA == CblasConjTrans ) TB='C';
else if ( TransA == CblasNoTrans ) TB='N';
else
{
cblas_xerbla(layout, 2, "cblas_zgemm", "Illegal TransA setting, %d\n", TransA);
return;
}
if(TransB == CblasTrans) TA='T';
else if ( TransB == CblasConjTrans ) TA='C';
else if ( TransB == CblasNoTrans ) TA='N';
else
{
cblas_xerbla(layout, 2, "cblas_zgemm", "Illegal TransB setting, %d\n", TransB);
return;
}
zgemm_(&TA, &TB, (int*)&N, (int*)&M, (int*)&K, (doublecomplex*)alpha, (doublecomplex*)B, (int*)&ldb,
(doublecomplex*)A, (int*)&lda, (doublecomplex*)beta, (doublecomplex*)C, (int*)&ldc);
}
else cblas_xerbla(layout, 1, "cblas_zgemm", "Illegal layout setting, %d\n", layout);
}
void cblas_xerbla(const CBLAS_LAYOUT layout, int info, const char *rout, const char *form, ...)
{
extern int RowMajorStrg;
char empty[1] = "";
va_list argptr;
va_start(argptr, form);
if (layout == CblasRowMajor)
{
if (strstr(rout,"gemm") != 0)
{
if (info == 5 ) info = 4;
else if (info == 4 ) info = 5;
else if (info == 11) info = 9;
else if (info == 9 ) info = 11;
}
else if (strstr(rout,"symm") != 0 || strstr(rout,"hemm") != 0)
{
if (info == 5 ) info = 4;
else if (info == 4 ) info = 5;
}
else if (strstr(rout,"trmm") != 0 || strstr(rout,"trsm") != 0)
{
if (info == 7 ) info = 6;
else if (info == 6 ) info = 7;
}
else if (strstr(rout,"gemv") != 0)
{
if (info == 4) info = 3;
else if (info == 3) info = 4;
}
else if (strstr(rout,"gbmv") != 0)
{
if (info == 4) info = 3;
else if (info == 3) info = 4;
else if (info == 6) info = 5;
else if (info == 5) info = 6;
}
else if (strstr(rout,"ger") != 0)
{
if (info == 3) info = 2;
else if (info == 2) info = 3;
else if (info == 8) info = 6;
else if (info == 6) info = 8;
}
else if ( (strstr(rout,"her2") != 0 || strstr(rout,"hpr2") != 0)
&& strstr(rout,"her2k") == 0 )
{
if (info == 8) info = 6;
else if (info == 6) info = 8;
}
}
if (info)
fprintf(stderr, "Parameter %d to routine %s was incorrect\n", info, rout);
vfprintf(stderr, form, argptr);
va_end(argptr);
if (info && !info)
xerbla_(empty, &info); /* Force link of our F77 error handler */
exit(-1);
}

72
3rdparty/clapack/runtime/dlamch_custom.c vendored
View File

@@ -1,72 +0,0 @@
#include "f2c.h"
#include <float.h>
#include <stdio.h>
/* *********************************************************************** */
double dlamc3_(double *a, double *b)
{
/* -- LAPACK auxiliary routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* DLAMC3 is intended to force A and B to be stored prior to doing */
/* the addition of A and B , for use in situations where optimizers */
/* might hold one of these in a register. */
/* Arguments */
/* ========= */
/* A (input) DOUBLE PRECISION */
/* B (input) DOUBLE PRECISION */
/* The values A and B. */
/* ===================================================================== */
/* .. Executable Statements .. */
double ret_val = *a + *b;
return ret_val;
/* End of DLAMC3 */
} /* dlamc3_ */
/* simpler version of dlamch for the case of IEEE754-compliant FPU module by Piotr Luszczek S.
taken from http://www.mail-archive.com/numpy-discussion@lists.sourceforge.net/msg02448.html */
#ifndef DBL_DIGITS
#define DBL_DIGITS 53
#endif
static const unsigned char lapack_dlamch_tab0[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, 8, 9, 0, 10, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, 8, 9,
0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
const double lapack_dlamch_tab1[] =
{
0, FLT_RADIX, DBL_EPSILON, DBL_MAX_EXP, DBL_MIN_EXP, DBL_DIGITS, DBL_MAX,
DBL_EPSILON*FLT_RADIX, 1, DBL_MIN*(1 + DBL_EPSILON), DBL_MIN
};
double dlamch_(char* cmach)
{
return lapack_dlamch_tab1[lapack_dlamch_tab0[(unsigned char)cmach[0]]];
}

96
3rdparty/clapack/runtime/lapack_stubs.c vendored
View File

@@ -1,96 +0,0 @@
#include "f2c.h"
static const int CLAPACK_NOT_IMPLEMENTED = -1024;
int sgesdd_(char *jobz, int *m, int *n, float *a, int *lda,
float *s, float *u, int *ldu, float *vt, int *ldvt, float *work,
int *lwork, int *iwork, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int dgels_(char *trans, int *m, int *n, int *nrhs, double *a,
int *lda, double *b, int *ldb, double *work, int *lwork, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int dgesv_(int *n, int *nrhs, double *a, int *lda, int *ipiv,
double *b, int *ldb, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int dgetrf_(int *m, int *n, double *a, int *lda, int *ipiv,
int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int dposv_(char *uplo, int *n, int *nrhs, double *a, int *
lda, double *b, int *ldb, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int dpotrf_(char *uplo, int *n, double *a, int *lda, int *
info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sgels_(char *trans, int *m, int *n, int *nrhs, float *a,
int *lda, float *b, int *ldb, float *work, int *lwork, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sgeev_(char *jobvl, char *jobvr, int *n, float *a, int *
lda, float *wr, float *wi, float *vl, int *ldvl, float *vr, int *
ldvr, float *work, int *lwork, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sgeqrf_(int *m, int *n, float *a, int *lda, float *tau,
float *work, int *lwork, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sgesv_(int *n, int *nrhs, float *a, int *lda, int *ipiv,
float *b, int *ldb, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sgetrf_(int *m, int *n, float *a, int *lda, int *ipiv,
int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int sposv_(char *uplo, int *n, int *nrhs, float *a, int *
lda, float *b, int *ldb, int *info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}
int spotrf_(char *uplo, int *n, float *a, int *lda, int *
info)
{
*info = CLAPACK_NOT_IMPLEMENTED;
return 0;
}

25
3rdparty/clapack/runtime/lsame_custom.c vendored
View File

@@ -1,25 +0,0 @@
#include "f2c.h"
static const unsigned char lapack_toupper_tab[] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
90, 91, 92, 93, 94, 95, 96, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 123, 124, 125, 126, 127, 128, 129, 130, 131,
132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149,
150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221,
222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255
};
#define lapack_toupper(c) ((char)lapack_toupper_tab[(unsigned char)(c)])
int lsame_(char *ca, char *cb)
{
return lapack_toupper(ca[0]) == lapack_toupper(cb[0]);
}

27
3rdparty/clapack/runtime/pow_di.c vendored
View File

@@ -1,27 +0,0 @@
#include "f2c.h"
double pow_di(double *ap, int *bp)
{
double p = 1;
double x = *ap;
int n = *bp;
if(n != 0)
{
if(n < 0)
{
n = -n;
x = 1/x;
}
unsigned u = (unsigned)n;
for(;;)
{
if((u & 1) != 0)
p *= x;
if((u >>= 1) == 0)
break;
x *= x;
}
}
return p;
}

25
3rdparty/clapack/runtime/pow_ii.c vendored
View File

@@ -1,25 +0,0 @@
#include "f2c.h"
int pow_ii(int *ap, int *bp)
{
int p;
int x = *ap;
int n = *bp;
if (n <= 0) {
if (n == 0 || x == 1)
return 1;
return x != -1 ? 0 : (n & 1) ? -1 : 1;
}
unsigned u = (unsigned)n;
for(p = 1; ; )
{
if(u & 01)
p *= x;
if(u >>= 1)
x *= x;
else
break;
}
return p;
}

22
3rdparty/clapack/runtime/s_cat.c vendored
View File

@@ -1,22 +0,0 @@
/* Unless compiled with -DNO_OVERWRITE, this variant of s_cat allows the
* target of a concatenation to appear on its right-hand side (contrary
* to the Fortran 77 Standard, but in accordance with Fortran 90).
*/
#include "f2c.h"
int s_cat(char *lp, char **rpp, int* rnp, int *np)
{
int i, L = 0;
int n = *np;
for(i = 0; i < n; i++) {
int ni = rnp[i];
if(ni > 0) {
memcpy(lp + L, rpp[i], ni);
L += ni;
}
}
lp[L] = '\0';
return 0;
}

40
3rdparty/clapack/runtime/s_cmp.c vendored
View File

@@ -1,40 +0,0 @@
#include "f2c.h"
/* compare two strings */
int s_cmp(char *a0, char *b0)
{
int la = (int)strlen(a0);
int lb = (int)strlen(b0);
unsigned char *a, *aend, *b, *bend;
a = (unsigned char *)a0;
b = (unsigned char *)b0;
aend = a + la;
bend = b + lb;
if(la <= lb)
{
while(a < aend)
if(*a != *b)
return( *a - *b );
else
{ ++a; ++b; }
while(b < bend)
if(*b != ' ')
return( ' ' - *b );
else ++b;
}
else
{
while(b < bend)
if(*a == *b)
{ ++a; ++b; }
else
return( *a - *b );
while(a < aend)
if(*a != ' ')
return(*a - ' ');
else ++a;
}
return(0);
}

71
3rdparty/clapack/runtime/slamch_custom.c vendored
View File

@@ -1,71 +0,0 @@
#include "f2c.h"
#include <float.h>
#include <stdio.h>
/* *********************************************************************** */
double slamc3_(float *a, float *b)
{
/* -- LAPACK auxiliary routine (version 3.1) -- */
/* Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/* November 2006 */
/* .. Scalar Arguments .. */
/* .. */
/* Purpose */
/* ======= */
/* SLAMC3 is intended to force A and B to be stored prior to doing */
/* the addition of A and B , for use in situations where optimizers */
/* might hold one of these in a register. */
/* Arguments */
/* ========= */
/* A (input) REAL */
/* B (input) REAL */
/* The values A and B. */
/* ===================================================================== */
/* .. Executable Statements .. */
float ret_val = *a + *b;
return ret_val;
/* End of SLAMC3 */
} /* slamc3_ */
/* simpler version of slamch for the case of IEEE754-compliant FPU module by Piotr Luszczek S.
taken from http://www.mail-archive.com/numpy-discussion@lists.sourceforge.net/msg02448.html */
#ifndef FLT_DIGITS
#define FLT_DIGITS 24
#endif
static const unsigned char lapack_slamch_tab0[] =
{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, 8, 9, 0, 10, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 3, 4, 5, 6, 7, 0, 8, 9,
0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
const double lapack_slamch_tab1[] =
{
0, FLT_RADIX, FLT_EPSILON, FLT_MAX_EXP, FLT_MIN_EXP, FLT_DIGITS, FLT_MAX,
FLT_EPSILON*FLT_RADIX, 1, FLT_MIN*(1 + FLT_EPSILON), FLT_MIN
};
double slamch_(char* cmach)
{
return lapack_slamch_tab1[lapack_slamch_tab0[(unsigned char)cmach[0]]];
}

19
3rdparty/clapack/runtime/xerbla_custom.c vendored
View File

@@ -1,19 +0,0 @@
/* xerbla.f -- translated by f2c (version 20061008).
You must link the resulting object file with libf2c:
on Microsoft Windows system, link with libf2c.lib;
on Linux or Unix systems, link with .../path/to/libf2c.a -lm
or, if you install libf2c.a in a standard place, with -lf2c -lm
-- in that order, at the end of the command line, as in
cc *.o -lf2c -lm
Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
http://www.netlib.org/f2c/libf2c.zip
*/
#include "f2c.h"
/* Subroutine */ int xerbla_(char *srname, int *info)
{
printf("** On entry to %s, parameter number %2i had an illegal value\n", srname, *info);
return 0;
} /* xerbla_ */

752
3rdparty/clapack/src/cgemm.c vendored
View File

@@ -1,752 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b CGEMM
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE CGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
//
// .. Scalar Arguments ..
// COMPLEX ALPHA,BETA
// INTEGER K,LDA,LDB,LDC,M,N
// CHARACTER TRANSA,TRANSB
// ..
// .. Array Arguments ..
// COMPLEX A(LDA,*),B(LDB,*),C(LDC,*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> CGEMM performs one of the matrix-matrix operations
//>
//> C := alpha*op( A )*op( B ) + beta*C,
//>
//> where op( X ) is one of
//>
//> op( X ) = X or op( X ) = X**T or op( X ) = X**H,
//>
//> alpha and beta are scalars, and A, B and C are matrices, with op( A )
//> an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TRANSA
//> \verbatim
//> TRANSA is CHARACTER*1
//> On entry, TRANSA specifies the form of op( A ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSA = 'N' or 'n', op( A ) = A.
//>
//> TRANSA = 'T' or 't', op( A ) = A**T.
//>
//> TRANSA = 'C' or 'c', op( A ) = A**H.
//> \endverbatim
//>
//> \param[in] TRANSB
//> \verbatim
//> TRANSB is CHARACTER*1
//> On entry, TRANSB specifies the form of op( B ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSB = 'N' or 'n', op( B ) = B.
//>
//> TRANSB = 'T' or 't', op( B ) = B**T.
//>
//> TRANSB = 'C' or 'c', op( B ) = B**H.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix
//> op( A ) and of the matrix C. M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix
//> op( B ) and the number of columns of the matrix C. N must be
//> at least zero.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> On entry, K specifies the number of columns of the matrix
//> op( A ) and the number of rows of the matrix op( B ). K must
//> be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is COMPLEX
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is COMPLEX array, dimension ( LDA, ka ), where ka is
//> k when TRANSA = 'N' or 'n', and is m otherwise.
//> Before entry with TRANSA = 'N' or 'n', the leading m by k
//> part of the array A must contain the matrix A, otherwise
//> the leading k by m part of the array A must contain the
//> matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. When TRANSA = 'N' or 'n' then
//> LDA must be at least max( 1, m ), otherwise LDA must be at
//> least max( 1, k ).
//> \endverbatim
//>
//> \param[in] B
//> \verbatim
//> B is COMPLEX array, dimension ( LDB, kb ), where kb is
//> n when TRANSB = 'N' or 'n', and is k otherwise.
//> Before entry with TRANSB = 'N' or 'n', the leading k by n
//> part of the array B must contain the matrix B, otherwise
//> the leading n by k part of the array B must contain the
//> matrix B.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> On entry, LDB specifies the first dimension of B as declared
//> in the calling (sub) program. When TRANSB = 'N' or 'n' then
//> LDB must be at least max( 1, k ), otherwise LDB must be at
//> least max( 1, n ).
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is COMPLEX
//> On entry, BETA specifies the scalar beta. When BETA is
//> supplied as zero then C need not be set on input.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is COMPLEX array, dimension ( LDC, N )
//> Before entry, the leading m by n part of the array C must
//> contain the matrix C, except when beta is zero, in which
//> case C need not be set on entry.
//> On exit, the array C is overwritten by the m by n matrix
//> ( alpha*op( A )*op( B ) + beta*C ).
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> On entry, LDC specifies the first dimension of C as declared
//> in the calling (sub) program. LDC must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup complex_blas_level3
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 3 Blas routine.
//>
//> -- Written on 8-February-1989.
//> Jack Dongarra, Argonne National Laboratory.
//> Iain Duff, AERE Harwell.
//> Jeremy Du Croz, Numerical Algorithms Group Ltd.
//> Sven Hammarling, Numerical Algorithms Group Ltd.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int cgemm_(char *transa, char *transb, int *m, int *n, int *
k, complex *alpha, complex *a, int *lda, complex *b, int *ldb,
complex *beta, complex *c__, int *ldc)
{
// Table of constant values
complex c_b1 = {1.f,0.f};
complex c_b2 = {0.f,0.f};
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2,
i__3, i__4, i__5, i__6;
complex q__1, q__2, q__3, q__4;
// Local variables
int i__, j, l, info;
int nota, notb;
complex temp;
int conja, conjb;
int ncola;
extern int lsame_(char *, char *);
int nrowa, nrowb;
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level3 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Local Scalars ..
// ..
// .. Parameters ..
// ..
//
// Set NOTA and NOTB as true if A and B respectively are not
// conjugated or transposed, set CONJA and CONJB as true if A and
// B respectively are to be transposed but not conjugated and set
// NROWA, NCOLA and NROWB as the number of rows and columns of A
// and the number of rows of B respectively.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
// Function Body
nota = lsame_(transa, "N");
notb = lsame_(transb, "N");
conja = lsame_(transa, "C");
conjb = lsame_(transb, "C");
if (nota) {
nrowa = *m;
ncola = *k;
} else {
nrowa = *k;
ncola = *m;
}
if (notb) {
nrowb = *k;
} else {
nrowb = *n;
}
//
// Test the input parameters.
//
info = 0;
if (! nota && ! conja && ! lsame_(transa, "T")) {
info = 1;
} else if (! notb && ! conjb && ! lsame_(transb, "T")) {
info = 2;
} else if (*m < 0) {
info = 3;
} else if (*n < 0) {
info = 4;
} else if (*k < 0) {
info = 5;
} else if (*lda < max(1,nrowa)) {
info = 8;
} else if (*ldb < max(1,nrowb)) {
info = 10;
} else if (*ldc < max(1,*m)) {
info = 13;
}
if (info != 0) {
xerbla_("CGEMM ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || (alpha->r == 0.f && alpha->i == 0.f || *k == 0)
&& (beta->r == 1.f && beta->i == 0.f)) {
return 0;
}
//
// And when alpha.eq.zero.
//
if (alpha->r == 0.f && alpha->i == 0.f) {
if (beta->r == 0.f && beta->i == 0.f) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0.f, c__[i__3].i = 0.f;
// L10:
}
// L20:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
q__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4].i,
q__1.i = beta->r * c__[i__4].i + beta->i * c__[
i__4].r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
// L30:
}
// L40:
}
}
return 0;
}
//
// Start the operations.
//
if (notb) {
if (nota) {
//
// Form C := alpha*A*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0.f && beta->i == 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0.f, c__[i__3].i = 0.f;
// L50:
}
} else if (beta->r != 1.f || beta->i != 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
q__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
// L60:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
i__3 = l + j * b_dim1;
q__1.r = alpha->r * b[i__3].r - alpha->i * b[i__3].i,
q__1.i = alpha->r * b[i__3].i + alpha->i * b[i__3]
.r;
temp.r = q__1.r, temp.i = q__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
q__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
q__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
q__1.r = c__[i__5].r + q__2.r, q__1.i = c__[i__5].i +
q__2.i;
c__[i__4].r = q__1.r, c__[i__4].i = q__1.i;
// L70:
}
// L80:
}
// L90:
}
} else if (conja) {
//
// Form C := alpha*A**H*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
r_cnjg(&q__3, &a[l + i__ * a_dim1]);
i__4 = l + j * b_dim1;
q__2.r = q__3.r * b[i__4].r - q__3.i * b[i__4].i,
q__2.i = q__3.r * b[i__4].i + q__3.i * b[i__4]
.r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L100:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L110:
}
// L120:
}
} else {
//
// Form C := alpha*A**T*B + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
i__5 = l + j * b_dim1;
q__2.r = a[i__4].r * b[i__5].r - a[i__4].i * b[i__5]
.i, q__2.i = a[i__4].r * b[i__5].i + a[i__4]
.i * b[i__5].r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L130:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L140:
}
// L150:
}
}
} else if (nota) {
if (conjb) {
//
// Form C := alpha*A*B**H + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0.f && beta->i == 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0.f, c__[i__3].i = 0.f;
// L160:
}
} else if (beta->r != 1.f || beta->i != 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
q__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
// L170:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
r_cnjg(&q__2, &b[j + l * b_dim1]);
q__1.r = alpha->r * q__2.r - alpha->i * q__2.i, q__1.i =
alpha->r * q__2.i + alpha->i * q__2.r;
temp.r = q__1.r, temp.i = q__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
q__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
q__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
q__1.r = c__[i__5].r + q__2.r, q__1.i = c__[i__5].i +
q__2.i;
c__[i__4].r = q__1.r, c__[i__4].i = q__1.i;
// L180:
}
// L190:
}
// L200:
}
} else {
//
// Form C := alpha*A*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0.f && beta->i == 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0.f, c__[i__3].i = 0.f;
// L210:
}
} else if (beta->r != 1.f || beta->i != 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
q__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
// L220:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
i__3 = j + l * b_dim1;
q__1.r = alpha->r * b[i__3].r - alpha->i * b[i__3].i,
q__1.i = alpha->r * b[i__3].i + alpha->i * b[i__3]
.r;
temp.r = q__1.r, temp.i = q__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
q__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
q__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
q__1.r = c__[i__5].r + q__2.r, q__1.i = c__[i__5].i +
q__2.i;
c__[i__4].r = q__1.r, c__[i__4].i = q__1.i;
// L230:
}
// L240:
}
// L250:
}
}
} else if (conja) {
if (conjb) {
//
// Form C := alpha*A**H*B**H + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
r_cnjg(&q__3, &a[l + i__ * a_dim1]);
r_cnjg(&q__4, &b[j + l * b_dim1]);
q__2.r = q__3.r * q__4.r - q__3.i * q__4.i, q__2.i =
q__3.r * q__4.i + q__3.i * q__4.r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L260:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L270:
}
// L280:
}
} else {
//
// Form C := alpha*A**H*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
r_cnjg(&q__3, &a[l + i__ * a_dim1]);
i__4 = j + l * b_dim1;
q__2.r = q__3.r * b[i__4].r - q__3.i * b[i__4].i,
q__2.i = q__3.r * b[i__4].i + q__3.i * b[i__4]
.r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L290:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L300:
}
// L310:
}
}
} else {
if (conjb) {
//
// Form C := alpha*A**T*B**H + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
r_cnjg(&q__3, &b[j + l * b_dim1]);
q__2.r = a[i__4].r * q__3.r - a[i__4].i * q__3.i,
q__2.i = a[i__4].r * q__3.i + a[i__4].i *
q__3.r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L320:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L330:
}
// L340:
}
} else {
//
// Form C := alpha*A**T*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0.f, temp.i = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
i__5 = j + l * b_dim1;
q__2.r = a[i__4].r * b[i__5].r - a[i__4].i * b[i__5]
.i, q__2.i = a[i__4].r * b[i__5].i + a[i__4]
.i * b[i__5].r;
q__1.r = temp.r + q__2.r, q__1.i = temp.i + q__2.i;
temp.r = q__1.r, temp.i = q__1.i;
// L350:
}
if (beta->r == 0.f && beta->i == 0.f) {
i__3 = i__ + j * c_dim1;
q__1.r = alpha->r * temp.r - alpha->i * temp.i,
q__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
} else {
i__3 = i__ + j * c_dim1;
q__2.r = alpha->r * temp.r - alpha->i * temp.i,
q__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
q__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, q__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
q__1.r = q__2.r + q__3.r, q__1.i = q__2.i + q__3.i;
c__[i__3].r = q__1.r, c__[i__3].i = q__1.i;
}
// L360:
}
// L370:
}
}
}
return 0;
//
// End of CGEMM .
//
} // cgemm_

171
3rdparty/clapack/src/dcopy.c vendored
View File

@@ -1,171 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DCOPY
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DCOPY(N,DX,INCX,DY,INCY)
//
// .. Scalar Arguments ..
// INTEGER INCX,INCY,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION DX(*),DY(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DCOPY copies a vector, x, to a vector, y.
//> uses unrolled loops for increments equal to 1.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in] DX
//> \verbatim
//> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//>
//> \param[out] DY
//> \verbatim
//> DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> storage spacing between elements of DY
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> jack dongarra, linpack, 3/11/78.
//> modified 12/3/93, array(1) declarations changed to array(*)
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dcopy_(int *n, double *dx, int *incx, double *dy, int *
incy)
{
// System generated locals
int i__1;
// Local variables
int i__, m, ix, iy, mp1;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// .. Intrinsic Functions ..
// ..
// Parameter adjustments
--dy;
--dx;
// Function Body
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
//
// code for both increments equal to 1
//
//
// clean-up loop
//
m = *n % 7;
if (m != 0) {
i__1 = m;
for (i__ = 1; i__ <= i__1; ++i__) {
dy[i__] = dx[i__];
}
if (*n < 7) {
return 0;
}
}
mp1 = m + 1;
i__1 = *n;
for (i__ = mp1; i__ <= i__1; i__ += 7) {
dy[i__] = dx[i__];
dy[i__ + 1] = dx[i__ + 1];
dy[i__ + 2] = dx[i__ + 2];
dy[i__ + 3] = dx[i__ + 3];
dy[i__ + 4] = dx[i__ + 4];
dy[i__ + 5] = dx[i__ + 5];
dy[i__ + 6] = dx[i__ + 6];
}
} else {
//
// code for unequal increments or equal increments
// not equal to 1
//
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
dy[iy] = dx[ix];
ix += *incx;
iy += *incy;
}
}
return 0;
} // dcopy_

172
3rdparty/clapack/src/ddot.c vendored
View File

@@ -1,172 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DDOT
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// DOUBLE PRECISION FUNCTION DDOT(N,DX,INCX,DY,INCY)
//
// .. Scalar Arguments ..
// INTEGER INCX,INCY,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION DX(*),DY(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DDOT forms the dot product of two vectors.
//> uses unrolled loops for increments equal to one.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in] DX
//> \verbatim
//> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//>
//> \param[in] DY
//> \verbatim
//> DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> storage spacing between elements of DY
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> jack dongarra, linpack, 3/11/78.
//> modified 12/3/93, array(1) declarations changed to array(*)
//> \endverbatim
//>
// =====================================================================
double ddot_(int *n, double *dx, int *incx, double *dy, int *incy)
{
// System generated locals
int i__1;
double ret_val;
// Local variables
int i__, m, ix, iy, mp1;
double dtemp;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// .. Intrinsic Functions ..
// ..
// Parameter adjustments
--dy;
--dx;
// Function Body
ret_val = 0.;
dtemp = 0.;
if (*n <= 0) {
return ret_val;
}
if (*incx == 1 && *incy == 1) {
//
// code for both increments equal to 1
//
//
// clean-up loop
//
m = *n % 5;
if (m != 0) {
i__1 = m;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp += dx[i__] * dy[i__];
}
if (*n < 5) {
ret_val = dtemp;
return ret_val;
}
}
mp1 = m + 1;
i__1 = *n;
for (i__ = mp1; i__ <= i__1; i__ += 5) {
dtemp = dtemp + dx[i__] * dy[i__] + dx[i__ + 1] * dy[i__ + 1] +
dx[i__ + 2] * dy[i__ + 2] + dx[i__ + 3] * dy[i__ + 3] +
dx[i__ + 4] * dy[i__ + 4];
}
} else {
//
// code for unequal increments or equal increments
// not equal to 1
//
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp += dx[ix] * dy[iy];
ix += *incx;
iy += *incy;
}
}
ret_val = dtemp;
return ret_val;
} // ddot_

14369
3rdparty/clapack/src/dgeev.c vendored
View File

File diff suppressed because it is too large Load Diff

444
3rdparty/clapack/src/dgemm.c vendored
View File

@@ -1,444 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DGEMM
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION ALPHA,BETA
// INTEGER K,LDA,LDB,LDC,M,N
// CHARACTER TRANSA,TRANSB
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DGEMM performs one of the matrix-matrix operations
//>
//> C := alpha*op( A )*op( B ) + beta*C,
//>
//> where op( X ) is one of
//>
//> op( X ) = X or op( X ) = X**T,
//>
//> alpha and beta are scalars, and A, B and C are matrices, with op( A )
//> an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TRANSA
//> \verbatim
//> TRANSA is CHARACTER*1
//> On entry, TRANSA specifies the form of op( A ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSA = 'N' or 'n', op( A ) = A.
//>
//> TRANSA = 'T' or 't', op( A ) = A**T.
//>
//> TRANSA = 'C' or 'c', op( A ) = A**T.
//> \endverbatim
//>
//> \param[in] TRANSB
//> \verbatim
//> TRANSB is CHARACTER*1
//> On entry, TRANSB specifies the form of op( B ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSB = 'N' or 'n', op( B ) = B.
//>
//> TRANSB = 'T' or 't', op( B ) = B**T.
//>
//> TRANSB = 'C' or 'c', op( B ) = B**T.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix
//> op( A ) and of the matrix C. M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix
//> op( B ) and the number of columns of the matrix C. N must be
//> at least zero.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> On entry, K specifies the number of columns of the matrix
//> op( A ) and the number of rows of the matrix op( B ). K must
//> be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION.
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension ( LDA, ka ), where ka is
//> k when TRANSA = 'N' or 'n', and is m otherwise.
//> Before entry with TRANSA = 'N' or 'n', the leading m by k
//> part of the array A must contain the matrix A, otherwise
//> the leading k by m part of the array A must contain the
//> matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. When TRANSA = 'N' or 'n' then
//> LDA must be at least max( 1, m ), otherwise LDA must be at
//> least max( 1, k ).
//> \endverbatim
//>
//> \param[in] B
//> \verbatim
//> B is DOUBLE PRECISION array, dimension ( LDB, kb ), where kb is
//> n when TRANSB = 'N' or 'n', and is k otherwise.
//> Before entry with TRANSB = 'N' or 'n', the leading k by n
//> part of the array B must contain the matrix B, otherwise
//> the leading n by k part of the array B must contain the
//> matrix B.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> On entry, LDB specifies the first dimension of B as declared
//> in the calling (sub) program. When TRANSB = 'N' or 'n' then
//> LDB must be at least max( 1, k ), otherwise LDB must be at
//> least max( 1, n ).
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is DOUBLE PRECISION.
//> On entry, BETA specifies the scalar beta. When BETA is
//> supplied as zero then C need not be set on input.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is DOUBLE PRECISION array, dimension ( LDC, N )
//> Before entry, the leading m by n part of the array C must
//> contain the matrix C, except when beta is zero, in which
//> case C need not be set on entry.
//> On exit, the array C is overwritten by the m by n matrix
//> ( alpha*op( A )*op( B ) + beta*C ).
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> On entry, LDC specifies the first dimension of C as declared
//> in the calling (sub) program. LDC must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup double_blas_level3
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 3 Blas routine.
//>
//> -- Written on 8-February-1989.
//> Jack Dongarra, Argonne National Laboratory.
//> Iain Duff, AERE Harwell.
//> Jeremy Du Croz, Numerical Algorithms Group Ltd.
//> Sven Hammarling, Numerical Algorithms Group Ltd.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dgemm_(char *transa, char *transb, int *m, int *n, int *
k, double *alpha, double *a, int *lda, double *b, int *ldb, double *
beta, double *c__, int *ldc)
{
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2,
i__3;
// Local variables
int i__, j, l, info;
int nota, notb;
double temp;
int ncola;
extern int lsame_(char *, char *);
int nrowa, nrowb;
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level3 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Local Scalars ..
// ..
// .. Parameters ..
// ..
//
// Set NOTA and NOTB as true if A and B respectively are not
// transposed and set NROWA, NCOLA and NROWB as the number of rows
// and columns of A and the number of rows of B respectively.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
// Function Body
nota = lsame_(transa, "N");
notb = lsame_(transb, "N");
if (nota) {
nrowa = *m;
ncola = *k;
} else {
nrowa = *k;
ncola = *m;
}
if (notb) {
nrowb = *k;
} else {
nrowb = *n;
}
//
// Test the input parameters.
//
info = 0;
if (! nota && ! lsame_(transa, "C") && ! lsame_(transa, "T")) {
info = 1;
} else if (! notb && ! lsame_(transb, "C") && ! lsame_(transb, "T")) {
info = 2;
} else if (*m < 0) {
info = 3;
} else if (*n < 0) {
info = 4;
} else if (*k < 0) {
info = 5;
} else if (*lda < max(1,nrowa)) {
info = 8;
} else if (*ldb < max(1,nrowb)) {
info = 10;
} else if (*ldc < max(1,*m)) {
info = 13;
}
if (info != 0) {
xerbla_("DGEMM ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || (*alpha == 0. || *k == 0) && *beta == 1.) {
return 0;
}
//
// And if alpha.eq.zero.
//
if (*alpha == 0.) {
if (*beta == 0.) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.;
// L10:
}
// L20:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L30:
}
// L40:
}
}
return 0;
}
//
// Start the operations.
//
if (notb) {
if (nota) {
//
// Form C := alpha*A*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (*beta == 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.;
// L50:
}
} else if (*beta != 1.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L60:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
temp = *alpha * b[l + j * b_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
// L70:
}
// L80:
}
// L90:
}
} else {
//
// Form C := alpha*A**T*B + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
temp += a[l + i__ * a_dim1] * b[l + j * b_dim1];
// L100:
}
if (*beta == 0.) {
c__[i__ + j * c_dim1] = *alpha * temp;
} else {
c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
i__ + j * c_dim1];
}
// L110:
}
// L120:
}
}
} else {
if (nota) {
//
// Form C := alpha*A*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (*beta == 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.;
// L130:
}
} else if (*beta != 1.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L140:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
temp = *alpha * b[j + l * b_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
// L150:
}
// L160:
}
// L170:
}
} else {
//
// Form C := alpha*A**T*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
temp += a[l + i__ * a_dim1] * b[j + l * b_dim1];
// L180:
}
if (*beta == 0.) {
c__[i__ + j * c_dim1] = *alpha * temp;
} else {
c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
i__ + j * c_dim1];
}
// L190:
}
// L200:
}
}
}
return 0;
//
// End of DGEMM .
//
} // dgemm_

370
3rdparty/clapack/src/dgemv.c vendored
View File

@@ -1,370 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DGEMV
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DGEMV(TRANS,M,N,ALPHA,A,LDA,X,INCX,BETA,Y,INCY)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION ALPHA,BETA
// INTEGER INCX,INCY,LDA,M,N
// CHARACTER TRANS
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A(LDA,*),X(*),Y(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DGEMV performs one of the matrix-vector operations
//>
//> y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y,
//>
//> where alpha and beta are scalars, x and y are vectors and A is an
//> m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TRANS
//> \verbatim
//> TRANS is CHARACTER*1
//> On entry, TRANS specifies the operation to be performed as
//> follows:
//>
//> TRANS = 'N' or 'n' y := alpha*A*x + beta*y.
//>
//> TRANS = 'T' or 't' y := alpha*A**T*x + beta*y.
//>
//> TRANS = 'C' or 'c' y := alpha*A**T*x + beta*y.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix A.
//> M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix A.
//> N must be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION.
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension ( LDA, N )
//> Before entry, the leading m by n part of the array A must
//> contain the matrix of coefficients.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. LDA must be at least
//> max( 1, m ).
//> \endverbatim
//>
//> \param[in] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension at least
//> ( 1 + ( n - 1 )*abs( INCX ) ) when TRANS = 'N' or 'n'
//> and at least
//> ( 1 + ( m - 1 )*abs( INCX ) ) otherwise.
//> Before entry, the incremented array X must contain the
//> vector x.
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> On entry, INCX specifies the increment for the elements of
//> X. INCX must not be zero.
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is DOUBLE PRECISION.
//> On entry, BETA specifies the scalar beta. When BETA is
//> supplied as zero then Y need not be set on input.
//> \endverbatim
//>
//> \param[in,out] Y
//> \verbatim
//> Y is DOUBLE PRECISION array, dimension at least
//> ( 1 + ( m - 1 )*abs( INCY ) ) when TRANS = 'N' or 'n'
//> and at least
//> ( 1 + ( n - 1 )*abs( INCY ) ) otherwise.
//> Before entry with BETA non-zero, the incremented array Y
//> must contain the vector y. On exit, Y is overwritten by the
//> updated vector y.
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> On entry, INCY specifies the increment for the elements of
//> Y. INCY must not be zero.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup double_blas_level2
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 2 Blas routine.
//> The vector and matrix arguments are not referenced when N = 0, or M = 0
//>
//> -- Written on 22-October-1986.
//> Jack Dongarra, Argonne National Lab.
//> Jeremy Du Croz, Nag Central Office.
//> Sven Hammarling, Nag Central Office.
//> Richard Hanson, Sandia National Labs.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dgemv_(char *trans, int *m, int *n, double *alpha,
double *a, int *lda, double *x, int *incx, double *beta, double *y,
int *incy)
{
// System generated locals
int a_dim1, a_offset, i__1, i__2;
// Local variables
int i__, j, ix, iy, jx, jy, kx, ky, info;
double temp;
int lenx, leny;
extern int lsame_(char *, char *);
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level2 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
//
// Test the input parameters.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--x;
--y;
// Function Body
info = 0;
if (! lsame_(trans, "N") && ! lsame_(trans, "T") && ! lsame_(trans, "C"))
{
info = 1;
} else if (*m < 0) {
info = 2;
} else if (*n < 0) {
info = 3;
} else if (*lda < max(1,*m)) {
info = 6;
} else if (*incx == 0) {
info = 8;
} else if (*incy == 0) {
info = 11;
}
if (info != 0) {
xerbla_("DGEMV ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || *alpha == 0. && *beta == 1.) {
return 0;
}
//
// Set LENX and LENY, the lengths of the vectors x and y, and set
// up the start points in X and Y.
//
if (lsame_(trans, "N")) {
lenx = *n;
leny = *m;
} else {
lenx = *m;
leny = *n;
}
if (*incx > 0) {
kx = 1;
} else {
kx = 1 - (lenx - 1) * *incx;
}
if (*incy > 0) {
ky = 1;
} else {
ky = 1 - (leny - 1) * *incy;
}
//
// Start the operations. In this version the elements of A are
// accessed sequentially with one pass through A.
//
// First form y := beta*y.
//
if (*beta != 1.) {
if (*incy == 1) {
if (*beta == 0.) {
i__1 = leny;
for (i__ = 1; i__ <= i__1; ++i__) {
y[i__] = 0.;
// L10:
}
} else {
i__1 = leny;
for (i__ = 1; i__ <= i__1; ++i__) {
y[i__] = *beta * y[i__];
// L20:
}
}
} else {
iy = ky;
if (*beta == 0.) {
i__1 = leny;
for (i__ = 1; i__ <= i__1; ++i__) {
y[iy] = 0.;
iy += *incy;
// L30:
}
} else {
i__1 = leny;
for (i__ = 1; i__ <= i__1; ++i__) {
y[iy] = *beta * y[iy];
iy += *incy;
// L40:
}
}
}
}
if (*alpha == 0.) {
return 0;
}
if (lsame_(trans, "N")) {
//
// Form y := alpha*A*x + y.
//
jx = kx;
if (*incy == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = *alpha * x[jx];
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
y[i__] += temp * a[i__ + j * a_dim1];
// L50:
}
jx += *incx;
// L60:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = *alpha * x[jx];
iy = ky;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
y[iy] += temp * a[i__ + j * a_dim1];
iy += *incy;
// L70:
}
jx += *incx;
// L80:
}
}
} else {
//
// Form y := alpha*A**T*x + y.
//
jy = ky;
if (*incx == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = 0.;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp += a[i__ + j * a_dim1] * x[i__];
// L90:
}
y[jy] += *alpha * temp;
jy += *incy;
// L100:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = 0.;
ix = kx;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp += a[i__ + j * a_dim1] * x[ix];
ix += *incx;
// L110:
}
y[jy] += *alpha * temp;
jy += *incy;
// L120:
}
}
}
return 0;
//
// End of DGEMV .
//
} // dgemv_

18599
3rdparty/clapack/src/dgesdd.c vendored
View File

File diff suppressed because it is too large Load Diff

186
3rdparty/clapack/src/disnan.c vendored
View File

@@ -1,186 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DISNAN tests input for NaN.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DISNAN + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/disnan.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/disnan.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/disnan.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// LOGICAL FUNCTION DISNAN( DIN )
//
// .. Scalar Arguments ..
// DOUBLE PRECISION, INTENT(IN) :: DIN
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DISNAN returns .TRUE. if its argument is NaN, and .FALSE.
//> otherwise. To be replaced by the Fortran 2003 intrinsic in the
//> future.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] DIN
//> \verbatim
//> DIN is DOUBLE PRECISION
//> Input to test for NaN.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date June 2017
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
int disnan_(double *din)
{
// System generated locals
int ret_val;
// Local variables
extern int dlaisnan_(double *, double *);
//
// -- LAPACK auxiliary routine (version 3.7.1) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// June 2017
//
// .. Scalar Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. Executable Statements ..
ret_val = dlaisnan_(din, din);
return ret_val;
} // disnan_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b DLAISNAN tests input for NaN by comparing two arguments for inequality.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLAISNAN + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlaisnan.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlaisnan.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlaisnan.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// LOGICAL FUNCTION DLAISNAN( DIN1, DIN2 )
//
// .. Scalar Arguments ..
// DOUBLE PRECISION, INTENT(IN) :: DIN1, DIN2
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> This routine is not for general use. It exists solely to avoid
//> over-optimization in DISNAN.
//>
//> DLAISNAN checks for NaNs by comparing its two arguments for
//> inequality. NaN is the only floating-point value where NaN != NaN
//> returns .TRUE. To check for NaNs, pass the same variable as both
//> arguments.
//>
//> A compiler must assume that the two arguments are
//> not the same variable, and the test will not be optimized away.
//> Interprocedural or whole-program optimization may delete this
//> test. The ISNAN functions will be replaced by the correct
//> Fortran 03 intrinsic once the intrinsic is widely available.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] DIN1
//> \verbatim
//> DIN1 is DOUBLE PRECISION
//> \endverbatim
//>
//> \param[in] DIN2
//> \verbatim
//> DIN2 is DOUBLE PRECISION
//> Two numbers to compare for inequality.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date June 2017
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
int dlaisnan_(double *din1, double *din2)
{
// System generated locals
int ret_val;
//
// -- LAPACK auxiliary routine (version 3.7.1) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// June 2017
//
// .. Scalar Arguments ..
// ..
//
// =====================================================================
//
// .. Executable Statements ..
ret_val = *din1 != *din2;
return ret_val;
} // dlaisnan_

184
3rdparty/clapack/src/dlacpy.c vendored
View File

@@ -1,184 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLACPY copies all or part of one two-dimensional array to another.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLACPY + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlacpy.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlacpy.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlacpy.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLACPY( UPLO, M, N, A, LDA, B, LDB )
//
// .. Scalar Arguments ..
// CHARACTER UPLO
// INTEGER LDA, LDB, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), B( LDB, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLACPY copies all or part of a two-dimensional matrix A to another
//> matrix B.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] UPLO
//> \verbatim
//> UPLO is CHARACTER*1
//> Specifies the part of the matrix A to be copied to B.
//> = 'U': Upper triangular part
//> = 'L': Lower triangular part
//> Otherwise: All of the matrix A
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A. N >= 0.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> The m by n matrix A. If UPLO = 'U', only the upper triangle
//> or trapezoid is accessed; if UPLO = 'L', only the lower
//> triangle or trapezoid is accessed.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//>
//> \param[out] B
//> \verbatim
//> B is DOUBLE PRECISION array, dimension (LDB,N)
//> On exit, B = A in the locations specified by UPLO.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> The leading dimension of the array B. LDB >= max(1,M).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlacpy_(char *uplo, int *m, int *n, double *a, int *lda,
double *b, int *ldb)
{
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, i__1, i__2;
// Local variables
int i__, j;
extern int lsame_(char *, char *);
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
// Function Body
if (lsame_(uplo, "U")) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = min(j,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
// L10:
}
// L20:
}
} else if (lsame_(uplo, "L")) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = j; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
// L30:
}
// L40:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] = a[i__ + j * a_dim1];
// L50:
}
// L60:
}
}
return 0;
//
// End of DLACPY
//
} // dlacpy_

367
3rdparty/clapack/src/dlange.c vendored
View File

@@ -1,367 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DCOMBSSQ adds two scaled sum of squares quantities.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//
// Definition:
// ===========
//
// SUBROUTINE DCOMBSSQ( V1, V2 )
//
// .. Array Arguments ..
// DOUBLE PRECISION V1( 2 ), V2( 2 )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DCOMBSSQ adds two scaled sum of squares quantities, V1 := V1 + V2.
//> That is,
//>
//> V1_scale**2 * V1_sumsq := V1_scale**2 * V1_sumsq
//> + V2_scale**2 * V2_sumsq
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in,out] V1
//> \verbatim
//> V1 is DOUBLE PRECISION array, dimension (2).
//> The first scaled sum.
//> V1(1) = V1_scale, V1(2) = V1_sumsq.
//> \endverbatim
//>
//> \param[in] V2
//> \verbatim
//> V2 is DOUBLE PRECISION array, dimension (2).
//> The second scaled sum.
//> V2(1) = V2_scale, V2(2) = V2_sumsq.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2018
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dcombssq_(double *v1, double *v2)
{
// System generated locals
double d__1;
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2018
//
// .. Array Arguments ..
// ..
//
//=====================================================================
//
// .. Parameters ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
--v2;
--v1;
// Function Body
if (v1[1] >= v2[1]) {
if (v1[1] != 0.) {
// Computing 2nd power
d__1 = v2[1] / v1[1];
v1[2] += d__1 * d__1 * v2[2];
}
} else {
// Computing 2nd power
d__1 = v1[1] / v2[1];
v1[2] = v2[2] + d__1 * d__1 * v1[2];
v1[1] = v2[1];
}
return 0;
//
// End of DCOMBSSQ
//
} // dcombssq_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b DLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a general rectangular matrix.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLANGE + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlange.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlange.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlange.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// DOUBLE PRECISION FUNCTION DLANGE( NORM, M, N, A, LDA, WORK )
//
// .. Scalar Arguments ..
// CHARACTER NORM
// INTEGER LDA, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLANGE returns the value of the one norm, or the Frobenius norm, or
//> the infinity norm, or the element of largest absolute value of a
//> real matrix A.
//> \endverbatim
//>
//> \return DLANGE
//> \verbatim
//>
//> DLANGE = ( max(abs(A(i,j))), NORM = 'M' or 'm'
//> (
//> ( norm1(A), NORM = '1', 'O' or 'o'
//> (
//> ( normI(A), NORM = 'I' or 'i'
//> (
//> ( normF(A), NORM = 'F', 'f', 'E' or 'e'
//>
//> where norm1 denotes the one norm of a matrix (maximum column sum),
//> normI denotes the infinity norm of a matrix (maximum row sum) and
//> normF denotes the Frobenius norm of a matrix (square root of sum of
//> squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] NORM
//> \verbatim
//> NORM is CHARACTER*1
//> Specifies the value to be returned in DLANGE as described
//> above.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A. M >= 0. When M = 0,
//> DLANGE is set to zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A. N >= 0. When N = 0,
//> DLANGE is set to zero.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> The m by n matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A. LDA >= max(M,1).
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK)),
//> where LWORK >= M when NORM = 'I'; otherwise, WORK is not
//> referenced.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleGEauxiliary
//
// =====================================================================
double dlange_(char *norm, int *m, int *n, double *a, int *lda, double *work)
{
// Table of constant values
int c__1 = 1;
// System generated locals
int a_dim1, a_offset, i__1, i__2;
double ret_val, d__1;
// Local variables
extern /* Subroutine */ int dcombssq_(double *, double *);
int i__, j;
double sum, ssq[2], temp;
extern int lsame_(char *, char *);
double value;
extern int disnan_(double *);
extern /* Subroutine */ int dlassq_(int *, double *, int *, double *,
double *);
double colssq[2];
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
//=====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. Local Arrays ..
// ..
// .. External Subroutines ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--work;
// Function Body
if (min(*m,*n) == 0) {
value = 0.;
} else if (lsame_(norm, "M")) {
//
// Find max(abs(A(i,j))).
//
value = 0.;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = (d__1 = a[i__ + j * a_dim1], abs(d__1));
if (value < temp || disnan_(&temp)) {
value = temp;
}
// L10:
}
// L20:
}
} else if (lsame_(norm, "O") || *(unsigned char *)norm == '1') {
//
// Find norm1(A).
//
value = 0.;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
sum = 0.;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
sum += (d__1 = a[i__ + j * a_dim1], abs(d__1));
// L30:
}
if (value < sum || disnan_(&sum)) {
value = sum;
}
// L40:
}
} else if (lsame_(norm, "I")) {
//
// Find normI(A).
//
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
work[i__] = 0.;
// L50:
}
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
work[i__] += (d__1 = a[i__ + j * a_dim1], abs(d__1));
// L60:
}
// L70:
}
value = 0.;
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
temp = work[i__];
if (value < temp || disnan_(&temp)) {
value = temp;
}
// L80:
}
} else if (lsame_(norm, "F") || lsame_(norm, "E")) {
//
// Find normF(A).
// SSQ(1) is scale
// SSQ(2) is sum-of-squares
// For better accuracy, sum each column separately.
//
ssq[0] = 0.;
ssq[1] = 1.;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
colssq[0] = 0.;
colssq[1] = 1.;
dlassq_(m, &a[j * a_dim1 + 1], &c__1, colssq, &colssq[1]);
dcombssq_(ssq, colssq);
// L90:
}
value = ssq[0] * sqrt(ssq[1]);
}
ret_val = value;
return ret_val;
//
// End of DLANGE
//
} // dlange_

125
3rdparty/clapack/src/dlapy2.c vendored
View File

@@ -1,125 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLAPY2 returns sqrt(x2+y2).
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLAPY2 + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlapy2.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlapy2.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlapy2.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// DOUBLE PRECISION FUNCTION DLAPY2( X, Y )
//
// .. Scalar Arguments ..
// DOUBLE PRECISION X, Y
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLAPY2 returns sqrt(x**2+y**2), taking care not to cause unnecessary
//> overflow.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] X
//> \verbatim
//> X is DOUBLE PRECISION
//> \endverbatim
//>
//> \param[in] Y
//> \verbatim
//> Y is DOUBLE PRECISION
//> X and Y specify the values x and y.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date June 2017
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
double dlapy2_(double *x, double *y)
{
// System generated locals
double ret_val, d__1;
// Local variables
int x_is_nan__, y_is_nan__;
double w, z__, xabs, yabs;
extern int disnan_(double *);
//
// -- LAPACK auxiliary routine (version 3.7.1) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// June 2017
//
// .. Scalar Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
x_is_nan__ = disnan_(x);
y_is_nan__ = disnan_(y);
if (x_is_nan__) {
ret_val = *x;
}
if (y_is_nan__) {
ret_val = *y;
}
if (! (x_is_nan__ || y_is_nan__)) {
xabs = abs(*x);
yabs = abs(*y);
w = max(xabs,yabs);
z__ = min(xabs,yabs);
if (z__ == 0.) {
ret_val = w;
} else {
// Computing 2nd power
d__1 = z__ / w;
ret_val = w * sqrt(d__1 * d__1 + 1.);
}
}
return ret_val;
//
// End of DLAPY2
//
} // dlapy2_

768
3rdparty/clapack/src/dlarf.c vendored
View File

@@ -1,768 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DGER
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DGER(M,N,ALPHA,X,INCX,Y,INCY,A,LDA)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION ALPHA
// INTEGER INCX,INCY,LDA,M,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A(LDA,*),X(*),Y(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DGER performs the rank 1 operation
//>
//> A := alpha*x*y**T + A,
//>
//> where alpha is a scalar, x is an m element vector, y is an n element
//> vector and A is an m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix A.
//> M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix A.
//> N must be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION.
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension at least
//> ( 1 + ( m - 1 )*abs( INCX ) ).
//> Before entry, the incremented array X must contain the m
//> element vector x.
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> On entry, INCX specifies the increment for the elements of
//> X. INCX must not be zero.
//> \endverbatim
//>
//> \param[in] Y
//> \verbatim
//> Y is DOUBLE PRECISION array, dimension at least
//> ( 1 + ( n - 1 )*abs( INCY ) ).
//> Before entry, the incremented array Y must contain the n
//> element vector y.
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> On entry, INCY specifies the increment for the elements of
//> Y. INCY must not be zero.
//> \endverbatim
//>
//> \param[in,out] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension ( LDA, N )
//> Before entry, the leading m by n part of the array A must
//> contain the matrix of coefficients. On exit, A is
//> overwritten by the updated matrix.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. LDA must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup double_blas_level2
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 2 Blas routine.
//>
//> -- Written on 22-October-1986.
//> Jack Dongarra, Argonne National Lab.
//> Jeremy Du Croz, Nag Central Office.
//> Sven Hammarling, Nag Central Office.
//> Richard Hanson, Sandia National Labs.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dger_(int *m, int *n, double *alpha, double *x, int *
incx, double *y, int *incy, double *a, int *lda)
{
// System generated locals
int a_dim1, a_offset, i__1, i__2;
// Local variables
int i__, j, ix, jy, kx, info;
double temp;
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level2 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
//
// Test the input parameters.
//
// Parameter adjustments
--x;
--y;
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
// Function Body
info = 0;
if (*m < 0) {
info = 1;
} else if (*n < 0) {
info = 2;
} else if (*incx == 0) {
info = 5;
} else if (*incy == 0) {
info = 7;
} else if (*lda < max(1,*m)) {
info = 9;
}
if (info != 0) {
xerbla_("DGER ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || *alpha == 0.) {
return 0;
}
//
// Start the operations. In this version the elements of A are
// accessed sequentially with one pass through A.
//
if (*incy > 0) {
jy = 1;
} else {
jy = 1 - (*n - 1) * *incy;
}
if (*incx == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (y[jy] != 0.) {
temp = *alpha * y[jy];
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] += x[i__] * temp;
// L10:
}
}
jy += *incy;
// L20:
}
} else {
if (*incx > 0) {
kx = 1;
} else {
kx = 1 - (*m - 1) * *incx;
}
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (y[jy] != 0.) {
temp = *alpha * y[jy];
ix = kx;
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] += x[ix] * temp;
ix += *incx;
// L30:
}
}
jy += *incy;
// L40:
}
}
return 0;
//
// End of DGER .
//
} // dger_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b DLARF applies an elementary reflector to a general rectangular matrix.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLARF + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlarf.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlarf.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlarf.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLARF( SIDE, M, N, V, INCV, TAU, C, LDC, WORK )
//
// .. Scalar Arguments ..
// CHARACTER SIDE
// INTEGER INCV, LDC, M, N
// DOUBLE PRECISION TAU
// ..
// .. Array Arguments ..
// DOUBLE PRECISION C( LDC, * ), V( * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLARF applies a real elementary reflector H to a real m by n matrix
//> C, from either the left or the right. H is represented in the form
//>
//> H = I - tau * v * v**T
//>
//> where tau is a real scalar and v is a real vector.
//>
//> If tau = 0, then H is taken to be the unit matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] SIDE
//> \verbatim
//> SIDE is CHARACTER*1
//> = 'L': form H * C
//> = 'R': form C * H
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix C.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix C.
//> \endverbatim
//>
//> \param[in] V
//> \verbatim
//> V is DOUBLE PRECISION array, dimension
//> (1 + (M-1)*abs(INCV)) if SIDE = 'L'
//> or (1 + (N-1)*abs(INCV)) if SIDE = 'R'
//> The vector v in the representation of H. V is not used if
//> TAU = 0.
//> \endverbatim
//>
//> \param[in] INCV
//> \verbatim
//> INCV is INTEGER
//> The increment between elements of v. INCV <> 0.
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION
//> The value tau in the representation of H.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is DOUBLE PRECISION array, dimension (LDC,N)
//> On entry, the m by n matrix C.
//> On exit, C is overwritten by the matrix H * C if SIDE = 'L',
//> or C * H if SIDE = 'R'.
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> The leading dimension of the array C. LDC >= max(1,M).
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension
//> (N) if SIDE = 'L'
//> or (M) if SIDE = 'R'
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlarf_(char *side, int *m, int *n, double *v, int *incv,
double *tau, double *c__, int *ldc, double *work)
{
// Table of constant values
double c_b4 = 1.;
double c_b5 = 0.;
int c__1 = 1;
// System generated locals
int c_dim1, c_offset;
double d__1;
// Local variables
int i__;
int applyleft;
extern /* Subroutine */ int dger_(int *, int *, double *, double *, int *,
double *, int *, double *, int *);
extern int lsame_(char *, char *);
extern /* Subroutine */ int dgemv_(char *, int *, int *, double *, double
*, int *, double *, int *, double *, double *, int *);
int lastc, lastv;
extern int iladlc_(int *, int *, double *, int *), iladlr_(int *, int *,
double *, int *);
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Subroutines ..
// ..
// .. External Functions ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
--v;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
--work;
// Function Body
applyleft = lsame_(side, "L");
lastv = 0;
lastc = 0;
if (*tau != 0.) {
// Set up variables for scanning V. LASTV begins pointing to the end
// of V.
if (applyleft) {
lastv = *m;
} else {
lastv = *n;
}
if (*incv > 0) {
i__ = (lastv - 1) * *incv + 1;
} else {
i__ = 1;
}
// Look for the last non-zero row in V.
while(lastv > 0 && v[i__] == 0.) {
--lastv;
i__ -= *incv;
}
if (applyleft) {
// Scan for the last non-zero column in C(1:lastv,:).
lastc = iladlc_(&lastv, n, &c__[c_offset], ldc);
} else {
// Scan for the last non-zero row in C(:,1:lastv).
lastc = iladlr_(m, &lastv, &c__[c_offset], ldc);
}
}
// Note that lastc.eq.0 renders the BLAS operations null; no special
// case is needed at this level.
if (applyleft) {
//
// Form H * C
//
if (lastv > 0) {
//
// w(1:lastc,1) := C(1:lastv,1:lastc)**T * v(1:lastv,1)
//
dgemv_("Transpose", &lastv, &lastc, &c_b4, &c__[c_offset], ldc, &
v[1], incv, &c_b5, &work[1], &c__1);
//
// C(1:lastv,1:lastc) := C(...) - v(1:lastv,1) * w(1:lastc,1)**T
//
d__1 = -(*tau);
dger_(&lastv, &lastc, &d__1, &v[1], incv, &work[1], &c__1, &c__[
c_offset], ldc);
}
} else {
//
// Form C * H
//
if (lastv > 0) {
//
// w(1:lastc,1) := C(1:lastc,1:lastv) * v(1:lastv,1)
//
dgemv_("No transpose", &lastc, &lastv, &c_b4, &c__[c_offset], ldc,
&v[1], incv, &c_b5, &work[1], &c__1);
//
// C(1:lastc,1:lastv) := C(...) - w(1:lastc,1) * v(1:lastv,1)**T
//
d__1 = -(*tau);
dger_(&lastc, &lastv, &d__1, &work[1], &c__1, &v[1], incv, &c__[
c_offset], ldc);
}
}
return 0;
//
// End of DLARF
//
} // dlarf_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b ILADLC scans a matrix for its last non-zero column.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download ILADLC + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/iladlc.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/iladlc.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/iladlc.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// INTEGER FUNCTION ILADLC( M, N, A, LDA )
//
// .. Scalar Arguments ..
// INTEGER M, N, LDA
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> ILADLC scans A for its last non-zero column.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> The m by n matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
int iladlc_(int *m, int *n, double *a, int *lda)
{
// System generated locals
int a_dim1, a_offset, ret_val, i__1;
// Local variables
int i__;
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. Executable Statements ..
//
// Quick test for the common case where one corner is non-zero.
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
// Function Body
if (*n == 0) {
ret_val = *n;
} else if (a[*n * a_dim1 + 1] != 0. || a[*m + *n * a_dim1] != 0.) {
ret_val = *n;
} else {
// Now scan each column from the end, returning with the first non-zero.
for (ret_val = *n; ret_val >= 1; --ret_val) {
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
if (a[i__ + ret_val * a_dim1] != 0.) {
return ret_val;
}
}
}
}
return ret_val;
} // iladlc_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b ILADLR scans a matrix for its last non-zero row.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download ILADLR + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/iladlr.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/iladlr.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/iladlr.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// INTEGER FUNCTION ILADLR( M, N, A, LDA )
//
// .. Scalar Arguments ..
// INTEGER M, N, LDA
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> ILADLR scans A for its last non-zero row.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> The m by n matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
int iladlr_(int *m, int *n, double *a, int *lda)
{
// System generated locals
int a_dim1, a_offset, ret_val, i__1;
// Local variables
int i__, j;
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. Executable Statements ..
//
// Quick test for the common case where one corner is non-zero.
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
// Function Body
if (*m == 0) {
ret_val = *m;
} else if (a[*m + a_dim1] != 0. || a[*m + *n * a_dim1] != 0.) {
ret_val = *m;
} else {
// Scan up each column tracking the last zero row seen.
ret_val = 0;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__ = *m;
while(a[max(i__,1) + j * a_dim1] == 0. && i__ >= 1) {
--i__;
}
ret_val = max(ret_val,i__);
}
}
return ret_val;
} // iladlr_

824
3rdparty/clapack/src/dlarfb.c vendored
View File

@@ -1,824 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLARFB applies a block reflector or its transpose to a general rectangular matrix.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLARFB + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlarfb.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlarfb.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlarfb.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLARFB( SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV,
// T, LDT, C, LDC, WORK, LDWORK )
//
// .. Scalar Arguments ..
// CHARACTER DIRECT, SIDE, STOREV, TRANS
// INTEGER K, LDC, LDT, LDV, LDWORK, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION C( LDC, * ), T( LDT, * ), V( LDV, * ),
// $ WORK( LDWORK, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLARFB applies a real block reflector H or its transpose H**T to a
//> real m by n matrix C, from either the left or the right.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] SIDE
//> \verbatim
//> SIDE is CHARACTER*1
//> = 'L': apply H or H**T from the Left
//> = 'R': apply H or H**T from the Right
//> \endverbatim
//>
//> \param[in] TRANS
//> \verbatim
//> TRANS is CHARACTER*1
//> = 'N': apply H (No transpose)
//> = 'T': apply H**T (Transpose)
//> \endverbatim
//>
//> \param[in] DIRECT
//> \verbatim
//> DIRECT is CHARACTER*1
//> Indicates how H is formed from a product of elementary
//> reflectors
//> = 'F': H = H(1) H(2) . . . H(k) (Forward)
//> = 'B': H = H(k) . . . H(2) H(1) (Backward)
//> \endverbatim
//>
//> \param[in] STOREV
//> \verbatim
//> STOREV is CHARACTER*1
//> Indicates how the vectors which define the elementary
//> reflectors are stored:
//> = 'C': Columnwise
//> = 'R': Rowwise
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix C.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix C.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The order of the matrix T (= the number of elementary
//> reflectors whose product defines the block reflector).
//> If SIDE = 'L', M >= K >= 0;
//> if SIDE = 'R', N >= K >= 0.
//> \endverbatim
//>
//> \param[in] V
//> \verbatim
//> V is DOUBLE PRECISION array, dimension
//> (LDV,K) if STOREV = 'C'
//> (LDV,M) if STOREV = 'R' and SIDE = 'L'
//> (LDV,N) if STOREV = 'R' and SIDE = 'R'
//> The matrix V. See Further Details.
//> \endverbatim
//>
//> \param[in] LDV
//> \verbatim
//> LDV is INTEGER
//> The leading dimension of the array V.
//> If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);
//> if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);
//> if STOREV = 'R', LDV >= K.
//> \endverbatim
//>
//> \param[in] T
//> \verbatim
//> T is DOUBLE PRECISION array, dimension (LDT,K)
//> The triangular k by k matrix T in the representation of the
//> block reflector.
//> \endverbatim
//>
//> \param[in] LDT
//> \verbatim
//> LDT is INTEGER
//> The leading dimension of the array T. LDT >= K.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is DOUBLE PRECISION array, dimension (LDC,N)
//> On entry, the m by n matrix C.
//> On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> The leading dimension of the array C. LDC >= max(1,M).
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension (LDWORK,K)
//> \endverbatim
//>
//> \param[in] LDWORK
//> \verbatim
//> LDWORK is INTEGER
//> The leading dimension of the array WORK.
//> If SIDE = 'L', LDWORK >= max(1,N);
//> if SIDE = 'R', LDWORK >= max(1,M).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date June 2013
//
//> \ingroup doubleOTHERauxiliary
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> The shape of the matrix V and the storage of the vectors which define
//> the H(i) is best illustrated by the following example with n = 5 and
//> k = 3. The elements equal to 1 are not stored; the corresponding
//> array elements are modified but restored on exit. The rest of the
//> array is not used.
//>
//> DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R':
//>
//> V = ( 1 ) V = ( 1 v1 v1 v1 v1 )
//> ( v1 1 ) ( 1 v2 v2 v2 )
//> ( v1 v2 1 ) ( 1 v3 v3 )
//> ( v1 v2 v3 )
//> ( v1 v2 v3 )
//>
//> DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R':
//>
//> V = ( v1 v2 v3 ) V = ( v1 v1 1 )
//> ( v1 v2 v3 ) ( v2 v2 v2 1 )
//> ( 1 v2 v3 ) ( v3 v3 v3 v3 1 )
//> ( 1 v3 )
//> ( 1 )
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dlarfb_(char *side, char *trans, char *direct, char *
storev, int *m, int *n, int *k, double *v, int *ldv, double *t, int *
ldt, double *c__, int *ldc, double *work, int *ldwork)
{
// Table of constant values
int c__1 = 1;
double c_b14 = 1.;
double c_b25 = -1.;
// System generated locals
int c_dim1, c_offset, t_dim1, t_offset, v_dim1, v_offset, work_dim1,
work_offset, i__1, i__2;
// Local variables
int i__, j;
extern /* Subroutine */ int dgemm_(char *, char *, int *, int *, int *,
double *, double *, int *, double *, int *, double *, double *,
int *);
extern int lsame_(char *, char *);
extern /* Subroutine */ int dcopy_(int *, double *, int *, double *, int *
), dtrmm_(char *, char *, char *, char *, int *, int *, double *,
double *, int *, double *, int *);
char transt[1+1]={'\0'};
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// June 2013
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Executable Statements ..
//
// Quick return if possible
//
// Parameter adjustments
v_dim1 = *ldv;
v_offset = 1 + v_dim1;
v -= v_offset;
t_dim1 = *ldt;
t_offset = 1 + t_dim1;
t -= t_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
work_dim1 = *ldwork;
work_offset = 1 + work_dim1;
work -= work_offset;
// Function Body
if (*m <= 0 || *n <= 0) {
return 0;
}
if (lsame_(trans, "N")) {
*(unsigned char *)transt = 'T';
} else {
*(unsigned char *)transt = 'N';
}
if (lsame_(storev, "C")) {
if (lsame_(direct, "F")) {
//
// Let V = ( V1 ) (first K rows)
// ( V2 )
// where V1 is unit lower triangular.
//
if (lsame_(side, "L")) {
//
// Form H * C or H**T * C where C = ( C1 )
// ( C2 )
//
// W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
//
// W := C1**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(n, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1],
&c__1);
// L10:
}
//
// W := W * V1
//
dtrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b14,
&v[v_offset], ldv, &work[work_offset], ldwork);
if (*m > *k) {
//
// W := W + C2**T * V2
//
i__1 = *m - *k;
dgemm_("Transpose", "No transpose", n, k, &i__1, &c_b14, &
c__[*k + 1 + c_dim1], ldc, &v[*k + 1 + v_dim1],
ldv, &c_b14, &work[work_offset], ldwork);
}
//
// W := W * T**T or W * T
//
dtrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - V * W**T
//
if (*m > *k) {
//
// C2 := C2 - V2 * W**T
//
i__1 = *m - *k;
dgemm_("No transpose", "Transpose", &i__1, n, k, &c_b25, &
v[*k + 1 + v_dim1], ldv, &work[work_offset],
ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
}
//
// W := W * V1**T
//
dtrmm_("Right", "Lower", "Transpose", "Unit", n, k, &c_b14, &
v[v_offset], ldv, &work[work_offset], ldwork);
//
// C1 := C1 - W**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
// L20:
}
// L30:
}
} else if (lsame_(side, "R")) {
//
// Form C * H or C * H**T where C = ( C1 C2 )
//
// W := C * V = (C1*V1 + C2*V2) (stored in WORK)
//
// W := C1
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(m, &c__[j * c_dim1 + 1], &c__1, &work[j *
work_dim1 + 1], &c__1);
// L40:
}
//
// W := W * V1
//
dtrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b14,
&v[v_offset], ldv, &work[work_offset], ldwork);
if (*n > *k) {
//
// W := W + C2 * V2
//
i__1 = *n - *k;
dgemm_("No transpose", "No transpose", m, k, &i__1, &
c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc, &v[*k +
1 + v_dim1], ldv, &c_b14, &work[work_offset],
ldwork);
}
//
// W := W * T or W * T**T
//
dtrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - W * V**T
//
if (*n > *k) {
//
// C2 := C2 - W * V2**T
//
i__1 = *n - *k;
dgemm_("No transpose", "Transpose", m, &i__1, k, &c_b25, &
work[work_offset], ldwork, &v[*k + 1 + v_dim1],
ldv, &c_b14, &c__[(*k + 1) * c_dim1 + 1], ldc);
}
//
// W := W * V1**T
//
dtrmm_("Right", "Lower", "Transpose", "Unit", m, k, &c_b14, &
v[v_offset], ldv, &work[work_offset], ldwork);
//
// C1 := C1 - W
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
// L50:
}
// L60:
}
}
} else {
//
// Let V = ( V1 )
// ( V2 ) (last K rows)
// where V2 is unit upper triangular.
//
if (lsame_(side, "L")) {
//
// Form H * C or H**T * C where C = ( C1 )
// ( C2 )
//
// W := C**T * V = (C1**T * V1 + C2**T * V2) (stored in WORK)
//
// W := C2**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(n, &c__[*m - *k + j + c_dim1], ldc, &work[j *
work_dim1 + 1], &c__1);
// L70:
}
//
// W := W * V2
//
dtrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b14,
&v[*m - *k + 1 + v_dim1], ldv, &work[work_offset],
ldwork);
if (*m > *k) {
//
// W := W + C1**T * V1
//
i__1 = *m - *k;
dgemm_("Transpose", "No transpose", n, k, &i__1, &c_b14, &
c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
work[work_offset], ldwork);
}
//
// W := W * T**T or W * T
//
dtrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - V * W**T
//
if (*m > *k) {
//
// C1 := C1 - V1 * W**T
//
i__1 = *m - *k;
dgemm_("No transpose", "Transpose", &i__1, n, k, &c_b25, &
v[v_offset], ldv, &work[work_offset], ldwork, &
c_b14, &c__[c_offset], ldc);
}
//
// W := W * V2**T
//
dtrmm_("Right", "Upper", "Transpose", "Unit", n, k, &c_b14, &
v[*m - *k + 1 + v_dim1], ldv, &work[work_offset],
ldwork);
//
// C2 := C2 - W**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[*m - *k + j + i__ * c_dim1] -= work[i__ + j *
work_dim1];
// L80:
}
// L90:
}
} else if (lsame_(side, "R")) {
//
// Form C * H or C * H**T where C = ( C1 C2 )
//
// W := C * V = (C1*V1 + C2*V2) (stored in WORK)
//
// W := C2
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(m, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[
j * work_dim1 + 1], &c__1);
// L100:
}
//
// W := W * V2
//
dtrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b14,
&v[*n - *k + 1 + v_dim1], ldv, &work[work_offset],
ldwork);
if (*n > *k) {
//
// W := W + C1 * V1
//
i__1 = *n - *k;
dgemm_("No transpose", "No transpose", m, k, &i__1, &
c_b14, &c__[c_offset], ldc, &v[v_offset], ldv, &
c_b14, &work[work_offset], ldwork);
}
//
// W := W * T or W * T**T
//
dtrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - W * V**T
//
if (*n > *k) {
//
// C1 := C1 - W * V1**T
//
i__1 = *n - *k;
dgemm_("No transpose", "Transpose", m, &i__1, k, &c_b25, &
work[work_offset], ldwork, &v[v_offset], ldv, &
c_b14, &c__[c_offset], ldc);
}
//
// W := W * V2**T
//
dtrmm_("Right", "Upper", "Transpose", "Unit", m, k, &c_b14, &
v[*n - *k + 1 + v_dim1], ldv, &work[work_offset],
ldwork);
//
// C2 := C2 - W
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + (*n - *k + j) * c_dim1] -= work[i__ + j *
work_dim1];
// L110:
}
// L120:
}
}
}
} else if (lsame_(storev, "R")) {
if (lsame_(direct, "F")) {
//
// Let V = ( V1 V2 ) (V1: first K columns)
// where V1 is unit upper triangular.
//
if (lsame_(side, "L")) {
//
// Form H * C or H**T * C where C = ( C1 )
// ( C2 )
//
// W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
//
// W := C1**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(n, &c__[j + c_dim1], ldc, &work[j * work_dim1 + 1],
&c__1);
// L130:
}
//
// W := W * V1**T
//
dtrmm_("Right", "Upper", "Transpose", "Unit", n, k, &c_b14, &
v[v_offset], ldv, &work[work_offset], ldwork);
if (*m > *k) {
//
// W := W + C2**T * V2**T
//
i__1 = *m - *k;
dgemm_("Transpose", "Transpose", n, k, &i__1, &c_b14, &
c__[*k + 1 + c_dim1], ldc, &v[(*k + 1) * v_dim1 +
1], ldv, &c_b14, &work[work_offset], ldwork);
}
//
// W := W * T**T or W * T
//
dtrmm_("Right", "Upper", transt, "Non-unit", n, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - V**T * W**T
//
if (*m > *k) {
//
// C2 := C2 - V2**T * W**T
//
i__1 = *m - *k;
dgemm_("Transpose", "Transpose", &i__1, n, k, &c_b25, &v[(
*k + 1) * v_dim1 + 1], ldv, &work[work_offset],
ldwork, &c_b14, &c__[*k + 1 + c_dim1], ldc);
}
//
// W := W * V1
//
dtrmm_("Right", "Upper", "No transpose", "Unit", n, k, &c_b14,
&v[v_offset], ldv, &work[work_offset], ldwork);
//
// C1 := C1 - W**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[j + i__ * c_dim1] -= work[i__ + j * work_dim1];
// L140:
}
// L150:
}
} else if (lsame_(side, "R")) {
//
// Form C * H or C * H**T where C = ( C1 C2 )
//
// W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
//
// W := C1
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(m, &c__[j * c_dim1 + 1], &c__1, &work[j *
work_dim1 + 1], &c__1);
// L160:
}
//
// W := W * V1**T
//
dtrmm_("Right", "Upper", "Transpose", "Unit", m, k, &c_b14, &
v[v_offset], ldv, &work[work_offset], ldwork);
if (*n > *k) {
//
// W := W + C2 * V2**T
//
i__1 = *n - *k;
dgemm_("No transpose", "Transpose", m, k, &i__1, &c_b14, &
c__[(*k + 1) * c_dim1 + 1], ldc, &v[(*k + 1) *
v_dim1 + 1], ldv, &c_b14, &work[work_offset],
ldwork);
}
//
// W := W * T or W * T**T
//
dtrmm_("Right", "Upper", trans, "Non-unit", m, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - W * V
//
if (*n > *k) {
//
// C2 := C2 - W * V2
//
i__1 = *n - *k;
dgemm_("No transpose", "No transpose", m, &i__1, k, &
c_b25, &work[work_offset], ldwork, &v[(*k + 1) *
v_dim1 + 1], ldv, &c_b14, &c__[(*k + 1) * c_dim1
+ 1], ldc);
}
//
// W := W * V1
//
dtrmm_("Right", "Upper", "No transpose", "Unit", m, k, &c_b14,
&v[v_offset], ldv, &work[work_offset], ldwork);
//
// C1 := C1 - W
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] -= work[i__ + j * work_dim1];
// L170:
}
// L180:
}
}
} else {
//
// Let V = ( V1 V2 ) (V2: last K columns)
// where V2 is unit lower triangular.
//
if (lsame_(side, "L")) {
//
// Form H * C or H**T * C where C = ( C1 )
// ( C2 )
//
// W := C**T * V**T = (C1**T * V1**T + C2**T * V2**T) (stored in WORK)
//
// W := C2**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(n, &c__[*m - *k + j + c_dim1], ldc, &work[j *
work_dim1 + 1], &c__1);
// L190:
}
//
// W := W * V2**T
//
dtrmm_("Right", "Lower", "Transpose", "Unit", n, k, &c_b14, &
v[(*m - *k + 1) * v_dim1 + 1], ldv, &work[work_offset]
, ldwork);
if (*m > *k) {
//
// W := W + C1**T * V1**T
//
i__1 = *m - *k;
dgemm_("Transpose", "Transpose", n, k, &i__1, &c_b14, &
c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
work[work_offset], ldwork);
}
//
// W := W * T**T or W * T
//
dtrmm_("Right", "Lower", transt, "Non-unit", n, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - V**T * W**T
//
if (*m > *k) {
//
// C1 := C1 - V1**T * W**T
//
i__1 = *m - *k;
dgemm_("Transpose", "Transpose", &i__1, n, k, &c_b25, &v[
v_offset], ldv, &work[work_offset], ldwork, &
c_b14, &c__[c_offset], ldc);
}
//
// W := W * V2
//
dtrmm_("Right", "Lower", "No transpose", "Unit", n, k, &c_b14,
&v[(*m - *k + 1) * v_dim1 + 1], ldv, &work[
work_offset], ldwork);
//
// C2 := C2 - W**T
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *n;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[*m - *k + j + i__ * c_dim1] -= work[i__ + j *
work_dim1];
// L200:
}
// L210:
}
} else if (lsame_(side, "R")) {
//
// Form C * H or C * H' where C = ( C1 C2 )
//
// W := C * V**T = (C1*V1**T + C2*V2**T) (stored in WORK)
//
// W := C2
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
dcopy_(m, &c__[(*n - *k + j) * c_dim1 + 1], &c__1, &work[
j * work_dim1 + 1], &c__1);
// L220:
}
//
// W := W * V2**T
//
dtrmm_("Right", "Lower", "Transpose", "Unit", m, k, &c_b14, &
v[(*n - *k + 1) * v_dim1 + 1], ldv, &work[work_offset]
, ldwork);
if (*n > *k) {
//
// W := W + C1 * V1**T
//
i__1 = *n - *k;
dgemm_("No transpose", "Transpose", m, k, &i__1, &c_b14, &
c__[c_offset], ldc, &v[v_offset], ldv, &c_b14, &
work[work_offset], ldwork);
}
//
// W := W * T or W * T**T
//
dtrmm_("Right", "Lower", trans, "Non-unit", m, k, &c_b14, &t[
t_offset], ldt, &work[work_offset], ldwork);
//
// C := C - W * V
//
if (*n > *k) {
//
// C1 := C1 - W * V1
//
i__1 = *n - *k;
dgemm_("No transpose", "No transpose", m, &i__1, k, &
c_b25, &work[work_offset], ldwork, &v[v_offset],
ldv, &c_b14, &c__[c_offset], ldc);
}
//
// W := W * V2
//
dtrmm_("Right", "Lower", "No transpose", "Unit", m, k, &c_b14,
&v[(*n - *k + 1) * v_dim1 + 1], ldv, &work[
work_offset], ldwork);
//
// C1 := C1 - W
//
i__1 = *k;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + (*n - *k + j) * c_dim1] -= work[i__ + j *
work_dim1];
// L230:
}
// L240:
}
}
}
}
return 0;
//
// End of DLARFB
//
} // dlarfb_

216
3rdparty/clapack/src/dlarfg.c vendored
View File

@@ -1,216 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLARFG generates an elementary reflector (Householder matrix).
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLARFG + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlarfg.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlarfg.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlarfg.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLARFG( N, ALPHA, X, INCX, TAU )
//
// .. Scalar Arguments ..
// INTEGER INCX, N
// DOUBLE PRECISION ALPHA, TAU
// ..
// .. Array Arguments ..
// DOUBLE PRECISION X( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLARFG generates a real elementary reflector H of order n, such
//> that
//>
//> H * ( alpha ) = ( beta ), H**T * H = I.
//> ( x ) ( 0 )
//>
//> where alpha and beta are scalars, and x is an (n-1)-element real
//> vector. H is represented in the form
//>
//> H = I - tau * ( 1 ) * ( 1 v**T ) ,
//> ( v )
//>
//> where tau is a real scalar and v is a real (n-1)-element
//> vector.
//>
//> If the elements of x are all zero, then tau = 0 and H is taken to be
//> the unit matrix.
//>
//> Otherwise 1 <= tau <= 2.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The order of the elementary reflector.
//> \endverbatim
//>
//> \param[in,out] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION
//> On entry, the value alpha.
//> On exit, it is overwritten with the value beta.
//> \endverbatim
//>
//> \param[in,out] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension
//> (1+(N-2)*abs(INCX))
//> On entry, the vector x.
//> On exit, it is overwritten with the vector v.
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> The increment between elements of X. INCX > 0.
//> \endverbatim
//>
//> \param[out] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION
//> The value tau.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup doubleOTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlarfg_(int *n, double *alpha, double *x, int *incx,
double *tau)
{
// System generated locals
int i__1;
double d__1;
// Local variables
int j, knt;
double beta;
extern double dnrm2_(int *, double *, int *);
extern /* Subroutine */ int dscal_(int *, double *, double *, int *);
double xnorm;
extern double dlapy2_(double *, double *), dlamch_(char *);
double safmin, rsafmn;
//
// -- LAPACK auxiliary routine (version 3.8.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
--x;
// Function Body
if (*n <= 1) {
*tau = 0.;
return 0;
}
i__1 = *n - 1;
xnorm = dnrm2_(&i__1, &x[1], incx);
if (xnorm == 0.) {
//
// H = I
//
*tau = 0.;
} else {
//
// general case
//
d__1 = dlapy2_(alpha, &xnorm);
beta = -d_sign(&d__1, alpha);
safmin = dlamch_("S") / dlamch_("E");
knt = 0;
if (abs(beta) < safmin) {
//
// XNORM, BETA may be inaccurate; scale X and recompute them
//
rsafmn = 1. / safmin;
L10:
++knt;
i__1 = *n - 1;
dscal_(&i__1, &rsafmn, &x[1], incx);
beta *= rsafmn;
*alpha *= rsafmn;
if (abs(beta) < safmin && knt < 20) {
goto L10;
}
//
// New BETA is at most 1, at least SAFMIN
//
i__1 = *n - 1;
xnorm = dnrm2_(&i__1, &x[1], incx);
d__1 = dlapy2_(alpha, &xnorm);
beta = -d_sign(&d__1, alpha);
}
*tau = (beta - *alpha) / beta;
i__1 = *n - 1;
d__1 = 1. / (*alpha - beta);
dscal_(&i__1, &d__1, &x[1], incx);
//
// If ALPHA is subnormal, it may lose relative accuracy
//
i__1 = knt;
for (j = 1; j <= i__1; ++j) {
beta *= safmin;
// L20:
}
*alpha = beta;
}
return 0;
//
// End of DLARFG
//
} // dlarfg_

389
3rdparty/clapack/src/dlarft.c vendored
View File

@@ -1,389 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLARFT forms the triangular factor T of a block reflector H = I - vtvH
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLARFT + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlarft.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlarft.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlarft.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLARFT( DIRECT, STOREV, N, K, V, LDV, TAU, T, LDT )
//
// .. Scalar Arguments ..
// CHARACTER DIRECT, STOREV
// INTEGER K, LDT, LDV, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION T( LDT, * ), TAU( * ), V( LDV, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLARFT forms the triangular factor T of a real block reflector H
//> of order n, which is defined as a product of k elementary reflectors.
//>
//> If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;
//>
//> If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.
//>
//> If STOREV = 'C', the vector which defines the elementary reflector
//> H(i) is stored in the i-th column of the array V, and
//>
//> H = I - V * T * V**T
//>
//> If STOREV = 'R', the vector which defines the elementary reflector
//> H(i) is stored in the i-th row of the array V, and
//>
//> H = I - V**T * T * V
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] DIRECT
//> \verbatim
//> DIRECT is CHARACTER*1
//> Specifies the order in which the elementary reflectors are
//> multiplied to form the block reflector:
//> = 'F': H = H(1) H(2) . . . H(k) (Forward)
//> = 'B': H = H(k) . . . H(2) H(1) (Backward)
//> \endverbatim
//>
//> \param[in] STOREV
//> \verbatim
//> STOREV is CHARACTER*1
//> Specifies how the vectors which define the elementary
//> reflectors are stored (see also Further Details):
//> = 'C': columnwise
//> = 'R': rowwise
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The order of the block reflector H. N >= 0.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The order of the triangular factor T (= the number of
//> elementary reflectors). K >= 1.
//> \endverbatim
//>
//> \param[in] V
//> \verbatim
//> V is DOUBLE PRECISION array, dimension
//> (LDV,K) if STOREV = 'C'
//> (LDV,N) if STOREV = 'R'
//> The matrix V. See further details.
//> \endverbatim
//>
//> \param[in] LDV
//> \verbatim
//> LDV is INTEGER
//> The leading dimension of the array V.
//> If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K.
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION array, dimension (K)
//> TAU(i) must contain the scalar factor of the elementary
//> reflector H(i).
//> \endverbatim
//>
//> \param[out] T
//> \verbatim
//> T is DOUBLE PRECISION array, dimension (LDT,K)
//> The k by k triangular factor T of the block reflector.
//> If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is
//> lower triangular. The rest of the array is not used.
//> \endverbatim
//>
//> \param[in] LDT
//> \verbatim
//> LDT is INTEGER
//> The leading dimension of the array T. LDT >= K.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERauxiliary
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> The shape of the matrix V and the storage of the vectors which define
//> the H(i) is best illustrated by the following example with n = 5 and
//> k = 3. The elements equal to 1 are not stored.
//>
//> DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R':
//>
//> V = ( 1 ) V = ( 1 v1 v1 v1 v1 )
//> ( v1 1 ) ( 1 v2 v2 v2 )
//> ( v1 v2 1 ) ( 1 v3 v3 )
//> ( v1 v2 v3 )
//> ( v1 v2 v3 )
//>
//> DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R':
//>
//> V = ( v1 v2 v3 ) V = ( v1 v1 1 )
//> ( v1 v2 v3 ) ( v2 v2 v2 1 )
//> ( 1 v2 v3 ) ( v3 v3 v3 v3 1 )
//> ( 1 v3 )
//> ( 1 )
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dlarft_(char *direct, char *storev, int *n, int *k,
double *v, int *ldv, double *tau, double *t, int *ldt)
{
// Table of constant values
int c__1 = 1;
double c_b7 = 1.;
// System generated locals
int t_dim1, t_offset, v_dim1, v_offset, i__1, i__2, i__3;
double d__1;
// Local variables
int i__, j, prevlastv;
extern int lsame_(char *, char *);
extern /* Subroutine */ int dgemv_(char *, int *, int *, double *, double
*, int *, double *, int *, double *, double *, int *);
int lastv;
extern /* Subroutine */ int dtrmv_(char *, char *, char *, int *, double *
, int *, double *, int *);
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Subroutines ..
// ..
// .. External Functions ..
// ..
// .. Executable Statements ..
//
// Quick return if possible
//
// Parameter adjustments
v_dim1 = *ldv;
v_offset = 1 + v_dim1;
v -= v_offset;
--tau;
t_dim1 = *ldt;
t_offset = 1 + t_dim1;
t -= t_offset;
// Function Body
if (*n == 0) {
return 0;
}
if (lsame_(direct, "F")) {
prevlastv = *n;
i__1 = *k;
for (i__ = 1; i__ <= i__1; ++i__) {
prevlastv = max(i__,prevlastv);
if (tau[i__] == 0.) {
//
// H(i) = I
//
i__2 = i__;
for (j = 1; j <= i__2; ++j) {
t[j + i__ * t_dim1] = 0.;
}
} else {
//
// general case
//
if (lsame_(storev, "C")) {
// Skip any trailing zeros.
i__2 = i__ + 1;
for (lastv = *n; lastv >= i__2; --lastv) {
if (v[lastv + i__ * v_dim1] != 0.) {
break;
}
}
i__2 = i__ - 1;
for (j = 1; j <= i__2; ++j) {
t[j + i__ * t_dim1] = -tau[i__] * v[i__ + j * v_dim1];
}
j = min(lastv,prevlastv);
//
// T(1:i-1,i) := - tau(i) * V(i:j,1:i-1)**T * V(i:j,i)
//
i__2 = j - i__;
i__3 = i__ - 1;
d__1 = -tau[i__];
dgemv_("Transpose", &i__2, &i__3, &d__1, &v[i__ + 1 +
v_dim1], ldv, &v[i__ + 1 + i__ * v_dim1], &c__1, &
c_b7, &t[i__ * t_dim1 + 1], &c__1);
} else {
// Skip any trailing zeros.
i__2 = i__ + 1;
for (lastv = *n; lastv >= i__2; --lastv) {
if (v[i__ + lastv * v_dim1] != 0.) {
break;
}
}
i__2 = i__ - 1;
for (j = 1; j <= i__2; ++j) {
t[j + i__ * t_dim1] = -tau[i__] * v[j + i__ * v_dim1];
}
j = min(lastv,prevlastv);
//
// T(1:i-1,i) := - tau(i) * V(1:i-1,i:j) * V(i,i:j)**T
//
i__2 = i__ - 1;
i__3 = j - i__;
d__1 = -tau[i__];
dgemv_("No transpose", &i__2, &i__3, &d__1, &v[(i__ + 1) *
v_dim1 + 1], ldv, &v[i__ + (i__ + 1) * v_dim1],
ldv, &c_b7, &t[i__ * t_dim1 + 1], &c__1);
}
//
// T(1:i-1,i) := T(1:i-1,1:i-1) * T(1:i-1,i)
//
i__2 = i__ - 1;
dtrmv_("Upper", "No transpose", "Non-unit", &i__2, &t[
t_offset], ldt, &t[i__ * t_dim1 + 1], &c__1);
t[i__ + i__ * t_dim1] = tau[i__];
if (i__ > 1) {
prevlastv = max(prevlastv,lastv);
} else {
prevlastv = lastv;
}
}
}
} else {
prevlastv = 1;
for (i__ = *k; i__ >= 1; --i__) {
if (tau[i__] == 0.) {
//
// H(i) = I
//
i__1 = *k;
for (j = i__; j <= i__1; ++j) {
t[j + i__ * t_dim1] = 0.;
}
} else {
//
// general case
//
if (i__ < *k) {
if (lsame_(storev, "C")) {
// Skip any leading zeros.
i__1 = i__ - 1;
for (lastv = 1; lastv <= i__1; ++lastv) {
if (v[lastv + i__ * v_dim1] != 0.) {
break;
}
}
i__1 = *k;
for (j = i__ + 1; j <= i__1; ++j) {
t[j + i__ * t_dim1] = -tau[i__] * v[*n - *k + i__
+ j * v_dim1];
}
j = max(lastv,prevlastv);
//
// T(i+1:k,i) = -tau(i) * V(j:n-k+i,i+1:k)**T * V(j:n-k+i,i)
//
i__1 = *n - *k + i__ - j;
i__2 = *k - i__;
d__1 = -tau[i__];
dgemv_("Transpose", &i__1, &i__2, &d__1, &v[j + (i__
+ 1) * v_dim1], ldv, &v[j + i__ * v_dim1], &
c__1, &c_b7, &t[i__ + 1 + i__ * t_dim1], &
c__1);
} else {
// Skip any leading zeros.
i__1 = i__ - 1;
for (lastv = 1; lastv <= i__1; ++lastv) {
if (v[i__ + lastv * v_dim1] != 0.) {
break;
}
}
i__1 = *k;
for (j = i__ + 1; j <= i__1; ++j) {
t[j + i__ * t_dim1] = -tau[i__] * v[j + (*n - *k
+ i__) * v_dim1];
}
j = max(lastv,prevlastv);
//
// T(i+1:k,i) = -tau(i) * V(i+1:k,j:n-k+i) * V(i,j:n-k+i)**T
//
i__1 = *k - i__;
i__2 = *n - *k + i__ - j;
d__1 = -tau[i__];
dgemv_("No transpose", &i__1, &i__2, &d__1, &v[i__ +
1 + j * v_dim1], ldv, &v[i__ + j * v_dim1],
ldv, &c_b7, &t[i__ + 1 + i__ * t_dim1], &c__1)
;
}
//
// T(i+1:k,i) := T(i+1:k,i+1:k) * T(i+1:k,i)
//
i__1 = *k - i__;
dtrmv_("Lower", "No transpose", "Non-unit", &i__1, &t[i__
+ 1 + (i__ + 1) * t_dim1], ldt, &t[i__ + 1 + i__ *
t_dim1], &c__1);
if (i__ > 1) {
prevlastv = min(prevlastv,lastv);
} else {
prevlastv = lastv;
}
}
t[i__ + i__ * t_dim1] = tau[i__];
}
}
}
return 0;
//
// End of DLARFT
//
} // dlarft_

236
3rdparty/clapack/src/dlartg.c vendored
View File

@@ -1,236 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLARTG generates a plane rotation with real cosine and real sine.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLARTG + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlartg.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlartg.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlartg.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLARTG( F, G, CS, SN, R )
//
// .. Scalar Arguments ..
// DOUBLE PRECISION CS, F, G, R, SN
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLARTG generate a plane rotation so that
//>
//> [ CS SN ] . [ F ] = [ R ] where CS**2 + SN**2 = 1.
//> [ -SN CS ] [ G ] [ 0 ]
//>
//> This is a slower, more accurate version of the BLAS1 routine DROTG,
//> with the following other differences:
//> F and G are unchanged on return.
//> If G=0, then CS=1 and SN=0.
//> If F=0 and (G .ne. 0), then CS=0 and SN=1 without doing any
//> floating point operations (saves work in DBDSQR when
//> there are zeros on the diagonal).
//>
//> If F exceeds G in magnitude, CS will be positive.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] F
//> \verbatim
//> F is DOUBLE PRECISION
//> The first component of vector to be rotated.
//> \endverbatim
//>
//> \param[in] G
//> \verbatim
//> G is DOUBLE PRECISION
//> The second component of vector to be rotated.
//> \endverbatim
//>
//> \param[out] CS
//> \verbatim
//> CS is DOUBLE PRECISION
//> The cosine of the rotation.
//> \endverbatim
//>
//> \param[out] SN
//> \verbatim
//> SN is DOUBLE PRECISION
//> The sine of the rotation.
//> \endverbatim
//>
//> \param[out] R
//> \verbatim
//> R is DOUBLE PRECISION
//> The nonzero component of the rotated vector.
//>
//> This version has a few statements commented out for thread safety
//> (machine parameters are computed on each entry). 10 feb 03, SJH.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlartg_(double *f, double *g, double *cs, double *sn,
double *r__)
{
// System generated locals
int i__1;
double d__1, d__2;
// Local variables
int i__;
double f1, g1, eps, scale;
int count;
double safmn2, safmx2;
extern double dlamch_(char *);
double safmin;
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// LOGICAL FIRST
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Save statement ..
// SAVE FIRST, SAFMX2, SAFMIN, SAFMN2
// ..
// .. Data statements ..
// DATA FIRST / .TRUE. /
// ..
// .. Executable Statements ..
//
// IF( FIRST ) THEN
safmin = dlamch_("S");
eps = dlamch_("E");
d__1 = dlamch_("B");
i__1 = (int) (log(safmin / eps) / log(dlamch_("B")) / 2.);
safmn2 = pow_di(&d__1, &i__1);
safmx2 = 1. / safmn2;
// FIRST = .FALSE.
// END IF
if (*g == 0.) {
*cs = 1.;
*sn = 0.;
*r__ = *f;
} else if (*f == 0.) {
*cs = 0.;
*sn = 1.;
*r__ = *g;
} else {
f1 = *f;
g1 = *g;
// Computing MAX
d__1 = abs(f1), d__2 = abs(g1);
scale = max(d__1,d__2);
if (scale >= safmx2) {
count = 0;
L10:
++count;
f1 *= safmn2;
g1 *= safmn2;
// Computing MAX
d__1 = abs(f1), d__2 = abs(g1);
scale = max(d__1,d__2);
if (scale >= safmx2) {
goto L10;
}
// Computing 2nd power
d__1 = f1;
// Computing 2nd power
d__2 = g1;
*r__ = sqrt(d__1 * d__1 + d__2 * d__2);
*cs = f1 / *r__;
*sn = g1 / *r__;
i__1 = count;
for (i__ = 1; i__ <= i__1; ++i__) {
*r__ *= safmx2;
// L20:
}
} else if (scale <= safmn2) {
count = 0;
L30:
++count;
f1 *= safmx2;
g1 *= safmx2;
// Computing MAX
d__1 = abs(f1), d__2 = abs(g1);
scale = max(d__1,d__2);
if (scale <= safmn2) {
goto L30;
}
// Computing 2nd power
d__1 = f1;
// Computing 2nd power
d__2 = g1;
*r__ = sqrt(d__1 * d__1 + d__2 * d__2);
*cs = f1 / *r__;
*sn = g1 / *r__;
i__1 = count;
for (i__ = 1; i__ <= i__1; ++i__) {
*r__ *= safmn2;
// L40:
}
} else {
// Computing 2nd power
d__1 = f1;
// Computing 2nd power
d__2 = g1;
*r__ = sqrt(d__1 * d__1 + d__2 * d__2);
*cs = f1 / *r__;
*sn = g1 / *r__;
}
if (abs(*f) > abs(*g) && *cs < 0.) {
*cs = -(*cs);
*sn = -(*sn);
*r__ = -(*r__);
}
}
return 0;
//
// End of DLARTG
//
} // dlartg_

413
3rdparty/clapack/src/dlascl.c vendored
View File

@@ -1,413 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLASCL multiplies a general rectangular matrix by a real scalar defined as cto/cfrom.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLASCL + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlascl.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlascl.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlascl.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLASCL( TYPE, KL, KU, CFROM, CTO, M, N, A, LDA, INFO )
//
// .. Scalar Arguments ..
// CHARACTER TYPE
// INTEGER INFO, KL, KU, LDA, M, N
// DOUBLE PRECISION CFROM, CTO
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLASCL multiplies the M by N real matrix A by the real scalar
//> CTO/CFROM. This is done without over/underflow as long as the final
//> result CTO*A(I,J)/CFROM does not over/underflow. TYPE specifies that
//> A may be full, upper triangular, lower triangular, upper Hessenberg,
//> or banded.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TYPE
//> \verbatim
//> TYPE is CHARACTER*1
//> TYPE indices the storage type of the input matrix.
//> = 'G': A is a full matrix.
//> = 'L': A is a lower triangular matrix.
//> = 'U': A is an upper triangular matrix.
//> = 'H': A is an upper Hessenberg matrix.
//> = 'B': A is a symmetric band matrix with lower bandwidth KL
//> and upper bandwidth KU and with the only the lower
//> half stored.
//> = 'Q': A is a symmetric band matrix with lower bandwidth KL
//> and upper bandwidth KU and with the only the upper
//> half stored.
//> = 'Z': A is a band matrix with lower bandwidth KL and upper
//> bandwidth KU. See DGBTRF for storage details.
//> \endverbatim
//>
//> \param[in] KL
//> \verbatim
//> KL is INTEGER
//> The lower bandwidth of A. Referenced only if TYPE = 'B',
//> 'Q' or 'Z'.
//> \endverbatim
//>
//> \param[in] KU
//> \verbatim
//> KU is INTEGER
//> The upper bandwidth of A. Referenced only if TYPE = 'B',
//> 'Q' or 'Z'.
//> \endverbatim
//>
//> \param[in] CFROM
//> \verbatim
//> CFROM is DOUBLE PRECISION
//> \endverbatim
//>
//> \param[in] CTO
//> \verbatim
//> CTO is DOUBLE PRECISION
//>
//> The matrix A is multiplied by CTO/CFROM. A(I,J) is computed
//> without over/underflow if the final result CTO*A(I,J)/CFROM
//> can be represented without over/underflow. CFROM must be
//> nonzero.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A. N >= 0.
//> \endverbatim
//>
//> \param[in,out] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> The matrix to be multiplied by CTO/CFROM. See TYPE for the
//> storage type.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A.
//> If TYPE = 'G', 'L', 'U', 'H', LDA >= max(1,M);
//> TYPE = 'B', LDA >= KL+1;
//> TYPE = 'Q', LDA >= KU+1;
//> TYPE = 'Z', LDA >= 2*KL+KU+1.
//> \endverbatim
//>
//> \param[out] INFO
//> \verbatim
//> INFO is INTEGER
//> 0 - successful exit
//> <0 - if INFO = -i, the i-th argument had an illegal value.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date June 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlascl_(char *type__, int *kl, int *ku, double *cfrom,
double *cto, int *m, int *n, double *a, int *lda, int *info)
{
// System generated locals
int a_dim1, a_offset, i__1, i__2, i__3, i__4, i__5;
// Local variables
int i__, j, k1, k2, k3, k4;
double mul, cto1;
int done;
double ctoc;
extern int lsame_(char *, char *);
int itype;
double cfrom1;
extern double dlamch_(char *);
double cfromc;
extern int disnan_(double *);
extern /* Subroutine */ int xerbla_(char *, int *);
double bignum, smlnum;
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// June 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Executable Statements ..
//
// Test the input arguments
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
// Function Body
*info = 0;
if (lsame_(type__, "G")) {
itype = 0;
} else if (lsame_(type__, "L")) {
itype = 1;
} else if (lsame_(type__, "U")) {
itype = 2;
} else if (lsame_(type__, "H")) {
itype = 3;
} else if (lsame_(type__, "B")) {
itype = 4;
} else if (lsame_(type__, "Q")) {
itype = 5;
} else if (lsame_(type__, "Z")) {
itype = 6;
} else {
itype = -1;
}
if (itype == -1) {
*info = -1;
} else if (*cfrom == 0. || disnan_(cfrom)) {
*info = -4;
} else if (disnan_(cto)) {
*info = -5;
} else if (*m < 0) {
*info = -6;
} else if (*n < 0 || itype == 4 && *n != *m || itype == 5 && *n != *m) {
*info = -7;
} else if (itype <= 3 && *lda < max(1,*m)) {
*info = -9;
} else if (itype >= 4) {
// Computing MAX
i__1 = *m - 1;
if (*kl < 0 || *kl > max(i__1,0)) {
*info = -2;
} else /* if(complicated condition) */ {
// Computing MAX
i__1 = *n - 1;
if (*ku < 0 || *ku > max(i__1,0) || (itype == 4 || itype == 5) &&
*kl != *ku) {
*info = -3;
} else if (itype == 4 && *lda < *kl + 1 || itype == 5 && *lda < *
ku + 1 || itype == 6 && *lda < (*kl << 1) + *ku + 1) {
*info = -9;
}
}
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DLASCL", &i__1);
return 0;
}
//
// Quick return if possible
//
if (*n == 0 || *m == 0) {
return 0;
}
//
// Get machine parameters
//
smlnum = dlamch_("S");
bignum = 1. / smlnum;
cfromc = *cfrom;
ctoc = *cto;
L10:
cfrom1 = cfromc * smlnum;
if (cfrom1 == cfromc) {
// CFROMC is an inf. Multiply by a correctly signed zero for
// finite CTOC, or a NaN if CTOC is infinite.
mul = ctoc / cfromc;
done = TRUE_;
cto1 = ctoc;
} else {
cto1 = ctoc / bignum;
if (cto1 == ctoc) {
// CTOC is either 0 or an inf. In both cases, CTOC itself
// serves as the correct multiplication factor.
mul = ctoc;
done = TRUE_;
cfromc = 1.;
} else if (abs(cfrom1) > abs(ctoc) && ctoc != 0.) {
mul = smlnum;
done = FALSE_;
cfromc = cfrom1;
} else if (abs(cto1) > abs(cfromc)) {
mul = bignum;
done = FALSE_;
ctoc = cto1;
} else {
mul = ctoc / cfromc;
done = TRUE_;
}
}
if (itype == 0) {
//
// Full matrix
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L20:
}
// L30:
}
} else if (itype == 1) {
//
// Lower triangular matrix
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = j; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L40:
}
// L50:
}
} else if (itype == 2) {
//
// Upper triangular matrix
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = min(j,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L60:
}
// L70:
}
} else if (itype == 3) {
//
// Upper Hessenberg matrix
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
// Computing MIN
i__3 = j + 1;
i__2 = min(i__3,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L80:
}
// L90:
}
} else if (itype == 4) {
//
// Lower half of a symmetric band matrix
//
k3 = *kl + 1;
k4 = *n + 1;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
// Computing MIN
i__3 = k3, i__4 = k4 - j;
i__2 = min(i__3,i__4);
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L100:
}
// L110:
}
} else if (itype == 5) {
//
// Upper half of a symmetric band matrix
//
k1 = *ku + 2;
k3 = *ku + 1;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
// Computing MAX
i__2 = k1 - j;
i__3 = k3;
for (i__ = max(i__2,1); i__ <= i__3; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L120:
}
// L130:
}
} else if (itype == 6) {
//
// Band matrix
//
k1 = *kl + *ku + 2;
k2 = *kl + 1;
k3 = (*kl << 1) + *ku + 1;
k4 = *kl + *ku + 1 + *m;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
// Computing MAX
i__3 = k1 - j;
// Computing MIN
i__4 = k3, i__5 = k4 - j;
i__2 = min(i__4,i__5);
for (i__ = max(i__3,k2); i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] *= mul;
// L140:
}
// L150:
}
}
if (! done) {
goto L10;
}
return 0;
//
// End of DLASCL
//
} // dlascl_

209
3rdparty/clapack/src/dlaset.c vendored
View File

@@ -1,209 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLASET initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLASET + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlaset.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlaset.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlaset.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLASET( UPLO, M, N, ALPHA, BETA, A, LDA )
//
// .. Scalar Arguments ..
// CHARACTER UPLO
// INTEGER LDA, M, N
// DOUBLE PRECISION ALPHA, BETA
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLASET initializes an m-by-n matrix A to BETA on the diagonal and
//> ALPHA on the offdiagonals.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] UPLO
//> \verbatim
//> UPLO is CHARACTER*1
//> Specifies the part of the matrix A to be set.
//> = 'U': Upper triangular part is set; the strictly lower
//> triangular part of A is not changed.
//> = 'L': Lower triangular part is set; the strictly upper
//> triangular part of A is not changed.
//> Otherwise: All of the matrix A is set.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix A. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix A. N >= 0.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION
//> The constant to which the offdiagonal elements are to be set.
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is DOUBLE PRECISION
//> The constant to which the diagonal elements are to be set.
//> \endverbatim
//>
//> \param[out] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> On exit, the leading m-by-n submatrix of A is set as follows:
//>
//> if UPLO = 'U', A(i,j) = ALPHA, 1<=i<=j-1, 1<=j<=n,
//> if UPLO = 'L', A(i,j) = ALPHA, j+1<=i<=m, 1<=j<=n,
//> otherwise, A(i,j) = ALPHA, 1<=i<=m, 1<=j<=n, i.ne.j,
//>
//> and, for all UPLO, A(i,i) = BETA, 1<=i<=min(m,n).
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlaset_(char *uplo, int *m, int *n, double *alpha,
double *beta, double *a, int *lda)
{
// System generated locals
int a_dim1, a_offset, i__1, i__2, i__3;
// Local variables
int i__, j;
extern int lsame_(char *, char *);
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
//=====================================================================
//
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
// Function Body
if (lsame_(uplo, "U")) {
//
// Set the strictly upper triangular or trapezoidal part of the
// array to ALPHA.
//
i__1 = *n;
for (j = 2; j <= i__1; ++j) {
// Computing MIN
i__3 = j - 1;
i__2 = min(i__3,*m);
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] = *alpha;
// L10:
}
// L20:
}
} else if (lsame_(uplo, "L")) {
//
// Set the strictly lower triangular or trapezoidal part of the
// array to ALPHA.
//
i__1 = min(*m,*n);
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = j + 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] = *alpha;
// L30:
}
// L40:
}
} else {
//
// Set the leading m-by-n submatrix to ALPHA.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] = *alpha;
// L50:
}
// L60:
}
}
//
// Set the first min(M,N) diagonal elements to BETA.
//
i__1 = min(*m,*n);
for (i__ = 1; i__ <= i__1; ++i__) {
a[i__ + i__ * a_dim1] = *beta;
// L70:
}
return 0;
//
// End of DLASET
//
} // dlaset_

172
3rdparty/clapack/src/dlassq.c vendored
View File

@@ -1,172 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DLASSQ updates a sum of squares represented in scaled form.
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DLASSQ + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dlassq.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dlassq.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dlassq.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DLASSQ( N, X, INCX, SCALE, SUMSQ )
//
// .. Scalar Arguments ..
// INTEGER INCX, N
// DOUBLE PRECISION SCALE, SUMSQ
// ..
// .. Array Arguments ..
// DOUBLE PRECISION X( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DLASSQ returns the values scl and smsq such that
//>
//> ( scl**2 )*smsq = x( 1 )**2 +...+ x( n )**2 + ( scale**2 )*sumsq,
//>
//> where x( i ) = X( 1 + ( i - 1 )*INCX ). The value of sumsq is
//> assumed to be non-negative and scl returns the value
//>
//> scl = max( scale, abs( x( i ) ) ).
//>
//> scale and sumsq must be supplied in SCALE and SUMSQ and
//> scl and smsq are overwritten on SCALE and SUMSQ respectively.
//>
//> The routine makes only one pass through the vector x.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of elements to be used from the vector X.
//> \endverbatim
//>
//> \param[in] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension (1+(N-1)*INCX)
//> The vector for which a scaled sum of squares is computed.
//> x( i ) = X( 1 + ( i - 1 )*INCX ), 1 <= i <= n.
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> The increment between successive values of the vector X.
//> INCX > 0.
//> \endverbatim
//>
//> \param[in,out] SCALE
//> \verbatim
//> SCALE is DOUBLE PRECISION
//> On entry, the value scale in the equation above.
//> On exit, SCALE is overwritten with scl , the scaling factor
//> for the sum of squares.
//> \endverbatim
//>
//> \param[in,out] SUMSQ
//> \verbatim
//> SUMSQ is DOUBLE PRECISION
//> On entry, the value sumsq in the equation above.
//> On exit, SUMSQ is overwritten with smsq , the basic sum of
//> squares from which scl has been factored out.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup OTHERauxiliary
//
// =====================================================================
/* Subroutine */ int dlassq_(int *n, double *x, int *incx, double *scale,
double *sumsq)
{
// System generated locals
int i__1, i__2;
double d__1;
// Local variables
int ix;
double absxi;
extern int disnan_(double *);
//
// -- LAPACK auxiliary routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
//=====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Parameter adjustments
--x;
// Function Body
if (*n > 0) {
i__1 = (*n - 1) * *incx + 1;
i__2 = *incx;
for (ix = 1; i__2 < 0 ? ix >= i__1 : ix <= i__1; ix += i__2) {
absxi = (d__1 = x[ix], abs(d__1));
if (absxi > 0. || disnan_(&absxi)) {
if (*scale < absxi) {
// Computing 2nd power
d__1 = *scale / absxi;
*sumsq = *sumsq * (d__1 * d__1) + 1;
*scale = absxi;
} else {
// Computing 2nd power
d__1 = absxi / *scale;
*sumsq += d__1 * d__1;
}
}
// L10:
}
}
return 0;
//
// End of DLASSQ
//
} // dlassq_

149
3rdparty/clapack/src/dnrm2.c vendored
View File

@@ -1,149 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DNRM2
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// DOUBLE PRECISION FUNCTION DNRM2(N,X,INCX)
//
// .. Scalar Arguments ..
// INTEGER INCX,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION X(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DNRM2 returns the euclidean norm of a vector via the function
//> name, so that
//>
//> DNRM2 := sqrt( x'*x )
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> -- This version written on 25-October-1982.
//> Modified on 14-October-1993 to inline the call to DLASSQ.
//> Sven Hammarling, Nag Ltd.
//> \endverbatim
//>
// =====================================================================
double dnrm2_(int *n, double *x, int *incx)
{
// System generated locals
int i__1, i__2;
double ret_val, d__1;
// Local variables
int ix;
double ssq, norm, scale, absxi;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. Intrinsic Functions ..
// ..
// Parameter adjustments
--x;
// Function Body
if (*n < 1 || *incx < 1) {
norm = 0.;
} else if (*n == 1) {
norm = abs(x[1]);
} else {
scale = 0.;
ssq = 1.;
// The following loop is equivalent to this call to the LAPACK
// auxiliary routine:
// CALL DLASSQ( N, X, INCX, SCALE, SSQ )
//
i__1 = (*n - 1) * *incx + 1;
i__2 = *incx;
for (ix = 1; i__2 < 0 ? ix >= i__1 : ix <= i__1; ix += i__2) {
if (x[ix] != 0.) {
absxi = (d__1 = x[ix], abs(d__1));
if (scale < absxi) {
// Computing 2nd power
d__1 = scale / absxi;
ssq = ssq * (d__1 * d__1) + 1.;
scale = absxi;
} else {
// Computing 2nd power
d__1 = absxi / scale;
ssq += d__1 * d__1;
}
}
// L10:
}
norm = scale * sqrt(ssq);
}
ret_val = norm;
return ret_val;
//
// End of DNRM2.
//
} // dnrm2_

571
3rdparty/clapack/src/dorgqr.c vendored
View File

@@ -1,571 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DORG2R generates all or part of the orthogonal matrix Q from a QR factorization determined by sgeqrf (unblocked algorithm).
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DORG2R + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dorg2r.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dorg2r.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dorg2r.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DORG2R( M, N, K, A, LDA, TAU, WORK, INFO )
//
// .. Scalar Arguments ..
// INTEGER INFO, K, LDA, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), TAU( * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DORG2R generates an m by n real matrix Q with orthonormal columns,
//> which is defined as the first n columns of a product of k elementary
//> reflectors of order m
//>
//> Q = H(1) H(2) . . . H(k)
//>
//> as returned by DGEQRF.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix Q. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix Q. M >= N >= 0.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The number of elementary reflectors whose product defines the
//> matrix Q. N >= K >= 0.
//> \endverbatim
//>
//> \param[in,out] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> On entry, the i-th column must contain the vector which
//> defines the elementary reflector H(i), for i = 1,2,...,k, as
//> returned by DGEQRF in the first k columns of its array
//> argument A.
//> On exit, the m-by-n matrix Q.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The first dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION array, dimension (K)
//> TAU(i) must contain the scalar factor of the elementary
//> reflector H(i), as returned by DGEQRF.
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension (N)
//> \endverbatim
//>
//> \param[out] INFO
//> \verbatim
//> INFO is INTEGER
//> = 0: successful exit
//> < 0: if INFO = -i, the i-th argument has an illegal value
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERcomputational
//
// =====================================================================
/* Subroutine */ int dorg2r_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *info)
{
// Table of constant values
int c__1 = 1;
// System generated locals
int a_dim1, a_offset, i__1, i__2;
double d__1;
// Local variables
int i__, j, l;
extern /* Subroutine */ int dscal_(int *, double *, double *, int *),
dlarf_(char *, int *, int *, double *, int *, double *, double *,
int *, double *), xerbla_(char *, int *);
//
// -- LAPACK computational routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Test the input arguments
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
// Function Body
*info = 0;
if (*m < 0) {
*info = -1;
} else if (*n < 0 || *n > *m) {
*info = -2;
} else if (*k < 0 || *k > *n) {
*info = -3;
} else if (*lda < max(1,*m)) {
*info = -5;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DORG2R", &i__1);
return 0;
}
//
// Quick return if possible
//
if (*n <= 0) {
return 0;
}
//
// Initialise columns k+1:n to columns of the unit matrix
//
i__1 = *n;
for (j = *k + 1; j <= i__1; ++j) {
i__2 = *m;
for (l = 1; l <= i__2; ++l) {
a[l + j * a_dim1] = 0.;
// L10:
}
a[j + j * a_dim1] = 1.;
// L20:
}
for (i__ = *k; i__ >= 1; --i__) {
//
// Apply H(i) to A(i:m,i:n) from the left
//
if (i__ < *n) {
a[i__ + i__ * a_dim1] = 1.;
i__1 = *m - i__ + 1;
i__2 = *n - i__;
dlarf_("Left", &i__1, &i__2, &a[i__ + i__ * a_dim1], &c__1, &tau[
i__], &a[i__ + (i__ + 1) * a_dim1], lda, &work[1]);
}
if (i__ < *m) {
i__1 = *m - i__;
d__1 = -tau[i__];
dscal_(&i__1, &d__1, &a[i__ + 1 + i__ * a_dim1], &c__1);
}
a[i__ + i__ * a_dim1] = 1. - tau[i__];
//
// Set A(1:i-1,i) to zero
//
i__1 = i__ - 1;
for (l = 1; l <= i__1; ++l) {
a[l + i__ * a_dim1] = 0.;
// L30:
}
// L40:
}
return 0;
//
// End of DORG2R
//
} // dorg2r_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b DORGQR
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DORGQR + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dorgqr.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dorgqr.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dorgqr.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DORGQR( M, N, K, A, LDA, TAU, WORK, LWORK, INFO )
//
// .. Scalar Arguments ..
// INTEGER INFO, K, LDA, LWORK, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), TAU( * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DORGQR generates an M-by-N real matrix Q with orthonormal columns,
//> which is defined as the first N columns of a product of K elementary
//> reflectors of order M
//>
//> Q = H(1) H(2) . . . H(k)
//>
//> as returned by DGEQRF.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix Q. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix Q. M >= N >= 0.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The number of elementary reflectors whose product defines the
//> matrix Q. N >= K >= 0.
//> \endverbatim
//>
//> \param[in,out] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,N)
//> On entry, the i-th column must contain the vector which
//> defines the elementary reflector H(i), for i = 1,2,...,k, as
//> returned by DGEQRF in the first k columns of its array
//> argument A.
//> On exit, the M-by-N matrix Q.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The first dimension of the array A. LDA >= max(1,M).
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION array, dimension (K)
//> TAU(i) must contain the scalar factor of the elementary
//> reflector H(i), as returned by DGEQRF.
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
//> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
//> \endverbatim
//>
//> \param[in] LWORK
//> \verbatim
//> LWORK is INTEGER
//> The dimension of the array WORK. LWORK >= max(1,N).
//> For optimum performance LWORK >= N*NB, where NB is the
//> optimal blocksize.
//>
//> If LWORK = -1, then a workspace query is assumed; the routine
//> only calculates the optimal size of the WORK array, returns
//> this value as the first entry of the WORK array, and no error
//> message related to LWORK is issued by XERBLA.
//> \endverbatim
//>
//> \param[out] INFO
//> \verbatim
//> INFO is INTEGER
//> = 0: successful exit
//> < 0: if INFO = -i, the i-th argument has an illegal value
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERcomputational
//
// =====================================================================
/* Subroutine */ int dorgqr_(int *m, int *n, int *k, double *a, int *lda,
double *tau, double *work, int *lwork, int *info)
{
// Table of constant values
int c__1 = 1;
int c_n1 = -1;
int c__3 = 3;
int c__2 = 2;
// System generated locals
int a_dim1, a_offset, i__1, i__2, i__3;
// Local variables
int i__, j, l, ib, nb, ki, kk, nx, iws, nbmin, iinfo;
extern /* Subroutine */ int dorg2r_(int *, int *, int *, double *, int *,
double *, double *, int *), dlarfb_(char *, char *, char *, char *
, int *, int *, int *, double *, int *, double *, int *, double *,
int *, double *, int *), dlarft_(char *, char *, int *, int *,
double *, int *, double *, double *, int *), xerbla_(char *, int *
);
extern int ilaenv_(int *, char *, char *, int *, int *, int *, int *);
int ldwork, lwkopt;
int lquery;
//
// -- LAPACK computational routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. External Functions ..
// ..
// .. Executable Statements ..
//
// Test the input arguments
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
--work;
// Function Body
*info = 0;
nb = ilaenv_(&c__1, "DORGQR", " ", m, n, k, &c_n1);
lwkopt = max(1,*n) * nb;
work[1] = (double) lwkopt;
lquery = *lwork == -1;
if (*m < 0) {
*info = -1;
} else if (*n < 0 || *n > *m) {
*info = -2;
} else if (*k < 0 || *k > *n) {
*info = -3;
} else if (*lda < max(1,*m)) {
*info = -5;
} else if (*lwork < max(1,*n) && ! lquery) {
*info = -8;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DORGQR", &i__1);
return 0;
} else if (lquery) {
return 0;
}
//
// Quick return if possible
//
if (*n <= 0) {
work[1] = 1.;
return 0;
}
nbmin = 2;
nx = 0;
iws = *n;
if (nb > 1 && nb < *k) {
//
// Determine when to cross over from blocked to unblocked code.
//
// Computing MAX
i__1 = 0, i__2 = ilaenv_(&c__3, "DORGQR", " ", m, n, k, &c_n1);
nx = max(i__1,i__2);
if (nx < *k) {
//
// Determine if workspace is large enough for blocked code.
//
ldwork = *n;
iws = ldwork * nb;
if (*lwork < iws) {
//
// Not enough workspace to use optimal NB: reduce NB and
// determine the minimum value of NB.
//
nb = *lwork / ldwork;
// Computing MAX
i__1 = 2, i__2 = ilaenv_(&c__2, "DORGQR", " ", m, n, k, &c_n1)
;
nbmin = max(i__1,i__2);
}
}
}
if (nb >= nbmin && nb < *k && nx < *k) {
//
// Use blocked code after the last block.
// The first kk columns are handled by the block method.
//
ki = (*k - nx - 1) / nb * nb;
// Computing MIN
i__1 = *k, i__2 = ki + nb;
kk = min(i__1,i__2);
//
// Set A(1:kk,kk+1:n) to zero.
//
i__1 = *n;
for (j = kk + 1; j <= i__1; ++j) {
i__2 = kk;
for (i__ = 1; i__ <= i__2; ++i__) {
a[i__ + j * a_dim1] = 0.;
// L10:
}
// L20:
}
} else {
kk = 0;
}
//
// Use unblocked code for the last or only block.
//
if (kk < *n) {
i__1 = *m - kk;
i__2 = *n - kk;
i__3 = *k - kk;
dorg2r_(&i__1, &i__2, &i__3, &a[kk + 1 + (kk + 1) * a_dim1], lda, &
tau[kk + 1], &work[1], &iinfo);
}
if (kk > 0) {
//
// Use blocked code
//
i__1 = -nb;
for (i__ = ki + 1; i__1 < 0 ? i__ >= 1 : i__ <= 1; i__ += i__1) {
// Computing MIN
i__2 = nb, i__3 = *k - i__ + 1;
ib = min(i__2,i__3);
if (i__ + ib <= *n) {
//
// Form the triangular factor of the block reflector
// H = H(i) H(i+1) . . . H(i+ib-1)
//
i__2 = *m - i__ + 1;
dlarft_("Forward", "Columnwise", &i__2, &ib, &a[i__ + i__ *
a_dim1], lda, &tau[i__], &work[1], &ldwork);
//
// Apply H to A(i:m,i+ib:n) from the left
//
i__2 = *m - i__ + 1;
i__3 = *n - i__ - ib + 1;
dlarfb_("Left", "No transpose", "Forward", "Columnwise", &
i__2, &i__3, &ib, &a[i__ + i__ * a_dim1], lda, &work[
1], &ldwork, &a[i__ + (i__ + ib) * a_dim1], lda, &
work[ib + 1], &ldwork);
}
//
// Apply H to rows i:m of current block
//
i__2 = *m - i__ + 1;
dorg2r_(&i__2, &ib, &ib, &a[i__ + i__ * a_dim1], lda, &tau[i__], &
work[1], &iinfo);
//
// Set rows 1:i-1 of current block to zero
//
i__2 = i__ + ib - 1;
for (j = i__; j <= i__2; ++j) {
i__3 = i__ - 1;
for (l = 1; l <= i__3; ++l) {
a[l + j * a_dim1] = 0.;
// L30:
}
// L40:
}
// L50:
}
}
work[1] = (double) iws;
return 0;
//
// End of DORGQR
//
} // dorgqr_

684
3rdparty/clapack/src/dormqr.c vendored
View File

@@ -1,684 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DORM2R multiplies a general matrix by the orthogonal matrix from a QR factorization determined by sgeqrf (unblocked algorithm).
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DORM2R + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dorm2r.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dorm2r.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dorm2r.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DORM2R( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
// WORK, INFO )
//
// .. Scalar Arguments ..
// CHARACTER SIDE, TRANS
// INTEGER INFO, K, LDA, LDC, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DORM2R overwrites the general real m by n matrix C with
//>
//> Q * C if SIDE = 'L' and TRANS = 'N', or
//>
//> Q**T* C if SIDE = 'L' and TRANS = 'T', or
//>
//> C * Q if SIDE = 'R' and TRANS = 'N', or
//>
//> C * Q**T if SIDE = 'R' and TRANS = 'T',
//>
//> where Q is a real orthogonal matrix defined as the product of k
//> elementary reflectors
//>
//> Q = H(1) H(2) . . . H(k)
//>
//> as returned by DGEQRF. Q is of order m if SIDE = 'L' and of order n
//> if SIDE = 'R'.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] SIDE
//> \verbatim
//> SIDE is CHARACTER*1
//> = 'L': apply Q or Q**T from the Left
//> = 'R': apply Q or Q**T from the Right
//> \endverbatim
//>
//> \param[in] TRANS
//> \verbatim
//> TRANS is CHARACTER*1
//> = 'N': apply Q (No transpose)
//> = 'T': apply Q**T (Transpose)
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix C. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix C. N >= 0.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The number of elementary reflectors whose product defines
//> the matrix Q.
//> If SIDE = 'L', M >= K >= 0;
//> if SIDE = 'R', N >= K >= 0.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,K)
//> The i-th column must contain the vector which defines the
//> elementary reflector H(i), for i = 1,2,...,k, as returned by
//> DGEQRF in the first k columns of its array argument A.
//> A is modified by the routine but restored on exit.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A.
//> If SIDE = 'L', LDA >= max(1,M);
//> if SIDE = 'R', LDA >= max(1,N).
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION array, dimension (K)
//> TAU(i) must contain the scalar factor of the elementary
//> reflector H(i), as returned by DGEQRF.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is DOUBLE PRECISION array, dimension (LDC,N)
//> On entry, the m by n matrix C.
//> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> The leading dimension of the array C. LDC >= max(1,M).
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension
//> (N) if SIDE = 'L',
//> (M) if SIDE = 'R'
//> \endverbatim
//>
//> \param[out] INFO
//> \verbatim
//> INFO is INTEGER
//> = 0: successful exit
//> < 0: if INFO = -i, the i-th argument had an illegal value
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERcomputational
//
// =====================================================================
/* Subroutine */ int dorm2r_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *info)
{
// Table of constant values
int c__1 = 1;
// System generated locals
int a_dim1, a_offset, c_dim1, c_offset, i__1, i__2;
// Local variables
int i__, i1, i2, i3, ic, jc, mi, ni, nq;
double aii;
int left;
extern /* Subroutine */ int dlarf_(char *, int *, int *, double *, int *,
double *, double *, int *, double *);
extern int lsame_(char *, char *);
extern /* Subroutine */ int xerbla_(char *, int *);
int notran;
//
// -- LAPACK computational routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Test the input arguments
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
--work;
// Function Body
*info = 0;
left = lsame_(side, "L");
notran = lsame_(trans, "N");
//
// NQ is the order of Q
//
if (left) {
nq = *m;
} else {
nq = *n;
}
if (! left && ! lsame_(side, "R")) {
*info = -1;
} else if (! notran && ! lsame_(trans, "T")) {
*info = -2;
} else if (*m < 0) {
*info = -3;
} else if (*n < 0) {
*info = -4;
} else if (*k < 0 || *k > nq) {
*info = -5;
} else if (*lda < max(1,nq)) {
*info = -7;
} else if (*ldc < max(1,*m)) {
*info = -10;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DORM2R", &i__1);
return 0;
}
//
// Quick return if possible
//
if (*m == 0 || *n == 0 || *k == 0) {
return 0;
}
if (left && ! notran || ! left && notran) {
i1 = 1;
i2 = *k;
i3 = 1;
} else {
i1 = *k;
i2 = 1;
i3 = -1;
}
if (left) {
ni = *n;
jc = 1;
} else {
mi = *m;
ic = 1;
}
i__1 = i2;
i__2 = i3;
for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
if (left) {
//
// H(i) is applied to C(i:m,1:n)
//
mi = *m - i__ + 1;
ic = i__;
} else {
//
// H(i) is applied to C(1:m,i:n)
//
ni = *n - i__ + 1;
jc = i__;
}
//
// Apply H(i)
//
aii = a[i__ + i__ * a_dim1];
a[i__ + i__ * a_dim1] = 1.;
dlarf_(side, &mi, &ni, &a[i__ + i__ * a_dim1], &c__1, &tau[i__], &c__[
ic + jc * c_dim1], ldc, &work[1]);
a[i__ + i__ * a_dim1] = aii;
// L10:
}
return 0;
//
// End of DORM2R
//
} // dorm2r_
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
//> \brief \b DORMQR
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
//> \htmlonly
//> Download DORMQR + dependencies
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.tgz?format=tgz&filename=/lapack/lapack_routine/dormqr.f">
//> [TGZ]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.zip?format=zip&filename=/lapack/lapack_routine/dormqr.f">
//> [ZIP]</a>
//> <a href="http://www.netlib.org/cgi-bin/netlibfiles.txt?format=txt&filename=/lapack/lapack_routine/dormqr.f">
//> [TXT]</a>
//> \endhtmlonly
//
// Definition:
// ===========
//
// SUBROUTINE DORMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC,
// WORK, LWORK, INFO )
//
// .. Scalar Arguments ..
// CHARACTER SIDE, TRANS
// INTEGER INFO, K, LDA, LDC, LWORK, M, N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A( LDA, * ), C( LDC, * ), TAU( * ), WORK( * )
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DORMQR overwrites the general real M-by-N matrix C with
//>
//> SIDE = 'L' SIDE = 'R'
//> TRANS = 'N': Q * C C * Q
//> TRANS = 'T': Q**T * C C * Q**T
//>
//> where Q is a real orthogonal matrix defined as the product of k
//> elementary reflectors
//>
//> Q = H(1) H(2) . . . H(k)
//>
//> as returned by DGEQRF. Q is of order M if SIDE = 'L' and of order N
//> if SIDE = 'R'.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] SIDE
//> \verbatim
//> SIDE is CHARACTER*1
//> = 'L': apply Q or Q**T from the Left;
//> = 'R': apply Q or Q**T from the Right.
//> \endverbatim
//>
//> \param[in] TRANS
//> \verbatim
//> TRANS is CHARACTER*1
//> = 'N': No transpose, apply Q;
//> = 'T': Transpose, apply Q**T.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> The number of rows of the matrix C. M >= 0.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> The number of columns of the matrix C. N >= 0.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> The number of elementary reflectors whose product defines
//> the matrix Q.
//> If SIDE = 'L', M >= K >= 0;
//> if SIDE = 'R', N >= K >= 0.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension (LDA,K)
//> The i-th column must contain the vector which defines the
//> elementary reflector H(i), for i = 1,2,...,k, as returned by
//> DGEQRF in the first k columns of its array argument A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> The leading dimension of the array A.
//> If SIDE = 'L', LDA >= max(1,M);
//> if SIDE = 'R', LDA >= max(1,N).
//> \endverbatim
//>
//> \param[in] TAU
//> \verbatim
//> TAU is DOUBLE PRECISION array, dimension (K)
//> TAU(i) must contain the scalar factor of the elementary
//> reflector H(i), as returned by DGEQRF.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is DOUBLE PRECISION array, dimension (LDC,N)
//> On entry, the M-by-N matrix C.
//> On exit, C is overwritten by Q*C or Q**T*C or C*Q**T or C*Q.
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> The leading dimension of the array C. LDC >= max(1,M).
//> \endverbatim
//>
//> \param[out] WORK
//> \verbatim
//> WORK is DOUBLE PRECISION array, dimension (MAX(1,LWORK))
//> On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
//> \endverbatim
//>
//> \param[in] LWORK
//> \verbatim
//> LWORK is INTEGER
//> The dimension of the array WORK.
//> If SIDE = 'L', LWORK >= max(1,N);
//> if SIDE = 'R', LWORK >= max(1,M).
//> For good performance, LWORK should generally be larger.
//>
//> If LWORK = -1, then a workspace query is assumed; the routine
//> only calculates the optimal size of the WORK array, returns
//> this value as the first entry of the WORK array, and no error
//> message related to LWORK is issued by XERBLA.
//> \endverbatim
//>
//> \param[out] INFO
//> \verbatim
//> INFO is INTEGER
//> = 0: successful exit
//> < 0: if INFO = -i, the i-th argument had an illegal value
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup doubleOTHERcomputational
//
// =====================================================================
/* Subroutine */ int dormqr_(char *side, char *trans, int *m, int *n, int *k,
double *a, int *lda, double *tau, double *c__, int *ldc, double *work,
int *lwork, int *info)
{
// Table of constant values
int c__1 = 1;
int c_n1 = -1;
int c__2 = 2;
int c__65 = 65;
// System generated locals
address a__1[2];
int a_dim1, a_offset, c_dim1, c_offset, i__1, i__2, i__3[2], i__4, i__5;
char ch__1[2+1]={'\0'};
// Local variables
int i__, i1, i2, i3, ib, ic, jc, nb, mi, ni, nq, nw, iwt;
int left;
extern int lsame_(char *, char *);
int nbmin, iinfo;
extern /* Subroutine */ int dorm2r_(char *, char *, int *, int *, int *,
double *, int *, double *, double *, int *, double *, int *),
dlarfb_(char *, char *, char *, char *, int *, int *, int *,
double *, int *, double *, int *, double *, int *, double *, int *
), dlarft_(char *, char *, int *, int *, double *, int *, double *
, double *, int *), xerbla_(char *, int *);
extern int ilaenv_(int *, char *, char *, int *, int *, int *, int *);
int notran;
int ldwork, lwkopt;
int lquery;
//
// -- LAPACK computational routine (version 3.7.0) --
// -- LAPACK is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Executable Statements ..
//
// Test the input arguments
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--tau;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
--work;
// Function Body
*info = 0;
left = lsame_(side, "L");
notran = lsame_(trans, "N");
lquery = *lwork == -1;
//
// NQ is the order of Q and NW is the minimum dimension of WORK
//
if (left) {
nq = *m;
nw = *n;
} else {
nq = *n;
nw = *m;
}
if (! left && ! lsame_(side, "R")) {
*info = -1;
} else if (! notran && ! lsame_(trans, "T")) {
*info = -2;
} else if (*m < 0) {
*info = -3;
} else if (*n < 0) {
*info = -4;
} else if (*k < 0 || *k > nq) {
*info = -5;
} else if (*lda < max(1,nq)) {
*info = -7;
} else if (*ldc < max(1,*m)) {
*info = -10;
} else if (*lwork < max(1,nw) && ! lquery) {
*info = -12;
}
if (*info == 0) {
//
// Compute the workspace requirements
//
// Computing MIN
// Writing concatenation
i__3[0] = 1, a__1[0] = side;
i__3[1] = 1, a__1[1] = trans;
s_cat(ch__1, a__1, i__3, &c__2);
i__1 = 64, i__2 = ilaenv_(&c__1, "DORMQR", ch__1, m, n, k, &c_n1);
nb = min(i__1,i__2);
lwkopt = max(1,nw) * nb + 4160;
work[1] = (double) lwkopt;
}
if (*info != 0) {
i__1 = -(*info);
xerbla_("DORMQR", &i__1);
return 0;
} else if (lquery) {
return 0;
}
//
// Quick return if possible
//
if (*m == 0 || *n == 0 || *k == 0) {
work[1] = 1.;
return 0;
}
nbmin = 2;
ldwork = nw;
if (nb > 1 && nb < *k) {
if (*lwork < nw * nb + 4160) {
nb = (*lwork - 4160) / ldwork;
// Computing MAX
// Writing concatenation
i__3[0] = 1, a__1[0] = side;
i__3[1] = 1, a__1[1] = trans;
s_cat(ch__1, a__1, i__3, &c__2);
i__1 = 2, i__2 = ilaenv_(&c__2, "DORMQR", ch__1, m, n, k, &c_n1);
nbmin = max(i__1,i__2);
}
}
if (nb < nbmin || nb >= *k) {
//
// Use unblocked code
//
dorm2r_(side, trans, m, n, k, &a[a_offset], lda, &tau[1], &c__[
c_offset], ldc, &work[1], &iinfo);
} else {
//
// Use blocked code
//
iwt = nw * nb + 1;
if (left && ! notran || ! left && notran) {
i1 = 1;
i2 = *k;
i3 = nb;
} else {
i1 = (*k - 1) / nb * nb + 1;
i2 = 1;
i3 = -nb;
}
if (left) {
ni = *n;
jc = 1;
} else {
mi = *m;
ic = 1;
}
i__1 = i2;
i__2 = i3;
for (i__ = i1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
// Computing MIN
i__4 = nb, i__5 = *k - i__ + 1;
ib = min(i__4,i__5);
//
// Form the triangular factor of the block reflector
// H = H(i) H(i+1) . . . H(i+ib-1)
//
i__4 = nq - i__ + 1;
dlarft_("Forward", "Columnwise", &i__4, &ib, &a[i__ + i__ *
a_dim1], lda, &tau[i__], &work[iwt], &c__65);
if (left) {
//
// H or H**T is applied to C(i:m,1:n)
//
mi = *m - i__ + 1;
ic = i__;
} else {
//
// H or H**T is applied to C(1:m,i:n)
//
ni = *n - i__ + 1;
jc = i__;
}
//
// Apply H or H**T
//
dlarfb_(side, trans, "Forward", "Columnwise", &mi, &ni, &ib, &a[
i__ + i__ * a_dim1], lda, &work[iwt], &c__65, &c__[ic +
jc * c_dim1], ldc, &work[1], &ldwork);
// L10:
}
}
work[1] = (double) lwkopt;
return 0;
//
// End of DORMQR
//
} // dormqr_

164
3rdparty/clapack/src/drot.c vendored
View File

@@ -1,164 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DROT
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DROT(N,DX,INCX,DY,INCY,C,S)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION C,S
// INTEGER INCX,INCY,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION DX(*),DY(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DROT applies a plane rotation.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in,out] DX
//> \verbatim
//> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//>
//> \param[in,out] DY
//> \verbatim
//> DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> storage spacing between elements of DY
//> \endverbatim
//>
//> \param[in] C
//> \verbatim
//> C is DOUBLE PRECISION
//> \endverbatim
//>
//> \param[in] S
//> \verbatim
//> S is DOUBLE PRECISION
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> jack dongarra, linpack, 3/11/78.
//> modified 12/3/93, array(1) declarations changed to array(*)
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int drot_(int *n, double *dx, int *incx, double *dy, int *
incy, double *c__, double *s)
{
// System generated locals
int i__1;
// Local variables
int i__, ix, iy;
double dtemp;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// Parameter adjustments
--dy;
--dx;
// Function Body
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
//
// code for both increments equal to 1
//
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp = *c__ * dx[i__] + *s * dy[i__];
dy[i__] = *c__ * dy[i__] - *s * dx[i__];
dx[i__] = dtemp;
}
} else {
//
// code for unequal increments or equal increments not equal
// to 1
//
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp = *c__ * dx[ix] + *s * dy[iy];
dy[iy] = *c__ * dy[iy] - *s * dx[ix];
dx[ix] = dtemp;
ix += *incx;
iy += *incy;
}
}
return 0;
} // drot_

155
3rdparty/clapack/src/dscal.c vendored
View File

@@ -1,155 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DSCAL
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DSCAL(N,DA,DX,INCX)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION DA
// INTEGER INCX,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION DX(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DSCAL scales a vector by a constant.
//> uses unrolled loops for increment equal to 1.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in] DA
//> \verbatim
//> DA is DOUBLE PRECISION
//> On entry, DA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in,out] DX
//> \verbatim
//> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> jack dongarra, linpack, 3/11/78.
//> modified 3/93 to return if incx .le. 0.
//> modified 12/3/93, array(1) declarations changed to array(*)
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dscal_(int *n, double *da, double *dx, int *incx)
{
// System generated locals
int i__1, i__2;
// Local variables
int i__, m, mp1, nincx;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// .. Intrinsic Functions ..
// ..
// Parameter adjustments
--dx;
// Function Body
if (*n <= 0 || *incx <= 0) {
return 0;
}
if (*incx == 1) {
//
// code for increment equal to 1
//
//
// clean-up loop
//
m = *n % 5;
if (m != 0) {
i__1 = m;
for (i__ = 1; i__ <= i__1; ++i__) {
dx[i__] = *da * dx[i__];
}
if (*n < 5) {
return 0;
}
}
mp1 = m + 1;
i__1 = *n;
for (i__ = mp1; i__ <= i__1; i__ += 5) {
dx[i__] = *da * dx[i__];
dx[i__ + 1] = *da * dx[i__ + 1];
dx[i__ + 2] = *da * dx[i__ + 2];
dx[i__ + 3] = *da * dx[i__ + 3];
dx[i__ + 4] = *da * dx[i__ + 4];
}
} else {
//
// code for increment not equal to 1
//
nincx = *n * *incx;
i__1 = nincx;
i__2 = *incx;
for (i__ = 1; i__2 < 0 ? i__ >= i__1 : i__ <= i__1; i__ += i__2) {
dx[i__] = *da * dx[i__];
}
}
return 0;
} // dscal_

178
3rdparty/clapack/src/dswap.c vendored
View File

@@ -1,178 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DSWAP
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DSWAP(N,DX,INCX,DY,INCY)
//
// .. Scalar Arguments ..
// INTEGER INCX,INCY,N
// ..
// .. Array Arguments ..
// DOUBLE PRECISION DX(*),DY(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DSWAP interchanges two vectors.
//> uses unrolled loops for increments equal to 1.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> number of elements in input vector(s)
//> \endverbatim
//>
//> \param[in,out] DX
//> \verbatim
//> DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> storage spacing between elements of DX
//> \endverbatim
//>
//> \param[in,out] DY
//> \verbatim
//> DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
//> \endverbatim
//>
//> \param[in] INCY
//> \verbatim
//> INCY is INTEGER
//> storage spacing between elements of DY
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date November 2017
//
//> \ingroup double_blas_level1
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> jack dongarra, linpack, 3/11/78.
//> modified 12/3/93, array(1) declarations changed to array(*)
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dswap_(int *n, double *dx, int *incx, double *dy, int *
incy)
{
// System generated locals
int i__1;
// Local variables
int i__, m, ix, iy, mp1;
double dtemp;
//
// -- Reference BLAS level1 routine (version 3.8.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// November 2017
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Local Scalars ..
// ..
// .. Intrinsic Functions ..
// ..
// Parameter adjustments
--dy;
--dx;
// Function Body
if (*n <= 0) {
return 0;
}
if (*incx == 1 && *incy == 1) {
//
// code for both increments equal to 1
//
//
// clean-up loop
//
m = *n % 3;
if (m != 0) {
i__1 = m;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp = dx[i__];
dx[i__] = dy[i__];
dy[i__] = dtemp;
}
if (*n < 3) {
return 0;
}
}
mp1 = m + 1;
i__1 = *n;
for (i__ = mp1; i__ <= i__1; i__ += 3) {
dtemp = dx[i__];
dx[i__] = dy[i__];
dy[i__] = dtemp;
dtemp = dx[i__ + 1];
dx[i__ + 1] = dy[i__ + 1];
dy[i__ + 1] = dtemp;
dtemp = dx[i__ + 2];
dx[i__ + 2] = dy[i__ + 2];
dy[i__ + 2] = dtemp;
}
} else {
//
// code for unequal increments or equal increments not equal
// to 1
//
ix = 1;
iy = 1;
if (*incx < 0) {
ix = (-(*n) + 1) * *incx + 1;
}
if (*incy < 0) {
iy = (-(*n) + 1) * *incy + 1;
}
i__1 = *n;
for (i__ = 1; i__ <= i__1; ++i__) {
dtemp = dx[ix];
dx[ix] = dy[iy];
dy[iy] = dtemp;
ix += *incx;
iy += *incy;
}
}
return 0;
} // dswap_

509
3rdparty/clapack/src/dtrmm.c vendored
View File

@@ -1,509 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DTRMM
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DTRMM(SIDE,UPLO,TRANSA,DIAG,M,N,ALPHA,A,LDA,B,LDB)
//
// .. Scalar Arguments ..
// DOUBLE PRECISION ALPHA
// INTEGER LDA,LDB,M,N
// CHARACTER DIAG,SIDE,TRANSA,UPLO
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A(LDA,*),B(LDB,*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DTRMM performs one of the matrix-matrix operations
//>
//> B := alpha*op( A )*B, or B := alpha*B*op( A ),
//>
//> where alpha is a scalar, B is an m by n matrix, A is a unit, or
//> non-unit, upper or lower triangular matrix and op( A ) is one of
//>
//> op( A ) = A or op( A ) = A**T.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] SIDE
//> \verbatim
//> SIDE is CHARACTER*1
//> On entry, SIDE specifies whether op( A ) multiplies B from
//> the left or right as follows:
//>
//> SIDE = 'L' or 'l' B := alpha*op( A )*B.
//>
//> SIDE = 'R' or 'r' B := alpha*B*op( A ).
//> \endverbatim
//>
//> \param[in] UPLO
//> \verbatim
//> UPLO is CHARACTER*1
//> On entry, UPLO specifies whether the matrix A is an upper or
//> lower triangular matrix as follows:
//>
//> UPLO = 'U' or 'u' A is an upper triangular matrix.
//>
//> UPLO = 'L' or 'l' A is a lower triangular matrix.
//> \endverbatim
//>
//> \param[in] TRANSA
//> \verbatim
//> TRANSA is CHARACTER*1
//> On entry, TRANSA specifies the form of op( A ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSA = 'N' or 'n' op( A ) = A.
//>
//> TRANSA = 'T' or 't' op( A ) = A**T.
//>
//> TRANSA = 'C' or 'c' op( A ) = A**T.
//> \endverbatim
//>
//> \param[in] DIAG
//> \verbatim
//> DIAG is CHARACTER*1
//> On entry, DIAG specifies whether or not A is unit triangular
//> as follows:
//>
//> DIAG = 'U' or 'u' A is assumed to be unit triangular.
//>
//> DIAG = 'N' or 'n' A is not assumed to be unit
//> triangular.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of B. M must be at
//> least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of B. N must be
//> at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is DOUBLE PRECISION.
//> On entry, ALPHA specifies the scalar alpha. When alpha is
//> zero then A is not referenced and B need not be set before
//> entry.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension ( LDA, k ), where k is m
//> when SIDE = 'L' or 'l' and is n when SIDE = 'R' or 'r'.
//> Before entry with UPLO = 'U' or 'u', the leading k by k
//> upper triangular part of the array A must contain the upper
//> triangular matrix and the strictly lower triangular part of
//> A is not referenced.
//> Before entry with UPLO = 'L' or 'l', the leading k by k
//> lower triangular part of the array A must contain the lower
//> triangular matrix and the strictly upper triangular part of
//> A is not referenced.
//> Note that when DIAG = 'U' or 'u', the diagonal elements of
//> A are not referenced either, but are assumed to be unity.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. When SIDE = 'L' or 'l' then
//> LDA must be at least max( 1, m ), when SIDE = 'R' or 'r'
//> then LDA must be at least max( 1, n ).
//> \endverbatim
//>
//> \param[in,out] B
//> \verbatim
//> B is DOUBLE PRECISION array, dimension ( LDB, N )
//> Before entry, the leading m by n part of the array B must
//> contain the matrix B, and on exit is overwritten by the
//> transformed matrix.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> On entry, LDB specifies the first dimension of B as declared
//> in the calling (sub) program. LDB must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup double_blas_level3
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 3 Blas routine.
//>
//> -- Written on 8-February-1989.
//> Jack Dongarra, Argonne National Laboratory.
//> Iain Duff, AERE Harwell.
//> Jeremy Du Croz, Numerical Algorithms Group Ltd.
//> Sven Hammarling, Numerical Algorithms Group Ltd.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dtrmm_(char *side, char *uplo, char *transa, char *diag,
int *m, int *n, double *alpha, double *a, int *lda, double *b, int *
ldb)
{
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, i__1, i__2, i__3;
// Local variables
int i__, j, k, info;
double temp;
int lside;
extern int lsame_(char *, char *);
int nrowa;
int upper;
extern /* Subroutine */ int xerbla_(char *, int *);
int nounit;
//
// -- Reference BLAS level3 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Local Scalars ..
// ..
// .. Parameters ..
// ..
//
// Test the input parameters.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
// Function Body
lside = lsame_(side, "L");
if (lside) {
nrowa = *m;
} else {
nrowa = *n;
}
nounit = lsame_(diag, "N");
upper = lsame_(uplo, "U");
info = 0;
if (! lside && ! lsame_(side, "R")) {
info = 1;
} else if (! upper && ! lsame_(uplo, "L")) {
info = 2;
} else if (! lsame_(transa, "N") && ! lsame_(transa, "T") && ! lsame_(
transa, "C")) {
info = 3;
} else if (! lsame_(diag, "U") && ! lsame_(diag, "N")) {
info = 4;
} else if (*m < 0) {
info = 5;
} else if (*n < 0) {
info = 6;
} else if (*lda < max(1,nrowa)) {
info = 9;
} else if (*ldb < max(1,*m)) {
info = 11;
}
if (info != 0) {
xerbla_("DTRMM ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0) {
return 0;
}
//
// And when alpha.eq.zero.
//
if (*alpha == 0.) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] = 0.;
// L10:
}
// L20:
}
return 0;
}
//
// Start the operations.
//
if (lside) {
if (lsame_(transa, "N")) {
//
// Form B := alpha*A*B.
//
if (upper) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (k = 1; k <= i__2; ++k) {
if (b[k + j * b_dim1] != 0.) {
temp = *alpha * b[k + j * b_dim1];
i__3 = k - 1;
for (i__ = 1; i__ <= i__3; ++i__) {
b[i__ + j * b_dim1] += temp * a[i__ + k *
a_dim1];
// L30:
}
if (nounit) {
temp *= a[k + k * a_dim1];
}
b[k + j * b_dim1] = temp;
}
// L40:
}
// L50:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
for (k = *m; k >= 1; --k) {
if (b[k + j * b_dim1] != 0.) {
temp = *alpha * b[k + j * b_dim1];
b[k + j * b_dim1] = temp;
if (nounit) {
b[k + j * b_dim1] *= a[k + k * a_dim1];
}
i__2 = *m;
for (i__ = k + 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] += temp * a[i__ + k *
a_dim1];
// L60:
}
}
// L70:
}
// L80:
}
}
} else {
//
// Form B := alpha*A**T*B.
//
if (upper) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
for (i__ = *m; i__ >= 1; --i__) {
temp = b[i__ + j * b_dim1];
if (nounit) {
temp *= a[i__ + i__ * a_dim1];
}
i__2 = i__ - 1;
for (k = 1; k <= i__2; ++k) {
temp += a[k + i__ * a_dim1] * b[k + j * b_dim1];
// L90:
}
b[i__ + j * b_dim1] = *alpha * temp;
// L100:
}
// L110:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = b[i__ + j * b_dim1];
if (nounit) {
temp *= a[i__ + i__ * a_dim1];
}
i__3 = *m;
for (k = i__ + 1; k <= i__3; ++k) {
temp += a[k + i__ * a_dim1] * b[k + j * b_dim1];
// L120:
}
b[i__ + j * b_dim1] = *alpha * temp;
// L130:
}
// L140:
}
}
}
} else {
if (lsame_(transa, "N")) {
//
// Form B := alpha*B*A.
//
if (upper) {
for (j = *n; j >= 1; --j) {
temp = *alpha;
if (nounit) {
temp *= a[j + j * a_dim1];
}
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
// L150:
}
i__1 = j - 1;
for (k = 1; k <= i__1; ++k) {
if (a[k + j * a_dim1] != 0.) {
temp = *alpha * a[k + j * a_dim1];
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] += temp * b[i__ + k *
b_dim1];
// L160:
}
}
// L170:
}
// L180:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = *alpha;
if (nounit) {
temp *= a[j + j * a_dim1];
}
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] = temp * b[i__ + j * b_dim1];
// L190:
}
i__2 = *n;
for (k = j + 1; k <= i__2; ++k) {
if (a[k + j * a_dim1] != 0.) {
temp = *alpha * a[k + j * a_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
b[i__ + j * b_dim1] += temp * b[i__ + k *
b_dim1];
// L200:
}
}
// L210:
}
// L220:
}
}
} else {
//
// Form B := alpha*B*A**T.
//
if (upper) {
i__1 = *n;
for (k = 1; k <= i__1; ++k) {
i__2 = k - 1;
for (j = 1; j <= i__2; ++j) {
if (a[j + k * a_dim1] != 0.) {
temp = *alpha * a[j + k * a_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
b[i__ + j * b_dim1] += temp * b[i__ + k *
b_dim1];
// L230:
}
}
// L240:
}
temp = *alpha;
if (nounit) {
temp *= a[k + k * a_dim1];
}
if (temp != 1.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
// L250:
}
}
// L260:
}
} else {
for (k = *n; k >= 1; --k) {
i__1 = *n;
for (j = k + 1; j <= i__1; ++j) {
if (a[j + k * a_dim1] != 0.) {
temp = *alpha * a[j + k * a_dim1];
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
b[i__ + j * b_dim1] += temp * b[i__ + k *
b_dim1];
// L270:
}
}
// L280:
}
temp = *alpha;
if (nounit) {
temp *= a[k + k * a_dim1];
}
if (temp != 1.) {
i__1 = *m;
for (i__ = 1; i__ <= i__1; ++i__) {
b[i__ + k * b_dim1] = temp * b[i__ + k * b_dim1];
// L290:
}
}
// L300:
}
}
}
}
return 0;
//
// End of DTRMM .
//
} // dtrmm_

396
3rdparty/clapack/src/dtrmv.c vendored
View File

@@ -1,396 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b DTRMV
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE DTRMV(UPLO,TRANS,DIAG,N,A,LDA,X,INCX)
//
// .. Scalar Arguments ..
// INTEGER INCX,LDA,N
// CHARACTER DIAG,TRANS,UPLO
// ..
// .. Array Arguments ..
// DOUBLE PRECISION A(LDA,*),X(*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> DTRMV performs one of the matrix-vector operations
//>
//> x := A*x, or x := A**T*x,
//>
//> where x is an n element vector and A is an n by n unit, or non-unit,
//> upper or lower triangular matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] UPLO
//> \verbatim
//> UPLO is CHARACTER*1
//> On entry, UPLO specifies whether the matrix is an upper or
//> lower triangular matrix as follows:
//>
//> UPLO = 'U' or 'u' A is an upper triangular matrix.
//>
//> UPLO = 'L' or 'l' A is a lower triangular matrix.
//> \endverbatim
//>
//> \param[in] TRANS
//> \verbatim
//> TRANS is CHARACTER*1
//> On entry, TRANS specifies the operation to be performed as
//> follows:
//>
//> TRANS = 'N' or 'n' x := A*x.
//>
//> TRANS = 'T' or 't' x := A**T*x.
//>
//> TRANS = 'C' or 'c' x := A**T*x.
//> \endverbatim
//>
//> \param[in] DIAG
//> \verbatim
//> DIAG is CHARACTER*1
//> On entry, DIAG specifies whether or not A is unit
//> triangular as follows:
//>
//> DIAG = 'U' or 'u' A is assumed to be unit triangular.
//>
//> DIAG = 'N' or 'n' A is not assumed to be unit
//> triangular.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the order of the matrix A.
//> N must be at least zero.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is DOUBLE PRECISION array, dimension ( LDA, N )
//> Before entry with UPLO = 'U' or 'u', the leading n by n
//> upper triangular part of the array A must contain the upper
//> triangular matrix and the strictly lower triangular part of
//> A is not referenced.
//> Before entry with UPLO = 'L' or 'l', the leading n by n
//> lower triangular part of the array A must contain the lower
//> triangular matrix and the strictly upper triangular part of
//> A is not referenced.
//> Note that when DIAG = 'U' or 'u', the diagonal elements of
//> A are not referenced either, but are assumed to be unity.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. LDA must be at least
//> max( 1, n ).
//> \endverbatim
//>
//> \param[in,out] X
//> \verbatim
//> X is DOUBLE PRECISION array, dimension at least
//> ( 1 + ( n - 1 )*abs( INCX ) ).
//> Before entry, the incremented array X must contain the n
//> element vector x. On exit, X is overwritten with the
//> transformed vector x.
//> \endverbatim
//>
//> \param[in] INCX
//> \verbatim
//> INCX is INTEGER
//> On entry, INCX specifies the increment for the elements of
//> X. INCX must not be zero.
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup double_blas_level2
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 2 Blas routine.
//> The vector and matrix arguments are not referenced when N = 0, or M = 0
//>
//> -- Written on 22-October-1986.
//> Jack Dongarra, Argonne National Lab.
//> Jeremy Du Croz, Nag Central Office.
//> Sven Hammarling, Nag Central Office.
//> Richard Hanson, Sandia National Labs.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int dtrmv_(char *uplo, char *trans, char *diag, int *n,
double *a, int *lda, double *x, int *incx)
{
// System generated locals
int a_dim1, a_offset, i__1, i__2;
// Local variables
int i__, j, ix, jx, kx, info;
double temp;
extern int lsame_(char *, char *);
extern /* Subroutine */ int xerbla_(char *, int *);
int nounit;
//
// -- Reference BLAS level2 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. Parameters ..
// ..
// .. Local Scalars ..
// ..
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
//
// Test the input parameters.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
--x;
// Function Body
info = 0;
if (! lsame_(uplo, "U") && ! lsame_(uplo, "L")) {
info = 1;
} else if (! lsame_(trans, "N") && ! lsame_(trans, "T") && ! lsame_(trans,
"C")) {
info = 2;
} else if (! lsame_(diag, "U") && ! lsame_(diag, "N")) {
info = 3;
} else if (*n < 0) {
info = 4;
} else if (*lda < max(1,*n)) {
info = 6;
} else if (*incx == 0) {
info = 8;
}
if (info != 0) {
xerbla_("DTRMV ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*n == 0) {
return 0;
}
nounit = lsame_(diag, "N");
//
// Set up the start point in X if the increment is not unity. This
// will be ( N - 1 )*INCX too small for descending loops.
//
if (*incx <= 0) {
kx = 1 - (*n - 1) * *incx;
} else if (*incx != 1) {
kx = 1;
}
//
// Start the operations. In this version the elements of A are
// accessed sequentially with one pass through A.
//
if (lsame_(trans, "N")) {
//
// Form x := A*x.
//
if (lsame_(uplo, "U")) {
if (*incx == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (x[j] != 0.) {
temp = x[j];
i__2 = j - 1;
for (i__ = 1; i__ <= i__2; ++i__) {
x[i__] += temp * a[i__ + j * a_dim1];
// L10:
}
if (nounit) {
x[j] *= a[j + j * a_dim1];
}
}
// L20:
}
} else {
jx = kx;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (x[jx] != 0.) {
temp = x[jx];
ix = kx;
i__2 = j - 1;
for (i__ = 1; i__ <= i__2; ++i__) {
x[ix] += temp * a[i__ + j * a_dim1];
ix += *incx;
// L30:
}
if (nounit) {
x[jx] *= a[j + j * a_dim1];
}
}
jx += *incx;
// L40:
}
}
} else {
if (*incx == 1) {
for (j = *n; j >= 1; --j) {
if (x[j] != 0.) {
temp = x[j];
i__1 = j + 1;
for (i__ = *n; i__ >= i__1; --i__) {
x[i__] += temp * a[i__ + j * a_dim1];
// L50:
}
if (nounit) {
x[j] *= a[j + j * a_dim1];
}
}
// L60:
}
} else {
kx += (*n - 1) * *incx;
jx = kx;
for (j = *n; j >= 1; --j) {
if (x[jx] != 0.) {
temp = x[jx];
ix = kx;
i__1 = j + 1;
for (i__ = *n; i__ >= i__1; --i__) {
x[ix] += temp * a[i__ + j * a_dim1];
ix -= *incx;
// L70:
}
if (nounit) {
x[jx] *= a[j + j * a_dim1];
}
}
jx -= *incx;
// L80:
}
}
}
} else {
//
// Form x := A**T*x.
//
if (lsame_(uplo, "U")) {
if (*incx == 1) {
for (j = *n; j >= 1; --j) {
temp = x[j];
if (nounit) {
temp *= a[j + j * a_dim1];
}
for (i__ = j - 1; i__ >= 1; --i__) {
temp += a[i__ + j * a_dim1] * x[i__];
// L90:
}
x[j] = temp;
// L100:
}
} else {
jx = kx + (*n - 1) * *incx;
for (j = *n; j >= 1; --j) {
temp = x[jx];
ix = jx;
if (nounit) {
temp *= a[j + j * a_dim1];
}
for (i__ = j - 1; i__ >= 1; --i__) {
ix -= *incx;
temp += a[i__ + j * a_dim1] * x[ix];
// L110:
}
x[jx] = temp;
jx -= *incx;
// L120:
}
}
} else {
if (*incx == 1) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = x[j];
if (nounit) {
temp *= a[j + j * a_dim1];
}
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
temp += a[i__ + j * a_dim1] * x[i__];
// L130:
}
x[j] = temp;
// L140:
}
} else {
jx = kx;
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
temp = x[jx];
ix = jx;
if (nounit) {
temp *= a[j + j * a_dim1];
}
i__2 = *n;
for (i__ = j + 1; i__ <= i__2; ++i__) {
ix += *incx;
temp += a[i__ + j * a_dim1] * x[ix];
// L150:
}
x[jx] = temp;
jx += *incx;
// L160:
}
}
}
}
return 0;
//
// End of DTRMV .
//
} // dtrmv_

1334
3rdparty/clapack/src/ilaenv.c vendored
View File

File diff suppressed because it is too large Load Diff

444
3rdparty/clapack/src/sgemm.c vendored
View File

@@ -1,444 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b SGEMM
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE SGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
//
// .. Scalar Arguments ..
// REAL ALPHA,BETA
// INTEGER K,LDA,LDB,LDC,M,N
// CHARACTER TRANSA,TRANSB
// ..
// .. Array Arguments ..
// REAL A(LDA,*),B(LDB,*),C(LDC,*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> SGEMM performs one of the matrix-matrix operations
//>
//> C := alpha*op( A )*op( B ) + beta*C,
//>
//> where op( X ) is one of
//>
//> op( X ) = X or op( X ) = X**T,
//>
//> alpha and beta are scalars, and A, B and C are matrices, with op( A )
//> an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TRANSA
//> \verbatim
//> TRANSA is CHARACTER*1
//> On entry, TRANSA specifies the form of op( A ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSA = 'N' or 'n', op( A ) = A.
//>
//> TRANSA = 'T' or 't', op( A ) = A**T.
//>
//> TRANSA = 'C' or 'c', op( A ) = A**T.
//> \endverbatim
//>
//> \param[in] TRANSB
//> \verbatim
//> TRANSB is CHARACTER*1
//> On entry, TRANSB specifies the form of op( B ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSB = 'N' or 'n', op( B ) = B.
//>
//> TRANSB = 'T' or 't', op( B ) = B**T.
//>
//> TRANSB = 'C' or 'c', op( B ) = B**T.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix
//> op( A ) and of the matrix C. M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix
//> op( B ) and the number of columns of the matrix C. N must be
//> at least zero.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> On entry, K specifies the number of columns of the matrix
//> op( A ) and the number of rows of the matrix op( B ). K must
//> be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is REAL
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is REAL array, dimension ( LDA, ka ), where ka is
//> k when TRANSA = 'N' or 'n', and is m otherwise.
//> Before entry with TRANSA = 'N' or 'n', the leading m by k
//> part of the array A must contain the matrix A, otherwise
//> the leading k by m part of the array A must contain the
//> matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. When TRANSA = 'N' or 'n' then
//> LDA must be at least max( 1, m ), otherwise LDA must be at
//> least max( 1, k ).
//> \endverbatim
//>
//> \param[in] B
//> \verbatim
//> B is REAL array, dimension ( LDB, kb ), where kb is
//> n when TRANSB = 'N' or 'n', and is k otherwise.
//> Before entry with TRANSB = 'N' or 'n', the leading k by n
//> part of the array B must contain the matrix B, otherwise
//> the leading n by k part of the array B must contain the
//> matrix B.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> On entry, LDB specifies the first dimension of B as declared
//> in the calling (sub) program. When TRANSB = 'N' or 'n' then
//> LDB must be at least max( 1, k ), otherwise LDB must be at
//> least max( 1, n ).
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is REAL
//> On entry, BETA specifies the scalar beta. When BETA is
//> supplied as zero then C need not be set on input.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is REAL array, dimension ( LDC, N )
//> Before entry, the leading m by n part of the array C must
//> contain the matrix C, except when beta is zero, in which
//> case C need not be set on entry.
//> On exit, the array C is overwritten by the m by n matrix
//> ( alpha*op( A )*op( B ) + beta*C ).
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> On entry, LDC specifies the first dimension of C as declared
//> in the calling (sub) program. LDC must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup single_blas_level3
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 3 Blas routine.
//>
//> -- Written on 8-February-1989.
//> Jack Dongarra, Argonne National Laboratory.
//> Iain Duff, AERE Harwell.
//> Jeremy Du Croz, Numerical Algorithms Group Ltd.
//> Sven Hammarling, Numerical Algorithms Group Ltd.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int sgemm_(char *transa, char *transb, int *m, int *n, int *
k, float *alpha, float *a, int *lda, float *b, int *ldb, float *beta,
float *c__, int *ldc)
{
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2,
i__3;
// Local variables
int i__, j, l, info;
int nota, notb;
float temp;
int ncola;
extern int lsame_(char *, char *);
int nrowa, nrowb;
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level3 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Local Scalars ..
// ..
// .. Parameters ..
// ..
//
// Set NOTA and NOTB as true if A and B respectively are not
// transposed and set NROWA, NCOLA and NROWB as the number of rows
// and columns of A and the number of rows of B respectively.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
// Function Body
nota = lsame_(transa, "N");
notb = lsame_(transb, "N");
if (nota) {
nrowa = *m;
ncola = *k;
} else {
nrowa = *k;
ncola = *m;
}
if (notb) {
nrowb = *k;
} else {
nrowb = *n;
}
//
// Test the input parameters.
//
info = 0;
if (! nota && ! lsame_(transa, "C") && ! lsame_(transa, "T")) {
info = 1;
} else if (! notb && ! lsame_(transb, "C") && ! lsame_(transb, "T")) {
info = 2;
} else if (*m < 0) {
info = 3;
} else if (*n < 0) {
info = 4;
} else if (*k < 0) {
info = 5;
} else if (*lda < max(1,nrowa)) {
info = 8;
} else if (*ldb < max(1,nrowb)) {
info = 10;
} else if (*ldc < max(1,*m)) {
info = 13;
}
if (info != 0) {
xerbla_("SGEMM ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || (*alpha == 0.f || *k == 0) && *beta == 1.f) {
return 0;
}
//
// And if alpha.eq.zero.
//
if (*alpha == 0.f) {
if (*beta == 0.f) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.f;
// L10:
}
// L20:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L30:
}
// L40:
}
}
return 0;
}
//
// Start the operations.
//
if (notb) {
if (nota) {
//
// Form C := alpha*A*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (*beta == 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.f;
// L50:
}
} else if (*beta != 1.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L60:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
temp = *alpha * b[l + j * b_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
// L70:
}
// L80:
}
// L90:
}
} else {
//
// Form C := alpha*A**T*B + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
temp += a[l + i__ * a_dim1] * b[l + j * b_dim1];
// L100:
}
if (*beta == 0.f) {
c__[i__ + j * c_dim1] = *alpha * temp;
} else {
c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
i__ + j * c_dim1];
}
// L110:
}
// L120:
}
}
} else {
if (nota) {
//
// Form C := alpha*A*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (*beta == 0.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = 0.f;
// L130:
}
} else if (*beta != 1.f) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
c__[i__ + j * c_dim1] = *beta * c__[i__ + j * c_dim1];
// L140:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
temp = *alpha * b[j + l * b_dim1];
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
c__[i__ + j * c_dim1] += temp * a[i__ + l * a_dim1];
// L150:
}
// L160:
}
// L170:
}
} else {
//
// Form C := alpha*A**T*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp = 0.f;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
temp += a[l + i__ * a_dim1] * b[j + l * b_dim1];
// L180:
}
if (*beta == 0.f) {
c__[i__ + j * c_dim1] = *alpha * temp;
} else {
c__[i__ + j * c_dim1] = *alpha * temp + *beta * c__[
i__ + j * c_dim1];
}
// L190:
}
// L200:
}
}
}
return 0;
//
// End of SGEMM .
//
} // sgemm_

752
3rdparty/clapack/src/zgemm.c vendored
View File

@@ -1,752 +0,0 @@
/* -- translated by f2c (version 20201020 (for_lapack)). -- */
#include "f2c.h"
//> \brief \b ZGEMM
//
// =========== DOCUMENTATION ===========
//
// Online html documentation available at
// http://www.netlib.org/lapack/explore-html/
//
// Definition:
// ===========
//
// SUBROUTINE ZGEMM(TRANSA,TRANSB,M,N,K,ALPHA,A,LDA,B,LDB,BETA,C,LDC)
//
// .. Scalar Arguments ..
// COMPLEX*16 ALPHA,BETA
// INTEGER K,LDA,LDB,LDC,M,N
// CHARACTER TRANSA,TRANSB
// ..
// .. Array Arguments ..
// COMPLEX*16 A(LDA,*),B(LDB,*),C(LDC,*)
// ..
//
//
//> \par Purpose:
// =============
//>
//> \verbatim
//>
//> ZGEMM performs one of the matrix-matrix operations
//>
//> C := alpha*op( A )*op( B ) + beta*C,
//>
//> where op( X ) is one of
//>
//> op( X ) = X or op( X ) = X**T or op( X ) = X**H,
//>
//> alpha and beta are scalars, and A, B and C are matrices, with op( A )
//> an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
//> \endverbatim
//
// Arguments:
// ==========
//
//> \param[in] TRANSA
//> \verbatim
//> TRANSA is CHARACTER*1
//> On entry, TRANSA specifies the form of op( A ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSA = 'N' or 'n', op( A ) = A.
//>
//> TRANSA = 'T' or 't', op( A ) = A**T.
//>
//> TRANSA = 'C' or 'c', op( A ) = A**H.
//> \endverbatim
//>
//> \param[in] TRANSB
//> \verbatim
//> TRANSB is CHARACTER*1
//> On entry, TRANSB specifies the form of op( B ) to be used in
//> the matrix multiplication as follows:
//>
//> TRANSB = 'N' or 'n', op( B ) = B.
//>
//> TRANSB = 'T' or 't', op( B ) = B**T.
//>
//> TRANSB = 'C' or 'c', op( B ) = B**H.
//> \endverbatim
//>
//> \param[in] M
//> \verbatim
//> M is INTEGER
//> On entry, M specifies the number of rows of the matrix
//> op( A ) and of the matrix C. M must be at least zero.
//> \endverbatim
//>
//> \param[in] N
//> \verbatim
//> N is INTEGER
//> On entry, N specifies the number of columns of the matrix
//> op( B ) and the number of columns of the matrix C. N must be
//> at least zero.
//> \endverbatim
//>
//> \param[in] K
//> \verbatim
//> K is INTEGER
//> On entry, K specifies the number of columns of the matrix
//> op( A ) and the number of rows of the matrix op( B ). K must
//> be at least zero.
//> \endverbatim
//>
//> \param[in] ALPHA
//> \verbatim
//> ALPHA is COMPLEX*16
//> On entry, ALPHA specifies the scalar alpha.
//> \endverbatim
//>
//> \param[in] A
//> \verbatim
//> A is COMPLEX*16 array, dimension ( LDA, ka ), where ka is
//> k when TRANSA = 'N' or 'n', and is m otherwise.
//> Before entry with TRANSA = 'N' or 'n', the leading m by k
//> part of the array A must contain the matrix A, otherwise
//> the leading k by m part of the array A must contain the
//> matrix A.
//> \endverbatim
//>
//> \param[in] LDA
//> \verbatim
//> LDA is INTEGER
//> On entry, LDA specifies the first dimension of A as declared
//> in the calling (sub) program. When TRANSA = 'N' or 'n' then
//> LDA must be at least max( 1, m ), otherwise LDA must be at
//> least max( 1, k ).
//> \endverbatim
//>
//> \param[in] B
//> \verbatim
//> B is COMPLEX*16 array, dimension ( LDB, kb ), where kb is
//> n when TRANSB = 'N' or 'n', and is k otherwise.
//> Before entry with TRANSB = 'N' or 'n', the leading k by n
//> part of the array B must contain the matrix B, otherwise
//> the leading n by k part of the array B must contain the
//> matrix B.
//> \endverbatim
//>
//> \param[in] LDB
//> \verbatim
//> LDB is INTEGER
//> On entry, LDB specifies the first dimension of B as declared
//> in the calling (sub) program. When TRANSB = 'N' or 'n' then
//> LDB must be at least max( 1, k ), otherwise LDB must be at
//> least max( 1, n ).
//> \endverbatim
//>
//> \param[in] BETA
//> \verbatim
//> BETA is COMPLEX*16
//> On entry, BETA specifies the scalar beta. When BETA is
//> supplied as zero then C need not be set on input.
//> \endverbatim
//>
//> \param[in,out] C
//> \verbatim
//> C is COMPLEX*16 array, dimension ( LDC, N )
//> Before entry, the leading m by n part of the array C must
//> contain the matrix C, except when beta is zero, in which
//> case C need not be set on entry.
//> On exit, the array C is overwritten by the m by n matrix
//> ( alpha*op( A )*op( B ) + beta*C ).
//> \endverbatim
//>
//> \param[in] LDC
//> \verbatim
//> LDC is INTEGER
//> On entry, LDC specifies the first dimension of C as declared
//> in the calling (sub) program. LDC must be at least
//> max( 1, m ).
//> \endverbatim
//
// Authors:
// ========
//
//> \author Univ. of Tennessee
//> \author Univ. of California Berkeley
//> \author Univ. of Colorado Denver
//> \author NAG Ltd.
//
//> \date December 2016
//
//> \ingroup complex16_blas_level3
//
//> \par Further Details:
// =====================
//>
//> \verbatim
//>
//> Level 3 Blas routine.
//>
//> -- Written on 8-February-1989.
//> Jack Dongarra, Argonne National Laboratory.
//> Iain Duff, AERE Harwell.
//> Jeremy Du Croz, Numerical Algorithms Group Ltd.
//> Sven Hammarling, Numerical Algorithms Group Ltd.
//> \endverbatim
//>
// =====================================================================
/* Subroutine */ int zgemm_(char *transa, char *transb, int *m, int *n, int *
k, doublecomplex *alpha, doublecomplex *a, int *lda, doublecomplex *b,
int *ldb, doublecomplex *beta, doublecomplex *c__, int *ldc)
{
// Table of constant values
doublecomplex c_b1 = {1.,0.};
doublecomplex c_b2 = {0.,0.};
// System generated locals
int a_dim1, a_offset, b_dim1, b_offset, c_dim1, c_offset, i__1, i__2,
i__3, i__4, i__5, i__6;
doublecomplex z__1, z__2, z__3, z__4;
// Local variables
int i__, j, l, info;
int nota, notb;
doublecomplex temp;
int conja, conjb;
int ncola;
extern int lsame_(char *, char *);
int nrowa, nrowb;
extern /* Subroutine */ int xerbla_(char *, int *);
//
// -- Reference BLAS level3 routine (version 3.7.0) --
// -- Reference BLAS is a software package provided by Univ. of Tennessee, --
// -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
// December 2016
//
// .. Scalar Arguments ..
// ..
// .. Array Arguments ..
// ..
//
// =====================================================================
//
// .. External Functions ..
// ..
// .. External Subroutines ..
// ..
// .. Intrinsic Functions ..
// ..
// .. Local Scalars ..
// ..
// .. Parameters ..
// ..
//
// Set NOTA and NOTB as true if A and B respectively are not
// conjugated or transposed, set CONJA and CONJB as true if A and
// B respectively are to be transposed but not conjugated and set
// NROWA, NCOLA and NROWB as the number of rows and columns of A
// and the number of rows of B respectively.
//
// Parameter adjustments
a_dim1 = *lda;
a_offset = 1 + a_dim1;
a -= a_offset;
b_dim1 = *ldb;
b_offset = 1 + b_dim1;
b -= b_offset;
c_dim1 = *ldc;
c_offset = 1 + c_dim1;
c__ -= c_offset;
// Function Body
nota = lsame_(transa, "N");
notb = lsame_(transb, "N");
conja = lsame_(transa, "C");
conjb = lsame_(transb, "C");
if (nota) {
nrowa = *m;
ncola = *k;
} else {
nrowa = *k;
ncola = *m;
}
if (notb) {
nrowb = *k;
} else {
nrowb = *n;
}
//
// Test the input parameters.
//
info = 0;
if (! nota && ! conja && ! lsame_(transa, "T")) {
info = 1;
} else if (! notb && ! conjb && ! lsame_(transb, "T")) {
info = 2;
} else if (*m < 0) {
info = 3;
} else if (*n < 0) {
info = 4;
} else if (*k < 0) {
info = 5;
} else if (*lda < max(1,nrowa)) {
info = 8;
} else if (*ldb < max(1,nrowb)) {
info = 10;
} else if (*ldc < max(1,*m)) {
info = 13;
}
if (info != 0) {
xerbla_("ZGEMM ", &info);
return 0;
}
//
// Quick return if possible.
//
if (*m == 0 || *n == 0 || (alpha->r == 0. && alpha->i == 0. || *k == 0) &&
(beta->r == 1. && beta->i == 0.)) {
return 0;
}
//
// And when alpha.eq.zero.
//
if (alpha->r == 0. && alpha->i == 0.) {
if (beta->r == 0. && beta->i == 0.) {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0., c__[i__3].i = 0.;
// L10:
}
// L20:
}
} else {
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
z__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4].i,
z__1.i = beta->r * c__[i__4].i + beta->i * c__[
i__4].r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
// L30:
}
// L40:
}
}
return 0;
}
//
// Start the operations.
//
if (notb) {
if (nota) {
//
// Form C := alpha*A*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0. && beta->i == 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0., c__[i__3].i = 0.;
// L50:
}
} else if (beta->r != 1. || beta->i != 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
z__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
// L60:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
i__3 = l + j * b_dim1;
z__1.r = alpha->r * b[i__3].r - alpha->i * b[i__3].i,
z__1.i = alpha->r * b[i__3].i + alpha->i * b[i__3]
.r;
temp.r = z__1.r, temp.i = z__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
z__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
z__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
z__1.r = c__[i__5].r + z__2.r, z__1.i = c__[i__5].i +
z__2.i;
c__[i__4].r = z__1.r, c__[i__4].i = z__1.i;
// L70:
}
// L80:
}
// L90:
}
} else if (conja) {
//
// Form C := alpha*A**H*B + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
d_cnjg(&z__3, &a[l + i__ * a_dim1]);
i__4 = l + j * b_dim1;
z__2.r = z__3.r * b[i__4].r - z__3.i * b[i__4].i,
z__2.i = z__3.r * b[i__4].i + z__3.i * b[i__4]
.r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L100:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L110:
}
// L120:
}
} else {
//
// Form C := alpha*A**T*B + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
i__5 = l + j * b_dim1;
z__2.r = a[i__4].r * b[i__5].r - a[i__4].i * b[i__5]
.i, z__2.i = a[i__4].r * b[i__5].i + a[i__4]
.i * b[i__5].r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L130:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L140:
}
// L150:
}
}
} else if (nota) {
if (conjb) {
//
// Form C := alpha*A*B**H + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0. && beta->i == 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0., c__[i__3].i = 0.;
// L160:
}
} else if (beta->r != 1. || beta->i != 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
z__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
// L170:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
d_cnjg(&z__2, &b[j + l * b_dim1]);
z__1.r = alpha->r * z__2.r - alpha->i * z__2.i, z__1.i =
alpha->r * z__2.i + alpha->i * z__2.r;
temp.r = z__1.r, temp.i = z__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
z__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
z__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
z__1.r = c__[i__5].r + z__2.r, z__1.i = c__[i__5].i +
z__2.i;
c__[i__4].r = z__1.r, c__[i__4].i = z__1.i;
// L180:
}
// L190:
}
// L200:
}
} else {
//
// Form C := alpha*A*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
if (beta->r == 0. && beta->i == 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
c__[i__3].r = 0., c__[i__3].i = 0.;
// L210:
}
} else if (beta->r != 1. || beta->i != 0.) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
i__3 = i__ + j * c_dim1;
i__4 = i__ + j * c_dim1;
z__1.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__1.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
// L220:
}
}
i__2 = *k;
for (l = 1; l <= i__2; ++l) {
i__3 = j + l * b_dim1;
z__1.r = alpha->r * b[i__3].r - alpha->i * b[i__3].i,
z__1.i = alpha->r * b[i__3].i + alpha->i * b[i__3]
.r;
temp.r = z__1.r, temp.i = z__1.i;
i__3 = *m;
for (i__ = 1; i__ <= i__3; ++i__) {
i__4 = i__ + j * c_dim1;
i__5 = i__ + j * c_dim1;
i__6 = i__ + l * a_dim1;
z__2.r = temp.r * a[i__6].r - temp.i * a[i__6].i,
z__2.i = temp.r * a[i__6].i + temp.i * a[i__6]
.r;
z__1.r = c__[i__5].r + z__2.r, z__1.i = c__[i__5].i +
z__2.i;
c__[i__4].r = z__1.r, c__[i__4].i = z__1.i;
// L230:
}
// L240:
}
// L250:
}
}
} else if (conja) {
if (conjb) {
//
// Form C := alpha*A**H*B**H + beta*C.
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
d_cnjg(&z__3, &a[l + i__ * a_dim1]);
d_cnjg(&z__4, &b[j + l * b_dim1]);
z__2.r = z__3.r * z__4.r - z__3.i * z__4.i, z__2.i =
z__3.r * z__4.i + z__3.i * z__4.r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L260:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L270:
}
// L280:
}
} else {
//
// Form C := alpha*A**H*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
d_cnjg(&z__3, &a[l + i__ * a_dim1]);
i__4 = j + l * b_dim1;
z__2.r = z__3.r * b[i__4].r - z__3.i * b[i__4].i,
z__2.i = z__3.r * b[i__4].i + z__3.i * b[i__4]
.r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L290:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L300:
}
// L310:
}
}
} else {
if (conjb) {
//
// Form C := alpha*A**T*B**H + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
d_cnjg(&z__3, &b[j + l * b_dim1]);
z__2.r = a[i__4].r * z__3.r - a[i__4].i * z__3.i,
z__2.i = a[i__4].r * z__3.i + a[i__4].i *
z__3.r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L320:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L330:
}
// L340:
}
} else {
//
// Form C := alpha*A**T*B**T + beta*C
//
i__1 = *n;
for (j = 1; j <= i__1; ++j) {
i__2 = *m;
for (i__ = 1; i__ <= i__2; ++i__) {
temp.r = 0., temp.i = 0.;
i__3 = *k;
for (l = 1; l <= i__3; ++l) {
i__4 = l + i__ * a_dim1;
i__5 = j + l * b_dim1;
z__2.r = a[i__4].r * b[i__5].r - a[i__4].i * b[i__5]
.i, z__2.i = a[i__4].r * b[i__5].i + a[i__4]
.i * b[i__5].r;
z__1.r = temp.r + z__2.r, z__1.i = temp.i + z__2.i;
temp.r = z__1.r, temp.i = z__1.i;
// L350:
}
if (beta->r == 0. && beta->i == 0.) {
i__3 = i__ + j * c_dim1;
z__1.r = alpha->r * temp.r - alpha->i * temp.i,
z__1.i = alpha->r * temp.i + alpha->i *
temp.r;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
} else {
i__3 = i__ + j * c_dim1;
z__2.r = alpha->r * temp.r - alpha->i * temp.i,
z__2.i = alpha->r * temp.i + alpha->i *
temp.r;
i__4 = i__ + j * c_dim1;
z__3.r = beta->r * c__[i__4].r - beta->i * c__[i__4]
.i, z__3.i = beta->r * c__[i__4].i + beta->i *
c__[i__4].r;
z__1.r = z__2.r + z__3.r, z__1.i = z__2.i + z__3.i;
c__[i__3].r = z__1.r, c__[i__3].i = z__1.i;
}
// L360:
}
// L370:
}
}
}
return 0;
//
// End of ZGEMM .
//
} // zgemm_

12
3rdparty/ffmpeg/ffmpeg.cmake vendored
View File

@@ -1,9 +1,9 @@
# Binaries branch name: ffmpeg/5.x_20261026
# Binaries were created for OpenCV: f7ca3a382a311db3a14f956698bb2520bd2d96de
ocv_update(FFMPEG_BINARIES_COMMIT "11bef4e1575a7f3c1577e726c1d7845ea02bce45")
ocv_update(FFMPEG_FILE_HASH_BIN32 "a927745d1cedad91e91aca4788af0e26")
ocv_update(FFMPEG_FILE_HASH_BIN64 "0b9cf6e88c8b554cccbf03653c0cccc2")
ocv_update(FFMPEG_FILE_HASH_CMAKE "b39b4f1cc54dd9723007b7a7abe4273e")
# Binaries branch name: ffmpeg/4.x_20260715
# Binaries were created for OpenCV: 6b640b424c516d27217700392a7ed6a362e040a5
ocv_update(FFMPEG_BINARIES_COMMIT "bd9418020a5c342be979c56d6e6434261959d3af")
ocv_update(FFMPEG_FILE_HASH_BIN32 "31968b434799d3dd56969b15aac3efa8")
ocv_update(FFMPEG_FILE_HASH_BIN64 "84757ed0f16ddedce99227529d3165e9")
ocv_update(FFMPEG_FILE_HASH_CMAKE "e09efc33312d1173be8a9446f3b088fe")
function(download_win_ffmpeg script_var)
set(${script_var} "" PARENT_SCOPE)

79
3rdparty/harfbuzz/CMakeLists.txt vendored
View File

@@ -1,79 +0,0 @@
# ----------------------------------------------------------------------------
# CMake file for the bundled HarfBuzz text-shaping library. See root CMakeLists.txt
#
# OpenCV vendors a minimal subset of HarfBuzz (core + HB_HAS_RASTER) as a
# normal static library: each .cc is a separate translation unit. The subset
# is produced by hb_extract.py (see that script to update HarfBuzz).
# ----------------------------------------------------------------------------
project(${HARFBUZZ_LIBRARY} CXX)
ocv_include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src")
# Every .cc copied by hb_extract.py is a real translation unit (the script
# never copies non-TU .cc files), so a plain recursive glob is exactly right.
file(GLOB_RECURSE lib_srcs src/*.cc)
file(GLOB_RECURSE lib_hdrs src/*.h src/*.hh)
# HarfBuzz is built with HB_TINY for minimum footprint. Because we request the
# software rasterizer (HB_HAS_RASTER, defined below), HB_TINY does NOT disable
# the draw/paint/color APIs nor CFF (PostScript/.otf
# outlines) -- see hb-config.hh: HB_NO_DRAW/COLOR/PAINT and the TINY->HB_NO_CFF
# rule only trigger when no HB_HAS_* backend is requested. So CFF (CJK/Indic),
# COLR/CPAL color and our rasterizer all survive HB_TINY.
#
# Two features HB_TINY (via HB_LEAN) would otherwise drop are restored through
# HarfBuzz's config-override hook (hb-opencv-config.hh): thread-safety (HB_NO_MT)
# and variable fonts (HB_NO_VAR). No platform backends (CoreText/DirectWrite/...).
add_library(${HARFBUZZ_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${lib_srcs} ${lib_hdrs})
target_compile_definitions(${HARFBUZZ_LIBRARY} PRIVATE
HB_TINY
HB_HAS_RASTER # request the software rasterizer: keeps draw/paint/color + CFF under HB_TINY
HB_NO_VAR_COMPOSITES # drop the VARC table (variable composite glyphs, 2024 format; ~20 KB of code)
"HB_CONFIG_OVERRIDE_H=\"hb-opencv-config.hh\"")
# Optimize HarfBuzz for size: it is ~0.5 MB of libopencv_imgproc at -O3 and ~18% less at -Os,
# while text rendering speed is dominated by the glyph cache, not by shaping. Target options
# come after CMAKE_CXX_FLAGS_<CONFIG> on the command line, so -Os overrides -O3.
# HarfBuzz's own build also disables exceptions/RTTI/thread-safe statics (it uses none).
if(CV_GCC OR CV_CLANG)
target_compile_options(${HARFBUZZ_LIBRARY} PRIVATE -Os -fno-exceptions -fno-rtti -fno-threadsafe-statics)
endif()
set_target_properties(${HARFBUZZ_LIBRARY} PROPERTIES
CXX_STANDARD 17
CXX_STANDARD_REQUIRED ON
)
ocv_warnings_disable(CMAKE_CXX_FLAGS
-Wunused-variable -Wunused-function -Wunused-parameter
-Wunused-but-set-variable # clang15/gcc
-Wshadow
-Wmissing-declarations # gcc
-Wmissing-prototypes # clang
-Wimplicit-fallthrough
-Wextra-semi # clang
-Wdeprecated-copy # gcc/clang
-Wsuggest-override
-Wcast-function-type
-Wclass-memaccess # gcc
-Wexpansion-to-defined
)
ocv_warnings_disable(CMAKE_CXX_FLAGS /wd4244 /wd4267 /wd4127 /wd4146 /wd4456 /wd4459) # MSVC
set_target_properties(${HARFBUZZ_LIBRARY}
PROPERTIES OUTPUT_NAME ${HARFBUZZ_LIBRARY}
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
COMPILE_PDB_NAME ${HARFBUZZ_LIBRARY}
COMPILE_PDB_NAME_DEBUG "${HARFBUZZ_LIBRARY}${OPENCV_DEBUG_POSTFIX}"
ARCHIVE_OUTPUT_DIRECTORY ${3P_LIBRARY_OUTPUT_PATH}
)
if(ENABLE_SOLUTION_FOLDERS)
set_target_properties(${HARFBUZZ_LIBRARY} PROPERTIES FOLDER "3rdparty")
endif()
if(NOT BUILD_SHARED_LIBS)
ocv_install_target(${HARFBUZZ_LIBRARY} EXPORT OpenCVModules ARCHIVE DESTINATION ${OPENCV_3P_LIB_INSTALL_PATH} COMPONENT dev OPTIONAL)
endif()

42
3rdparty/harfbuzz/COPYING vendored
View File

@@ -1,42 +0,0 @@
HarfBuzz is licensed under the so-called "Old MIT" license. Details follow.
For parts of HarfBuzz that are licensed under different licenses see individual
files names COPYING in subdirectories where applicable.
Copyright © 2010-2022 Google, Inc.
Copyright © 2015-2020 Ebrahim Byagowi
Copyright © 2019,2020 Facebook, Inc.
Copyright © 2012,2015 Mozilla Foundation
Copyright © 2011 Codethink Limited
Copyright © 2008,2010 Nokia Corporation and/or its subsidiary(-ies)
Copyright © 2009 Keith Stribley
Copyright © 2011 Martin Hosken and SIL International
Copyright © 2007 Chris Wilson
Copyright © 2005,2006,2020,2021,2022,2023 Behdad Esfahbod
Copyright © 2004,2007,2008,2009,2010,2013,2021,2022,2023 Red Hat, Inc.
Copyright © 1998-2005 David Turner and Werner Lemberg
Copyright © 2016 Igalia S.L.
Copyright © 2022 Matthias Clasen
Copyright © 2018,2021 Khaled Hosny
Copyright © 2018,2019,2020 Adobe, Inc
Copyright © 2013-2015 Alexei Podtelezhnikov
For full copyright notices consult the individual files in the package.
Permission is hereby granted, without written agreement and without
license or royalty fees, to use, copy, modify, and distribute this
software and its documentation for any purpose, provided that the
above copyright notice and the following two paragraphs appear in
all copies of this software.
IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.
THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

220
3rdparty/harfbuzz/README.md vendored
View File

@@ -1,220 +0,0 @@
# HarfBuzz
<div align="center">
<p><img src="HarfBuzz.png" alt="HarfBuzz Logo" width="256"/></p>
[![Linux CI Status](https://github.com/harfbuzz/harfbuzz/actions/workflows/linux.yml/badge.svg)](https://github.com/harfbuzz/harfbuzz/actions/workflows/linux.yml)
[![macoOS CI Status](https://github.com/harfbuzz/harfbuzz/actions/workflows/macos.yml/badge.svg)](https://github.com/harfbuzz/harfbuzz/actions/workflows/macos.yml)
[![Windows CI Status](https://github.com/harfbuzz/harfbuzz/actions/workflows/msvc.yml/badge.svg)](https://github.com/harfbuzz/harfbuzz/actions/workflows/msvc.yml)
[![OSS-Fuzz Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/harfbuzz.svg)](https://oss-fuzz-build-logs.storage.googleapis.com/index.html#harfbuzz)
[![Coverity Scan Build Status](https://scan.coverity.com/projects/15166/badge.svg)](https://scan.coverity.com/projects/harfbuzz)
[![Packaging status](https://repology.org/badge/tiny-repos/harfbuzz.svg)](https://repology.org/project/harfbuzz/versions)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/harfbuzz/harfbuzz/badge)](https://securityscorecards.dev/viewer/?uri=github.com/harfbuzz/harfbuzz)
</div>
HarfBuzz started as a text shaping engine but has grown into a
full font platform — the `ffmpeg` of text shaping. It primarily
supports [OpenType][1], but also [Apple Advanced Typography][2].
HarfBuzz shapes the majority of text on modern screens.
HarfBuzz is optimized for robustness, correctness, and performance
— in that order. Achieve all.
**[Try it live at harfbuzz-world.cc](https://harfbuzz-world.cc/)** — an interactive playground for shaping, subsetting, rasterization, vector output, and GPU rendering, all running in your browser.
Here is a quick map of its components:
### Core libraries
| Library | Description |
|---------|-------------|
| **libharfbuzz** | Text shaping, draw API, paint API. Highly configurable (see [CONFIG.md](CONFIG.md)). Optional integration backends compiled in: hb-ft (FreeType), hb-coretext (macOS), hb-uniscribe (Windows), hb-directwrite (Windows), hb-gdi (Windows), hb-glib, hb-graphite2. |
| **libharfbuzz-subset** | Font subsetting and variable-font instancing. |
### Auxiliary libraries
| Library | Description |
|---------|-------------|
| **libharfbuzz-icu** | ICU Unicode integration. |
| **libharfbuzz-cairo** | Cairo rendering integration. |
| **libharfbuzz-gobject** | GObject/GI bindings. |
### Experimental libraries
| Library | Description |
|---------|-------------|
| **libharfbuzz-raster** | Glyph rasterization to bitmaps, including color fonts. Uses hb-draw and hb-paint. |
| **libharfbuzz-vector** | Glyph output to vector formats (currently SVG), including color fonts. Uses hb-draw and hb-paint. |
| **libharfbuzz-gpu** | Encodes glyph outlines for GPU rasterization (Slug algorithm). Provides shader sources in GLSL, WGSL, MSL, and HLSL. [Live demo.](https://harfbuzz.github.io/hb-gpu-demo/) |
Notable missing feature: font hinting (including autohinting)
is not implemented. For hinted rasterization, use FreeType or
Skrifa.
For simplified builds, amalgamated sources are available:
`harfbuzz.cc` (just libharfbuzz), `harfbuzz-subset.cc` (just
libharfbuzz-subset), or `harfbuzz-world.cc` (everything, driven
by a custom `hb-features.h`). For a live in-browser playground
plus a worked example of the world.cc single-file build, see
[harfbuzz-world.cc][26].
### Command-line tools
| Tool | Description |
|------|-------------|
| **hb-shape** | Shape text and display glyph output. |
| **hb-view** | Render shaped text to an image. |
| **hb-subset** | Subset and optimize fonts. |
| **hb-info** | Display font metadata. |
| **hb-raster** | Render glyphs to bitmap images. |
| **hb-vector** | Render glyphs to vector formats (SVG). |
| **hb-gpu** | Interactive GPU text rendering. |
The canonical source tree and bug trackers are available on [github][4].
Both development and user support discussion around HarfBuzz happen on
[github][4] as well.
For license information, see [COPYING](COPYING).
## API stability
The API that comes with `hb.h` will not change incompatibly. Other, peripheral,
headers are more likely to go through minor modifications, but again, we do our
best to never change API in an incompatible way. We will never break the ABI.
The API and ABI are stable even across major version number jumps. In fact,
current HarfBuzz is API/ABI compatible all the way back to the 0.9.x series.
If one day we need to break the API/ABI, that would be called a new library.
As such, we bump the major version number only when we add major new features,
the minor version when there is new API, and the micro version when there
are bug fixes.
## Documentation
For user manual as well as API documentation, check: https://harfbuzz.github.io
## Download
Tarball releases and Win32/Win64 binary bundles are available on the
[github releases][3] page.
## Development
For build information, see [BUILD.md](BUILD.md).
For custom configurations, see [CONFIG.md](CONFIG.md).
For testing and profiling, see [TESTING.md](TESTING.md).
For using with Python, see [README.python.md](README.python.md). There is also [uharfbuzz](https://github.com/harfbuzz/uharfbuzz).
For cross-compiling to Windows from Linux or macOS, see [README.mingw.md](README.mingw.md).
To report bugs or submit patches please use [github][4] issues and pull-requests.
### Developer documents
To get a better idea of where HarfBuzz stands in the text rendering stack you
may want to read [State of Text Rendering 2024][6].
Here are a few presentation slides about HarfBuzz over the years:
- 2026 – [HarfBuzz at 20!][25]
- 2016 – [Ten Years of HarfBuzz][20]
- 2014 – [Unicode, OpenType, and HarfBuzz: Closing the Circle][7]
- 2012 – [HarfBuzz, The Free and Open Text Shaping Engine][8]
- 2009 – [HarfBuzz: the Free and Open Shaping Engine][9]
More presentations and papers are available on [behdad][11]'s website.
In particular, the following _studies_ are relevant to HarfBuzz development:
- 2025 – [AAT layout caches][24]
- 2025 – [OpenType Layout lookup caches][23]
- 2025 – [Introducing HarfRust][22]
- 2025 – [Subsetting][21]
- 2025 – [Caching][12]
- 2025 – [`hb-decycler`][13]
- 2022 – [`hb-iter`][14]
- 2022 – [A C library written in C++][15]
- 2022 – [The case of the slow `hb-ft` `>h_advance` function][18]
- 2022 – [PackTab: A static integer table packer][16]
- 2020 – [HarfBuzz OT+AAT "Unishaper"][19]
- 2014 – [Building the Indic Shaper][17]
- 2012 – [Memory Consumption][10]
## Name
HarfBuzz /hærfˈbɒːz/
From Persian حرف (*Harf*: letter) and باز (*Buzz*: open).
Transliteration of the Persian calque for *OpenType*.
As a noun: *The* Open Source *text shaping* engine.
As an adjective: Insincerely talkative; glib. A nod to the
GNOME project where HarfBuzz originates from.
The logo shows حرف‌باز in the IranNastaliq font, on a Damascus
steel background.
> Background: Originally there was this font format called TrueType. People and
> companies started calling their type engines all things ending in Type:
> FreeType, CoolType, ClearType, etc. And then came OpenType, which is the
> successor of TrueType. So, for my OpenType implementation, I decided to stick
> with the concept but use the Persian translation. Which is fitting given that
> Persian is written in the Arabic script, and OpenType is an extension of
> TrueType that adds support for complex script rendering, and HarfBuzz is an
> implementation of OpenType text shaping.
## Users
HarfBuzz is used in Android, Chrome, ChromeOS, Firefox, Flutter, GNOME, GTK+, KDE,
Qt, LibreOffice, OpenJDK, XeTeX, Adobe Photoshop, Illustrator, InDesign,
Microsoft Edge, Amazon Kindle, PlayStation, Godot Engine, Unreal Engine,
Figma, Canva, QuarkXPress, Scribus, smart TVs,
car displays, and many other places.
<p align="center">
<a href="https://xkcd.com/2347/" rel="nofollow">
<img src="xkcd.png" width="256" alt="xkcd-derived image">
</a>
</p>
## Distribution
<details>
<summary>Packaging status of HarfBuzz</summary>
[![Packaging status](https://repology.org/badge/vertical-allrepos/harfbuzz.svg?header=harfbuzz)](https://repology.org/project/harfbuzz/versions)
</details>
[1]: https://docs.microsoft.com/en-us/typography/opentype/spec/
[2]: https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6AATIntro.html
[3]: https://github.com/harfbuzz/harfbuzz/releases
[4]: https://github.com/harfbuzz/harfbuzz
[6]: https://behdad.org/text2024
[7]: https://docs.google.com/presentation/d/1x97pfbB1gbD53Yhz6-_yBUozQMVJ_5yMqqR_D-R7b7I/preview
[8]: https://docs.google.com/presentation/d/1ySTZaXP5XKFg0OpmHZM00v5b17GSr3ojnzJekl4U8qI/preview
[9]: https://behdad.org/doc/harfbuzz2009-slides.pdf
[10]: https://docs.google.com/document/d/12jfNpQJzeVIAxoUSpk7KziyINAa1msbGliyXqguS86M/preview
[11]: https://behdad.org/
[12]: https://docs.google.com/document/d/1_VgObf6Je0J8byMLsi7HCQHnKo2emGnx_ib_sHo-bt4/preview
[13]: https://docs.google.com/document/d/1Y-u08l9YhObRVObETZt1k8f_5lQdOix9TRH3zEXaoAw/preview
[14]: https://docs.google.com/document/d/1o-xvxCbgMe9JYFHLVnPjk01ZY_8Cj0vB9-KTI1d0nyk/preview
[15]: https://docs.google.com/document/d/18hI56KJpvXtwWbc9QSaz9zzhJwIMnrJ-zkAaKS-W-8k/preview
[16]: https://docs.google.com/document/d/1Xq3owVt61HVkJqbLFHl73il6pcTy6PdPJJ7bSouQiQw/preview
[17]: https://docs.google.com/document/d/1wMPwVNBvsIriamcyBO5aNs7Cdr8lmbwLJ8GmZBAswF4/preview
[18]: https://docs.google.com/document/d/1wskYbA-czBt57oH9gEuGf3sWbTx7bfOiEIcDs36-heo/preview
[19]: https://prezi.com/view/THNPJGFVDUCWoM20syev/
[20]: https://behdad.org/doc/harfbuzz10years-slides.pdf
[21]: https://docs.google.com/document/d/1_vZrt97OorJ0jA1YzJ29LRcGr3YGrNJANdOABjVZGEs/preview
[22]: https://docs.google.com/document/d/1aH_waagdEM5UhslQxCeFEb82ECBhPlZjy5_MwLNLBYo/preview
[23]: https://docs.google.com/document/d/1hRd5oYQJLrt0JuwWhEJWi7wh_9rbaIJkX6IR9DW7rZQ/preview
[24]: https://docs.google.com/document/d/1a3K6fHjsiWW36vSzwJwCwEBOgznunKs80PSpBbpfHiA/preview
[25]: https://docs.google.com/presentation/d/1o9Exz1c-Lr-dJjA8dcBn_Vl_Y37cupmFzmclMjBE_Bc/view
[26]: https://harfbuzz-world.cc/

386
3rdparty/harfbuzz/hb_extract.py vendored
View File

@@ -1,386 +0,0 @@
#!/usr/bin/env python3
"""
hb_extract.py -- copy the minimal subset of HarfBuzz sources used by OpenCV.
OpenCV vendors HarfBuzz as a normal static library: every .cc is a separate
translation unit (no unity / amalgamation build). This script reproduces the
exact src/ tree that OpenCV ships, from a pristine HarfBuzz checkout.
It does three things beyond a naive copy, all to keep the vendored tree small
and buildable with OpenCV's configuration (HB_TINY + HB_HAS_RASTER, see
CMakeLists.txt):
1. Copies the translation units that upstream `harfbuzz-world.cc` would
compile for the requested HB_HAS_* sections -- EXCEPT the ones that build
to an empty object under our config (see EMPTY_TUS). It never emits
`harfbuzz-world.cc` itself (we compile each .cc directly), and never
copies non-TU .cc files found under src/OT|graph (only real TUs from the
parsed world.cc lists are copied), so CMake's file(GLOB_RECURSE src/*.cc)
picks up exactly the right set.
2. Prunes headers down to the set actually reachable by #include from the
copied TUs (+ the public headers OpenCV includes). This automatically
drops the large amount of HarfBuzz src/ that we never compile -- GPU and
WASM backends, the subset/repacker graph, platform backends (CoreText/
DirectWrite/GDI/Uniscribe/Graphite2/GObject/Cairo), the vector-paint
backend, and headers used only by the skipped empty TUs -- without a
hardcoded blocklist.
3. Generates `hb-opencv-config.hh`, the config-override header CMakeLists.txt
points HB_CONFIG_OVERRIDE_H at. It re-enables thread-safety (HB_NO_MT) and
variable fonts (HB_NO_VAR) that HB_TINY would otherwise switch off. (It
does NOT generate upstream's hb-features.h: nothing we compile includes
it.)
Usage (to refresh this very directory, just point it at a harfbuzz checkout):
python hb_extract.py path/to/harfbuzz
The defaults already produce the OpenCV subset: output '.', features
HB_HAS_RASTER, and it also copies README.md + COPYING. Override only if needed:
-o DIR output root (default '.')
-f FLAGS comma-separated HB_HAS_* (default HB_HAS_RASTER)
-a FILES extra files (default README.md,COPYING)
--list-flags print available HB_HAS_* flags and exit
-a paths are relative to the harfbuzz repo root (parent of src/):
-a README.md -> copied to <out>/README.md
-a COPYING -> copied to <out>/COPYING
-a src/hb-raster.h -> copied to <out>/src/hb-raster.h
"""
import argparse
import posixpath
import re
import shutil
import sys
from pathlib import Path
# Translation units that compile to an EMPTY object (libtool: "has no symbols")
# under OpenCV's HarfBuzz configuration (HB_TINY + HB_HAS_RASTER => AAT, legacy
# fallback shaping, math, meta, name, buffer (de)serialize/verify and the style
# API are all compiled out). They contribute nothing, so we do not vendor them.
# Re-derive this list (from the libtool warnings of a clean libharfbuzz build)
# if the HarfBuzz configuration in CMakeLists.txt changes.
EMPTY_TUS = {
"hb-aat-layout.cc",
"hb-aat-map.cc",
"hb-buffer-serialize.cc",
"hb-buffer-verify.cc",
"hb-fallback-shape.cc",
"hb-ot-math.cc",
"hb-ot-meta.cc",
"hb-ot-name.cc",
"hb-raster.cc",
"hb-style.cc",
}
# Public headers OpenCV's text engine (drawing_text.cpp) includes directly.
# Used together with the copied TUs as the roots of the header-reachability
# prune.
SEED_PUBLIC_HEADERS = ("hb.h", "hb-ot.h", "hb-raster.h")
# Generated config-override header. CMakeLists.txt builds HarfBuzz with HB_TINY
# and HB_CONFIG_OVERRIDE_H="hb-opencv-config.hh"; this file is included by
# hb-config.hh after HB_TINY/HB_LEAN expand (so the #undef takes effect) but
# before the option-closure derives dependent macros.
OPENCV_CONFIG_HH = '''\
/*
* OpenCV-specific HarfBuzz configuration override. GENERATED by hb_extract.py.
*
* HarfBuzz is built with HB_TINY (see 3rdparty/harfbuzz/CMakeLists.txt) for the
* smallest possible footprint. HB_TINY pulls in HB_LEAN + HB_MINI, which would
* disable two features that OpenCV's text engine relies on. We restore them
* here.
*
* This file is included by hb-config.hh via HB_CONFIG_OVERRIDE_H, i.e. AFTER
* HB_TINY/HB_LEAN/HB_MINI have expanded their macros (so the #undef below takes
* effect) but BEFORE the "closure of options" derives dependent macros (e.g.
* HB_NO_VAR_COMPOSITES from HB_NO_VAR). That ordering is what makes a plain
* #undef sufficient.
*
* HB_NO_MT - keep thread-safety. hb_font_t instances live inside cv::FontFace
* objects, NOT in the thread_local FontRenderEngine, so a single
* FontFace (and its hb_font_t) can be shared across threads; its
* reference counting must stay atomic.
*
* HB_NO_VAR - keep variable-font support: the 'wght' axis used for synthetic
* weights and named-instance/axis queries (hb_font_set_variations,
* hb_ot_var_*). Variable fonts are a primary reason OpenCV adopted
* HarfBuzz, so this must remain enabled.
*/
#undef HB_NO_MT
#undef HB_NO_VAR
'''
OPENCV_CONFIG_NAME = "hb-opencv-config.hh"
def parse_world_cc(path):
"""Return (core_files, sections) parsed from harfbuzz-world.cc.
core_files -- list of .cc paths (relative to src/) in the unconditional
"Core library" section.
sections -- dict HB_HAS_XXX -> list of .cc paths from that #ifdef block.
"""
lines = path.read_text(encoding="utf-8").splitlines()
include_re = re.compile(r'^\s*#include\s+"([^"]+\.cc)"')
core_files = []
sections = {}
STATE_PREAMBLE, STATE_CORE, STATE_IFDEF = "preamble", "core", "ifdef"
state = STATE_PREAMBLE
current_flag = None
ifdef_depth = 0
for line in lines:
if state == STATE_PREAMBLE:
if "/* Core library." in line:
state = STATE_CORE
elif state == STATE_CORE:
m = include_re.match(line)
if m:
core_files.append(m.group(1))
else:
m = re.match(r"^\s*#ifdef\s+(HB_HAS_\w+)", line)
if m:
current_flag = m.group(1)
sections[current_flag] = []
state = STATE_IFDEF
ifdef_depth = 1
elif state == STATE_IFDEF:
if re.match(r"^\s*#if", line):
ifdef_depth += 1
elif re.match(r"^\s*#endif", line):
ifdef_depth -= 1
if ifdef_depth == 0:
state = STATE_CORE
current_flag = None
else:
m = include_re.match(line)
if m and current_flag is not None:
sections[current_flag].append(m.group(1))
return core_files, sections
def copy_files(file_list, src_dir, out_src_dir, label=""):
skipped = []
for rel in file_list:
if Path(rel).name in EMPTY_TUS:
skipped.append(rel)
continue
src = src_dir / rel
dst = out_src_dir / rel
dst.parent.mkdir(parents=True, exist_ok=True)
if not src.exists():
print(f" [WARN] not found: {src}", file=sys.stderr)
continue
shutil.copy2(src, dst)
print(f" [{label or 'core'}] src/{rel}")
for rel in skipped:
print(f" [skip-empty] src/{rel}")
def copy_headers(src_dir, out_src_dir, public_h=True):
"""Copy all candidate headers: src/*.hh, src/*.h (public API), and *.h/*.hh
from src/OT/** and src/graph/**. The unreferenced ones are removed later by
prune_unreferenced_headers().
NOTE: .cc files under OT/ and graph/ are intentionally NOT copied here --
the only ones we need are real translation units, copied via the parsed
world.cc lists. Copying e.g. src/graph/test-classdef-graph.cc would make
CMake's file(GLOB_RECURSE src/*.cc) try to compile a non-TU file.
"""
count = 0
def _copy(p):
nonlocal count
dst = out_src_dir / p.relative_to(src_dir)
dst.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(p, dst)
count += 1
for hdr in src_dir.glob("*.hh"):
_copy(hdr)
for subdir in ("OT", "graph"):
d = src_dir / subdir
if not d.exists():
continue
for hdr in d.rglob("*"):
if hdr.is_file() and hdr.suffix in (".h", ".hh"):
_copy(hdr)
if public_h:
for hdr in src_dir.glob("*.h"):
_copy(hdr)
return count
def prune_unreferenced_headers(out_src_dir):
"""Delete every header not reachable by #include from the copied TUs and the
public seed headers, then drop any directory left empty.
HarfBuzz's amalgamated src/ ships many headers we never compile (GPU/WASM
backends, subset/repacker graph, platform backends, vector-paint, and the
headers used only by the empty TUs we skip). Reachability removes them all
without a hardcoded list. The edge regex also treats any quoted "...h"/
"...hh" literal as an include, which covers the `#include HB_STRING_ARRAY_LIST`
macro-indirection trick (e.g. hb-ot-cff1-std-str.hh, hb-ot-post-macroman.hh).
"""
files = {p.relative_to(out_src_dir).as_posix()
for p in out_src_dir.rglob("*") if p.is_file()}
headers = {f for f in files if f.endswith((".h", ".hh"))}
edge_re = re.compile(r'#\s*include\s+["<]([^">]+)[">]|"([^"]+\.hh?)"')
def resolve(inc, including):
for cand in (posixpath.normpath(posixpath.join(posixpath.dirname(including), inc)),
posixpath.normpath(inc)):
if cand in files:
return cand
return None
seeds = {f for f in files if f.endswith(".cc")}
seeds |= {h for h in SEED_PUBLIC_HEADERS if h in files}
seen, stack = set(), list(seeds)
while stack:
cur = stack.pop()
if cur in seen:
continue
seen.add(cur)
try:
txt = (out_src_dir / cur).read_text(encoding="utf-8", errors="ignore")
except OSError:
continue
for m in edge_re.finditer(txt):
inc = m.group(1) or m.group(2)
r = resolve(inc, cur)
if r and r not in seen:
stack.append(r)
needed = {f for f in seen if f.endswith((".h", ".hh"))}
for h in sorted(headers - needed):
(out_src_dir / h).unlink()
print(f" [prune] src/{h}")
# remove directories left empty by pruning (deepest first)
for d in sorted((p for p in out_src_dir.rglob("*") if p.is_dir()),
key=lambda p: len(p.parts), reverse=True):
try:
d.rmdir()
except OSError:
pass
return len(headers - needed), len(needed)
def write_opencv_config_h(out_src_dir):
"""Generate hb-opencv-config.hh (the HB_CONFIG_OVERRIDE_H header)."""
(out_src_dir / OPENCV_CONFIG_NAME).write_text(OPENCV_CONFIG_HH, encoding="utf-8")
print(f" [gen] src/{OPENCV_CONFIG_NAME}")
def main():
parser = argparse.ArgumentParser(
description="Copy the OpenCV subset of HarfBuzz sources.",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
examples:
python hb_extract.py ~/work/harfbuzz -o . -f HB_HAS_RASTER -a README.md,COPYING
python hb_extract.py ~/work/harfbuzz --list-flags
""",
)
parser.add_argument("harfbuzz_dir", metavar="harfbuzz-dir",
help="path to the harfbuzz repo root (contains src/)")
parser.add_argument("-o", "--output", metavar="DIR", default=".",
help="output root directory; sources go into DIR/src/ "
"(default: current directory)")
parser.add_argument("-f", "--features", metavar="FLAGS", default="HB_HAS_RASTER",
help="comma-separated HB_HAS_* flags (default: HB_HAS_RASTER)")
parser.add_argument("-a", "--add", metavar="FILES", default="README.md,COPYING",
help="comma-separated files relative to the harfbuzz repo "
"root (default: README.md,COPYING)")
parser.add_argument("--no-public-headers", action="store_true",
help="skip copying public src/*.h API headers "
"(OT/, graph/, *.hh are always copied)")
parser.add_argument("--list-flags", action="store_true",
help="list available HB_HAS_* flags and exit")
args = parser.parse_args()
repo_dir = Path(args.harfbuzz_dir).resolve()
world_cc_path = repo_dir / "src" / "harfbuzz-world.cc"
if not world_cc_path.exists():
print(f"error: {world_cc_path} not found", file=sys.stderr)
sys.exit(1)
src_dir = world_cc_path.parent
core_files, sections = parse_world_cc(world_cc_path)
if args.list_flags:
for flag, files in sorted(sections.items()):
print(f" {flag:<22} ({len(files)} .cc files)")
return
enabled_flags = [f.strip() for f in args.features.split(",") if f.strip()]
extra_files = [f.strip() for f in args.add.split(",") if f.strip()]
out_dir = Path(args.output).resolve()
out_src_dir = out_dir / "src"
# Start from a clean src/ so removed-upstream files do not linger.
if out_src_dir.exists():
shutil.rmtree(out_src_dir)
out_src_dir.mkdir(parents=True, exist_ok=True)
print(f"\nsource : {repo_dir}")
print(f"output : {out_dir}")
print(f"flags : {enabled_flags}\n")
print("core:")
copy_files(core_files, src_dir, out_src_dir)
for flag in enabled_flags:
flag_files = sections.get(flag)
if not flag_files:
print(f"\n[{flag}]: no .cc files (flag not found in harfbuzz-world.cc)")
continue
print(f"\n[{flag}]:")
copy_files(flag_files, src_dir, out_src_dir, label=flag)
if extra_files:
print("\nextra:")
for rel in extra_files:
src = repo_dir / rel
dst = out_dir / rel
dst.parent.mkdir(parents=True, exist_ok=True)
if not src.exists():
print(f" [WARN] not found: {src}", file=sys.stderr)
continue
shutil.copy2(src, dst)
print(f" [add] {rel}")
n = copy_headers(src_dir, out_src_dir,
public_h=not args.no_public_headers)
print(f"\nheaders: {n} files copied")
print("\nprune (unreferenced headers):")
removed, kept = prune_unreferenced_headers(out_src_dir)
print(f" removed {removed}, kept {kept}")
print("\ngenerated:")
write_opencv_config_h(out_src_dir)
all_cc = sorted(out_src_dir.rglob("*.cc"))
all_h = list(out_src_dir.rglob("*.h")) + list(out_src_dir.rglob("*.hh"))
print(f"\ndone: {len(all_cc)} .cc | {len(all_h)} headers -> {out_dir}")
if __name__ == "__main__":
main()

1033
3rdparty/harfbuzz/src/OT/Color/CBDT/CBDT.hh vendored
View File

File diff suppressed because it is too large Load Diff

2861
3rdparty/harfbuzz/src/OT/Color/COLR/COLR.hh vendored
View File

File diff suppressed because it is too large Load Diff

367
3rdparty/harfbuzz/src/OT/Color/CPAL/CPAL.hh vendored
View File

@@ -1,367 +0,0 @@
/*
* Copyright © 2016 Google, Inc.
* Copyright © 2018 Ebrahim Byagowi
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Google Author(s): Sascha Brawer
*/
#ifndef OT_COLOR_CPAL_CPAL_HH
#define OT_COLOR_CPAL_CPAL_HH
#include "../../../hb-open-type.hh"
#include "../../../hb-ot-color.h"
#include "../../../hb-ot-name.h"
/*
* CPAL -- Color Palette
* https://docs.microsoft.com/en-us/typography/opentype/spec/cpal
*/
#define HB_OT_TAG_CPAL HB_TAG('C','P','A','L')
namespace OT {
struct CPALV1Tail
{
friend struct CPAL;
private:
hb_ot_color_palette_flags_t get_palette_flags (const void *base,
unsigned int palette_index,
unsigned int palette_count) const
{
if (!paletteFlagsZ) return HB_OT_COLOR_PALETTE_FLAG_DEFAULT;
return (hb_ot_color_palette_flags_t) (uint32_t)
(base+paletteFlagsZ).as_array (palette_count)[palette_index];
}
hb_ot_name_id_t get_palette_name_id (const void *base,
unsigned int palette_index,
unsigned int palette_count) const
{
if (!paletteLabelsZ) return HB_OT_NAME_ID_INVALID;
return (base+paletteLabelsZ).as_array (palette_count)[palette_index];
}
hb_ot_name_id_t get_color_name_id (const void *base,
unsigned int color_index,
unsigned int color_count) const
{
if (!colorLabelsZ) return HB_OT_NAME_ID_INVALID;
return (base+colorLabelsZ).as_array (color_count)[color_index];
}
public:
void collect_name_ids (const void *base,
unsigned palette_count,
unsigned color_count,
const hb_map_t *color_index_map,
hb_set_t *nameids_to_retain /* OUT */) const
{
if (paletteLabelsZ)
{
+ (base+paletteLabelsZ).as_array (palette_count)
| hb_sink (nameids_to_retain)
;
}
if (colorLabelsZ)
{
const hb_array_t<const NameID> colorLabels = (base+colorLabelsZ).as_array (color_count);
for (unsigned i = 0; i < color_count; i++)
{
if (!color_index_map->has (i)) continue;
nameids_to_retain->add (colorLabels[i]);
}
}
}
bool serialize (hb_serialize_context_t *c,
unsigned palette_count,
unsigned color_count,
const void *base,
const hb_map_t *color_index_map) const
{
TRACE_SERIALIZE (this);
auto *out = c->allocate_size<CPALV1Tail> (static_size);
if (unlikely (!out)) return_trace (false);
out->paletteFlagsZ = 0;
if (paletteFlagsZ)
out->paletteFlagsZ.serialize_copy (c, paletteFlagsZ, base, 0, hb_serialize_context_t::Head, palette_count);
out->paletteLabelsZ = 0;
if (paletteLabelsZ)
out->paletteLabelsZ.serialize_copy (c, paletteLabelsZ, base, 0, hb_serialize_context_t::Head, palette_count);
const hb_array_t<const NameID> colorLabels = (base+colorLabelsZ).as_array (color_count);
if (colorLabelsZ)
{
c->push ();
for (unsigned i = 0; i < color_count; i++)
{
if (!color_index_map->has (i)) continue;
if (!c->copy<NameID> (colorLabels[i]))
{
c->pop_discard ();
return_trace (false);
}
}
c->add_link (out->colorLabelsZ, c->pop_pack ());
}
return_trace (true);
}
bool sanitize (hb_sanitize_context_t *c,
const void *base,
unsigned int palette_count,
unsigned int color_count) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
(!paletteFlagsZ || (base+paletteFlagsZ).sanitize (c, palette_count)) &&
(!paletteLabelsZ || (base+paletteLabelsZ).sanitize (c, palette_count)) &&
(!colorLabelsZ || (base+colorLabelsZ).sanitize (c, color_count)));
}
protected:
// TODO(garretrieger): these offsets can hold nulls so we should not be using non-null offsets
// here. Currently they are needed since UnsizedArrayOf doesn't define null_size
NNOffset32To<UnsizedArrayOf<HBUINT32>>
paletteFlagsZ; /* Offset from the beginning of CPAL table to
* the Palette Type Array. Set to 0 if no array
* is provided. */
NNOffset32To<UnsizedArrayOf<NameID>>
paletteLabelsZ; /* Offset from the beginning of CPAL table to
* the palette labels array. Set to 0 if no
* array is provided. */
NNOffset32To<UnsizedArrayOf<NameID>>
colorLabelsZ; /* Offset from the beginning of CPAL table to
* the color labels array. Set to 0
* if no array is provided. */
public:
DEFINE_SIZE_STATIC (12);
};
typedef HBUINT32 BGRAColor;
struct CPAL
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_CPAL;
bool has_data () const { return numPalettes; }
size_t get_size () const
{ return min_size + numPalettes * sizeof (colorRecordIndicesZ[0]); }
unsigned int get_palette_count () const { return numPalettes; }
unsigned int get_color_count () const { return numColors; }
hb_ot_color_palette_flags_t get_palette_flags (unsigned int palette_index) const
{ return v1 ().get_palette_flags (this, palette_index, numPalettes); }
hb_ot_name_id_t get_palette_name_id (unsigned int palette_index) const
{ return v1 ().get_palette_name_id (this, palette_index, numPalettes); }
hb_ot_name_id_t get_color_name_id (unsigned int color_index) const
{ return v1 ().get_color_name_id (this, color_index, numColors); }
hb_array_t<const BGRAColor> get_palette_colors (unsigned int palette_index) const
{
if (unlikely (palette_index >= numPalettes))
return hb_array_t<const BGRAColor> ();
unsigned int start_index = colorRecordIndicesZ[palette_index];
hb_array_t<const BGRAColor> all_colors ((this+colorRecordsZ).arrayZ, numColorRecords);
return all_colors.sub_array (start_index, numColors);
}
unsigned int get_palette_colors (unsigned int palette_index,
unsigned int start_offset,
unsigned int *color_count, /* IN/OUT. May be NULL. */
hb_color_t *colors /* OUT. May be NULL. */) const
{
if (unlikely (palette_index >= numPalettes))
{
if (color_count) *color_count = 0;
return 0;
}
unsigned int start_index = colorRecordIndicesZ[palette_index];
hb_array_t<const BGRAColor> all_colors ((this+colorRecordsZ).arrayZ, numColorRecords);
hb_array_t<const BGRAColor> palette_colors = all_colors.sub_array (start_index,
numColors);
if (color_count)
{
+ palette_colors.sub_array (start_offset, color_count)
| hb_sink (hb_array (colors, *color_count))
;
}
return numColors;
}
void collect_name_ids (const hb_map_t *color_index_map,
hb_set_t *nameids_to_retain /* OUT */) const
{
if (version == 1)
{
hb_barrier ();
v1 ().collect_name_ids (this, numPalettes, numColors, color_index_map, nameids_to_retain);
}
}
private:
const CPALV1Tail& v1 () const
{
if (version == 0) return Null (CPALV1Tail);
hb_barrier ();
return StructAfter<CPALV1Tail> (*this);
}
public:
bool serialize (hb_serialize_context_t *c,
const hb_array_t<const HBUINT16> &color_record_indices,
const hb_array_t<const BGRAColor> &color_records,
const hb_vector_t<unsigned>& first_color_index_for_layer,
const hb_map_t& first_color_to_layer_index,
const hb_set_t &retained_color_indices) const
{
TRACE_SERIALIZE (this);
// TODO(grieger): limit total final size.
for (const auto idx : color_record_indices)
{
hb_codepoint_t layer_index = first_color_to_layer_index[idx];
HBUINT16 new_idx;
new_idx = layer_index * retained_color_indices.get_population ();
if (!c->copy<HBUINT16> (new_idx)) return_trace (false);
}
c->push ();
for (unsigned first_color_index : first_color_index_for_layer)
{
for (hb_codepoint_t color_index : retained_color_indices)
{
if (!c->copy<BGRAColor> (color_records[first_color_index + color_index]))
{
c->pop_discard ();
return_trace (false);
}
}
}
c->add_link (colorRecordsZ, c->pop_pack ());
return_trace (true);
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
if (!numPalettes) return_trace (false);
const hb_map_t *color_index_map = &c->plan->colr_palettes;
if (color_index_map->is_empty ()) return_trace (false);
hb_set_t retained_color_indices;
for (const auto _ : color_index_map->keys ())
{
if (_ == 0xFFFF) continue;
retained_color_indices.add (_);
}
if (retained_color_indices.is_empty ()) return_trace (false);
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->version = version;
out->numColors = retained_color_indices.get_population ();
out->numPalettes = numPalettes;
hb_vector_t<unsigned> first_color_index_for_layer;
hb_map_t first_color_to_layer_index;
const hb_array_t<const HBUINT16> colorRecordIndices = colorRecordIndicesZ.as_array (numPalettes);
for (const auto first_color_record_idx : colorRecordIndices)
{
if (first_color_to_layer_index.has (first_color_record_idx)) continue;
first_color_index_for_layer.push (first_color_record_idx);
if (unlikely (!c->serializer->propagate_error (first_color_index_for_layer))) return_trace (false);
first_color_to_layer_index.set (first_color_record_idx,
first_color_index_for_layer.length - 1);
}
out->numColorRecords = first_color_index_for_layer.length
* retained_color_indices.get_population ();
const hb_array_t<const BGRAColor> color_records = (this+colorRecordsZ).as_array (numColorRecords);
if (!out->serialize (c->serializer,
colorRecordIndices,
color_records,
first_color_index_for_layer,
first_color_to_layer_index,
retained_color_indices))
return_trace (false);
if (version == 1)
{
hb_barrier ();
return_trace (v1 ().serialize (c->serializer, numPalettes, numColors, this, color_index_map));
}
return_trace (true);
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
hb_barrier () &&
(this+colorRecordsZ).sanitize (c, numColorRecords) &&
colorRecordIndicesZ.sanitize (c, numPalettes) &&
(version == 0 || v1 ().sanitize (c, this, numPalettes, numColors)));
}
protected:
HBUINT16 version; /* Table version number */
/* Version 0 */
HBUINT16 numColors; /* Number of colors in each palette. */
HBUINT16 numPalettes; /* Number of palettes in the table. */
HBUINT16 numColorRecords; /* Total number of color records, combined for
* all palettes. */
NNOffset32To<UnsizedArrayOf<BGRAColor>>
colorRecordsZ; /* Offset from the beginning of CPAL table to
* the first ColorRecord. */
UnsizedArrayOf<HBUINT16>
colorRecordIndicesZ; /* Index of each palette’s first color record in
* the combined color record array. */
/*CPALV1Tail v1;*/
public:
DEFINE_SIZE_ARRAY (12, colorRecordIndicesZ);
};
} /* namespace OT */
#endif /* OT_COLOR_CPAL_CPAL_HH */

449
3rdparty/harfbuzz/src/OT/Color/sbix/sbix.hh vendored
View File

@@ -1,449 +0,0 @@
/*
* Copyright © 2018 Ebrahim Byagowi
* Copyright © 2020 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Google Author(s): Calder Kitagawa
*/
#ifndef OT_COLOR_SBIX_SBIX_HH
#define OT_COLOR_SBIX_SBIX_HH
#include "../../../hb-open-type.hh"
#include "../../../hb-paint.hh"
/*
* sbix -- Standard Bitmap Graphics
* https://docs.microsoft.com/en-us/typography/opentype/spec/sbix
* https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html
*/
#define HB_OT_TAG_sbix HB_TAG('s','b','i','x')
namespace OT {
struct SBIXGlyph
{
SBIXGlyph* copy (hb_serialize_context_t *c, unsigned int data_length) const
{
TRACE_SERIALIZE (this);
SBIXGlyph* new_glyph = c->start_embed<SBIXGlyph> ();
if (unlikely (!c->extend_min (new_glyph))) return_trace (nullptr);
new_glyph->xOffset = xOffset;
new_glyph->yOffset = yOffset;
new_glyph->graphicType = graphicType;
data.copy (c, data_length);
return_trace (new_glyph);
}
HBINT16 xOffset; /* The horizontal (x-axis) offset from the left
* edge of the graphic to the glyph’s origin.
* That is, the x-coordinate of the point on the
* baseline at the left edge of the glyph. */
HBINT16 yOffset; /* The vertical (y-axis) offset from the bottom
* edge of the graphic to the glyph’s origin.
* That is, the y-coordinate of the point on the
* baseline at the left edge of the glyph. */
Tag graphicType; /* Indicates the format of the embedded graphic
* data: one of 'jpg ', 'png ' or 'tiff', or the
* special format 'dupe'. */
UnsizedArrayOf<HBUINT8>
data; /* The actual embedded graphic data. The total
* length is inferred from sequential entries in
* the glyphDataOffsets array and the fixed size
* (8 bytes) of the preceding fields. */
public:
DEFINE_SIZE_ARRAY (8, data);
};
struct SBIXStrike
{
static size_t get_size (unsigned num_glyphs)
{ return min_size + num_glyphs * HBUINT32::static_size; }
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
imageOffsetsZ.sanitize_shallow (c, c->get_num_glyphs () + 1));
}
hb_blob_t *get_glyph_blob (unsigned int glyph_id,
hb_blob_t *sbix_blob,
hb_tag_t file_type,
int *x_offset,
int *y_offset,
unsigned int num_glyphs,
unsigned int *strike_ppem) const
{
if (unlikely (!ppem)) return hb_blob_get_empty (); /* To get Null() object out of the way. */
unsigned int retry_count = 8;
unsigned int sbix_len = sbix_blob->length;
unsigned int strike_offset = (const char *) this - (const char *) sbix_blob->data;
assert (strike_offset < sbix_len);
retry:
if (unlikely (glyph_id >= num_glyphs ||
imageOffsetsZ[glyph_id + 1] <= imageOffsetsZ[glyph_id] ||
imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] <= SBIXGlyph::min_size ||
(unsigned int) imageOffsetsZ[glyph_id + 1] > sbix_len - strike_offset))
return hb_blob_get_empty ();
unsigned int glyph_offset = strike_offset + (unsigned int) imageOffsetsZ[glyph_id] + SBIXGlyph::min_size;
unsigned int glyph_length = imageOffsetsZ[glyph_id + 1] - imageOffsetsZ[glyph_id] - SBIXGlyph::min_size;
const SBIXGlyph *glyph = &(this+imageOffsetsZ[glyph_id]);
if (glyph->graphicType == HB_TAG ('d','u','p','e'))
{
if (glyph_length >= 2)
{
glyph_id = *((HBUINT16 *) &glyph->data);
if (retry_count--)
goto retry;
}
return hb_blob_get_empty ();
}
if (unlikely (file_type != glyph->graphicType))
return hb_blob_get_empty ();
if (strike_ppem) *strike_ppem = ppem;
if (x_offset) *x_offset = glyph->xOffset;
if (y_offset) *y_offset = glyph->yOffset;
return hb_blob_create_sub_blob (sbix_blob, glyph_offset, glyph_length);
}
bool subset (hb_subset_context_t *c, unsigned int available_len) const
{
TRACE_SUBSET (this);
unsigned int num_output_glyphs = c->plan->num_output_glyphs ();
auto* out = c->serializer->start_embed<SBIXStrike> ();
auto snap = c->serializer->snapshot ();
if (unlikely (!c->serializer->extend (out, num_output_glyphs + 1))) return_trace (false);
out->ppem = ppem;
out->resolution = resolution;
HBUINT32 head;
head = get_size (num_output_glyphs + 1);
bool has_glyphs = false;
for (unsigned new_gid = 0; new_gid < num_output_glyphs; new_gid++)
{
hb_codepoint_t old_gid;
if (!c->plan->old_gid_for_new_gid (new_gid, &old_gid) ||
unlikely (imageOffsetsZ[old_gid].is_null () ||
imageOffsetsZ[old_gid + 1].is_null () ||
imageOffsetsZ[old_gid + 1] <= imageOffsetsZ[old_gid] ||
imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid] <= SBIXGlyph::min_size) ||
(unsigned int) imageOffsetsZ[old_gid + 1] > available_len)
{
out->imageOffsetsZ[new_gid] = head;
continue;
}
has_glyphs = true;
unsigned int delta = imageOffsetsZ[old_gid + 1] - imageOffsetsZ[old_gid];
unsigned int glyph_data_length = delta - SBIXGlyph::min_size;
if (!(this+imageOffsetsZ[old_gid]).copy (c->serializer, glyph_data_length))
return_trace (false);
out->imageOffsetsZ[new_gid] = head;
head += delta;
}
if (has_glyphs)
out->imageOffsetsZ[num_output_glyphs] = head;
else
c->serializer->revert (snap);
return_trace (has_glyphs);
}
public:
HBUINT16 ppem; /* The PPEM size for which this strike was designed. */
HBUINT16 resolution; /* The device pixel density (in PPI) for which this
* strike was designed. (E.g., 96 PPI, 192 PPI.) */
protected:
UnsizedArrayOf<Offset32To<SBIXGlyph>>
imageOffsetsZ; /* Offset from the beginning of the strike data header
* to bitmap data for an individual glyph ID. */
public:
DEFINE_SIZE_ARRAY (4, imageOffsetsZ);
};
struct sbix
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_sbix;
bool has_data () const { return version; }
const SBIXStrike &get_strike (unsigned int i) const { return this+strikes[i]; }
struct accelerator_t
{
accelerator_t (hb_face_t *face)
{
table = hb_sanitize_context_t ().reference_table<sbix> (face);
num_glyphs = face->get_num_glyphs ();
}
~accelerator_t () { table.destroy (); }
bool has_data () const { return table->has_data (); }
bool get_extents (hb_font_t *font,
hb_codepoint_t glyph,
hb_glyph_extents_t *extents,
bool scale = true) const
{
/* We only support PNG right now, and following function checks type. */
return get_png_extents (font, glyph, extents, scale);
}
hb_blob_t *reference_png (hb_font_t *font,
hb_codepoint_t glyph_id,
int *x_offset,
int *y_offset,
unsigned int *available_ppem) const
{
return choose_strike (font).get_glyph_blob (glyph_id, table.get_blob (),
HB_TAG ('p','n','g',' '),
x_offset, y_offset,
num_glyphs, available_ppem);
}
bool paint_glyph (hb_font_t *font, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data) const
{
if (!has_data ())
return false;
int x_offset = 0, y_offset = 0;
unsigned int strike_ppem = 0;
hb_glyph_extents_t extents;
hb_glyph_extents_t pixel_extents;
if (!font->get_glyph_extents (glyph, &extents, false))
return false;
if (unlikely (!get_extents (font, glyph, &pixel_extents, false)))
return false;
hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);
if (hb_blob_is_immutable (blob))
return false;
bool ret = funcs->image (data,
blob,
pixel_extents.width, -pixel_extents.height,
HB_PAINT_IMAGE_FORMAT_PNG,
0.f,
&extents);
hb_blob_destroy (blob);
return ret;
}
private:
const SBIXStrike &choose_strike (hb_font_t *font) const
{
unsigned count = table->strikes.len;
if (unlikely (!count))
return Null (SBIXStrike);
unsigned int requested_ppem = hb_max (font->x_ppem, font->y_ppem);
if (!requested_ppem)
requested_ppem = 1<<30; /* Choose largest strike. */
/* TODO Add DPI sensitivity as well? */
unsigned int best_i = 0;
unsigned int best_ppem = table->get_strike (0).ppem;
for (unsigned int i = 1; i < count; i++)
{
unsigned int ppem = (table->get_strike (i)).ppem;
if ((requested_ppem <= ppem && ppem < best_ppem) ||
(requested_ppem > best_ppem && ppem > best_ppem))
{
best_i = i;
best_ppem = ppem;
}
}
return table->get_strike (best_i);
}
struct PNGHeader
{
HBUINT8 signature[8];
struct
{
struct
{
HBUINT32 length;
Tag type;
} header;
HBUINT32 width;
HBUINT32 height;
HBUINT8 bitDepth;
HBUINT8 colorType;
HBUINT8 compressionMethod;
HBUINT8 filterMethod;
HBUINT8 interlaceMethod;
} IHDR;
public:
DEFINE_SIZE_STATIC (29);
};
bool get_png_extents (hb_font_t *font,
hb_codepoint_t glyph,
hb_glyph_extents_t *extents,
bool scale = true) const
{
/* Following code is safe to call even without data.
* But faster to short-circuit. */
if (!has_data ())
return false;
int x_offset = 0, y_offset = 0;
unsigned int strike_ppem = 0;
hb_blob_t *blob = reference_png (font, glyph, &x_offset, &y_offset, &strike_ppem);
const PNGHeader &png = *blob->as<PNGHeader>();
if (png.IHDR.height >= 65536 || png.IHDR.width >= 65536)
{
hb_blob_destroy (blob);
return false;
}
extents->x_bearing = x_offset;
extents->y_bearing = png.IHDR.height + y_offset;
extents->width = png.IHDR.width;
extents->height = -1 * png.IHDR.height;
/* Convert to font units. */
if (strike_ppem && scale)
{
float scale = font->face->get_upem () / (float) strike_ppem;
extents->x_bearing = roundf (extents->x_bearing * scale);
extents->y_bearing = roundf (extents->y_bearing * scale);
extents->width = roundf (extents->width * scale);
extents->height = roundf (extents->height * scale);
}
if (scale)
font->scale_glyph_extents (extents);
hb_blob_destroy (blob);
return strike_ppem;
}
private:
hb_blob_ptr_t<sbix> table;
unsigned int num_glyphs;
};
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
hb_barrier () &&
version >= 1 &&
strikes.sanitize (c, this)));
}
bool
add_strike (hb_subset_context_t *c, unsigned i) const
{
if (strikes[i].is_null () || c->source_blob->length < (unsigned) strikes[i])
return false;
return (this+strikes[i]).subset (c, c->source_blob->length - (unsigned) strikes[i]);
}
bool serialize_strike_offsets (hb_subset_context_t *c) const
{
TRACE_SERIALIZE (this);
auto *out = c->serializer->start_embed<Array32OfOffset32To<SBIXStrike>> ();
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
hb_vector_t<Offset32To<SBIXStrike>*> new_strikes;
hb_vector_t<hb_serialize_context_t::objidx_t> objidxs;
for (int i = strikes.len - 1; i >= 0; --i)
{
auto* o = out->serialize_append (c->serializer);
if (unlikely (!o)) return_trace (false);
*o = 0;
auto snap = c->serializer->snapshot ();
c->serializer->push ();
bool ret = add_strike (c, i);
if (!ret)
{
c->serializer->pop_discard ();
out->pop ();
c->serializer->revert (snap);
}
else
{
objidxs.push (c->serializer->pop_pack ());
new_strikes.push (o);
}
}
for (unsigned int i = 0; i < new_strikes.length; ++i)
c->serializer->add_link (*new_strikes[i], objidxs[new_strikes.length - 1 - i]);
return_trace (true);
}
bool subset (hb_subset_context_t* c) const
{
TRACE_SUBSET (this);
if (unlikely (!c->serializer->embed (this->version))) return_trace (false);
if (unlikely (!c->serializer->embed (this->flags))) return_trace (false);
return_trace (serialize_strike_offsets (c));
}
protected:
HBUINT16 version; /* Table version number — set to 1 */
HBUINT16 flags; /* Bit 0: Set to 1. Bit 1: Draw outlines.
* Bits 2 to 15: reserved (set to 0). */
Array32OfOffset32To<SBIXStrike>
strikes; /* Offsets from the beginning of the 'sbix'
* table to data for each individual bitmap strike. */
public:
DEFINE_SIZE_ARRAY (8, strikes);
};
struct sbix_accelerator_t : sbix::accelerator_t {
sbix_accelerator_t (hb_face_t *face) : sbix::accelerator_t (face) {}
};
} /* namespace OT */
#endif /* OT_COLOR_SBIX_SBIX_HH */

829
3rdparty/harfbuzz/src/OT/Color/svg/svg.hh vendored
View File

@@ -1,829 +0,0 @@
/*
* Copyright © 2018 Ebrahim Byagowi
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*/
#ifndef OT_COLOR_SVG_SVG_HH
#define OT_COLOR_SVG_SVG_HH
#include "../../../hb-open-type.hh"
#include "../../../hb-blob.hh"
#include "../../../hb-limits.hh"
#include "../../../hb-map.hh"
#include "../../../hb-paint.hh"
#include "../../../hb-zlib.hh"
#include <ctype.h>
#include <string.h>
/*
* SVG -- SVG (Scalable Vector Graphics)
* https://docs.microsoft.com/en-us/typography/opentype/spec/svg
*/
#define HB_OT_TAG_SVG HB_TAG('S','V','G',' ')
namespace OT {
static inline hb_blob_t *
hb_ot_svg_reference_normalized_blob (hb_blob_t *image,
const char **svg,
unsigned *len)
{
hb_blob_t *blob = hb_blob_reference (image);
unsigned data_len = 0;
const char *data = hb_blob_get_data (blob, &data_len);
if (!data || !data_len)
goto fail;
if (hb_blob_is_gzip (data, data_len))
{
uint32_t expected_size = 0;
if (hb_gzip_get_uncompressed_size (data, data_len, &expected_size) &&
unlikely ((size_t) expected_size > (size_t) HB_SVG_MAX_DOCUMENT_SIZE))
goto fail;
hb_blob_t *uncompressed = hb_blob_decompress_gzip (blob,
HB_SVG_MAX_DOCUMENT_SIZE);
if (!uncompressed)
goto fail;
hb_blob_destroy (blob);
blob = uncompressed;
data = hb_blob_get_data (blob, &data_len);
if (!data || !data_len)
goto fail;
}
if (unlikely ((size_t) data_len > (size_t) HB_SVG_MAX_DOCUMENT_SIZE))
goto fail;
if (svg) *svg = data;
if (len) *len = data_len;
return blob;
fail:
hb_blob_destroy (blob);
if (svg) *svg = nullptr;
if (len) *len = 0;
return nullptr;
}
struct SVGDocumentIndexEntry
{
int cmp (hb_codepoint_t g) const
{ return g < startGlyphID ? -1 : g > endGlyphID ? 1 : 0; }
hb_codepoint_t get_start_glyph () const
{ return startGlyphID; }
hb_codepoint_t get_end_glyph () const
{ return endGlyphID; }
hb_blob_t *reference_blob (hb_blob_t *svg_blob, unsigned int index_offset) const
{
return hb_blob_create_sub_blob (svg_blob,
index_offset + (unsigned int) svgDoc,
svgDocLength);
}
bool sanitize (hb_sanitize_context_t *c, const void *base) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
hb_barrier () &&
svgDoc.sanitize (c, base, svgDocLength));
}
protected:
HBUINT16 startGlyphID; /* The first glyph ID in the range described by
* this index entry. */
HBUINT16 endGlyphID; /* The last glyph ID in the range described by
* this index entry. Must be >= startGlyphID. */
NNOffset32To<UnsizedArrayOf<HBUINT8>>
svgDoc; /* Offset from the beginning of the SVG Document Index
* to an SVG document. Must be non-zero. */
HBUINT32 svgDocLength; /* Length of the SVG document.
* Must be non-zero. */
public:
DEFINE_SIZE_STATIC (12);
};
struct SVG
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_SVG;
struct svg_id_span_t
{
const char *p;
unsigned len;
bool operator == (const svg_id_span_t &o) const
{
return len == o.len && !memcmp (p, o.p, len);
}
uint32_t hash () const
{
uint32_t h = hb_hash (len);
for (unsigned i = 0; i < len; i++)
h = h * 33u + (unsigned char) p[i];
return h;
}
};
struct svg_defs_entry_t
{
svg_id_span_t id;
unsigned start;
unsigned end;
};
struct svg_doc_cache_t
{
hb_blob_t *blob = nullptr;
const char *svg = nullptr;
unsigned len = 0;
hb_vector_t<svg_defs_entry_t> defs_entries;
hb_codepoint_t start_glyph = HB_CODEPOINT_INVALID;
hb_codepoint_t end_glyph = HB_CODEPOINT_INVALID;
hb_vector_t<hb_pair_t<uint32_t, uint32_t>> glyph_spans;
hb_hashmap_t<svg_id_span_t, hb_pair_t<uint32_t, uint32_t>> id_spans;
};
bool has_data () const { return svgDocEntries; }
struct accelerator_t
{
accelerator_t (hb_face_t *face);
~accelerator_t ();
hb_blob_t *reference_blob_for_glyph (hb_codepoint_t glyph_id) const
{
return table->get_glyph_entry (glyph_id).reference_blob (table.get_blob (),
table->svgDocEntries);
}
unsigned get_document_count () const
{ return table->get_document_count (); }
bool get_glyph_document_index (hb_codepoint_t glyph_id, unsigned *index) const
{ return table->get_glyph_document_index (glyph_id, index); }
bool get_document_glyph_range (unsigned index,
hb_codepoint_t *start_glyph,
hb_codepoint_t *end_glyph) const
{ return table->get_document_glyph_range (index, start_glyph, end_glyph); }
bool has_data () const { return table->has_data (); }
const svg_doc_cache_t *
get_or_create_doc_cache (hb_blob_t *image,
const char *svg,
unsigned len,
unsigned doc_index,
hb_codepoint_t start_glyph,
hb_codepoint_t end_glyph) const;
const char *
doc_cache_get_svg (const svg_doc_cache_t *doc,
unsigned *len) const;
const hb_vector_t<svg_defs_entry_t> *
doc_cache_get_defs_entries (const svg_doc_cache_t *doc) const;
bool
doc_cache_get_glyph_span (const svg_doc_cache_t *doc,
hb_codepoint_t glyph,
unsigned *start,
unsigned *end) const;
bool
doc_cache_find_id_span (const svg_doc_cache_t *doc,
svg_id_span_t id,
unsigned *start,
unsigned *end) const;
bool
doc_cache_find_id_cstr (const svg_doc_cache_t *doc,
const char *id,
unsigned *start,
unsigned *end) const;
bool paint_glyph (hb_font_t *font HB_UNUSED, hb_codepoint_t glyph, hb_paint_funcs_t *funcs, void *data) const
{
if (!has_data ())
return false;
hb_blob_t *blob = reference_blob_for_glyph (glyph);
if (blob == hb_blob_get_empty ())
return false;
bool ret = funcs->image (data,
blob,
0, 0,
HB_PAINT_IMAGE_FORMAT_SVG,
0.f,
nullptr);
hb_blob_destroy (blob);
return ret;
}
private:
svg_doc_cache_t *
make_doc_cache (hb_blob_t *image,
const char *svg,
unsigned len,
hb_codepoint_t start_glyph,
hb_codepoint_t end_glyph) const;
static void destroy_doc_cache (svg_doc_cache_t *doc);
hb_blob_ptr_t<SVG> table;
mutable hb_vector_t<hb_atomic_t<svg_doc_cache_t *>> doc_caches;
public:
DEFINE_SIZE_STATIC (sizeof (hb_blob_ptr_t<SVG>) +
sizeof (hb_vector_t<hb_atomic_t<svg_doc_cache_t *>>));
};
const SVGDocumentIndexEntry &get_glyph_entry (hb_codepoint_t glyph_id) const
{ return (this+svgDocEntries).bsearch (glyph_id); }
unsigned get_document_count () const
{
if (!has_data ())
return 0;
return (this + svgDocEntries).len;
}
bool get_glyph_document_index (hb_codepoint_t glyph_id, unsigned *index) const
{
if (!has_data ())
return false;
return (this + svgDocEntries).bfind (glyph_id, index);
}
bool get_document_glyph_range (unsigned index,
hb_codepoint_t *start_glyph,
hb_codepoint_t *end_glyph) const
{
if (!has_data ())
return false;
const auto &entries = this + svgDocEntries;
if (index >= entries.len)
return false;
const auto &entry = entries.arrayZ[index];
if (start_glyph) *start_glyph = entry.get_start_glyph ();
if (end_glyph) *end_glyph = entry.get_end_glyph ();
return true;
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (likely (c->check_struct (this) &&
(this+svgDocEntries).sanitize_shallow (c)));
}
protected:
HBUINT16 version; /* Table version (starting at 0). */
Offset32To<SortedArray16Of<SVGDocumentIndexEntry>>
svgDocEntries; /* Offset (relative to the start of the SVG table) to the
* SVG Documents Index. Must be non-zero. */
/* Array of SVG Document Index Entries. */
HBUINT32 reserved; /* Set to 0. */
public:
DEFINE_SIZE_STATIC (10);
};
namespace _hb_svg_cache_impl {
struct glyph_entry_t
{
hb_codepoint_t glyph;
uint32_t start;
uint32_t end;
};
struct id_entry_t
{
SVG::svg_id_span_t id;
uint32_t start;
uint32_t end;
};
struct open_elem_t
{
unsigned start;
SVG::svg_id_span_t id;
bool in_defs_content;
bool is_defs;
};
static const unsigned MAX_DEPTH = 128;
static inline int
find_substr (const char *s,
unsigned n,
unsigned from,
const char *needle,
unsigned needle_len)
{
if (!needle_len || from >= n || needle_len > n)
return -1;
for (unsigned i = from; i + needle_len <= n; i++)
if (s[i] == needle[0] && !memcmp (s + i, needle, needle_len))
return (int) i;
return -1;
}
static inline bool
parse_id_in_start_tag (const char *svg,
unsigned tag_start,
unsigned tag_end,
SVG::svg_id_span_t *id)
{
unsigned p = tag_start;
while (p + 4 <= tag_end)
{
if (!memcmp (svg + p, "id=\"", 4))
{
unsigned b = p + 4;
unsigned e = b;
while (e < tag_end && svg[e] != '"') e++;
if (e <= tag_end && e > b)
{
*id = {svg + b, e - b};
return true;
}
}
if (!memcmp (svg + p, "id='", 4))
{
unsigned b = p + 4;
unsigned e = b;
while (e < tag_end && svg[e] != '\'') e++;
if (e <= tag_end && e > b)
{
*id = {svg + b, e - b};
return true;
}
}
p++;
}
return false;
}
static inline bool
parse_glyph_id_span (const SVG::svg_id_span_t &id,
hb_codepoint_t *glyph)
{
if (id.len <= 5 || memcmp (id.p, "glyph", 5))
return false;
hb_codepoint_t gid = 0;
for (unsigned i = 5; i < id.len; i++)
{
unsigned char c = (unsigned char) id.p[i];
if (c < '0' || c > '9')
return false;
hb_codepoint_t digit = (hb_codepoint_t) (c - '0');
if (unlikely (gid > HB_CODEPOINT_INVALID / 10 ||
(gid == HB_CODEPOINT_INVALID / 10 &&
digit > HB_CODEPOINT_INVALID % 10)))
return false;
gid = (hb_codepoint_t) (gid * 10 + digit);
}
*glyph = gid;
return true;
}
static inline bool
parse_cache_entries_linear (const char *svg,
unsigned len,
hb_vector_t<SVG::svg_defs_entry_t> *defs_entries,
hb_vector_t<glyph_entry_t> *glyph_spans,
hb_vector_t<id_entry_t> *id_entries)
{
open_elem_t stack[MAX_DEPTH] = {};
unsigned depth = 0;
if (unlikely (!defs_entries->alloc (256) ||
!glyph_spans->alloc (256) ||
!id_entries->alloc (256)))
return false;
unsigned defs_depth = 0;
unsigned i = 0;
while (i < len)
{
if (svg[i] != '<')
{
i++;
continue;
}
if (i + 4 <= len && !memcmp (svg + i, "<!--", 4))
{
int cend = find_substr (svg, len, i + 4, "-->", 3);
if (cend < 0) return false;
i = (unsigned) cend + 3;
continue;
}
if (i + 9 <= len && !memcmp (svg + i, "<![CDATA[", 9))
{
int cend = find_substr (svg, len, i + 9, "]]>", 3);
if (cend < 0) return false;
i = (unsigned) cend + 3;
continue;
}
bool closing = (i + 1 < len && svg[i + 1] == '/');
bool special = (i + 1 < len && (svg[i + 1] == '!' || svg[i + 1] == '?'));
unsigned gt = i + 1;
char quote = 0;
while (gt < len)
{
char c = svg[gt];
if (quote)
{
if (c == quote) quote = 0;
}
else
{
if (c == '"' || c == '\'')
quote = c;
else if (c == '>')
break;
}
gt++;
}
if (gt >= len)
return false;
if (special)
{
i = gt + 1;
continue;
}
unsigned p = i + (closing ? 2 : 1);
while (p < gt && isspace ((unsigned char) svg[p])) p++;
const char *name = svg + p;
unsigned name_len = 0;
while (p + name_len < gt)
{
unsigned char c = (unsigned char) name[name_len];
if (!(isalnum (c) || c == '_' || c == '-' || c == ':'))
break;
name_len++;
}
bool is_defs = (name_len == 4 && !memcmp (name, "defs", 4));
if (closing)
{
if (!depth)
{
i = gt + 1;
continue;
}
open_elem_t e = stack[--depth];
unsigned end = gt + 1;
if (e.id.len)
{
if (unlikely (!id_entries->push_or_fail (id_entry_t {e.id, (uint32_t) e.start, (uint32_t) end})))
return false;
if (e.in_defs_content)
{
if (unlikely (!defs_entries->push_or_fail ()))
return false;
auto &slot = defs_entries->tail ();
slot.id = e.id;
slot.start = e.start;
slot.end = end;
}
hb_codepoint_t gid;
if (parse_glyph_id_span (e.id, &gid))
{
if (unlikely (!glyph_spans->push_or_fail (glyph_entry_t {gid, (uint32_t) e.start, (uint32_t) end})))
return false;
}
}
if (e.is_defs && defs_depth)
defs_depth--;
i = end;
continue;
}
SVG::svg_id_span_t id = {};
parse_id_in_start_tag (svg, i, gt, &id);
unsigned r = gt;
while (r > i && isspace ((unsigned char) svg[r - 1])) r--;
bool self_closing = (r > i && svg[r - 1] == '/');
open_elem_t e = {};
e.start = i;
e.id = id;
e.in_defs_content = defs_depth > 0;
e.is_defs = is_defs;
if (self_closing)
{
unsigned end = gt + 1;
if (e.id.len)
{
if (unlikely (!id_entries->push_or_fail (id_entry_t {e.id, (uint32_t) e.start, (uint32_t) end})))
return false;
if (e.in_defs_content)
{
if (unlikely (!defs_entries->push_or_fail ()))
return false;
auto &slot = defs_entries->tail ();
slot.id = e.id;
slot.start = e.start;
slot.end = end;
}
hb_codepoint_t gid;
if (parse_glyph_id_span (e.id, &gid))
{
if (unlikely (!glyph_spans->push_or_fail (glyph_entry_t {gid, (uint32_t) e.start, (uint32_t) end})))
return false;
}
}
}
else
{
if (unlikely (depth >= MAX_DEPTH))
return false;
stack[depth++] = e;
if (is_defs)
defs_depth++;
}
i = gt + 1;
}
return true;
}
} /* namespace _hb_svg_cache_impl */
inline
SVG::accelerator_t::accelerator_t (hb_face_t *face)
{
table = hb_sanitize_context_t ().reference_table<SVG> (face);
doc_caches.init ();
unsigned doc_count = table->get_document_count ();
if (doc_count && unlikely (!doc_caches.resize (doc_count)))
doc_caches.clear ();
for (unsigned i = 0; i < doc_caches.length; i++)
doc_caches.arrayZ[i].set_relaxed (nullptr);
}
inline
SVG::accelerator_t::~accelerator_t ()
{
for (unsigned i = 0; i < doc_caches.length; i++)
destroy_doc_cache (doc_caches.arrayZ[i].get_relaxed ());
doc_caches.fini ();
table.destroy ();
}
inline void
SVG::accelerator_t::destroy_doc_cache (svg_doc_cache_t *doc)
{
if (!doc)
return;
doc->glyph_spans.fini ();
doc->defs_entries.fini ();
doc->id_spans.fini ();
hb_blob_destroy (doc->blob);
hb_free (doc);
}
inline SVG::svg_doc_cache_t *
SVG::accelerator_t::make_doc_cache (hb_blob_t *image,
const char *svg,
unsigned len,
hb_codepoint_t start_glyph,
hb_codepoint_t end_glyph) const
{
static const uint32_t INVALID_SPAN = 0xFFFFFFFFu;
auto *doc = (svg_doc_cache_t *) hb_malloc (sizeof (svg_doc_cache_t));
if (!doc)
return nullptr;
doc->blob = nullptr;
doc->svg = nullptr;
doc->len = 0;
doc->defs_entries.init ();
doc->start_glyph = HB_CODEPOINT_INVALID;
doc->end_glyph = HB_CODEPOINT_INVALID;
doc->glyph_spans.init ();
doc->id_spans.init ();
doc->blob = hb_blob_reference (image);
doc->svg = svg;
doc->len = len;
doc->start_glyph = start_glyph;
doc->end_glyph = end_glyph;
if (unlikely (start_glyph == HB_CODEPOINT_INVALID || end_glyph < start_glyph))
{
destroy_doc_cache (doc);
return nullptr;
}
unsigned glyph_count = end_glyph - start_glyph + 1;
if (!doc->glyph_spans.resize ((int) glyph_count))
{
destroy_doc_cache (doc);
return nullptr;
}
for (unsigned i = 0; i < glyph_count; i++)
doc->glyph_spans.arrayZ[i] = hb_pair_t<uint32_t, uint32_t> (INVALID_SPAN, INVALID_SPAN);
hb_vector_t<_hb_svg_cache_impl::glyph_entry_t> glyph_spans;
glyph_spans.init ();
hb_vector_t<_hb_svg_cache_impl::id_entry_t> id_entries;
id_entries.init ();
if (!_hb_svg_cache_impl::parse_cache_entries_linear (svg, len,
&doc->defs_entries,
&glyph_spans,
&id_entries))
{
id_entries.fini ();
glyph_spans.fini ();
destroy_doc_cache (doc);
return nullptr;
}
for (unsigned i = 0; i < glyph_spans.length; i++)
{
const auto &span = glyph_spans.arrayZ[i];
if (unlikely (span.glyph < start_glyph || span.glyph > end_glyph))
continue;
doc->glyph_spans.arrayZ[span.glyph - start_glyph] = hb_pair_t<uint32_t, uint32_t> (span.start, span.end);
}
for (unsigned i = 0; i < id_entries.length; i++)
{
const auto &e = id_entries.arrayZ[i];
hb_pair_t<uint32_t, uint32_t> *out = nullptr;
if (doc->id_spans.has (e.id, &out))
continue;
if (unlikely (!doc->id_spans.set (e.id, hb_pair_t<uint32_t, uint32_t> (e.start, e.end))))
{
id_entries.fini ();
glyph_spans.fini ();
destroy_doc_cache (doc);
return nullptr;
}
}
id_entries.fini ();
glyph_spans.fini ();
return doc;
}
inline const SVG::svg_doc_cache_t *
SVG::accelerator_t::get_or_create_doc_cache (hb_blob_t *image,
const char *svg,
unsigned len,
unsigned doc_index,
hb_codepoint_t start_glyph,
hb_codepoint_t end_glyph) const
{
if (doc_index >= doc_caches.length)
return nullptr;
auto &slot = doc_caches.arrayZ[doc_index];
auto *doc = slot.get_acquire ();
if (doc)
return doc;
auto *fresh = make_doc_cache (image, svg, len, start_glyph, end_glyph);
if (!fresh)
return nullptr;
auto *expected = (svg_doc_cache_t *) nullptr;
if (slot.cmpexch (expected, fresh))
return fresh;
destroy_doc_cache (fresh);
return expected;
}
inline const char *
SVG::accelerator_t::doc_cache_get_svg (const svg_doc_cache_t *doc,
unsigned *len) const
{
if (!doc)
{
if (len) *len = 0;
return nullptr;
}
if (len) *len = doc->len;
return doc->svg;
}
inline const hb_vector_t<SVG::svg_defs_entry_t> *
SVG::accelerator_t::doc_cache_get_defs_entries (const svg_doc_cache_t *doc) const
{
return doc ? &doc->defs_entries : nullptr;
}
inline bool
SVG::accelerator_t::doc_cache_get_glyph_span (const svg_doc_cache_t *doc,
hb_codepoint_t glyph,
unsigned *start,
unsigned *end) const
{
static const uint32_t INVALID_SPAN = 0xFFFFFFFFu;
if (!doc || doc->start_glyph == HB_CODEPOINT_INVALID ||
glyph < doc->start_glyph || glyph > doc->end_glyph)
return false;
const auto &span = doc->glyph_spans.arrayZ[glyph - doc->start_glyph];
if (span.first == INVALID_SPAN)
return false;
if (unlikely (span.first > span.second || span.second > doc->len))
return false;
if (start) *start = span.first;
if (end) *end = span.second;
return true;
}
inline bool
SVG::accelerator_t::doc_cache_find_id_span (const svg_doc_cache_t *doc,
svg_id_span_t id,
unsigned *start,
unsigned *end) const
{
if (!doc || !id.p || !id.len)
return false;
hb_pair_t<uint32_t, uint32_t> *span = nullptr;
if (!doc->id_spans.has (id, &span))
return false;
if (unlikely (span->first > span->second || span->second > doc->len))
return false;
if (start) *start = span->first;
if (end) *end = span->second;
return true;
}
inline bool
SVG::accelerator_t::doc_cache_find_id_cstr (const svg_doc_cache_t *doc,
const char *id,
unsigned *start,
unsigned *end) const
{
if (!id) return false;
svg_id_span_t key = {id, (unsigned) strlen (id)};
return doc_cache_find_id_span (doc, key, start, end);
}
struct SVG_accelerator_t : SVG::accelerator_t {
SVG_accelerator_t (hb_face_t *face) : SVG::accelerator_t (face) {}
};
} /* namespace OT */
#endif /* OT_COLOR_SVG_SVG_HH */

394
3rdparty/harfbuzz/src/OT/Layout/Common/Coverage.hh vendored
View File

@@ -1,394 +0,0 @@
/*
* Copyright © 2007,2008,2009 Red Hat, Inc.
* Copyright © 2010,2012 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Red Hat Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod, Garret Rieger
*/
#ifndef OT_LAYOUT_COMMON_COVERAGE_HH
#define OT_LAYOUT_COMMON_COVERAGE_HH
#include "../types.hh"
#include "CoverageFormat1.hh"
#include "CoverageFormat2.hh"
namespace OT {
namespace Layout {
namespace Common {
template<typename Iterator>
static inline void Coverage_serialize (hb_serialize_context_t *c,
Iterator it);
struct Coverage
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
CoverageFormat1_3<SmallTypes> format1;
CoverageFormat2_4<SmallTypes> format2;
#ifndef HB_NO_BEYOND_64K
CoverageFormat1_3<MediumTypes>format3;
CoverageFormat2_4<MediumTypes>format4;
#endif
} u;
public:
DEFINE_SIZE_UNION (2, format.v);
#ifndef HB_OPTIMIZE_SIZE
HB_ALWAYS_INLINE
#endif
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (!u.format.v.sanitize (c)) return_trace (false);
hb_barrier ();
switch (u.format.v)
{
case 1: return_trace (u.format1.sanitize (c));
case 2: return_trace (u.format2.sanitize (c));
#ifndef HB_NO_BEYOND_64K
case 3: return_trace (u.format3.sanitize (c));
case 4: return_trace (u.format4.sanitize (c));
#endif
default:return_trace (true);
}
}
/* Has interface. */
unsigned operator [] (hb_codepoint_t k) const { return get (k); }
bool has (hb_codepoint_t k) const { return (*this)[k] != NOT_COVERED; }
/* Predicate. */
bool operator () (hb_codepoint_t k) const { return has (k); }
unsigned int get (hb_codepoint_t k) const { return get_coverage (k); }
unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
switch (u.format.v) {
case 1: return u.format1.get_coverage (glyph_id);
case 2: return u.format2.get_coverage (glyph_id);
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.get_coverage (glyph_id);
case 4: return u.format4.get_coverage (glyph_id);
#endif
default:return NOT_COVERED;
}
}
unsigned int get_coverage (hb_codepoint_t glyph_id,
hb_ot_layout_mapping_cache_t *cache) const
{
unsigned coverage;
if (cache && cache->get (glyph_id, &coverage)) return coverage < cache->MAX_VALUE ? coverage : NOT_COVERED;
coverage = get_coverage (glyph_id);
if (cache) {
if (coverage == NOT_COVERED)
cache->set_unchecked (glyph_id, cache->MAX_VALUE);
else if (likely (coverage < cache->MAX_VALUE))
cache->set_unchecked (glyph_id, coverage);
}
return coverage;
}
unsigned int get_coverage_binary (hb_codepoint_t glyph_id,
hb_ot_layout_binary_cache_t *cache) const
{
unsigned coverage;
if (cache && cache->get (glyph_id, &coverage)) return coverage < cache->MAX_VALUE ? coverage : NOT_COVERED;
coverage = get_coverage (glyph_id);
if (cache) {
if (coverage == NOT_COVERED)
cache->set_unchecked (glyph_id, cache->MAX_VALUE);
else
cache->set_unchecked (glyph_id, 0);
}
return coverage;
}
unsigned get_population () const
{
switch (u.format.v) {
case 1: return u.format1.get_population ();
case 2: return u.format2.get_population ();
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.get_population ();
case 4: return u.format4.get_population ();
#endif
default:return NOT_COVERED;
}
}
template <typename Iterator,
hb_requires (hb_is_sorted_source_of (Iterator, hb_codepoint_t))>
bool serialize (hb_serialize_context_t *c, Iterator glyphs)
{
TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (this))) return_trace (false);
unsigned count = hb_len (glyphs);
unsigned num_ranges = 0;
hb_codepoint_t last = (hb_codepoint_t) -2;
hb_codepoint_t max = 0;
bool unsorted = false;
for (auto g: glyphs)
{
if (last != (hb_codepoint_t) -2 && g < last)
unsorted = true;
if (last + 1 != g)
num_ranges++;
last = g;
if (g > max) max = g;
}
u.format.v = !unsorted && count <= num_ranges * 3 ? 1 : 2;
#ifndef HB_NO_BEYOND_64K
if (max > 0xFFFFu)
u.format.v += 2;
if (unlikely (max > 0xFFFFFFu))
#else
if (unlikely (max > 0xFFFFu))
#endif
{
c->check_success (false, HB_SERIALIZE_ERROR_INT_OVERFLOW);
return_trace (false);
}
switch (u.format.v)
{
case 1: return_trace (u.format1.serialize (c, glyphs));
case 2: return_trace (u.format2.serialize (c, glyphs));
#ifndef HB_NO_BEYOND_64K
case 3: return_trace (u.format3.serialize (c, glyphs));
case 4: return_trace (u.format4.serialize (c, glyphs));
#endif
default:return_trace (false);
}
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
auto it =
+ iter ()
| hb_take (c->plan->source->get_num_glyphs ())
| hb_map_retains_sorting (c->plan->glyph_map_gsub)
| hb_filter ([] (hb_codepoint_t glyph) { return glyph != HB_MAP_VALUE_INVALID; })
;
// Cache the iterator result as it will be iterated multiple times
// by the serialize code below.
hb_sorted_vector_t<hb_codepoint_t> glyphs (it);
Coverage_serialize (c->serializer, glyphs.iter ());
return_trace (bool (glyphs));
}
bool intersects (const hb_set_t *glyphs) const
{
switch (u.format.v)
{
case 1: return u.format1.intersects (glyphs);
case 2: return u.format2.intersects (glyphs);
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.intersects (glyphs);
case 4: return u.format4.intersects (glyphs);
#endif
default:return false;
}
}
bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const
{
switch (u.format.v)
{
case 1: return u.format1.intersects_coverage (glyphs, index);
case 2: return u.format2.intersects_coverage (glyphs, index);
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.intersects_coverage (glyphs, index);
case 4: return u.format4.intersects_coverage (glyphs, index);
#endif
default:return false;
}
}
unsigned cost () const
{
switch (u.format.v) {
case 1: hb_barrier (); return u.format1.cost ();
case 2: hb_barrier (); return u.format2.cost ();
#ifndef HB_NO_BEYOND_64K
case 3: hb_barrier (); return u.format3.cost ();
case 4: hb_barrier (); return u.format4.cost ();
#endif
default:return 0u;
}
}
/* Might return false if array looks unsorted.
* Used for faster rejection of corrupt data. */
template <typename set_t>
bool collect_coverage (set_t *glyphs) const
{
switch (u.format.v)
{
case 1: return u.format1.collect_coverage (glyphs);
case 2: return u.format2.collect_coverage (glyphs);
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.collect_coverage (glyphs);
case 4: return u.format4.collect_coverage (glyphs);
#endif
default:return false;
}
}
template <typename IterableOut,
hb_requires (hb_is_sink_of (IterableOut, hb_codepoint_t))>
void intersect_set (const hb_set_t &glyphs, IterableOut&& intersect_glyphs) const
{
switch (u.format.v)
{
case 1: return u.format1.intersect_set (glyphs, intersect_glyphs);
case 2: return u.format2.intersect_set (glyphs, intersect_glyphs);
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.intersect_set (glyphs, intersect_glyphs);
case 4: return u.format4.intersect_set (glyphs, intersect_glyphs);
#endif
default:return ;
}
}
struct iter_t : hb_iter_with_fallback_t<iter_t, hb_codepoint_t>
{
static constexpr bool is_sorted_iterator = true;
iter_t (const Coverage &c_ = Null (Coverage))
{
hb_memset (this, 0, sizeof (*this));
format = c_.u.format.v;
switch (format)
{
case 1: u.format1.init (c_.u.format1); return;
case 2: u.format2.init (c_.u.format2); return;
#ifndef HB_NO_BEYOND_64K
case 3: u.format3.init (c_.u.format3); return;
case 4: u.format4.init (c_.u.format4); return;
#endif
default: return;
}
}
bool __more__ () const
{
switch (format)
{
case 1: return u.format1.__more__ ();
case 2: return u.format2.__more__ ();
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.__more__ ();
case 4: return u.format4.__more__ ();
#endif
default:return false;
}
}
void __next__ ()
{
switch (format)
{
case 1: u.format1.__next__ (); break;
case 2: u.format2.__next__ (); break;
#ifndef HB_NO_BEYOND_64K
case 3: u.format3.__next__ (); break;
case 4: u.format4.__next__ (); break;
#endif
default: break;
}
}
typedef hb_codepoint_t __item_t__;
__item_t__ __item__ () const { return get_glyph (); }
hb_codepoint_t get_glyph () const
{
switch (format)
{
case 1: return u.format1.get_glyph ();
case 2: return u.format2.get_glyph ();
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3.get_glyph ();
case 4: return u.format4.get_glyph ();
#endif
default:return 0;
}
}
bool operator != (const iter_t& o) const
{
if (unlikely (format != o.format)) return true;
switch (format)
{
case 1: return u.format1 != o.u.format1;
case 2: return u.format2 != o.u.format2;
#ifndef HB_NO_BEYOND_64K
case 3: return u.format3 != o.u.format3;
case 4: return u.format4 != o.u.format4;
#endif
default:return false;
}
}
iter_t __end__ () const
{
iter_t it;
it.format = format;
switch (format)
{
case 1: it.u.format1 = u.format1.__end__ (); break;
case 2: it.u.format2 = u.format2.__end__ (); break;
#ifndef HB_NO_BEYOND_64K
case 3: it.u.format3 = u.format3.__end__ (); break;
case 4: it.u.format4 = u.format4.__end__ (); break;
#endif
default: break;
}
return it;
}
private:
unsigned int format;
union {
#ifndef HB_NO_BEYOND_64K
CoverageFormat2_4<MediumTypes>::iter_t format4; /* Put this one first since it's larger; helps shut up compiler. */
CoverageFormat1_3<MediumTypes>::iter_t format3;
#endif
CoverageFormat2_4<SmallTypes>::iter_t format2; /* Put this one first since it's larger; helps shut up compiler. */
CoverageFormat1_3<SmallTypes>::iter_t format1;
} u;
};
iter_t iter () const { return iter_t (*this); }
};
template<typename Iterator>
static inline void
Coverage_serialize (hb_serialize_context_t *c,
Iterator it)
{ c->start_embed<Coverage> ()->serialize (c, it); }
}
}
}
#endif // #ifndef OT_LAYOUT_COMMON_COVERAGE_HH

135
3rdparty/harfbuzz/src/OT/Layout/Common/CoverageFormat1.hh vendored
View File

@@ -1,135 +0,0 @@
/*
* Copyright © 2007,2008,2009 Red Hat, Inc.
* Copyright © 2010,2012 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Red Hat Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod, Garret Rieger
*/
#ifndef OT_LAYOUT_COMMON_COVERAGEFORMAT1_HH
#define OT_LAYOUT_COMMON_COVERAGEFORMAT1_HH
namespace OT {
namespace Layout {
namespace Common {
#define NOT_COVERED ((unsigned int) -1)
template <typename Types>
struct CoverageFormat1_3
{
friend struct Coverage;
public:
HBUINT16 coverageFormat; /* Format identifier--format = 1 */
SortedArray16Of<typename Types::HBGlyphID>
glyphArray; /* Array of GlyphIDs--in numerical order */
DEFINE_SIZE_ARRAY (4, glyphArray);
private:
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (glyphArray.sanitize (c));
}
unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
unsigned int i;
glyphArray.bfind (glyph_id, &i, HB_NOT_FOUND_STORE, NOT_COVERED);
return i;
}
unsigned get_population () const
{
return glyphArray.len;
}
template <typename Iterator,
hb_requires (hb_is_sorted_source_of (Iterator, hb_codepoint_t))>
bool serialize (hb_serialize_context_t *c, Iterator glyphs)
{
TRACE_SERIALIZE (this);
return_trace (glyphArray.serialize (c, glyphs));
}
bool intersects (const hb_set_t *glyphs) const
{
if (glyphArray.len > glyphs->get_population () * hb_bit_storage ((unsigned) glyphArray.len))
{
for (auto g : *glyphs)
if (get_coverage (g) != NOT_COVERED)
return true;
return false;
}
for (const auto& g : glyphArray.as_array ())
if (glyphs->has (g))
return true;
return false;
}
bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const
{ return glyphs->has (glyphArray[index]); }
template <typename IterableOut,
hb_requires (hb_is_sink_of (IterableOut, hb_codepoint_t))>
void intersect_set (const hb_set_t &glyphs, IterableOut&& intersect_glyphs) const
{
unsigned count = glyphArray.len;
for (unsigned i = 0; i < count; i++)
if (glyphs.has (glyphArray[i]))
intersect_glyphs << glyphArray[i];
}
unsigned cost () const { return hb_bit_storage ((unsigned) glyphArray.len); /* bsearch cost */ }
template <typename set_t>
bool collect_coverage (set_t *glyphs) const
{ return glyphs->add_sorted_array (glyphArray.as_array ()); }
public:
/* Older compilers need this to be public. */
struct iter_t
{
void init (const struct CoverageFormat1_3 &c_) { c = &c_; i = 0; }
bool __more__ () const { return i < c->glyphArray.len; }
void __next__ () { i++; }
hb_codepoint_t get_glyph () const { return c->glyphArray[i]; }
bool operator != (const iter_t& o) const
{ return i != o.i; }
iter_t __end__ () const { iter_t it; it.init (*c); it.i = c->glyphArray.len; return it; }
private:
const struct CoverageFormat1_3 *c;
unsigned int i;
};
private:
};
}
}
}
#endif // #ifndef OT_LAYOUT_COMMON_COVERAGEFORMAT1_HH

241
3rdparty/harfbuzz/src/OT/Layout/Common/CoverageFormat2.hh vendored
View File

@@ -1,241 +0,0 @@
/*
* Copyright © 2007,2008,2009 Red Hat, Inc.
* Copyright © 2010,2012 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Red Hat Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod, Garret Rieger
*/
#ifndef OT_LAYOUT_COMMON_COVERAGEFORMAT2_HH
#define OT_LAYOUT_COMMON_COVERAGEFORMAT2_HH
#include "RangeRecord.hh"
namespace OT {
namespace Layout {
namespace Common {
template <typename Types>
struct CoverageFormat2_4
{
friend struct Coverage;
public:
HBUINT16 coverageFormat; /* Format identifier--format = 2 */
SortedArray16Of<RangeRecord<Types>>
rangeRecord; /* Array of glyph ranges--ordered by
* Start GlyphID. rangeCount entries
* long */
public:
DEFINE_SIZE_ARRAY (4, rangeRecord);
private:
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (rangeRecord.sanitize (c));
}
unsigned int get_coverage (hb_codepoint_t glyph_id) const
{
const RangeRecord<Types> &range = rangeRecord.bsearch (glyph_id);
return likely (range.first <= range.last)
? (unsigned int) range.value + (glyph_id - range.first)
: NOT_COVERED;
}
unsigned get_population () const
{
typename Types::large_int ret = 0;
for (const auto &r : rangeRecord)
ret += r.get_population ();
return ret > UINT_MAX ? UINT_MAX : (unsigned) ret;
}
template <typename Iterator,
hb_requires (hb_is_sorted_source_of (Iterator, hb_codepoint_t))>
bool serialize (hb_serialize_context_t *c, Iterator glyphs)
{
TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (this))) return_trace (false);
unsigned num_ranges = 0;
hb_codepoint_t last = (hb_codepoint_t) -2;
for (auto g: glyphs)
{
if (last + 1 != g)
num_ranges++;
last = g;
}
if (unlikely (!rangeRecord.serialize (c, num_ranges))) return_trace (false);
if (!num_ranges) return_trace (true);
unsigned count = 0;
unsigned range = (unsigned) -1;
last = (hb_codepoint_t) -2;
unsigned unsorted = false;
for (auto g: glyphs)
{
if (last + 1 != g)
{
if (unlikely (last != (hb_codepoint_t) -2 && last + 1 > g))
unsorted = true;
range++;
rangeRecord.arrayZ[range].first = g;
rangeRecord.arrayZ[range].value = count;
}
rangeRecord.arrayZ[range].last = g;
last = g;
count++;
}
if (unlikely (unsorted))
rangeRecord.as_array ().qsort (RangeRecord<Types>::cmp_range);
return_trace (true);
}
bool intersects (const hb_set_t *glyphs) const
{
if (rangeRecord.len > glyphs->get_population () * hb_bit_storage ((unsigned) rangeRecord.len))
{
for (auto g : *glyphs)
if (get_coverage (g) != NOT_COVERED)
return true;
return false;
}
return hb_any (+ hb_iter (rangeRecord)
| hb_map ([glyphs] (const RangeRecord<Types> &range) { return range.intersects (*glyphs); }));
}
bool intersects_coverage (const hb_set_t *glyphs, unsigned int index) const
{
auto *range = rangeRecord.as_array ().bsearch (index);
if (range)
return range->intersects (*glyphs);
return false;
}
template <typename IterableOut,
hb_requires (hb_is_sink_of (IterableOut, hb_codepoint_t))>
void intersect_set (const hb_set_t &glyphs, IterableOut&& intersect_glyphs) const
{
/* Break out of loop for overlapping, broken, tables,
* to avoid fuzzer timouts. */
hb_codepoint_t last = 0;
for (const auto& range : rangeRecord)
{
if (unlikely (range.first < last))
break;
last = range.last;
for (hb_codepoint_t g = range.first - 1;
glyphs.next (&g) && g <= last;)
intersect_glyphs << g;
}
}
unsigned cost () const { return hb_bit_storage ((unsigned) rangeRecord.len); /* bsearch cost */ }
template <typename set_t>
bool collect_coverage (set_t *glyphs) const
{
for (const auto& range: rangeRecord)
if (unlikely (!range.collect_coverage (glyphs)))
return false;
return true;
}
public:
/* Older compilers need this to be public. */
struct iter_t
{
void init (const CoverageFormat2_4 &c_)
{
c = &c_;
coverage = 0;
i = 0;
j = c->rangeRecord.len ? c->rangeRecord[0].first : 0;
if (unlikely (c->rangeRecord[0].first > c->rangeRecord[0].last))
{
/* Broken table. Skip. */
i = c->rangeRecord.len;
j = 0;
}
}
bool __more__ () const { return i < c->rangeRecord.len; }
void __next__ ()
{
if (j >= c->rangeRecord[i].last)
{
i++;
if (__more__ ())
{
unsigned int old = coverage;
j = c->rangeRecord.arrayZ[i].first;
coverage = c->rangeRecord.arrayZ[i].value;
if (unlikely (coverage != old + 1))
{
/* Broken table. Skip. Important to avoid DoS.
* Also, our callers depend on coverage being
* consecutive and monotonically increasing,
* ie. iota(). */
i = c->rangeRecord.len;
j = 0;
return;
}
}
else
j = 0;
return;
}
coverage++;
j++;
}
hb_codepoint_t get_glyph () const { return j; }
bool operator != (const iter_t& o) const
{ return i != o.i || j != o.j; }
iter_t __end__ () const
{
iter_t it;
it.init (*c);
it.i = c->rangeRecord.len;
it.j = 0;
return it;
}
private:
const struct CoverageFormat2_4 *c;
unsigned int i, coverage;
hb_codepoint_t j;
};
private:
};
}
}
}
#endif // #ifndef OT_LAYOUT_COMMON_COVERAGEFORMAT2_HH

97
3rdparty/harfbuzz/src/OT/Layout/Common/RangeRecord.hh vendored
View File

@@ -1,97 +0,0 @@
/*
* Copyright © 2007,2008,2009 Red Hat, Inc.
* Copyright © 2010,2012 Google, Inc.
*
* This is part of HarfBuzz, a text shaping library.
*
* Permission is hereby granted, without written agreement and without
* license or royalty fees, to use, copy, modify, and distribute this
* software and its documentation for any purpose, provided that the
* above copyright notice and the following two paragraphs appear in
* all copies of this software.
*
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* Red Hat Author(s): Behdad Esfahbod
* Google Author(s): Behdad Esfahbod, Garret Rieger
*/
#ifndef OT_LAYOUT_COMMON_RANGERECORD_HH
#define OT_LAYOUT_COMMON_RANGERECORD_HH
namespace OT {
namespace Layout {
namespace Common {
template <typename Types>
struct RangeRecord
{
typename Types::HBGlyphID first; /* First GlyphID in the range */
typename Types::HBGlyphID last; /* Last GlyphID in the range */
HBUINT16 value; /* Value */
DEFINE_SIZE_STATIC (2 + 2 * Types::size);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
int cmp (hb_codepoint_t g) const
{ return g < first ? -1 : g <= last ? 0 : +1; }
HB_INTERNAL static int cmp_range (const void *pa, const void *pb) {
const RangeRecord *a = (const RangeRecord *) pa;
const RangeRecord *b = (const RangeRecord *) pb;
if (a->first < b->first) return -1;
if (a->first > b->first) return +1;
if (a->last < b->last) return -1;
if (a->last > b->last) return +1;
if (a->value < b->value) return -1;
if (a->value > b->value) return +1;
return 0;
}
unsigned get_population () const
{
if (unlikely (last < first)) return 0;
return (last - first + 1);
}
bool intersects (const hb_set_t &glyphs) const
{ return glyphs.intersects (first, last); }
template <typename set_t>
bool collect_coverage (set_t *glyphs) const
{ return glyphs->add_range (first, last); }
};
}
}
}
// TODO(garretrieger): This was previously implemented using
// DECLARE_NULL_NAMESPACE_BYTES_TEMPLATE1 (OT, RangeRecord, 9);
// but that only works when there is only a single namespace level.
// The macro should probably be fixed so it can work in this situation.
extern HB_INTERNAL const unsigned char _hb_Null_OT_RangeRecord[9];
template <typename Spec>
struct Null<OT::Layout::Common::RangeRecord<Spec>> {
static OT::Layout::Common::RangeRecord<Spec> const & get_null () {
return *reinterpret_cast<const OT::Layout::Common::RangeRecord<Spec> *> (_hb_Null_OT_RangeRecord);
}
};
#endif // #ifndef OT_LAYOUT_COMMON_RANGERECORD_HH

1060
3rdparty/harfbuzz/src/OT/Layout/GDEF/GDEF.hh vendored
View File

File diff suppressed because it is too large Load Diff

84
3rdparty/harfbuzz/src/OT/Layout/GPOS/Anchor.hh vendored
View File

@@ -1,84 +0,0 @@
#ifndef OT_LAYOUT_GPOS_ANCHOR_HH
#define OT_LAYOUT_GPOS_ANCHOR_HH
#include "AnchorFormat1.hh"
#include "AnchorFormat2.hh"
#include "AnchorFormat3.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct Anchor
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
AnchorFormat1 format1;
AnchorFormat2 format2;
AnchorFormat3 format3;
} u;
public:
DEFINE_SIZE_UNION (2, format.v);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (!u.format.v.sanitize (c)) return_trace (false);
hb_barrier ();
switch (u.format.v) {
case 1: return_trace (u.format1.sanitize (c));
case 2: return_trace (u.format2.sanitize (c));
case 3: return_trace (u.format3.sanitize (c));
default:return_trace (true);
}
}
void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
float *x, float *y) const
{
*x = *y = 0;
switch (u.format.v) {
case 1: u.format1.get_anchor (c, glyph_id, x, y); return;
case 2: u.format2.get_anchor (c, glyph_id, x, y); return;
case 3: u.format3.get_anchor (c, glyph_id, x, y); return;
default: return;
}
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
switch (u.format.v) {
case 1: return_trace (bool (reinterpret_cast<Anchor *> (u.format1.copy (c->serializer))));
case 2:
if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
{
// AnchorFormat 2 just containins extra hinting information, so
// if hints are being dropped convert to format 1.
return_trace (bool (reinterpret_cast<Anchor *> (u.format1.copy (c->serializer))));
}
return_trace (bool (reinterpret_cast<Anchor *> (u.format2.copy (c->serializer))));
case 3: return_trace (u.format3.subset (c));
default:return_trace (false);
}
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
switch (u.format.v) {
case 1: case 2:
return;
case 3:
u.format3.collect_variation_indices (c);
return;
default: return;
}
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_ANCHOR_HH

46
3rdparty/harfbuzz/src/OT/Layout/GPOS/AnchorFormat1.hh vendored
View File

@@ -1,46 +0,0 @@
#ifndef OT_LAYOUT_GPOS_ANCHORFORMAT1_HH
#define OT_LAYOUT_GPOS_ANCHORFORMAT1_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct AnchorFormat1
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
FWORD xCoordinate; /* Horizontal value--in design units */
FWORD yCoordinate; /* Vertical value--in design units */
public:
DEFINE_SIZE_STATIC (6);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
float *x, float *y) const
{
hb_font_t *font = c->font;
*x = font->em_fscale_x (xCoordinate);
*y = font->em_fscale_y (yCoordinate);
}
AnchorFormat1* copy (hb_serialize_context_t *c) const
{
TRACE_SERIALIZE (this);
AnchorFormat1* out = c->embed<AnchorFormat1> (this);
if (!out) return_trace (out);
out->format = 1;
return_trace (out);
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_ANCHORFORMAT1_HH

58
3rdparty/harfbuzz/src/OT/Layout/GPOS/AnchorFormat2.hh vendored
View File

@@ -1,58 +0,0 @@
#ifndef OT_LAYOUT_GPOS_ANCHORFORMAT2_HH
#define OT_LAYOUT_GPOS_ANCHORFORMAT2_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct AnchorFormat2
{
protected:
HBUINT16 format; /* Format identifier--format = 2 */
FWORD xCoordinate; /* Horizontal value--in design units */
FWORD yCoordinate; /* Vertical value--in design units */
HBUINT16 anchorPoint; /* Index to glyph contour point */
public:
DEFINE_SIZE_STATIC (8);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this));
}
void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
float *x, float *y) const
{
hb_font_t *font = c->font;
#ifdef HB_NO_HINTING
*x = font->em_fscale_x (xCoordinate);
*y = font->em_fscale_y (yCoordinate);
return;
#endif
unsigned int x_ppem = font->x_ppem;
unsigned int y_ppem = font->y_ppem;
hb_position_t cx = 0, cy = 0;
bool ret;
ret = (x_ppem || y_ppem) &&
font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
*x = ret && x_ppem ? cx : font->em_fscale_x (xCoordinate);
*y = ret && y_ppem ? cy : font->em_fscale_y (yCoordinate);
}
AnchorFormat2* copy (hb_serialize_context_t *c) const
{
TRACE_SERIALIZE (this);
return_trace (c->embed<AnchorFormat2> (this));
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_ANCHORFORMAT2_HH

123
3rdparty/harfbuzz/src/OT/Layout/GPOS/AnchorFormat3.hh vendored
View File

@@ -1,123 +0,0 @@
#ifndef OT_LAYOUT_GPOS_ANCHORFORMAT3_HH
#define OT_LAYOUT_GPOS_ANCHORFORMAT3_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct AnchorFormat3
{
protected:
HBUINT16 format; /* Format identifier--format = 3 */
FWORD xCoordinate; /* Horizontal value--in design units */
FWORD yCoordinate; /* Vertical value--in design units */
Offset16To<Device>
xDeviceTable; /* Offset to Device table for X
* coordinate-- from beginning of
* Anchor table (may be NULL) */
Offset16To<Device>
yDeviceTable; /* Offset to Device table for Y
* coordinate-- from beginning of
* Anchor table (may be NULL) */
public:
DEFINE_SIZE_STATIC (10);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (unlikely (!c->check_struct (this))) return_trace (false);
return_trace (xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
}
void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
float *x, float *y) const
{
hb_font_t *font = c->font;
*x = font->em_fscale_x (xCoordinate);
*y = font->em_fscale_y (yCoordinate);
if ((font->x_ppem || font->has_nonzero_coords) && xDeviceTable.sanitize (&c->sanitizer, this))
{
hb_barrier ();
*x += (this+xDeviceTable).get_x_delta (font, c->var_store, c->var_store_cache);
}
if ((font->y_ppem || font->has_nonzero_coords) && yDeviceTable.sanitize (&c->sanitizer, this))
{
hb_barrier ();
*y += (this+yDeviceTable).get_y_delta (font, c->var_store, c->var_store_cache);
}
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->embed (format))) return_trace (false);
if (unlikely (!c->serializer->embed (xCoordinate))) return_trace (false);
if (unlikely (!c->serializer->embed (yCoordinate))) return_trace (false);
unsigned x_varidx = xDeviceTable ? (this+xDeviceTable).get_variation_index () : HB_OT_LAYOUT_NO_VARIATIONS_INDEX;
if (x_varidx != HB_OT_LAYOUT_NO_VARIATIONS_INDEX)
{
hb_pair_t<unsigned, int> *new_varidx_delta;
if (!c->plan->layout_variation_idx_delta_map.has (x_varidx, &new_varidx_delta))
return_trace (false);
x_varidx = hb_first (*new_varidx_delta);
int delta = hb_second (*new_varidx_delta);
if (delta != 0)
{
if (!c->serializer->check_assign (out->xCoordinate, xCoordinate + delta,
HB_SERIALIZE_ERROR_INT_OVERFLOW))
return_trace (false);
}
}
unsigned y_varidx = yDeviceTable ? (this+yDeviceTable).get_variation_index () : HB_OT_LAYOUT_NO_VARIATIONS_INDEX;
if (y_varidx != HB_OT_LAYOUT_NO_VARIATIONS_INDEX)
{
hb_pair_t<unsigned, int> *new_varidx_delta;
if (!c->plan->layout_variation_idx_delta_map.has (y_varidx, &new_varidx_delta))
return_trace (false);
y_varidx = hb_first (*new_varidx_delta);
int delta = hb_second (*new_varidx_delta);
if (delta != 0)
{
if (!c->serializer->check_assign (out->yCoordinate, yCoordinate + delta,
HB_SERIALIZE_ERROR_INT_OVERFLOW))
return_trace (false);
}
}
bool no_downgrade = (!xDeviceTable.is_null () && !(this+xDeviceTable).is_variation_device ()) ||
x_varidx != HB_OT_LAYOUT_NO_VARIATIONS_INDEX ||
y_varidx != HB_OT_LAYOUT_NO_VARIATIONS_INDEX ||
(!yDeviceTable.is_null () && !(this+yDeviceTable).is_variation_device ());
if (!no_downgrade)
return_trace (c->serializer->check_assign (out->format, 1, HB_SERIALIZE_ERROR_INT_OVERFLOW));
if (!c->serializer->embed (xDeviceTable)) return_trace (false);
if (!c->serializer->embed (yDeviceTable)) return_trace (false);
out->xDeviceTable.serialize_copy (c->serializer, xDeviceTable, this, 0, hb_serialize_context_t::Head, &c->plan->layout_variation_idx_delta_map);
out->yDeviceTable.serialize_copy (c->serializer, yDeviceTable, this, 0, hb_serialize_context_t::Head, &c->plan->layout_variation_idx_delta_map);
return_trace (out);
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
(this+xDeviceTable).collect_variation_indices (c);
(this+yDeviceTable).collect_variation_indices (c);
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_ANCHORFORMAT3_HH

94
3rdparty/harfbuzz/src/OT/Layout/GPOS/AnchorMatrix.hh vendored
View File

@@ -1,94 +0,0 @@
#ifndef OT_LAYOUT_GPOS_ANCHORMATRIX_HH
#define OT_LAYOUT_GPOS_ANCHORMATRIX_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct AnchorMatrix
{
HBUINT16 rows; /* Number of rows */
UnsizedArrayOf<Offset16To<Anchor, AnchorMatrix>>
matrixZ; /* Matrix of offsets to Anchor tables--
* from beginning of AnchorMatrix table */
public:
DEFINE_SIZE_ARRAY (2, matrixZ);
bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const
{
TRACE_SANITIZE (this);
if (!c->check_struct (this)) return_trace (false);
hb_barrier ();
if (unlikely (hb_unsigned_mul_overflows (rows, cols))) return_trace (false);
unsigned int count = rows * cols;
if (!c->check_array (matrixZ.arrayZ, count)) return_trace (false);
if (c->lazy_some_gpos)
return_trace (true);
hb_barrier ();
for (unsigned int i = 0; i < count; i++)
if (!matrixZ[i].sanitize (c, this)) return_trace (false);
return_trace (true);
}
const Anchor& get_anchor (hb_ot_apply_context_t *c,
unsigned int row, unsigned int col,
unsigned int cols, bool *found) const
{
*found = false;
if (unlikely (row >= rows || col >= cols)) return Null (Anchor);
auto &offset = matrixZ[row * cols + col];
if (unlikely (!offset.sanitize (&c->sanitizer, this))) return Null (Anchor);
hb_barrier ();
*found = !offset.is_null ();
return this+offset;
}
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
Iterator index_iter) const
{
for (unsigned i : index_iter)
(this+matrixZ[i]).collect_variation_indices (c);
}
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
bool subset (hb_subset_context_t *c,
unsigned num_rows,
Iterator index_iter) const
{
TRACE_SUBSET (this);
auto *out = c->serializer->start_embed (this);
if (!index_iter) return_trace (false);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->rows = num_rows;
for (const unsigned i : index_iter)
{
auto *offset = c->serializer->embed (matrixZ[i]);
if (!offset) return_trace (false);
offset->serialize_subset (c, matrixZ[i], this);
}
return_trace (true);
}
bool offset_is_null (unsigned row, unsigned col, unsigned num_cols) const
{
if (unlikely (row >= rows || col >= num_cols)) return true;
auto &offset = matrixZ[row * num_cols + col];
return offset.is_null ();
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_ANCHORMATRIX_HH */

14
3rdparty/harfbuzz/src/OT/Layout/GPOS/ChainContextPos.hh vendored
View File

@@ -1,14 +0,0 @@
#ifndef OT_LAYOUT_GPOS_CHAINCONTEXTPOS_HH
#define OT_LAYOUT_GPOS_CHAINCONTEXTPOS_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct ChainContextPos : ChainContext {};
}
}
}
#endif /* OT_LAYOUT_GPOS_CHAINCONTEXTPOS_HH */

33
3rdparty/harfbuzz/src/OT/Layout/GPOS/Common.hh vendored
View File

@@ -1,33 +0,0 @@
#ifndef OT_LAYOUT_GPOS_COMMON_HH
#define OT_LAYOUT_GPOS_COMMON_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
enum attach_type_t {
ATTACH_TYPE_NONE = 0X00,
/* Each attachment should be either a mark or a cursive; can't be both. */
ATTACH_TYPE_MARK = 0X01,
ATTACH_TYPE_CURSIVE = 0X02,
};
/* buffer **position** var allocations */
#define attach_chain() var.i16[0] /* glyph to which this attaches to, relative to current glyphs; negative for going back, positive for forward. */
#define attach_type() var.u8[2] /* attachment type */
/* Note! if attach_chain() is zero, the value of attach_type() is irrelevant. */
template<typename Iterator, typename SrcLookup>
static void SinglePos_serialize (hb_serialize_context_t *c,
const SrcLookup *src,
Iterator it,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map,
unsigned new_format);
}
}
}
#endif // OT_LAYOUT_GPOS_COMMON_HH

14
3rdparty/harfbuzz/src/OT/Layout/GPOS/ContextPos.hh vendored
View File

@@ -1,14 +0,0 @@
#ifndef OT_LAYOUT_GPOS_CONTEXTPOS_HH
#define OT_LAYOUT_GPOS_CONTEXTPOS_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct ContextPos : Context {};
}
}
}
#endif /* OT_LAYOUT_GPOS_CONTEXTPOS_HH */

35
3rdparty/harfbuzz/src/OT/Layout/GPOS/CursivePos.hh vendored
View File

@@ -1,35 +0,0 @@
#ifndef OT_LAYOUT_GPOS_CURSIVEPOS_HH
#define OT_LAYOUT_GPOS_CURSIVEPOS_HH
#include "CursivePosFormat1.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct CursivePos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
CursivePosFormat1 format1;
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
default:return_trace (c->default_return_value ());
}
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_CURSIVEPOS_HH */

332
3rdparty/harfbuzz/src/OT/Layout/GPOS/CursivePosFormat1.hh vendored
View File

@@ -1,332 +0,0 @@
#ifndef OT_LAYOUT_GPOS_CURSIVEPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_CURSIVEPOSFORMAT1_HH
#include "Anchor.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct EntryExitRecord
{
friend struct CursivePosFormat1;
bool sanitize (hb_sanitize_context_t *c, const struct CursivePosFormat1 *base) const
{
TRACE_SANITIZE (this);
return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
const struct CursivePosFormat1 *src_base) const
{
(src_base+entryAnchor).collect_variation_indices (c);
(src_base+exitAnchor).collect_variation_indices (c);
}
bool subset (hb_subset_context_t *c,
const struct CursivePosFormat1 *src_base) const
{
TRACE_SERIALIZE (this);
auto *out = c->serializer->embed (this);
if (unlikely (!out)) return_trace (false);
bool ret = false;
ret |= out->entryAnchor.serialize_subset (c, entryAnchor, src_base);
ret |= out->exitAnchor.serialize_subset (c, exitAnchor, src_base);
return_trace (ret);
}
protected:
Offset16To<Anchor, struct CursivePosFormat1>
entryAnchor; /* Offset to EntryAnchor table--from
* beginning of CursivePos
* subtable--may be NULL */
Offset16To<Anchor, struct CursivePosFormat1>
exitAnchor; /* Offset to ExitAnchor table--from
* beginning of CursivePos
* subtable--may be NULL */
public:
DEFINE_SIZE_STATIC (4);
};
static inline void
reverse_cursive_minor_offset (hb_glyph_position_t *pos,
unsigned int len,
unsigned int i,
hb_direction_t direction,
unsigned int new_parent)
{
int chain = pos[i].attach_chain(), type = pos[i].attach_type();
if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE)))
return;
pos[i].attach_chain() = 0;
unsigned int j = (int) i + chain;
if (unlikely (j >= len))
return;
/* Stop if we see new parent in the chain. */
if (j == new_parent)
return;
int16_t reversed_chain = -chain;
/* The old edge was cleared above; if the reversed distance truncates,
* keep it detached instead of storing a poisoned chain.
*/
if (unlikely (reversed_chain != -chain))
return;
reverse_cursive_minor_offset (pos, len, j, direction, new_parent);
if (HB_DIRECTION_IS_HORIZONTAL (direction))
pos[j].y_offset = -pos[i].y_offset;
else
pos[j].x_offset = -pos[i].x_offset;
pos[j].attach_chain() = reversed_chain;
pos[j].attach_type() = type;
}
struct CursivePosFormat1
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
Offset16To<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
Array16Of<EntryExitRecord>
entryExitRecord; /* Array of EntryExit records--in
* Coverage Index order */
public:
DEFINE_SIZE_ARRAY (6, entryExitRecord);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (unlikely (!coverage.sanitize (c, this)))
return_trace (false);
if (c->lazy_some_gpos)
return_trace (entryExitRecord.sanitize_shallow (c));
else
return_trace (entryExitRecord.sanitize (c, this));
}
bool intersects (const hb_set_t *glyphs) const
{ return (this+coverage).intersects (glyphs); }
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
+ hb_zip (this+coverage, entryExitRecord)
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
| hb_apply ([&] (const EntryExitRecord& record) { record.collect_variation_indices (c, this); })
;
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{ if (unlikely (!(this+coverage).collect_coverage (c->input))) return; }
const Coverage &get_coverage () const { return this+coverage; }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)];
if (!this_record.entryAnchor ||
unlikely (!this_record.entryAnchor.sanitize (&c->sanitizer, this))) return_trace (false);
hb_barrier ();
auto &skippy_iter = c->iter_input;
skippy_iter.reset_fast (buffer->idx);
unsigned unsafe_from;
if (unlikely (!skippy_iter.prev (&unsafe_from)))
{
buffer->unsafe_to_concat_from_outbuffer (unsafe_from, buffer->idx + 1);
return_trace (false);
}
const EntryExitRecord &prev_record = entryExitRecord[(this+coverage).get_coverage (buffer->info[skippy_iter.idx].codepoint)];
if (!prev_record.exitAnchor ||
unlikely (!prev_record.exitAnchor.sanitize (&c->sanitizer, this)))
{
buffer->unsafe_to_concat_from_outbuffer (skippy_iter.idx, buffer->idx + 1);
return_trace (false);
}
hb_barrier ();
unsigned int i = skippy_iter.idx;
unsigned int j = buffer->idx;
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"cursive attaching glyph at %u to glyph at %u",
i, j);
}
buffer->unsafe_to_break (i, j + 1);
float entry_x, entry_y, exit_x, exit_y;
(this+prev_record.exitAnchor).get_anchor (c, buffer->info[i].codepoint, &exit_x, &exit_y);
(this+this_record.entryAnchor).get_anchor (c, buffer->info[j].codepoint, &entry_x, &entry_y);
hb_glyph_position_t *pos = buffer->pos;
hb_position_t d;
/* Main-direction adjustment */
switch (c->direction) {
case HB_DIRECTION_LTR:
pos[i].x_advance = roundf (exit_x) + pos[i].x_offset;
d = roundf (entry_x) + pos[j].x_offset;
pos[j].x_advance -= d;
pos[j].x_offset -= d;
break;
case HB_DIRECTION_RTL:
d = roundf (exit_x) + pos[i].x_offset;
pos[i].x_advance -= d;
pos[i].x_offset -= d;
pos[j].x_advance = roundf (entry_x) + pos[j].x_offset;
break;
case HB_DIRECTION_TTB:
pos[i].y_advance = roundf (exit_y) + pos[i].y_offset;
d = roundf (entry_y) + pos[j].y_offset;
pos[j].y_advance -= d;
pos[j].y_offset -= d;
break;
case HB_DIRECTION_BTT:
d = roundf (exit_y) + pos[i].y_offset;
pos[i].y_advance -= d;
pos[i].y_offset -= d;
pos[j].y_advance = roundf (entry_y);
break;
case HB_DIRECTION_INVALID:
default:
break;
}
/* Cross-direction adjustment */
/* We attach child to parent (think graph theory and rooted trees whereas
* the root stays on baseline and each node aligns itself against its
* parent.
*
* Optimize things for the case of RightToLeft, as that's most common in
* Arabic. */
unsigned int child = i;
unsigned int parent = j;
hb_position_t x_offset = roundf (entry_x - exit_x);
hb_position_t y_offset = roundf (entry_y - exit_y);
if (!(c->lookup_props & LookupFlag::RightToLeft))
{
unsigned int k = child;
child = parent;
parent = k;
x_offset = -x_offset;
y_offset = -y_offset;
}
/* If child was already connected to someone else, walk through its old
* chain and reverse the link direction, such that the whole tree of its
* previous connection now attaches to new parent. Watch out for case
* where new parent is on the path from old chain...
*/
reverse_cursive_minor_offset (pos, buffer->len, child, c->direction, parent);
pos[child].attach_chain() = (int) parent - (int) child;
if (pos[child].attach_chain() != (int) parent - (int) child)
{
pos[child].attach_chain() = 0;
goto overflow;
}
pos[child].attach_type() = ATTACH_TYPE_CURSIVE;
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
pos[child].y_offset = y_offset;
else
pos[child].x_offset = x_offset;
/* If parent was attached to child, separate them.
* https://github.com/harfbuzz/harfbuzz/issues/2469
*/
if (unlikely (pos[parent].attach_chain() == -pos[child].attach_chain()))
{
pos[parent].attach_chain() = 0;
if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
pos[parent].y_offset = 0;
else
pos[parent].x_offset = 0;
}
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"cursive attached glyph at %u to glyph at %u",
i, j);
}
overflow:
buffer->idx++;
return_trace (true);
}
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
void serialize (hb_subset_context_t *c,
Iterator it,
const struct CursivePosFormat1 *src_base)
{
if (unlikely (!c->serializer->extend_min ((*this)))) return;
this->format = 1;
this->entryExitRecord.len = it.len ();
for (const EntryExitRecord& entry_record : + it
| hb_map (hb_second))
entry_record.subset (c, src_base);
auto glyphs =
+ it
| hb_map_retains_sorting (hb_first)
;
coverage.serialize_serialize (c->serializer, glyphs);
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto *out = c->serializer->start_embed (*this);
auto it =
+ hb_zip (this+coverage, entryExitRecord)
| hb_filter (glyphset, hb_first)
| hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const EntryExitRecord&> p) -> hb_pair_t<hb_codepoint_t, const EntryExitRecord&>
{ return hb_pair (glyph_map[p.first], p.second);})
;
bool ret = bool (it);
out->serialize (c, it, this);
return_trace (ret);
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_CURSIVEPOSFORMAT1_HH */

17
3rdparty/harfbuzz/src/OT/Layout/GPOS/ExtensionPos.hh vendored
View File

@@ -1,17 +0,0 @@
#ifndef OT_LAYOUT_GPOS_EXTENSIONPOS_HH
#define OT_LAYOUT_GPOS_EXTENSIONPOS_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct ExtensionPos : Extension<ExtensionPos>
{
typedef struct PosLookupSubTable SubTable;
};
}
}
}
#endif /* OT_LAYOUT_GPOS_EXTENSIONPOS_HH */

206
3rdparty/harfbuzz/src/OT/Layout/GPOS/GPOS.hh vendored
View File

@@ -1,206 +0,0 @@
#ifndef OT_LAYOUT_GPOS_GPOS_HH
#define OT_LAYOUT_GPOS_GPOS_HH
#include "../../../hb-ot-layout-common.hh"
#include "../../../hb-ot-layout-gsubgpos.hh"
#include "Common.hh"
#include "PosLookup.hh"
namespace OT {
using Layout::GPOS_impl::PosLookup;
namespace Layout {
static void
propagate_attachment_offsets (hb_glyph_position_t *pos,
unsigned int len,
unsigned int i,
hb_direction_t direction,
unsigned nesting_level = HB_MAX_NESTING_LEVEL);
/*
* GPOS -- Glyph Positioning
* https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
*/
struct GPOS : GSUBGPOS
{
static constexpr hb_tag_t tableTag = HB_OT_TAG_GPOS;
using Lookup = PosLookup;
const PosLookup& get_lookup (unsigned int i) const
{ return static_cast<const PosLookup &> (GSUBGPOS::get_lookup (i)); }
static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);
static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);
bool subset (hb_subset_context_t *c) const
{
hb_subset_layout_context_t l (c, tableTag);
return GSUBGPOS::subset<PosLookup> (&l);
}
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (GSUBGPOS::sanitize<PosLookup> (c));
}
HB_INTERNAL bool is_blocklisted (hb_blob_t *blob,
hb_face_t *face) const;
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
for (unsigned i = 0; i < GSUBGPOS::get_lookup_count (); i++)
{
if (!c->gpos_lookups->has (i)) continue;
const PosLookup &l = get_lookup (i);
l.dispatch (c);
}
}
void closure_lookups (hb_face_t *face,
const hb_set_t *glyphs,
hb_set_t *lookup_indexes /* IN/OUT */) const
{ GSUBGPOS::closure_lookups<PosLookup> (face, glyphs, lookup_indexes); }
typedef GSUBGPOS::accelerator_t<GPOS> accelerator_t;
};
static void
propagate_attachment_offsets (hb_glyph_position_t *pos,
unsigned int len,
unsigned int i,
hb_direction_t direction,
unsigned nesting_level)
{
/* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate
* offset of glyph they are attached to. */
int chain = pos[i].attach_chain();
int type = pos[i].attach_type();
pos[i].attach_chain() = 0;
unsigned int j = (int) i + chain;
if (unlikely (j >= len))
return;
if (unlikely (!nesting_level))
return;
if (pos[j].attach_chain())
propagate_attachment_offsets (pos, len, j, direction, nesting_level - 1);
assert (!!(type & GPOS_impl::ATTACH_TYPE_MARK) ^ !!(type & GPOS_impl::ATTACH_TYPE_CURSIVE));
if (type & GPOS_impl::ATTACH_TYPE_CURSIVE)
{
if (HB_DIRECTION_IS_HORIZONTAL (direction))
pos[i].y_offset += pos[j].y_offset;
else
pos[i].x_offset += pos[j].x_offset;
}
else /*if (type & GPOS_impl::ATTACH_TYPE_MARK)*/
{
pos[i].x_offset += pos[j].x_offset;
pos[i].y_offset += pos[j].y_offset;
// i is the position of the mark; j is the base.
if (j < i)
{
/* This is the common case: mark follows base.
* And currently the only way in OpenType. */
if (HB_DIRECTION_IS_FORWARD (direction))
for (unsigned int k = j; k < i; k++) {
pos[i].x_offset -= pos[k].x_advance;
pos[i].y_offset -= pos[k].y_advance;
}
else
for (unsigned int k = j + 1; k < i + 1; k++) {
pos[i].x_offset += pos[k].x_advance;
pos[i].y_offset += pos[k].y_advance;
}
}
else // j > i
{
/* This can happen with `kerx`: a mark attaching
* to a base after it in the logical order. */
if (HB_DIRECTION_IS_FORWARD (direction))
for (unsigned int k = i; k < j; k++) {
pos[i].x_offset += pos[k].x_advance;
pos[i].y_offset += pos[k].y_advance;
}
else
for (unsigned int k = i + 1; k < j + 1; k++) {
pos[i].x_offset -= pos[k].x_advance;
pos[i].y_offset -= pos[k].y_advance;
}
}
}
}
void
GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
{
unsigned int count = buffer->len;
for (unsigned int i = 0; i < count; i++)
buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;
}
void
GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
{
//_hb_buffer_assert_gsubgpos_vars (buffer);
}
void
GPOS::position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer)
{
_hb_buffer_assert_gsubgpos_vars (buffer);
unsigned int len;
hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
hb_direction_t direction = buffer->props.direction;
/* Handle attachments */
if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)
{
auto *pos = buffer->pos;
// https://github.com/harfbuzz/harfbuzz/issues/5514
if (HB_DIRECTION_IS_FORWARD (direction))
{
for (unsigned i = 0; i < len; i++)
if (pos[i].attach_chain())
propagate_attachment_offsets (pos, len, i, direction);
} else {
for (unsigned i = len; i-- > 0; )
if (pos[i].attach_chain())
propagate_attachment_offsets (pos, len, i, direction);
}
}
if (unlikely (font->slant_xy) &&
HB_DIRECTION_IS_HORIZONTAL (direction))
{
/* Slanting shaping results is only supported for horizontal text,
* as it gets weird otherwise. */
for (unsigned i = 0; i < len; i++)
if (unlikely (pos[i].y_offset))
pos[i].x_offset += roundf (font->slant_xy * pos[i].y_offset);
}
}
}
struct GPOS_accelerator_t : Layout::GPOS::accelerator_t {
GPOS_accelerator_t (hb_face_t *face) : Layout::GPOS::accelerator_t (face) {}
};
}
#endif /* OT_LAYOUT_GPOS_GPOS_HH */

68
3rdparty/harfbuzz/src/OT/Layout/GPOS/LigatureArray.hh vendored
View File

@@ -1,68 +0,0 @@
#ifndef OT_LAYOUT_GPOS_LIGATUREARRAY_HH
#define OT_LAYOUT_GPOS_LIGATUREARRAY_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
typedef AnchorMatrix LigatureAttach; /* component-major--
* in order of writing direction--,
* mark-minor--
* ordered by class--zero-based. */
/* Array of LigatureAttach tables ordered by LigatureCoverage Index */
struct LigatureArray : List16OfOffset16To<LigatureAttach>
{
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
bool subset (hb_subset_context_t *c,
Iterator coverage,
unsigned class_count,
const hb_map_t *klass_mapping,
hb_sorted_vector_t<hb_codepoint_t> &new_coverage /* OUT */) const
{
TRACE_SUBSET (this);
const hb_map_t &glyph_map = c->plan->glyph_map_gsub;
auto *out = c->serializer->start_embed (this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
bool ret = false;
for (const auto _ : + hb_zip (coverage, *this)
| hb_filter (glyph_map, hb_first))
{
const LigatureAttach& src = (this + _.second);
bool non_empty = + hb_range (src.rows * class_count)
| hb_filter ([=] (unsigned index) { return klass_mapping->has (index % class_count); })
| hb_map ([&] (const unsigned index) { return !src.offset_is_null (index / class_count, index % class_count, class_count); })
| hb_any;
if (!non_empty) continue;
auto *matrix = out->serialize_append (c->serializer);
if (unlikely (!matrix)) return_trace (false);
auto indexes =
+ hb_range (src.rows * class_count)
| hb_filter ([=] (unsigned index) { return klass_mapping->has (index % class_count); })
;
ret |= matrix->serialize_subset (c,
_.second,
this,
src.rows,
indexes);
hb_codepoint_t new_gid = glyph_map.get (_.first);
new_coverage.push (new_gid);
}
return_trace (ret);
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_LIGATUREARRAY_HH */

134
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkArray.hh vendored
View File

@@ -1,134 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKARRAY_HH
#define OT_LAYOUT_GPOS_MARKARRAY_HH
#include "AnchorMatrix.hh"
#include "MarkRecord.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct MarkArray : Array16Of<MarkRecord> /* Array of MarkRecords--in Coverage order */
{
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (Array16Of<MarkRecord>::sanitize (c, this));
}
bool apply (hb_ot_apply_context_t *c,
unsigned int mark_index, unsigned int glyph_index,
const AnchorMatrix &anchors, unsigned int class_count,
unsigned int glyph_pos) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
const MarkRecord &record = Array16Of<MarkRecord>::operator[](mark_index);
unsigned int mark_class = record.klass;
const Anchor& mark_anchor = this + record.markAnchor;
bool found;
const Anchor& glyph_anchor = anchors.get_anchor (c, glyph_index, mark_class, class_count, &found);
/* If this subtable doesn't have an anchor for this base and this class,
* return false such that the subsequent subtables have a chance at it. */
if (unlikely (!found)) return_trace (false);
float mark_x, mark_y, base_x, base_y;
buffer->unsafe_to_break (glyph_pos, buffer->idx + 1);
mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);
glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"attaching mark glyph at %u to glyph at %u",
c->buffer->idx, glyph_pos);
}
hb_glyph_position_t &o = buffer->cur_pos();
o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
if (o.attach_chain() != (int) glyph_pos - (int) buffer->idx)
{
o.attach_chain() = 0;
goto overflow;
}
o.attach_type() = ATTACH_TYPE_MARK;
o.x_offset = roundf (base_x - mark_x);
o.y_offset = roundf (base_y - mark_y);
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"attached mark glyph at %u to glyph at %u",
c->buffer->idx, glyph_pos);
}
overflow:
buffer->idx++;
return_trace (true);
}
template <typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
bool subset (hb_subset_context_t *c,
Iterator coverage,
const hb_map_t *klass_mapping) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
auto* out = c->serializer->start_embed (this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
auto mark_iter =
+ hb_zip (coverage, this->iter ())
| hb_filter (glyphset, hb_first)
| hb_map (hb_second)
;
bool ret = false;
unsigned new_length = 0;
for (const auto& mark_record : mark_iter) {
ret |= mark_record.subset (c, this, klass_mapping);
new_length++;
}
if (unlikely (!c->serializer->check_assign (out->len, new_length,
HB_SERIALIZE_ERROR_ARRAY_OVERFLOW)))
return_trace (false);
return_trace (ret);
}
};
HB_INTERNAL inline
void Markclass_closure_and_remap_indexes (const Coverage &mark_coverage,
const MarkArray &mark_array,
const hb_set_t &glyphset,
hb_map_t* klass_mapping /* INOUT */)
{
hb_set_t orig_classes;
+ hb_zip (mark_coverage, mark_array)
| hb_filter (glyphset, hb_first)
| hb_map (hb_second)
| hb_map (&MarkRecord::get_class)
| hb_sink (orig_classes)
;
unsigned idx = 0;
for (auto klass : orig_classes.iter ())
{
if (klass_mapping->has (klass)) continue;
klass_mapping->set (klass, idx);
idx++;
}
}
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKARRAY_HH */

41
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkBasePos.hh vendored
View File

@@ -1,41 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKBASEPOS_HH
#define OT_LAYOUT_GPOS_MARKBASEPOS_HH
#include "MarkBasePosFormat1.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct MarkBasePos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
MarkBasePosFormat1_2<SmallTypes> format1;
#ifndef HB_NO_BEYOND_64K
MarkBasePosFormat1_2<MediumTypes> format2;
#endif
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
#ifndef HB_NO_BEYOND_64K
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
#endif
default:return_trace (c->default_return_value ());
}
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKBASEPOS_HH */

250
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkBasePosFormat1.hh vendored
View File

@@ -1,250 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH
#include "MarkArray.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
typedef AnchorMatrix BaseArray; /* base-major--
* in order of BaseCoverage Index--,
* mark-minor--
* ordered by class--zero-based. */
template <typename Types>
struct MarkBasePosFormat1_2
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
typename Types::template OffsetTo<Coverage>
markCoverage; /* Offset to MarkCoverage table--from
* beginning of MarkBasePos subtable */
typename Types::template OffsetTo<Coverage>
baseCoverage; /* Offset to BaseCoverage table--from
* beginning of MarkBasePos subtable */
HBUINT16 classCount; /* Number of classes defined for marks */
typename Types::template OffsetTo<MarkArray>
markArray; /* Offset to MarkArray table--from
* beginning of MarkBasePos subtable */
typename Types::template OffsetTo<BaseArray>
baseArray; /* Offset to BaseArray table--from
* beginning of MarkBasePos subtable */
public:
DEFINE_SIZE_STATIC (4 + 4 * Types::size);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
markCoverage.sanitize (c, this) &&
baseCoverage.sanitize (c, this) &&
markArray.sanitize (c, this) &&
baseArray.sanitize (c, this, (unsigned int) classCount));
}
bool intersects (const hb_set_t *glyphs) const
{
return (this+markCoverage).intersects (glyphs) &&
(this+baseCoverage).intersects (glyphs);
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
+ hb_zip (this+markCoverage, this+markArray)
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
| hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+markArray)); })
;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, *c->glyph_set, &klass_mapping);
unsigned basecount = (this+baseArray).rows;
auto base_iter =
+ hb_zip (this+baseCoverage, hb_range (basecount))
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
;
hb_sorted_vector_t<unsigned> base_indexes;
for (const unsigned row : base_iter)
{
+ hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
| hb_sink (base_indexes)
;
}
(this+baseArray).collect_variation_indices (c, base_indexes.iter ());
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+markCoverage).collect_coverage (c->input))) return;
if (unlikely (!(this+baseCoverage).collect_coverage (c->input))) return;
}
const Coverage &get_coverage () const { return this+markCoverage; }
static inline bool accept (hb_buffer_t *buffer, unsigned idx)
{
/* We only want to attach to the first of a MultipleSubst sequence.
* https://github.com/harfbuzz/harfbuzz/issues/740
* Reject others...
* ...but stop if we find a mark in the MultipleSubst sequence:
* https://github.com/harfbuzz/harfbuzz/issues/1020 */
return !_hb_glyph_info_multiplied (&buffer->info[idx]) ||
0 == _hb_glyph_info_get_lig_comp (&buffer->info[idx]) ||
(idx == 0 ||
_hb_glyph_info_is_mark (&buffer->info[idx - 1]) ||
!_hb_glyph_info_multiplied (&buffer->info[idx - 1]) ||
_hb_glyph_info_get_lig_id (&buffer->info[idx]) !=
_hb_glyph_info_get_lig_id (&buffer->info[idx - 1]) ||
_hb_glyph_info_get_lig_comp (&buffer->info[idx]) !=
_hb_glyph_info_get_lig_comp (&buffer->info[idx - 1]) + 1
);
}
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
if (likely (mark_index == NOT_COVERED)) return_trace (false);
/* Now we search backwards for a non-mark glyph.
* We don't use skippy_iter.prev() to avoid O(n^2) behavior. */
auto &skippy_iter = c->iter_input;
skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
if (c->last_base_until > buffer->idx)
{
c->last_base_until = 0;
c->last_base = -1;
}
unsigned j;
for (j = buffer->idx; j > c->last_base_until; j--)
{
auto match = skippy_iter.match (buffer->info[j - 1]);
if (match == skippy_iter.MATCH)
{
// https://github.com/harfbuzz/harfbuzz/issues/4124
if (!accept (buffer, j - 1) &&
NOT_COVERED == (this+baseCoverage).get_coverage (buffer->info[j - 1].codepoint))
match = skippy_iter.SKIP;
}
if (match == skippy_iter.MATCH)
{
c->last_base = (signed) j - 1;
break;
}
}
c->last_base_until = buffer->idx;
if (c->last_base == -1)
{
buffer->unsafe_to_concat_from_outbuffer (0, buffer->idx + 1);
return_trace (false);
}
unsigned idx = (unsigned) c->last_base;
/* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
//if (!_hb_glyph_info_is_base_glyph (&buffer->info[idx])) { return_trace (false); }
unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[idx].codepoint);
if (base_index == NOT_COVERED)
{
buffer->unsafe_to_concat_from_outbuffer (idx, buffer->idx + 1);
return_trace (false);
}
return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, idx));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping);
if (!klass_mapping.get_population ()) return_trace (false);
out->classCount = klass_mapping.get_population ();
auto mark_iter =
+ hb_zip (this+markCoverage, this+markArray)
| hb_filter (glyphset, hb_first)
;
hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+ mark_iter
| hb_map (hb_first)
| hb_map (glyph_map)
| hb_sink (new_coverage)
;
if (!out->markCoverage.serialize_serialize (c->serializer, new_coverage.iter ()))
return_trace (false);
if (unlikely (!out->markArray.serialize_subset (c, markArray, this,
(this+markCoverage).iter (),
&klass_mapping)))
return_trace (false);
unsigned basecount = (this+baseArray).rows;
auto base_iter =
+ hb_zip (this+baseCoverage, hb_range (basecount))
| hb_filter (glyphset, hb_first)
;
new_coverage.reset ();
hb_sorted_vector_t<unsigned> base_indexes;
auto &base_array = (this+baseArray);
for (const auto _ : + base_iter)
{
unsigned row = _.second;
bool non_empty = + hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return !base_array.offset_is_null (row, col, (unsigned) classCount); })
| hb_any
;
if (!non_empty) continue;
hb_codepoint_t new_g = glyph_map.get ( _.first);
new_coverage.push (new_g);
+ hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
| hb_sink (base_indexes)
;
}
if (!new_coverage) return_trace (false);
if (!out->baseCoverage.serialize_serialize (c->serializer, new_coverage.iter ()))
return_trace (false);
return_trace (out->baseArray.serialize_subset (c, baseArray, this,
new_coverage.length,
base_indexes.iter ()));
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKBASEPOSFORMAT1_HH */

41
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkLigPos.hh vendored
View File

@@ -1,41 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKLIGPOS_HH
#define OT_LAYOUT_GPOS_MARKLIGPOS_HH
#include "MarkLigPosFormat1.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct MarkLigPos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
MarkLigPosFormat1_2<SmallTypes> format1;
#ifndef HB_NO_BEYOND_64K
MarkLigPosFormat1_2<MediumTypes> format2;
#endif
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
#ifndef HB_NO_BEYOND_64K
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
#endif
default:return_trace (c->default_return_value ());
}
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKLIGPOS_HH */

218
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkLigPosFormat1.hh vendored
View File

@@ -1,218 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKLIGPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_MARKLIGPOSFORMAT1_HH
#include "LigatureArray.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
template <typename Types>
struct MarkLigPosFormat1_2
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
typename Types::template OffsetTo<Coverage>
markCoverage; /* Offset to Mark Coverage table--from
* beginning of MarkLigPos subtable */
typename Types::template OffsetTo<Coverage>
ligatureCoverage; /* Offset to Ligature Coverage
* table--from beginning of MarkLigPos
* subtable */
HBUINT16 classCount; /* Number of defined mark classes */
typename Types::template OffsetTo<MarkArray>
markArray; /* Offset to MarkArray table--from
* beginning of MarkLigPos subtable */
typename Types::template OffsetTo<LigatureArray>
ligatureArray; /* Offset to LigatureArray table--from
* beginning of MarkLigPos subtable */
public:
DEFINE_SIZE_STATIC (4 + 4 * Types::size);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
markCoverage.sanitize (c, this) &&
ligatureCoverage.sanitize (c, this) &&
markArray.sanitize (c, this) &&
ligatureArray.sanitize (c, this, (unsigned int) classCount));
}
bool intersects (const hb_set_t *glyphs) const
{
return (this+markCoverage).intersects (glyphs) &&
(this+ligatureCoverage).intersects (glyphs);
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
+ hb_zip (this+markCoverage, this+markArray)
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
| hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+markArray)); })
;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, *c->glyph_set, &klass_mapping);
unsigned ligcount = (this+ligatureArray).len;
auto lig_iter =
+ hb_zip (this+ligatureCoverage, hb_range (ligcount))
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
;
const LigatureArray& lig_array = this+ligatureArray;
for (const unsigned i : lig_iter)
{
hb_sorted_vector_t<unsigned> lig_indexes;
unsigned row_count = lig_array[i].rows;
for (unsigned row : + hb_range (row_count))
{
+ hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
| hb_sink (lig_indexes)
;
}
lig_array[i].collect_variation_indices (c, lig_indexes.iter ());
}
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+markCoverage).collect_coverage (c->input))) return;
if (unlikely (!(this+ligatureCoverage).collect_coverage (c->input))) return;
}
const Coverage &get_coverage () const { return this+markCoverage; }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
if (likely (mark_index == NOT_COVERED)) return_trace (false);
/* Now we search backwards for a non-mark glyph */
auto &skippy_iter = c->iter_input;
skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
if (c->last_base_until > buffer->idx)
{
c->last_base_until = 0;
c->last_base = -1;
}
unsigned j;
for (j = buffer->idx; j > c->last_base_until; j--)
{
auto match = skippy_iter.match (buffer->info[j - 1]);
if (match == skippy_iter.MATCH)
{
c->last_base = (signed) j - 1;
break;
}
}
c->last_base_until = buffer->idx;
if (c->last_base == -1)
{
buffer->unsafe_to_concat_from_outbuffer (0, buffer->idx + 1);
return_trace (false);
}
unsigned idx = (unsigned) c->last_base;
/* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
//if (!_hb_glyph_info_is_ligature (&buffer->info[idx])) { return_trace (false); }
unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[idx].codepoint);
if (lig_index == NOT_COVERED)
{
buffer->unsafe_to_concat_from_outbuffer (idx, buffer->idx + 1);
return_trace (false);
}
const LigatureArray& lig_array = this+ligatureArray;
const LigatureAttach& lig_attach = lig_array[lig_index];
/* Find component to attach to */
unsigned int comp_count = lig_attach.rows;
if (unlikely (!comp_count))
{
buffer->unsafe_to_concat_from_outbuffer (idx, buffer->idx + 1);
return_trace (false);
}
/* We must now check whether the ligature ID of the current mark glyph
* is identical to the ligature ID of the found ligature. If yes, we
* can directly use the component index. If not, we attach the mark
* glyph to the last component of the ligature. */
unsigned int comp_index;
unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[idx]);
unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur());
unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
if (lig_id && lig_id == mark_id && mark_comp > 0)
comp_index = hb_min (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1;
else
comp_index = comp_count - 1;
return_trace ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, idx));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = c->plan->glyph_map_gsub;
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+markCoverage, this+markArray, glyphset, &klass_mapping);
if (!klass_mapping.get_population ()) return_trace (false);
out->classCount = klass_mapping.get_population ();
auto mark_iter =
+ hb_zip (this+markCoverage, this+markArray)
| hb_filter (glyphset, hb_first)
;
auto new_mark_coverage =
+ mark_iter
| hb_map_retains_sorting (hb_first)
| hb_map_retains_sorting (glyph_map)
;
if (!out->markCoverage.serialize_serialize (c->serializer, new_mark_coverage))
return_trace (false);
if (unlikely (!out->markArray.serialize_subset (c, markArray, this,
(this+markCoverage).iter (),
&klass_mapping)))
return_trace (false);
hb_sorted_vector_t<hb_codepoint_t> new_lig_coverage;
if (!out->ligatureArray.serialize_subset (c, ligatureArray, this,
hb_iter (this+ligatureCoverage),
classCount, &klass_mapping, new_lig_coverage))
return_trace (false);
return_trace (out->ligatureCoverage.serialize_serialize (c->serializer, new_lig_coverage.iter ()));
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKLIGPOSFORMAT1_HH */

42
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkMarkPos.hh vendored
View File

@@ -1,42 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKMARKPOS_HH
#define OT_LAYOUT_GPOS_MARKMARKPOS_HH
#include "MarkMarkPosFormat1.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct MarkMarkPos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
MarkMarkPosFormat1_2<SmallTypes> format1;
#ifndef HB_NO_BEYOND_64K
MarkMarkPosFormat1_2<MediumTypes> format2;
#endif
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
#ifndef HB_NO_BEYOND_64K
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
#endif
default:return_trace (c->default_return_value ());
}
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKMARKPOS_HH */

239
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkMarkPosFormat1.hh vendored
View File

@@ -1,239 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKMARKPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_MARKMARKPOSFORMAT1_HH
#include "MarkMarkPosFormat1.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
typedef AnchorMatrix Mark2Array; /* mark2-major--
* in order of Mark2Coverage Index--,
* mark1-minor--
* ordered by class--zero-based. */
template <typename Types>
struct MarkMarkPosFormat1_2
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
typename Types::template OffsetTo<Coverage>
mark1Coverage; /* Offset to Combining Mark1 Coverage
* table--from beginning of MarkMarkPos
* subtable */
typename Types::template OffsetTo<Coverage>
mark2Coverage; /* Offset to Combining Mark2 Coverage
* table--from beginning of MarkMarkPos
* subtable */
HBUINT16 classCount; /* Number of defined mark classes */
typename Types::template OffsetTo<MarkArray>
mark1Array; /* Offset to Mark1Array table--from
* beginning of MarkMarkPos subtable */
typename Types::template OffsetTo<Mark2Array>
mark2Array; /* Offset to Mark2Array table--from
* beginning of MarkMarkPos subtable */
public:
DEFINE_SIZE_STATIC (4 + 4 * Types::size);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
mark1Coverage.sanitize (c, this) &&
mark2Coverage.sanitize (c, this) &&
mark1Array.sanitize (c, this) &&
hb_barrier () &&
mark2Array.sanitize (c, this, (unsigned int) classCount));
}
bool intersects (const hb_set_t *glyphs) const
{
return (this+mark1Coverage).intersects (glyphs) &&
(this+mark2Coverage).intersects (glyphs);
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
+ hb_zip (this+mark1Coverage, this+mark1Array)
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
| hb_apply ([&] (const MarkRecord& record) { record.collect_variation_indices (c, &(this+mark1Array)); })
;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+mark1Coverage, this+mark1Array, *c->glyph_set, &klass_mapping);
unsigned mark2_count = (this+mark2Array).rows;
auto mark2_iter =
+ hb_zip (this+mark2Coverage, hb_range (mark2_count))
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
;
hb_sorted_vector_t<unsigned> mark2_indexes;
for (const unsigned row : mark2_iter)
{
+ hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
| hb_sink (mark2_indexes)
;
}
(this+mark2Array).collect_variation_indices (c, mark2_indexes.iter ());
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+mark1Coverage).collect_coverage (c->input))) return;
if (unlikely (!(this+mark2Coverage).collect_coverage (c->input))) return;
}
const Coverage &get_coverage () const { return this+mark1Coverage; }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int mark1_index = (this+mark1Coverage).get_coverage (buffer->cur().codepoint);
if (likely (mark1_index == NOT_COVERED)) return_trace (false);
/* now we search backwards for a suitable mark glyph until a non-mark glyph */
auto &skippy_iter = c->iter_input;
skippy_iter.reset_fast (buffer->idx);
skippy_iter.set_lookup_props (c->lookup_props & ~(uint32_t)LookupFlag::IgnoreFlags);
unsigned unsafe_from;
if (unlikely (!skippy_iter.prev (&unsafe_from)))
{
buffer->unsafe_to_concat_from_outbuffer (unsafe_from, buffer->idx + 1);
return_trace (false);
}
if (likely (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])))
{
buffer->unsafe_to_concat_from_outbuffer (skippy_iter.idx, buffer->idx + 1);
return_trace (false);
}
unsigned int j = skippy_iter.idx;
unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur());
unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]);
unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur());
unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]);
if (likely (id1 == id2))
{
if (id1 == 0) /* Marks belonging to the same base. */
goto good;
else if (comp1 == comp2) /* Marks belonging to the same ligature component. */
goto good;
}
else
{
/* If ligature ids don't match, it may be the case that one of the marks
* itself is a ligature. In which case match. */
if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2))
goto good;
}
/* Didn't match. */
buffer->unsafe_to_concat_from_outbuffer (skippy_iter.idx, buffer->idx + 1);
return_trace (false);
good:
unsigned int mark2_index = (this+mark2Coverage).get_coverage (buffer->info[j].codepoint);
if (mark2_index == NOT_COVERED)
{
buffer->unsafe_to_concat_from_outbuffer (skippy_iter.idx, buffer->idx + 1);
return_trace (false);
}
return_trace ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_map_t klass_mapping;
Markclass_closure_and_remap_indexes (this+mark1Coverage, this+mark1Array, glyphset, &klass_mapping);
if (!klass_mapping.get_population ()) return_trace (false);
out->classCount = klass_mapping.get_population ();
auto mark1_iter =
+ hb_zip (this+mark1Coverage, this+mark1Array)
| hb_filter (glyphset, hb_first)
;
hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+ mark1_iter
| hb_map (hb_first)
| hb_map (glyph_map)
| hb_sink (new_coverage)
;
if (!out->mark1Coverage.serialize_serialize (c->serializer, new_coverage.iter ()))
return_trace (false);
if (unlikely (!out->mark1Array.serialize_subset (c, mark1Array, this,
(this+mark1Coverage).iter (),
&klass_mapping)))
return_trace (false);
unsigned mark2count = (this+mark2Array).rows;
auto mark2_iter =
+ hb_zip (this+mark2Coverage, hb_range (mark2count))
| hb_filter (glyphset, hb_first)
;
new_coverage.reset ();
hb_sorted_vector_t<unsigned> mark2_indexes;
auto &mark2_array = (this+mark2Array);
for (const auto _ : + mark2_iter)
{
unsigned row = _.second;
bool non_empty = + hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return !mark2_array.offset_is_null (row, col, (unsigned) classCount); })
| hb_any
;
if (!non_empty) continue;
hb_codepoint_t new_g = glyph_map.get ( _.first);
new_coverage.push (new_g);
+ hb_range ((unsigned) classCount)
| hb_filter (klass_mapping)
| hb_map ([&] (const unsigned col) { return row * (unsigned) classCount + col; })
| hb_sink (mark2_indexes)
;
}
if (!new_coverage) return_trace (false);
if (!out->mark2Coverage.serialize_serialize (c->serializer, new_coverage.iter ()))
return_trace (false);
return_trace (out->mark2Array.serialize_subset (c, mark2Array, this,
mark2_iter.len (),
mark2_indexes.iter ()));
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKMARKPOSFORMAT1_HH */

51
3rdparty/harfbuzz/src/OT/Layout/GPOS/MarkRecord.hh vendored
View File

@@ -1,51 +0,0 @@
#ifndef OT_LAYOUT_GPOS_MARKRECORD_HH
#define OT_LAYOUT_GPOS_MARKRECORD_HH
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct MarkRecord
{
friend struct MarkArray;
public:
HBUINT16 klass; /* Class defined for this mark */
Offset16To<Anchor>
markAnchor; /* Offset to Anchor table--from
* beginning of MarkArray table */
public:
DEFINE_SIZE_STATIC (4);
unsigned get_class () const { return (unsigned) klass; }
bool sanitize (hb_sanitize_context_t *c, const void *base) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));
}
bool subset (hb_subset_context_t *c,
const void *src_base,
const hb_map_t *klass_mapping) const
{
TRACE_SUBSET (this);
auto *out = c->serializer->embed (this);
if (unlikely (!out)) return_trace (false);
out->klass = klass_mapping->get (klass);
return_trace (out->markAnchor.serialize_subset (c, markAnchor, src_base));
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
const void *src_base) const
{
(src_base+markAnchor).collect_variation_indices (c);
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_MARKRECORD_HH */

46
3rdparty/harfbuzz/src/OT/Layout/GPOS/PairPos.hh vendored
View File

@@ -1,46 +0,0 @@
#ifndef OT_LAYOUT_GPOS_PAIRPOS_HH
#define OT_LAYOUT_GPOS_PAIRPOS_HH
#include "PairPosFormat1.hh"
#include "PairPosFormat2.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct PairPos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
PairPosFormat1_3<SmallTypes> format1;
PairPosFormat2_4<SmallTypes> format2;
#ifndef HB_NO_BEYOND_64K
PairPosFormat1_3<MediumTypes> format3;
PairPosFormat2_4<MediumTypes> format4;
#endif
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
#ifndef HB_NO_BEYOND_64K
case 3: return_trace (c->dispatch (u.format3, std::forward<Ts> (ds)...));
case 4: return_trace (c->dispatch (u.format4, std::forward<Ts> (ds)...));
#endif
default:return_trace (c->default_return_value ());
}
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_PAIRPOS_HH

254
3rdparty/harfbuzz/src/OT/Layout/GPOS/PairPosFormat1.hh vendored
View File

@@ -1,254 +0,0 @@
#ifndef OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH
#include "PairSet.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
template <typename Types>
struct PairPosFormat1_3
{
using PairSet = GPOS_impl::PairSet<Types>;
using PairValueRecord = GPOS_impl::PairValueRecord<Types>;
protected:
HBUINT16 format; /* Format identifier--format = 1 */
typename Types::template OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat[2]; /* [0] Defines the types of data in
* ValueRecord1--for the first glyph
* in the pair--may be zero (0) */
/* [1] Defines the types of data in
* ValueRecord2--for the second glyph
* in the pair--may be zero (0) */
Array16Of<typename Types::template OffsetTo<PairSet>>
pairSet; /* Array of PairSet tables
* ordered by Coverage Index */
public:
DEFINE_SIZE_ARRAY (8 + Types::size, pairSet);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (!c->check_struct (this)) return_trace (false);
hb_barrier ();
unsigned int len1 = valueFormat[0].get_len ();
unsigned int len2 = valueFormat[1].get_len ();
typename PairSet::sanitize_closure_t closure =
{
valueFormat,
len1,
PairSet::get_size (len1, len2)
};
return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
}
bool intersects (const hb_set_t *glyphs) const
{
auto &cov = this+coverage;
if (pairSet.len > glyphs->get_population () * hb_bit_storage ((unsigned) pairSet.len))
{
for (hb_codepoint_t g : glyphs->iter())
{
unsigned i = cov.get_coverage (g);
if ((this+pairSet[i]).intersects (glyphs, valueFormat))
return true;
}
return false;
}
return
+ hb_zip (cov, pairSet)
| hb_filter (*glyphs, hb_first)
| hb_map (hb_second)
| hb_map ([glyphs, this] (const typename Types::template OffsetTo<PairSet> &_)
{ return (this+_).intersects (glyphs, valueFormat); })
| hb_any
;
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
if ((!valueFormat[0].has_device ()) && (!valueFormat[1].has_device ())) return;
auto it =
+ hb_zip (this+coverage, pairSet)
| hb_filter (c->glyph_set, hb_first)
| hb_map (hb_second)
;
if (!it) return;
+ it
| hb_map (hb_add (this))
| hb_apply ([&] (const PairSet& _) { _.collect_variation_indices (c, valueFormat); })
;
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
unsigned int count = pairSet.len;
for (unsigned int i = 0; i < count; i++)
(this+pairSet[i]).collect_glyphs (c, valueFormat);
}
const Coverage &get_coverage () const { return this+coverage; }
struct external_cache_t
{
hb_ot_layout_mapping_cache_t coverage;
};
void *external_cache_create () const
{
external_cache_t *cache = (external_cache_t *) hb_malloc (sizeof (external_cache_t));
if (likely (cache))
{
cache->coverage.clear ();
}
return cache;
}
bool apply (hb_ot_apply_context_t *c, void *external_cache) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
#ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
external_cache_t *cache = (external_cache_t *) external_cache;
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint, cache ? &cache->coverage : nullptr);
#else
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
#endif
if (index == NOT_COVERED) return_trace (false);
auto &skippy_iter = c->iter_input;
skippy_iter.reset_fast (buffer->idx);
unsigned unsafe_to;
if (unlikely (!skippy_iter.next (&unsafe_to)))
{
buffer->unsafe_to_concat (buffer->idx, unsafe_to);
return_trace (false);
}
return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_pair_t<unsigned, unsigned> newFormats = hb_pair (valueFormat[0], valueFormat[1]);
if (c->plan->normalized_coords)
{
/* all device flags will be dropped when full instancing, no need to strip
* hints, also do not strip emtpy cause we don't compute the new default
* value during stripping */
newFormats = compute_effective_value_formats (glyphset, false, false, &c->plan->layout_variation_idx_delta_map);
}
/* do not strip hints for VF */
else if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
{
hb_blob_t* blob = hb_face_reference_table (c->plan->source, HB_TAG ('f','v','a','r'));
bool has_fvar = (blob != hb_blob_get_empty ());
hb_blob_destroy (blob);
bool strip = !has_fvar;
/* special case: strip hints when a VF has no GDEF varstore after
* subsetting*/
if (has_fvar && !c->plan->has_gdef_varstore)
strip = true;
newFormats = compute_effective_value_formats (glyphset, strip, true);
}
out->valueFormat[0] = newFormats.first;
out->valueFormat[1] = newFormats.second;
hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+ hb_zip (this+coverage, pairSet)
| hb_filter (glyphset, hb_first)
| hb_filter ([this, c, out] (const typename Types::template OffsetTo<PairSet>& _)
{
auto snap = c->serializer->snapshot ();
auto *o = out->pairSet.serialize_append (c->serializer);
if (unlikely (!o)) return false;
bool ret = o->serialize_subset (c, _, this, valueFormat, out->valueFormat);
if (!ret)
{
out->pairSet.pop ();
c->serializer->revert (snap);
}
return ret;
},
hb_second)
| hb_map (hb_first)
| hb_map (glyph_map)
| hb_sink (new_coverage)
;
out->coverage.serialize_serialize (c->serializer, new_coverage.iter ());
return_trace (bool (new_coverage));
}
hb_pair_t<unsigned, unsigned> compute_effective_value_formats (const hb_set_t& glyphset,
bool strip_hints, bool strip_empty,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map = nullptr) const
{
unsigned record_size = PairSet::get_size (valueFormat);
unsigned format1 = 0;
unsigned format2 = 0;
for (const auto & _ :
+ hb_zip (this+coverage, pairSet)
| hb_filter (glyphset, hb_first)
| hb_map (hb_second)
)
{
const PairSet& set = (this + _);
const PairValueRecord *record = &set.firstPairValueRecord;
unsigned count = set.len;
for (unsigned i = 0; i < count; i++)
{
if (record->intersects (glyphset))
{
format1 = format1 | valueFormat[0].get_effective_format (record->get_values_1 (), strip_hints, strip_empty, &set, varidx_delta_map);
format2 = format2 | valueFormat[1].get_effective_format (record->get_values_2 (valueFormat[0]), strip_hints, strip_empty, &set, varidx_delta_map);
}
record = &StructAtOffset<const PairValueRecord> (record, record_size);
}
if (format1 == valueFormat[0] && format2 == valueFormat[1])
break;
}
return hb_pair (format1, format2);
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_PAIRPOSFORMAT1_HH

389
3rdparty/harfbuzz/src/OT/Layout/GPOS/PairPosFormat2.hh vendored
View File

@@ -1,389 +0,0 @@
#ifndef OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH
#define OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH
#include "ValueFormat.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
template <typename Types>
struct PairPosFormat2_4 : ValueBase
{
protected:
HBUINT16 format; /* Format identifier--format = 2 */
typename Types::template OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat1; /* ValueRecord definition--for the
* first glyph of the pair--may be zero
* (0) */
ValueFormat valueFormat2; /* ValueRecord definition--for the
* second glyph of the pair--may be
* zero (0) */
typename Types::template OffsetTo<ClassDef>
classDef1; /* Offset to ClassDef table--from
* beginning of PairPos subtable--for
* the first glyph of the pair */
typename Types::template OffsetTo<ClassDef>
classDef2; /* Offset to ClassDef table--from
* beginning of PairPos subtable--for
* the second glyph of the pair */
HBUINT16 class1Count; /* Number of classes in ClassDef1
* table--includes Class0 */
HBUINT16 class2Count; /* Number of classes in ClassDef2
* table--includes Class0 */
ValueRecord values; /* Matrix of value pairs:
* class1-major, class2-minor,
* Each entry has value1 and value2 */
public:
DEFINE_SIZE_ARRAY (10 + 3 * Types::size, values);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
if (!(c->check_struct (this)
&& coverage.sanitize (c, this)
&& classDef1.sanitize (c, this)
&& classDef2.sanitize (c, this))) return_trace (false);
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
unsigned int stride = HBUINT16::static_size * (len1 + len2);
unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
return_trace (c->check_range ((const void *) values,
count,
stride) &&
(c->lazy_some_gpos ||
(valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride))));
}
bool intersects (const hb_set_t *glyphs) const
{
return (this+coverage).intersects (glyphs) &&
(this+classDef2).intersects (glyphs);
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
if (!intersects (c->glyph_set)) return;
if ((!valueFormat1.has_device ()) && (!valueFormat2.has_device ())) return;
hb_set_t klass1_glyphs, klass2_glyphs;
if (!(this+classDef1).collect_coverage (&klass1_glyphs)) return;
if (!(this+classDef2).collect_coverage (&klass2_glyphs)) return;
hb_set_t class1_set, class2_set;
for (const unsigned cp : + c->glyph_set->iter () | hb_filter (this + coverage))
{
if (!klass1_glyphs.has (cp)) class1_set.add (0);
else
{
unsigned klass1 = (this+classDef1).get (cp);
class1_set.add (klass1);
}
}
class2_set.add (0);
for (const unsigned cp : + c->glyph_set->iter () | hb_filter (klass2_glyphs))
{
unsigned klass2 = (this+classDef2).get (cp);
class2_set.add (klass2);
}
if (class1_set.is_empty ()
|| class2_set.is_empty ()
|| (class2_set.get_population() == 1 && class2_set.has(0)))
return;
unsigned len1 = valueFormat1.get_len ();
unsigned len2 = valueFormat2.get_len ();
const hb_array_t<const Value> values_array = values.as_array ((unsigned)class1Count * (unsigned) class2Count * (len1 + len2));
for (const unsigned class1_idx : class1_set.iter ())
{
for (const unsigned class2_idx : class2_set.iter ())
{
unsigned start_offset = (class1_idx * (unsigned) class2Count + class2_idx) * (len1 + len2);
if (valueFormat1.has_device ())
valueFormat1.collect_variation_indices (c, this, values_array.sub_array (start_offset, len1));
if (valueFormat2.has_device ())
valueFormat2.collect_variation_indices (c, this, values_array.sub_array (start_offset+len1, len2));
}
}
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
if (unlikely (!(this+classDef2).collect_coverage (c->input))) return;
}
const Coverage &get_coverage () const { return this+coverage; }
struct external_cache_t
{
hb_ot_layout_mapping_cache_t coverage;
hb_ot_layout_mapping_cache_t first;
hb_ot_layout_mapping_cache_t second;
};
void *external_cache_create () const
{
external_cache_t *cache = (external_cache_t *) hb_malloc (sizeof (external_cache_t));
if (likely (cache))
{
cache->coverage.clear ();
cache->first.clear ();
cache->second.clear ();
}
return cache;
}
bool apply (hb_ot_apply_context_t *c, void *external_cache) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
#ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
external_cache_t *cache = (external_cache_t *) external_cache;
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint, cache ? &cache->coverage : nullptr);
#else
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
#endif
if (index == NOT_COVERED) return_trace (false);
auto &skippy_iter = c->iter_input;
skippy_iter.reset_fast (buffer->idx);
unsigned unsafe_to;
if (unlikely (!skippy_iter.next (&unsafe_to)))
{
buffer->unsafe_to_concat (buffer->idx, unsafe_to);
return_trace (false);
}
#ifndef HB_NO_OT_LAYOUT_LOOKUP_CACHE
unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint, cache ? &cache->first : nullptr);
unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint, cache ? &cache->second : nullptr);
#else
unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
#endif
if (unlikely (klass1 >= class1Count || klass2 >= class2Count))
{
buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1);
return_trace (false);
}
unsigned int len1 = valueFormat1.get_len ();
unsigned int len2 = valueFormat2.get_len ();
unsigned int record_len = len1 + len2;
const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
bool applied_first = false, applied_second = false;
/* Isolate simple kerning and apply it half to each side.
* Results in better cursor positioning / underline drawing.
*
* Disabled, because causes issues... :-(
* https://github.com/harfbuzz/harfbuzz/issues/3408
* https://github.com/harfbuzz/harfbuzz/pull/3235#issuecomment-1029814978
*/
#ifndef HB_SPLIT_KERN
if (false)
#endif
{
if (!len2)
{
const hb_direction_t dir = buffer->props.direction;
const bool horizontal = HB_DIRECTION_IS_HORIZONTAL (dir);
const bool backward = HB_DIRECTION_IS_BACKWARD (dir);
unsigned mask = horizontal ? ValueFormat::xAdvance : ValueFormat::yAdvance;
if (backward)
mask |= mask >> 2; /* Add eg. xPlacement in RTL. */
/* Add Devices. */
mask |= mask << 4;
if (valueFormat1 & ~mask)
goto bail;
/* Is simple kern. Apply value on an empty position slot,
* then split it between sides. */
hb_glyph_position_t pos{};
if (valueFormat1.apply_value (c, this, v, pos))
{
hb_position_t *src = &pos.x_advance;
hb_position_t *dst1 = &buffer->cur_pos().x_advance;
hb_position_t *dst2 = &buffer->pos[skippy_iter.idx].x_advance;
unsigned i = horizontal ? 0 : 1;
hb_position_t kern = src[i];
hb_position_t kern1 = kern >> 1;
hb_position_t kern2 = kern - kern1;
if (!backward)
{
dst1[i] += kern1;
dst2[i] += kern2;
dst2[i + 2] += kern2;
}
else
{
dst1[i] += kern1;
dst1[i + 2] += src[i + 2] - kern2;
dst2[i] += kern2;
}
applied_first = applied_second = kern != 0;
goto success;
}
goto boring;
}
}
bail:
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"try kerning glyphs at %u,%u",
c->buffer->idx, skippy_iter.idx);
}
applied_first = len1 && valueFormat1.apply_value (c, this, v, buffer->cur_pos());
applied_second = len2 && valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]);
if (applied_first || applied_second)
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"kerned glyphs at %u,%u",
c->buffer->idx, skippy_iter.idx);
}
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"tried kerning glyphs at %u,%u",
c->buffer->idx, skippy_iter.idx);
}
success:
if (applied_first || applied_second)
buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
else
boring:
buffer->unsafe_to_concat (buffer->idx, skippy_iter.idx + 1);
if (len2)
{
skippy_iter.idx++;
// https://github.com/harfbuzz/harfbuzz/issues/3824
// https://github.com/harfbuzz/harfbuzz/issues/3888#issuecomment-1326781116
buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
}
buffer->idx = skippy_iter.idx;
return_trace (true);
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_map_t klass1_map;
out->classDef1.serialize_subset (c, classDef1, this, &klass1_map, true, true, &(this + coverage));
out->class1Count = klass1_map.get_population ();
hb_map_t klass2_map;
out->classDef2.serialize_subset (c, classDef2, this, &klass2_map, true, false);
out->class2Count = klass2_map.get_population ();
unsigned len1 = valueFormat1.get_len ();
unsigned len2 = valueFormat2.get_len ();
hb_pair_t<unsigned, unsigned> newFormats = hb_pair (valueFormat1, valueFormat2);
if (c->plan->normalized_coords)
{
/* in case of full instancing, all var device flags will be dropped so no
* need to strip hints here */
newFormats = compute_effective_value_formats (klass1_map, klass2_map, false, false, &c->plan->layout_variation_idx_delta_map);
}
/* do not strip hints for VF */
else if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
{
hb_blob_t* blob = hb_face_reference_table (c->plan->source, HB_TAG ('f','v','a','r'));
bool has_fvar = (blob != hb_blob_get_empty ());
hb_blob_destroy (blob);
bool strip = !has_fvar;
/* special case: strip hints when a VF has no GDEF varstore after
* subsetting*/
if (has_fvar && !c->plan->has_gdef_varstore)
strip = true;
newFormats = compute_effective_value_formats (klass1_map, klass2_map, strip, true);
}
out->valueFormat1 = newFormats.first;
out->valueFormat2 = newFormats.second;
unsigned total_len = len1 + len2;
hb_vector_t<unsigned> class2_idxs (+ hb_range ((unsigned) class2Count) | hb_filter (klass2_map));
for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map))
{
for (unsigned class2_idx : class2_idxs)
{
unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * total_len;
valueFormat1.copy_values (c->serializer, out->valueFormat1, this, &values[idx], &c->plan->layout_variation_idx_delta_map);
valueFormat2.copy_values (c->serializer, out->valueFormat2, this, &values[idx + len1], &c->plan->layout_variation_idx_delta_map);
}
}
bool ret = out->coverage.serialize_subset(c, coverage, this);
return_trace (out->class1Count && out->class2Count && ret);
}
hb_pair_t<unsigned, unsigned> compute_effective_value_formats (const hb_map_t& klass1_map,
const hb_map_t& klass2_map,
bool strip_hints, bool strip_empty,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map = nullptr) const
{
unsigned len1 = valueFormat1.get_len ();
unsigned len2 = valueFormat2.get_len ();
unsigned record_size = len1 + len2;
unsigned format1 = 0;
unsigned format2 = 0;
for (unsigned class1_idx : + hb_range ((unsigned) class1Count) | hb_filter (klass1_map))
{
for (unsigned class2_idx : + hb_range ((unsigned) class2Count) | hb_filter (klass2_map))
{
unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * record_size;
format1 = format1 | valueFormat1.get_effective_format (&values[idx], strip_hints, strip_empty, this, varidx_delta_map);
format2 = format2 | valueFormat2.get_effective_format (&values[idx + len1], strip_hints, strip_empty, this, varidx_delta_map);
}
if (format1 == valueFormat1 && format2 == valueFormat2)
break;
}
return hb_pair (format1, format2);
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_PAIRPOSFORMAT2_HH

210
3rdparty/harfbuzz/src/OT/Layout/GPOS/PairSet.hh vendored
View File

@@ -1,210 +0,0 @@
#ifndef OT_LAYOUT_GPOS_PAIRSET_HH
#define OT_LAYOUT_GPOS_PAIRSET_HH
#include "PairValueRecord.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
template <typename Types>
struct PairSet : ValueBase
{
template <typename Types2>
friend struct PairPosFormat1_3;
using PairValueRecord = GPOS_impl::PairValueRecord<Types>;
protected:
HBUINT16 len; /* Number of PairValueRecords */
PairValueRecord firstPairValueRecord;
/* Array of PairValueRecords--ordered
* by GlyphID of the second glyph */
public:
DEFINE_SIZE_MIN (2);
static size_t get_size (unsigned len1, unsigned len2)
{
return Types::HBGlyphID::static_size + Value::static_size * (len1 + len2);
}
static size_t get_size (const ValueFormat valueFormats[2])
{
unsigned len1 = valueFormats[0].get_len ();
unsigned len2 = valueFormats[1].get_len ();
return get_size (len1, len2);
}
struct sanitize_closure_t
{
const ValueFormat *valueFormats;
unsigned int len1; /* valueFormats[0].get_len() */
size_t stride; /* bytes */
};
bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
{
TRACE_SANITIZE (this);
if (!(c->check_struct (this) &&
hb_barrier () &&
c->check_range (&firstPairValueRecord,
len,
closure->stride))) return_trace (false);
hb_barrier ();
unsigned int count = len;
const PairValueRecord *record = &firstPairValueRecord;
return_trace (c->lazy_some_gpos ||
(closure->valueFormats[0].sanitize_values_stride_unsafe (c, this, &record->values[0], count, closure->stride) &&
closure->valueFormats[1].sanitize_values_stride_unsafe (c, this, &record->values[closure->len1], count, closure->stride)));
}
bool intersects (const hb_set_t *glyphs,
const ValueFormat *valueFormats) const
{
unsigned record_size = get_size (valueFormats);
const PairValueRecord *record = &firstPairValueRecord;
unsigned int count = len;
for (unsigned int i = 0; i < count; i++)
{
if (glyphs->has (record->secondGlyph))
return true;
record = &StructAtOffset<const PairValueRecord> (record, record_size);
}
return false;
}
void collect_glyphs (hb_collect_glyphs_context_t *c,
const ValueFormat *valueFormats) const
{
unsigned record_size = get_size (valueFormats);
const PairValueRecord *record = &firstPairValueRecord;
c->input->add_array (&record->secondGlyph, len, record_size);
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
const ValueFormat *valueFormats) const
{
unsigned record_size = get_size (valueFormats);
const PairValueRecord *record = &firstPairValueRecord;
unsigned count = len;
for (unsigned i = 0; i < count; i++)
{
if (c->glyph_set->has (record->secondGlyph))
{ record->collect_variation_indices (c, valueFormats, this); }
record = &StructAtOffset<const PairValueRecord> (record, record_size);
}
}
bool apply (hb_ot_apply_context_t *c,
const ValueFormat *valueFormats,
unsigned int pos) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int len1 = valueFormats[0].get_len ();
unsigned int len2 = valueFormats[1].get_len ();
unsigned record_size = get_size (len1, len2);
const PairValueRecord *record = hb_bsearch (buffer->info[pos].codepoint,
&firstPairValueRecord,
len,
record_size);
if (record)
{
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"try kerning glyphs at %u,%u",
c->buffer->idx, pos);
}
bool applied_first = len1 && valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos());
bool applied_second = len2 && valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]);
if (applied_first || applied_second)
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"kerned glyphs at %u,%u",
c->buffer->idx, pos);
}
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"tried kerning glyphs at %u,%u",
c->buffer->idx, pos);
}
if (applied_first || applied_second)
buffer->unsafe_to_break (buffer->idx, pos + 1);
if (len2)
{
pos++;
// https://github.com/harfbuzz/harfbuzz/issues/3824
// https://github.com/harfbuzz/harfbuzz/issues/3888#issuecomment-1326781116
buffer->unsafe_to_break (buffer->idx, pos + 1);
}
buffer->idx = pos;
return_trace (true);
}
buffer->unsafe_to_concat (buffer->idx, pos + 1);
return_trace (false);
}
bool subset (hb_subset_context_t *c,
const ValueFormat valueFormats[2],
const ValueFormat newFormats[2]) const
{
TRACE_SUBSET (this);
auto snap = c->serializer->snapshot ();
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->len = 0;
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
unsigned len1 = valueFormats[0].get_len ();
unsigned len2 = valueFormats[1].get_len ();
unsigned record_size = get_size (len1, len2);
typename PairValueRecord::context_t context =
{
this,
valueFormats,
newFormats,
len1,
&glyph_map,
&c->plan->layout_variation_idx_delta_map
};
const PairValueRecord *record = &firstPairValueRecord;
unsigned count = len, num = 0;
for (unsigned i = 0; i < count; i++)
{
if (glyphset.has (record->secondGlyph)
&& record->subset (c, &context)) num++;
record = &StructAtOffset<const PairValueRecord> (record, record_size);
}
out->len = num;
if (!num) c->serializer->revert (snap);
return_trace (num);
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_PAIRSET_HH

99
3rdparty/harfbuzz/src/OT/Layout/GPOS/PairValueRecord.hh vendored
View File

@@ -1,99 +0,0 @@
#ifndef OT_LAYOUT_GPOS_PAIRVALUERECORD_HH
#define OT_LAYOUT_GPOS_PAIRVALUERECORD_HH
#include "ValueFormat.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
template <typename Types>
struct PairValueRecord
{
template <typename Types2>
friend struct PairSet;
protected:
typename Types::HBGlyphID
secondGlyph; /* GlyphID of second glyph in the
* pair--first glyph is listed in the
* Coverage table */
ValueRecord values; /* Positioning data for the first glyph
* followed by for second glyph */
public:
DEFINE_SIZE_ARRAY (Types::HBGlyphID::static_size, values);
int cmp (hb_codepoint_t k) const
{ return secondGlyph.cmp (k); }
struct context_t
{
const ValueBase *base;
const ValueFormat *valueFormats;
const ValueFormat *newFormats;
unsigned len1; /* valueFormats[0].get_len() */
const hb_map_t *glyph_map;
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map;
};
bool subset (hb_subset_context_t *c,
context_t *closure) const
{
TRACE_SERIALIZE (this);
auto *s = c->serializer;
auto *out = s->start_embed (*this);
if (unlikely (!s->extend_min (out))) return_trace (false);
out->secondGlyph = (*closure->glyph_map)[secondGlyph];
closure->valueFormats[0].copy_values (s,
closure->newFormats[0],
closure->base, &values[0],
closure->layout_variation_idx_delta_map);
closure->valueFormats[1].copy_values (s,
closure->newFormats[1],
closure->base,
&values[closure->len1],
closure->layout_variation_idx_delta_map);
return_trace (true);
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
const ValueFormat *valueFormats,
const ValueBase *base) const
{
unsigned record1_len = valueFormats[0].get_len ();
unsigned record2_len = valueFormats[1].get_len ();
const hb_array_t<const Value> values_array = values.as_array (record1_len + record2_len);
if (valueFormats[0].has_device ())
valueFormats[0].collect_variation_indices (c, base, values_array.sub_array (0, record1_len));
if (valueFormats[1].has_device ())
valueFormats[1].collect_variation_indices (c, base, values_array.sub_array (record1_len, record2_len));
}
bool intersects (const hb_set_t& glyphset) const
{
return glyphset.has(secondGlyph);
}
const Value* get_values_1 () const
{
return &values[0];
}
const Value* get_values_2 (ValueFormat format1) const
{
return &values[format1.get_len ()];
}
};
}
}
}
#endif // OT_LAYOUT_GPOS_PAIRVALUERECORD_HH

79
3rdparty/harfbuzz/src/OT/Layout/GPOS/PosLookup.hh vendored
View File

@@ -1,79 +0,0 @@
#ifndef OT_LAYOUT_GPOS_POSLOOKUP_HH
#define OT_LAYOUT_GPOS_POSLOOKUP_HH
#include "PosLookupSubTable.hh"
#include "../../../hb-ot-layout-common.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct PosLookup : Lookup
{
using SubTable = PosLookupSubTable;
const SubTable& get_subtable (unsigned int i) const
{ return Lookup::get_subtable<SubTable> (i); }
bool is_reverse () const
{
return false;
}
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
return_trace (dispatch (c));
}
bool intersects (const hb_set_t *glyphs) const
{
hb_intersects_context_t c (glyphs);
return dispatch (&c);
}
hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
{ return dispatch (c); }
hb_closure_lookups_context_t::return_t closure_lookups (hb_closure_lookups_context_t *c, unsigned this_index) const
{
if (c->is_lookup_visited (this_index))
return hb_closure_lookups_context_t::default_return_value ();
c->set_lookup_visited (this_index);
if (!intersects (c->glyphs))
{
c->set_lookup_inactive (this_index);
return hb_closure_lookups_context_t::default_return_value ();
}
hb_closure_lookups_context_t::return_t ret = dispatch (c);
return ret;
}
template <typename set_t>
void collect_coverage (set_t *glyphs) const
{
hb_collect_coverage_context_t<set_t> c (glyphs);
dispatch (&c);
}
template <typename context_t>
static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{ return Lookup::dispatch<SubTable> (c, std::forward<Ts> (ds)...); }
bool subset (hb_subset_context_t *c) const
{ return Lookup::subset<SubTable> (c); }
bool sanitize (hb_sanitize_context_t *c) const
{ return Lookup::sanitize<SubTable> (c); }
};
}
}
}
#endif /* OT_LAYOUT_GPOS_POSLOOKUP_HH */

79
3rdparty/harfbuzz/src/OT/Layout/GPOS/PosLookupSubTable.hh vendored
View File

@@ -1,79 +0,0 @@
#ifndef OT_LAYOUT_GPOS_POSLOOKUPSUBTABLE_HH
#define OT_LAYOUT_GPOS_POSLOOKUPSUBTABLE_HH
#include "SinglePos.hh"
#include "PairPos.hh"
#include "CursivePos.hh"
#include "MarkBasePos.hh"
#include "MarkLigPos.hh"
#include "MarkMarkPos.hh"
#include "ContextPos.hh"
#include "ChainContextPos.hh"
#include "ExtensionPos.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct PosLookupSubTable
{
friend struct ::OT::Lookup;
friend struct PosLookup;
enum Type {
Single = 1,
Pair = 2,
Cursive = 3,
MarkBase = 4,
MarkLig = 5,
MarkMark = 6,
Context = 7,
ChainContext = 8,
Extension = 9
};
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type, Ts&&... ds) const
{
TRACE_DISPATCH (this, lookup_type);
switch (lookup_type) {
case Single: return_trace (u.single.dispatch (c, std::forward<Ts> (ds)...));
case Pair: return_trace (u.pair.dispatch (c, std::forward<Ts> (ds)...));
case Cursive: return_trace (u.cursive.dispatch (c, std::forward<Ts> (ds)...));
case MarkBase: return_trace (u.markBase.dispatch (c, std::forward<Ts> (ds)...));
case MarkLig: return_trace (u.markLig.dispatch (c, std::forward<Ts> (ds)...));
case MarkMark: return_trace (u.markMark.dispatch (c, std::forward<Ts> (ds)...));
case Context: return_trace (u.context.dispatch (c, std::forward<Ts> (ds)...));
case ChainContext: return_trace (u.chainContext.dispatch (c, std::forward<Ts> (ds)...));
case Extension: return_trace (u.extension.dispatch (c, std::forward<Ts> (ds)...));
default: return_trace (c->default_return_value ());
}
}
bool intersects (const hb_set_t *glyphs, unsigned int lookup_type) const
{
hb_intersects_context_t c (glyphs);
return dispatch (&c, lookup_type);
}
protected:
union {
SinglePos single;
PairPos pair;
CursivePos cursive;
MarkBasePos markBase;
MarkLigPos markLig;
MarkMarkPos markMark;
ContextPos context;
ChainContextPos chainContext;
ExtensionPos extension;
} u;
public:
DEFINE_SIZE_MIN (0);
};
}
}
}
#endif /* HB_OT_LAYOUT_GPOS_POSLOOKUPSUBTABLE_HH */

98
3rdparty/harfbuzz/src/OT/Layout/GPOS/SinglePos.hh vendored
View File

@@ -1,98 +0,0 @@
#ifndef OT_LAYOUT_GPOS_SINGLEPOS_HH
#define OT_LAYOUT_GPOS_SINGLEPOS_HH
#include "SinglePosFormat1.hh"
#include "SinglePosFormat2.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct SinglePos
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
SinglePosFormat1 format1;
SinglePosFormat2 format2;
} u;
public:
template<typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
unsigned get_format (Iterator glyph_val_iter_pairs)
{
hb_array_t<const Value> first_val_iter = hb_second (*glyph_val_iter_pairs);
for (const auto iter : glyph_val_iter_pairs)
for (const auto _ : hb_zip (iter.second, first_val_iter))
if (_.first != _.second)
return 2;
return 1;
}
template<typename Iterator,
typename SrcLookup,
hb_requires (hb_is_iterator (Iterator))>
void serialize (hb_serialize_context_t *c,
const SrcLookup* src,
Iterator glyph_val_iter_pairs,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map,
unsigned newFormat)
{
if (unlikely (!c->extend_min (u.format.v))) return;
unsigned format = 2;
ValueFormat new_format;
new_format = newFormat;
if (glyph_val_iter_pairs)
format = get_format (glyph_val_iter_pairs);
u.format.v = format;
switch (u.format.v) {
case 1: u.format1.serialize (c,
src,
glyph_val_iter_pairs,
new_format,
layout_variation_idx_delta_map);
return;
case 2: u.format2.serialize (c,
src,
glyph_val_iter_pairs,
new_format,
layout_variation_idx_delta_map);
return;
default:return;
}
}
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
default:return_trace (c->default_return_value ());
}
}
};
template<typename Iterator, typename SrcLookup>
static void
SinglePos_serialize (hb_serialize_context_t *c,
const SrcLookup *src,
Iterator it,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map,
unsigned new_format)
{ c->start_embed<SinglePos> ()->serialize (c, src, it, layout_variation_idx_delta_map, new_format); }
}
}
}
#endif /* OT_LAYOUT_GPOS_SINGLEPOS_HH */

190
3rdparty/harfbuzz/src/OT/Layout/GPOS/SinglePosFormat1.hh vendored
View File

@@ -1,190 +0,0 @@
#ifndef OT_LAYOUT_GPOS_SINGLEPOSFORMAT1_HH
#define OT_LAYOUT_GPOS_SINGLEPOSFORMAT1_HH
#include "Common.hh"
#include "ValueFormat.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct SinglePosFormat1 : ValueBase
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
Offset16To<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat; /* Defines the types of data in the
* ValueRecord */
ValueRecord values; /* Defines positioning
* value(s)--applied to all glyphs in
* the Coverage table */
public:
DEFINE_SIZE_ARRAY (6, values);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
coverage.sanitize (c, this) &&
hb_barrier () &&
/* The coverage table may use a range to represent a set
* of glyphs, which means a small number of bytes can
* generate a large glyph set. Manually modify the
* sanitizer max ops to take this into account.
*
* Note: This check *must* be right after coverage sanitize. */
c->check_ops ((this + coverage).get_population () >> 1) &&
valueFormat.sanitize_value (c, this, values));
}
bool intersects (const hb_set_t *glyphs) const
{ return (this+coverage).intersects (glyphs); }
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
if (!valueFormat.has_device ()) return;
hb_set_t intersection;
(this+coverage).intersect_set (*c->glyph_set, intersection);
if (!intersection) return;
valueFormat.collect_variation_indices (c, this, values.as_array (valueFormat.get_len ()));
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{ if (unlikely (!(this+coverage).collect_coverage (c->input))) return; }
const Coverage &get_coverage () const { return this+coverage; }
ValueFormat get_value_format () const { return valueFormat; }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
if (index == NOT_COVERED) return_trace (false);
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"positioning glyph at %u",
c->buffer->idx);
}
valueFormat.apply_value (c, this, values, buffer->cur_pos());
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"positioned glyph at %u",
c->buffer->idx);
}
buffer->idx++;
return_trace (true);
}
bool
position_single (hb_font_t *font,
hb_blob_t *table_blob,
hb_direction_t direction,
hb_codepoint_t gid,
hb_glyph_position_t &pos) const
{
unsigned int index = (this+coverage).get_coverage (gid);
if (likely (index == NOT_COVERED)) return false;
/* This is ugly... */
hb_buffer_t buffer {};
buffer.props.direction = direction;
OT::hb_ot_apply_context_t c (1, font, &buffer, table_blob);
valueFormat.apply_value (&c, this, values, pos);
return true;
}
template<typename Iterator,
typename SrcLookup,
hb_requires (hb_is_iterator (Iterator))>
void serialize (hb_serialize_context_t *c,
const SrcLookup *src,
Iterator it,
ValueFormat newFormat,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map)
{
if (unlikely (!c->extend_min (this))) return;
if (unlikely (!c->check_assign (valueFormat,
newFormat,
HB_SERIALIZE_ERROR_INT_OVERFLOW))) return;
for (const hb_array_t<const Value>& _ : + it | hb_map (hb_second))
{
src->get_value_format ().copy_values (c, newFormat, src, &_, layout_variation_idx_delta_map);
// Only serialize the first entry in the iterator, the rest are assumed to
// be the same.
break;
}
auto glyphs =
+ it
| hb_map_retains_sorting (hb_first)
;
coverage.serialize_serialize (c, glyphs);
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
hb_set_t intersection;
(this+coverage).intersect_set (glyphset, intersection);
unsigned new_format = valueFormat;
if (c->plan->normalized_coords)
{
new_format = valueFormat.get_effective_format (values.arrayZ, false, false, this, &c->plan->layout_variation_idx_delta_map);
}
/* do not strip hints for VF */
else if (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING)
{
hb_blob_t* blob = hb_face_reference_table (c->plan->source, HB_TAG ('f','v','a','r'));
bool has_fvar = (blob != hb_blob_get_empty ());
hb_blob_destroy (blob);
bool strip = !has_fvar;
/* special case: strip hints when a VF has no GDEF varstore after
* subsetting*/
if (has_fvar && !c->plan->has_gdef_varstore)
strip = true;
new_format = valueFormat.get_effective_format (values.arrayZ,
strip, /* strip hints */
true, /* strip empty */
this, nullptr);
}
auto it =
+ hb_iter (intersection)
| hb_map_retains_sorting (glyph_map)
| hb_zip (hb_repeat (values.as_array (valueFormat.get_len ())))
;
bool ret = bool (it);
SinglePos_serialize (c->serializer, this, it, &c->plan->layout_variation_idx_delta_map, new_format);
return_trace (ret);
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_SINGLEPOSFORMAT1_HH */

213
3rdparty/harfbuzz/src/OT/Layout/GPOS/SinglePosFormat2.hh vendored
View File

@@ -1,213 +0,0 @@
#ifndef OT_LAYOUT_GPOS_SINGLEPOSFORMAT2_HH
#define OT_LAYOUT_GPOS_SINGLEPOSFORMAT2_HH
#include "Common.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
struct SinglePosFormat2 : ValueBase
{
protected:
HBUINT16 format; /* Format identifier--format = 2 */
Offset16To<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of subtable */
ValueFormat valueFormat; /* Defines the types of data in the
* ValueRecord */
HBUINT16 valueCount; /* Number of ValueRecords */
ValueRecord values; /* Array of ValueRecords--positioning
* values applied to glyphs */
public:
DEFINE_SIZE_ARRAY (8, values);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (c->check_struct (this) &&
coverage.sanitize (c, this) &&
valueFormat.sanitize_values (c, this, values, valueCount));
}
bool intersects (const hb_set_t *glyphs) const
{ return (this+coverage).intersects (glyphs); }
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_variation_indices (hb_collect_variation_indices_context_t *c) const
{
if (!valueFormat.has_device ()) return;
auto it =
+ hb_zip (this+coverage, hb_range ((unsigned) valueCount))
| hb_filter (c->glyph_set, hb_first)
;
if (!it) return;
unsigned sub_length = valueFormat.get_len ();
const hb_array_t<const Value> values_array = values.as_array (valueCount * sub_length);
for (unsigned i : + it
| hb_map (hb_second))
valueFormat.collect_variation_indices (c, this, values_array.sub_array (i * sub_length, sub_length));
}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{ if (unlikely (!(this+coverage).collect_coverage (c->input))) return; }
const Coverage &get_coverage () const { return this+coverage; }
ValueFormat get_value_format () const { return valueFormat; }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
hb_buffer_t *buffer = c->buffer;
unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
if (index == NOT_COVERED) return_trace (false);
if (unlikely (index >= valueCount)) return_trace (false);
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"positioning glyph at %u",
c->buffer->idx);
}
valueFormat.apply_value (c, this,
&values[index * valueFormat.get_len ()],
buffer->cur_pos());
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"positioned glyph at %u",
c->buffer->idx);
}
buffer->idx++;
return_trace (true);
}
bool
position_single (hb_font_t *font,
hb_blob_t *table_blob,
hb_direction_t direction,
hb_codepoint_t gid,
hb_glyph_position_t &pos) const
{
unsigned int index = (this+coverage).get_coverage (gid);
if (likely (index == NOT_COVERED)) return false;
if (unlikely (index >= valueCount)) return false;
/* This is ugly... */
hb_buffer_t buffer {};
buffer.props.direction = direction;
OT::hb_ot_apply_context_t c (1, font, &buffer, table_blob);
valueFormat.apply_value (&c, this,
&values[index * valueFormat.get_len ()],
pos);
return true;
}
template<typename Iterator,
typename SrcLookup,
hb_requires (hb_is_iterator (Iterator))>
void serialize (hb_serialize_context_t *c,
const SrcLookup *src,
Iterator it,
ValueFormat newFormat,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map)
{
auto out = c->extend_min (this);
if (unlikely (!out)) return;
if (unlikely (!c->check_assign (valueFormat, newFormat, HB_SERIALIZE_ERROR_INT_OVERFLOW))) return;
if (unlikely (!c->check_assign (valueCount, it.len (), HB_SERIALIZE_ERROR_ARRAY_OVERFLOW))) return;
+ it
| hb_map (hb_second)
| hb_apply ([&] (hb_array_t<const Value> _)
{ src->get_value_format ().copy_values (c, newFormat, src, &_, layout_variation_idx_delta_map); })
;
auto glyphs =
+ it
| hb_map_retains_sorting (hb_first)
;
coverage.serialize_serialize (c, glyphs);
}
template<typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
unsigned compute_effective_format (const hb_face_t *face,
Iterator it,
bool is_instancing, bool strip_hints,
bool has_gdef_varstore,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map) const
{
hb_blob_t* blob = hb_face_reference_table (face, HB_TAG ('f','v','a','r'));
bool has_fvar = (blob != hb_blob_get_empty ());
hb_blob_destroy (blob);
unsigned new_format = 0;
if (is_instancing)
{
new_format = new_format | valueFormat.get_effective_format (+ it | hb_map (hb_second), false, false, this, varidx_delta_map);
}
/* do not strip hints for VF */
else if (strip_hints)
{
bool strip = !has_fvar;
if (has_fvar && !has_gdef_varstore)
strip = true;
new_format = new_format | valueFormat.get_effective_format (+ it | hb_map (hb_second), strip, true, this, nullptr);
}
else
new_format = valueFormat;
return new_format;
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
unsigned sub_length = valueFormat.get_len ();
auto values_array = values.as_array (valueCount * sub_length);
auto it =
+ hb_zip (this+coverage, hb_range ((unsigned) valueCount))
| hb_filter (glyphset, hb_first)
| hb_map_retains_sorting ([&] (const hb_pair_t<hb_codepoint_t, unsigned>& _)
{
return hb_pair (glyph_map[_.first],
values_array.sub_array (_.second * sub_length,
sub_length));
})
;
unsigned new_format = compute_effective_format (c->plan->source, it,
bool (c->plan->normalized_coords),
bool (c->plan->flags & HB_SUBSET_FLAGS_NO_HINTING),
c->plan->has_gdef_varstore,
&c->plan->layout_variation_idx_delta_map);
bool ret = bool (it);
SinglePos_serialize (c->serializer, this, it, &c->plan->layout_variation_idx_delta_map, new_format);
return_trace (ret);
}
};
}
}
}
#endif /* OT_LAYOUT_GPOS_SINGLEPOSFORMAT2_HH */

446
3rdparty/harfbuzz/src/OT/Layout/GPOS/ValueFormat.hh vendored
View File

@@ -1,446 +0,0 @@
#ifndef OT_LAYOUT_GPOS_VALUEFORMAT_HH
#define OT_LAYOUT_GPOS_VALUEFORMAT_HH
#include "../../../hb-ot-layout-gsubgpos.hh"
namespace OT {
namespace Layout {
namespace GPOS_impl {
typedef HBUINT16 Value;
struct ValueBase {}; // Dummy base class tag for OffsetTo<Value> bases.
typedef UnsizedArrayOf<Value> ValueRecord;
struct ValueFormat : HBUINT16
{
enum Flags {
xPlacement = 0x0001u, /* Includes horizontal adjustment for placement */
yPlacement = 0x0002u, /* Includes vertical adjustment for placement */
xAdvance = 0x0004u, /* Includes horizontal adjustment for advance */
yAdvance = 0x0008u, /* Includes vertical adjustment for advance */
xPlaDevice = 0x0010u, /* Includes horizontal Device table for placement */
yPlaDevice = 0x0020u, /* Includes vertical Device table for placement */
xAdvDevice = 0x0040u, /* Includes horizontal Device table for advance */
yAdvDevice = 0x0080u, /* Includes vertical Device table for advance */
ignored = 0x0F00u, /* Was used in TrueType Open for MM fonts */
reserved = 0xF000u, /* For future use */
devices = 0x00F0u /* Mask for having any Device table */
};
/* All fields are options. Only those available advance the value pointer. */
#if 0
HBINT16 xPlacement; /* Horizontal adjustment for
* placement--in design units */
HBINT16 yPlacement; /* Vertical adjustment for
* placement--in design units */
HBINT16 xAdvance; /* Horizontal adjustment for
* advance--in design units (only used
* for horizontal writing) */
HBINT16 yAdvance; /* Vertical adjustment for advance--in
* design units (only used for vertical
* writing) */
Offset16To<Device> xPlaDevice; /* Offset to Device table for
* horizontal placement--measured from
* beginning of PosTable (may be NULL) */
Offset16To<Device> yPlaDevice; /* Offset to Device table for vertical
* placement--measured from beginning
* of PosTable (may be NULL) */
Offset16To<Device> xAdvDevice; /* Offset to Device table for
* horizontal advance--measured from
* beginning of PosTable (may be NULL) */
Offset16To<Device> yAdvDevice; /* Offset to Device table for vertical
* advance--measured from beginning of
* PosTable (may be NULL) */
#endif
NumType& operator = (uint16_t i) { v = i; return *this; }
// Note: spec says skip 2 bytes per bit in the valueformat. But reports
// from Microsoft developers indicate that only the fields that are
// currently defined are counted. We don't expect any new fields to
// be added to ValueFormat. As such, we use the faster hb_popcount8
// that only processes the lowest 8 bits.
unsigned int get_len () const { return hb_popcount8 ((uint8_t) *this); }
size_t get_size () const { return get_len () * Value::static_size; }
hb_vector_t<unsigned> get_device_table_indices () const {
unsigned i = 0;
hb_vector_t<unsigned> result;
unsigned format = *this;
if (format & xPlacement) i++;
if (format & yPlacement) i++;
if (format & xAdvance) i++;
if (format & yAdvance) i++;
if (format & xPlaDevice) result.push (i++);
if (format & yPlaDevice) result.push (i++);
if (format & xAdvDevice) result.push (i++);
if (format & yAdvDevice) result.push (i++);
return result;
}
bool apply_value (hb_ot_apply_context_t *c,
const ValueBase *base,
const Value *values,
hb_glyph_position_t &glyph_pos) const
{
bool ret = false;
unsigned int format = *this;
if (!format) return ret;
hb_font_t *font = c->font;
bool horizontal =
#ifndef HB_NO_VERTICAL
HB_DIRECTION_IS_HORIZONTAL (c->direction)
#else
true
#endif
;
if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++, &ret));
if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++, &ret));
if (format & xAdvance) {
if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values, &ret));
values++;
}
/* y_advance values grow downward but font-space grows upward, hence negation */
if (format & yAdvance) {
if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values, &ret));
values++;
}
if (!has_device ()) return ret;
bool use_x_device = font->x_ppem || font->has_nonzero_coords;
bool use_y_device = font->y_ppem || font->has_nonzero_coords;
if (!use_x_device && !use_y_device) return ret;
const ItemVariationStore &store = c->var_store;
auto *cache = c->var_store_cache;
/* pixel -> fractional pixel */
if (format & xPlaDevice)
{
if (use_x_device) glyph_pos.x_offset += get_device (values, &ret, base, c->sanitizer).get_x_delta (font, store, cache);
values++;
}
if (format & yPlaDevice)
{
if (use_y_device) glyph_pos.y_offset += get_device (values, &ret, base, c->sanitizer).get_y_delta (font, store, cache);
values++;
}
if (format & xAdvDevice)
{
if (horizontal && use_x_device) glyph_pos.x_advance += get_device (values, &ret, base, c->sanitizer).get_x_delta (font, store, cache);
values++;
}
if (format & yAdvDevice)
{
/* y_advance values grow downward but font-space grows upward, hence negation */
if (!horizontal && use_y_device) glyph_pos.y_advance -= get_device (values, &ret, base, c->sanitizer).get_y_delta (font, store, cache);
values++;
}
return ret;
}
unsigned int get_effective_format (const Value *values, bool strip_hints, bool strip_empty, const ValueBase *base,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map) const
{
unsigned int format = *this;
for (unsigned flag = xPlacement; flag <= yAdvDevice; flag = flag << 1) {
if (format & flag)
{
if (strip_hints && flag >= xPlaDevice)
{
format = format & ~flag;
values++;
continue;
}
if (varidx_delta_map && flag >= xPlaDevice)
{
update_var_flag (values++, (Flags) flag, &format, base, varidx_delta_map);
continue;
}
/* do not strip empty when instancing, cause we don't know whether the new
* default value is 0 or not */
if (strip_empty) should_drop (*values, (Flags) flag, &format);
values++;
}
}
return format;
}
template<typename Iterator,
hb_requires (hb_is_iterator (Iterator))>
unsigned int get_effective_format (Iterator it, bool strip_hints, bool strip_empty, const ValueBase *base,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map) const {
unsigned int new_format = 0;
for (const hb_array_t<const Value>& values : it)
new_format = new_format | get_effective_format (&values, strip_hints, strip_empty, base, varidx_delta_map);
return new_format;
}
void copy_values (hb_serialize_context_t *c,
unsigned int new_format,
const ValueBase *base,
const Value *values,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map) const
{
unsigned int format = *this;
if (!format) return;
HBINT16 *x_placement = nullptr, *y_placement = nullptr, *x_adv = nullptr, *y_adv = nullptr;
if (format & xPlacement) x_placement = copy_value (c, new_format, xPlacement, *values++);
if (format & yPlacement) y_placement = copy_value (c, new_format, yPlacement, *values++);
if (format & xAdvance) x_adv = copy_value (c, new_format, xAdvance, *values++);
if (format & yAdvance) y_adv = copy_value (c, new_format, yAdvance, *values++);
if (!has_device ())
return;
if (format & xPlaDevice)
{
add_delta_to_value (x_placement, base, values, layout_variation_idx_delta_map);
copy_device (c, base, values++, layout_variation_idx_delta_map, new_format, xPlaDevice);
}
if (format & yPlaDevice)
{
add_delta_to_value (y_placement, base, values, layout_variation_idx_delta_map);
copy_device (c, base, values++, layout_variation_idx_delta_map, new_format, yPlaDevice);
}
if (format & xAdvDevice)
{
add_delta_to_value (x_adv, base, values, layout_variation_idx_delta_map);
copy_device (c, base, values++, layout_variation_idx_delta_map, new_format, xAdvDevice);
}
if (format & yAdvDevice)
{
add_delta_to_value (y_adv, base, values, layout_variation_idx_delta_map);
copy_device (c, base, values++, layout_variation_idx_delta_map, new_format, yAdvDevice);
}
}
HBINT16* copy_value (hb_serialize_context_t *c,
unsigned int new_format,
Flags flag,
Value value) const
{
// Filter by new format.
if (!(new_format & flag)) return nullptr;
return reinterpret_cast<HBINT16 *> (c->copy (value));
}
void collect_variation_indices (hb_collect_variation_indices_context_t *c,
const ValueBase *base,
const hb_array_t<const Value>& values) const
{
unsigned format = *this;
unsigned i = 0;
if (format & xPlacement) i++;
if (format & yPlacement) i++;
if (format & xAdvance) i++;
if (format & yAdvance) i++;
if (format & xPlaDevice)
{
(base + get_device (&(values[i]))).collect_variation_indices (c);
i++;
}
if (format & ValueFormat::yPlaDevice)
{
(base + get_device (&(values[i]))).collect_variation_indices (c);
i++;
}
if (format & ValueFormat::xAdvDevice)
{
(base + get_device (&(values[i]))).collect_variation_indices (c);
i++;
}
if (format & ValueFormat::yAdvDevice)
{
(base + get_device (&(values[i]))).collect_variation_indices (c);
i++;
}
}
private:
bool sanitize_value_devices (hb_sanitize_context_t *c, const ValueBase *base, const Value *values) const
{
unsigned int format = *this;
if (format & xPlacement) values++;
if (format & yPlacement) values++;
if (format & xAdvance) values++;
if (format & yAdvance) values++;
if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
return true;
}
static inline Offset16To<Device, ValueBase>& get_device (Value* value)
{
return *static_cast<Offset16To<Device, ValueBase> *> (value);
}
static inline const Offset16To<Device, ValueBase>& get_device (const Value* value)
{
return *static_cast<const Offset16To<Device, ValueBase> *> (value);
}
static inline const Device& get_device (const Value* value,
bool *worked,
const ValueBase *base,
hb_sanitize_context_t &c)
{
if (worked) *worked |= bool (*value);
auto &offset = *static_cast<const Offset16To<Device> *> (value);
if (unlikely (!offset.sanitize (&c, base)))
return Null(Device);
hb_barrier ();
return base + offset;
}
void add_delta_to_value (HBINT16 *value,
const ValueBase *base,
const Value *src_value,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map) const
{
if (!value) return;
unsigned varidx = (base + get_device (src_value)).get_variation_index ();
hb_pair_t<unsigned, int> *varidx_delta;
if (!layout_variation_idx_delta_map->has (varidx, &varidx_delta)) return;
*value += hb_second (*varidx_delta);
}
bool copy_device (hb_serialize_context_t *c,
const ValueBase *base,
const Value *src_value,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *layout_variation_idx_delta_map,
unsigned int new_format, Flags flag) const
{
// Filter by new format.
if (!(new_format & flag)) return true;
Value *dst_value = c->copy (*src_value);
if (!dst_value) return false;
if (*dst_value == 0) return true;
*dst_value = 0;
c->push ();
if ((base + get_device (src_value)).copy (c, layout_variation_idx_delta_map))
{
c->add_link (*dst_value, c->pop_pack ());
return true;
}
else
{
c->pop_discard ();
return false;
}
}
static inline const HBINT16& get_short (const Value* value, bool *worked=nullptr)
{
if (worked) *worked |= bool (*value);
return *reinterpret_cast<const HBINT16 *> (value);
}
public:
bool has_device () const
{
unsigned int format = *this;
return (format & devices) != 0;
}
bool sanitize_value (hb_sanitize_context_t *c, const ValueBase *base, const Value *values) const
{
TRACE_SANITIZE (this);
if (unlikely (!c->check_range (values, get_size ()))) return_trace (false);
if (c->lazy_some_gpos)
return_trace (true);
return_trace (!has_device () || sanitize_value_devices (c, base, values));
}
bool sanitize_values (hb_sanitize_context_t *c, const ValueBase *base, const Value *values, unsigned int count) const
{
TRACE_SANITIZE (this);
unsigned size = get_size ();
if (!c->check_range (values, count, size)) return_trace (false);
if (c->lazy_some_gpos)
return_trace (true);
hb_barrier ();
return_trace (sanitize_values_stride_unsafe (c, base, values, count, size));
}
/* Just sanitize referenced Device tables. Doesn't check the values themselves. */
bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const ValueBase *base, const Value *values, unsigned int count, unsigned int stride) const
{
TRACE_SANITIZE (this);
if (!has_device ()) return_trace (true);
for (unsigned int i = 0; i < count; i++) {
if (!sanitize_value_devices (c, base, values))
return_trace (false);
values = &StructAtOffset<const Value> (values, stride);
}
return_trace (true);
}
private:
void should_drop (Value value, Flags flag, unsigned int* format) const
{
if (value) return;
*format = *format & ~flag;
}
void update_var_flag (const Value* value, Flags flag,
unsigned int* format, const ValueBase *base,
const hb_hashmap_t<unsigned, hb_pair_t<unsigned, int>> *varidx_delta_map) const
{
if (*value)
{
unsigned varidx = (base + get_device (value)).get_variation_index ();
hb_pair_t<unsigned, int> *varidx_delta;
if (varidx_delta_map->has (varidx, &varidx_delta) &&
varidx_delta->first != HB_OT_LAYOUT_NO_VARIATIONS_INDEX)
return;
}
*format = *format & ~flag;
}
};
}
}
}
#endif // #ifndef OT_LAYOUT_GPOS_VALUEFORMAT_HH

139
3rdparty/harfbuzz/src/OT/Layout/GSUB/AlternateSet.hh vendored
View File

@@ -1,139 +0,0 @@
#ifndef OT_LAYOUT_GSUB_ALTERNATESET_HH
#define OT_LAYOUT_GSUB_ALTERNATESET_HH
#include "Common.hh"
namespace OT {
namespace Layout {
namespace GSUB_impl {
template <typename Types>
struct AlternateSet
{
protected:
Array16Of<typename Types::HBGlyphID>
alternates; /* Array of alternate GlyphIDs--in
* arbitrary order */
public:
DEFINE_SIZE_ARRAY (2, alternates);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (alternates.sanitize (c));
}
bool intersects (const hb_set_t *glyphs) const
{ return hb_any (alternates, glyphs); }
void closure (hb_closure_context_t *c) const
{ c->output->add_array (alternates.arrayZ, alternates.len); }
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{ c->output->add_array (alternates.arrayZ, alternates.len); }
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
unsigned int count = alternates.len;
if (unlikely (!count)) return_trace (false);
hb_mask_t glyph_mask = c->buffer->cur().mask;
hb_mask_t lookup_mask = c->lookup_mask;
/* Note: This breaks badly if two features enabled this lookup together. */
unsigned int shift = hb_ctz (lookup_mask);
unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift);
/* If alt_index is MAX_VALUE, randomize feature if it is the rand feature. */
if (alt_index == HB_OT_MAP_MAX_VALUE && c->random)
{
/* Maybe we can do better than unsafe-to-break all; but since we are
* changing random state, it would be hard to track that. Good 'nough. */
c->buffer->unsafe_to_break (0, c->buffer->len);
alt_index = c->random_number () % count + 1;
}
if (unlikely (alt_index > count || alt_index == 0)) return_trace (false);
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->sync_so_far ();
c->buffer->message (c->font,
"replacing glyph at %u (alternate substitution)",
c->buffer->idx);
}
c->replace_glyph (alternates[alt_index - 1]);
if (HB_BUFFER_MESSAGE_MORE && c->buffer->messaging ())
{
c->buffer->message (c->font,
"replaced glyph at %u (alternate substitution)",
c->buffer->idx - 1u);
}
return_trace (true);
}
unsigned
get_alternates (unsigned start_offset,
unsigned *alternate_count /* IN/OUT. May be NULL. */,
hb_codepoint_t *alternate_glyphs /* OUT. May be NULL. */) const
{
if (alternates.len && alternate_count)
{
+ alternates.as_array ().sub_array (start_offset, alternate_count)
| hb_sink (hb_array (alternate_glyphs, *alternate_count))
;
}
return alternates.len;
}
void
collect_alternates (hb_codepoint_t gid,
hb_map_t *alternate_count /* IN/OUT */,
hb_map_t *alternate_glyphs /* IN/OUT */) const
{
+ hb_enumerate (alternates)
| hb_map ([gid] (hb_pair_t<unsigned, hb_codepoint_t> _) { return hb_pair (gid + (_.first << 24), _.second); })
| hb_apply ([&] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t> &p) -> void
{ _hb_collect_glyph_alternates_add (p.first, p.second,
alternate_count, alternate_glyphs); })
;
}
template <typename Iterator,
hb_requires (hb_is_source_of (Iterator, hb_codepoint_t))>
bool serialize (hb_serialize_context_t *c,
Iterator alts)
{
TRACE_SERIALIZE (this);
return_trace (alternates.serialize (c, alts));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto it =
+ hb_iter (alternates)
| hb_filter (glyphset)
| hb_map (glyph_map)
;
auto *out = c->serializer->start_embed (*this);
return_trace (out->serialize (c->serializer, it) &&
out->alternates);
}
};
}
}
}
#endif /* OT_LAYOUT_GSUB_ALTERNATESET_HH */

62
3rdparty/harfbuzz/src/OT/Layout/GSUB/AlternateSubst.hh vendored
View File

@@ -1,62 +0,0 @@
#ifndef OT_LAYOUT_GSUB_ALTERNATESUBST_HH
#define OT_LAYOUT_GSUB_ALTERNATESUBST_HH
#include "AlternateSubstFormat1.hh"
#include "Common.hh"
namespace OT {
namespace Layout {
namespace GSUB_impl {
struct AlternateSubst
{
protected:
union {
struct { HBUINT16 v; } format; /* Format identifier */
AlternateSubstFormat1_2<SmallTypes> format1;
#ifndef HB_NO_BEYOND_64K
AlternateSubstFormat1_2<MediumTypes> format2;
#endif
} u;
public:
template <typename context_t, typename ...Ts>
typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
{
if (unlikely (!c->may_dispatch (this, &u.format.v))) return c->no_dispatch_return_value ();
TRACE_DISPATCH (this, u.format.v);
switch (u.format.v) {
case 1: return_trace (c->dispatch (u.format1, std::forward<Ts> (ds)...));
#ifndef HB_NO_BEYOND_64K
case 2: return_trace (c->dispatch (u.format2, std::forward<Ts> (ds)...));
#endif
default:return_trace (c->default_return_value ());
}
}
/* TODO This function is unused and not updated to 24bit GIDs. Should be done by using
* iterators. While at it perhaps using iterator of arrays of hb_codepoint_t instead. */
bool serialize (hb_serialize_context_t *c,
hb_sorted_array_t<const HBGlyphID16> glyphs,
hb_array_t<const unsigned int> alternate_len_list,
hb_array_t<const HBGlyphID16> alternate_glyphs_list)
{
TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (u.format.v))) return_trace (false);
unsigned int format = 1;
u.format.v = format;
switch (u.format.v) {
case 1: return_trace (u.format1.serialize (c, glyphs, alternate_len_list, alternate_glyphs_list));
default:return_trace (false);
}
}
/* TODO subset() should choose format. */
};
}
}
}
#endif /* OT_LAYOUT_GSUB_ALTERNATESUBST_HH */

141
3rdparty/harfbuzz/src/OT/Layout/GSUB/AlternateSubstFormat1.hh vendored
View File

@@ -1,141 +0,0 @@
#ifndef OT_LAYOUT_GSUB_ALTERNATESUBSTFORMAT1_HH
#define OT_LAYOUT_GSUB_ALTERNATESUBSTFORMAT1_HH
#include "AlternateSet.hh"
#include "Common.hh"
namespace OT {
namespace Layout {
namespace GSUB_impl {
template <typename Types>
struct AlternateSubstFormat1_2
{
protected:
HBUINT16 format; /* Format identifier--format = 1 */
typename Types::template OffsetTo<Coverage>
coverage; /* Offset to Coverage table--from
* beginning of Substitution table */
Array16Of<typename Types::template OffsetTo<AlternateSet<Types>>>
alternateSet; /* Array of AlternateSet tables
* ordered by Coverage Index */
public:
DEFINE_SIZE_ARRAY (2 + 2 * Types::size, alternateSet);
bool sanitize (hb_sanitize_context_t *c) const
{
TRACE_SANITIZE (this);
return_trace (coverage.sanitize (c, this) && alternateSet.sanitize (c, this));
}
bool intersects (const hb_set_t *glyphs) const
{ return (this+coverage).intersects (glyphs); }
bool may_have_non_1to1 () const
{ return false; }
void closure (hb_closure_context_t *c) const
{
+ hb_zip (this+coverage, alternateSet)
| hb_filter (c->parent_active_glyphs (), hb_first)
| hb_map (hb_second)
| hb_map (hb_add (this))
| hb_apply ([c] (const AlternateSet<Types> &_) { _.closure (c); })
;
}
void closure_lookups (hb_closure_lookups_context_t *c) const {}
void collect_glyphs (hb_collect_glyphs_context_t *c) const
{
if (unlikely (!(this+coverage).collect_coverage (c->input))) return;
+ hb_zip (this+coverage, alternateSet)
| hb_map (hb_second)
| hb_map (hb_add (this))
| hb_apply ([c] (const AlternateSet<Types> &_) { _.collect_glyphs (c); })
;
}
const Coverage &get_coverage () const { return this+coverage; }
bool would_apply (hb_would_apply_context_t *c) const
{ return c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED; }
unsigned
get_glyph_alternates (hb_codepoint_t gid,
unsigned start_offset,
unsigned *alternate_count /* IN/OUT. May be NULL. */,
hb_codepoint_t *alternate_glyphs /* OUT. May be NULL. */) const
{ return (this+alternateSet[(this+coverage).get_coverage (gid)])
.get_alternates (start_offset, alternate_count, alternate_glyphs); }
void
collect_glyph_alternates (hb_map_t *alternate_count /* IN/OUT */,
hb_map_t *alternate_glyphs /* IN/OUT */) const
{
+ hb_iter (alternateSet)
| hb_map (hb_add (this))
| hb_zip (this+coverage)
| hb_apply ([&] (const hb_pair_t<const AlternateSet<Types> &, hb_codepoint_t> _) {
_.first.collect_alternates (_.second, alternate_count, alternate_glyphs);
})
;
}
bool apply (hb_ot_apply_context_t *c) const
{
TRACE_APPLY (this);
unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
if (index == NOT_COVERED) return_trace (false);
return_trace ((this+alternateSet[index]).apply (c));
}
bool serialize (hb_serialize_context_t *c,
hb_sorted_array_t<const HBGlyphID16> glyphs,
hb_array_t<const unsigned int> alternate_len_list,
hb_array_t<const HBGlyphID16> alternate_glyphs_list)
{
TRACE_SERIALIZE (this);
if (unlikely (!c->extend_min (this))) return_trace (false);
if (unlikely (!alternateSet.serialize (c, glyphs.length))) return_trace (false);
for (unsigned int i = 0; i < glyphs.length; i++)
{
unsigned int alternate_len = alternate_len_list[i];
if (unlikely (!alternateSet[i]
.serialize_serialize (c, alternate_glyphs_list.sub_array (0, alternate_len))))
return_trace (false);
alternate_glyphs_list += alternate_len;
}
return_trace (coverage.serialize_serialize (c, glyphs));
}
bool subset (hb_subset_context_t *c) const
{
TRACE_SUBSET (this);
const hb_set_t &glyphset = *c->plan->glyphset_gsub ();
const hb_map_t &glyph_map = *c->plan->glyph_map;
auto *out = c->serializer->start_embed (*this);
if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
out->format = format;
hb_sorted_vector_t<hb_codepoint_t> new_coverage;
+ hb_zip (this+coverage, alternateSet)
| hb_filter (glyphset, hb_first)
| hb_filter (subset_offset_array (c, out->alternateSet, this), hb_second)
| hb_map (hb_first)
| hb_map (glyph_map)
| hb_sink (new_coverage)
;
out->coverage.serialize_serialize (c->serializer, new_coverage.iter ());
return_trace (bool (new_coverage));
}
};
}
}
}
#endif /* OT_LAYOUT_GSUB_ALTERNATESUBSTFORMAT1_HH */

Some files were not shown because too many files have changed in this diff Show More