Administrator/opencv-MIRROR
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-11-10 18:49:00 -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
350 changed files with 25225 additions and 5234 deletions
Expand all files Collapse all files

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

@@ -58,4 +58,6 @@ jobs:
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-4.x-RISCV.yaml@main
uses: opencv/ci-gha-workflow/.github/workflows/OCV-PR-RISCV.yaml@main
with:
workflow_branch: main

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

@@ -1,9 +1,9 @@
# Binaries branch name: ffmpeg/4.x_20251226
# Binaries were created for OpenCV: cff7581175d2abfc6aef2e4f04f482e258b5c864
ocv_update(FFMPEG_BINARIES_COMMIT "d82ad9a54a7b42a1648a9cae8fed5c2f20ea396c")
ocv_update(FFMPEG_FILE_HASH_BIN32 "47730de2286110b0d1250ff9cf50ce56")
ocv_update(FFMPEG_FILE_HASH_BIN64 "3248b4663ffef770cdb54ec8b9d16a28")
ocv_update(FFMPEG_FILE_HASH_CMAKE "8862c87496e2e8c375965e1277dee1c7")
# 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)

10
3rdparty/ippicv/ippicv.cmake vendored
View File

@@ -2,7 +2,7 @@ function(download_ippicv root_var)
set(${root_var} "" PARENT_SCOPE)
# Commit SHA in the opencv_3rdparty repo
set(IPPICV_COMMIT "406d398c436d0465c8e53dd432d9ecd9301d5f4a")
set(IPPICV_COMMIT "4fe81acdb1688d5f2a3fa6f34b1c28793e706f0b")
# Define actual ICV versions
if(APPLE)
set(IPPICV_COMMIT "0cc4aa06bf2bef4b05d237c69a5a96b9cd0cb85a")
@@ -14,8 +14,8 @@ function(download_ippicv root_var)
set(OPENCV_ICV_PLATFORM "linux")
set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_lnx")
if(X86_64)
set(OPENCV_ICV_NAME "ippicv_2026.0.0_lnx_intel64_20260327_general.tgz")
set(OPENCV_ICV_HASH "9a3ee0c5c3c02102faa422d60bfd1f4a")
set(OPENCV_ICV_NAME "ippicv_2026.1.0_lnx_intel64_20260922_general.tgz")
set(OPENCV_ICV_HASH "78f38db04a4d8f08f7d715a5c976347b")
else()
if(ANDROID)
set(IPPICV_COMMIT "c7c6d527dde5fee7cb914ee9e4e20f7436aab3a1")
@@ -31,8 +31,8 @@ function(download_ippicv root_var)
set(OPENCV_ICV_PLATFORM "windows")
set(OPENCV_ICV_PACKAGE_SUBDIR "ippicv_win")
if(X86_64)
set(OPENCV_ICV_NAME "ippicv_2026.0.0_win_intel64_20260327_general.zip")
set(OPENCV_ICV_HASH "73bc67cd5e4c8da706fa88fe84630231")
set(OPENCV_ICV_NAME "ippicv_2026.1.0_win_intel64_20260922_general.zip")
set(OPENCV_ICV_HASH "d24183f73b413c5b4e2d2b371affc82a")
else()
set(IPPICV_COMMIT "7f55c0c26be418d494615afca15218566775c725")
set(OPENCV_ICV_NAME "ippicv_2021.12.0_win_ia32_20240425_general.zip")

21
3rdparty/libtiff/CMakeLists.txt vendored
View File

@@ -297,6 +297,16 @@ if(JPEG_SUPPORT AND old-jpeg)
set(OJPEG_SUPPORT TRUE)
endif()
# WEBP
set(WEBP_SUPPORT FALSE)
if(HAVE_WEBP)
set(WEBP_SUPPORT TRUE)
if(TARGET ${WEBP_LIBRARY} AND DEFINED ${WEBP_LIBRARY}_BINARY_DIR)
include_directories("${${WEBP_LIBRARY}_BINARY_DIR}")
endif()
include_directories(${WEBP_INCLUDE_DIR})
endif()
# OpenCV: turned off
set(JBIG_SUPPORT 0)
set(LZMA_SUPPORT 0) # OpenCV: turned off
@@ -329,6 +339,9 @@ endif()
if(JPEG12_INCLUDE_DIR)
list(APPEND TIFF_INCLUDES ${JPEG12_INCLUDE_DIR})
endif()
if(WEBP_INCLUDE_DIR)
list(APPEND TIFF_INCLUDES ${WEBP_INCLUDE_DIR})
endif()
if(JBIG_INCLUDE_DIR)
list(APPEND TIFF_INCLUDES ${JBIG_INCLUDE_DIR})
endif()
@@ -347,6 +360,9 @@ endif()
if(JPEG_LIBRARIES)
list(APPEND TIFF_LIBRARY_DEPS ${JPEG_LIBRARIES})
endif()
if(WEBP_LIBRARIES)
list(APPEND TIFF_LIBRARY_DEPS ${WEBP_LIBRARIES})
endif()
if(JPEG12_LIBRARIES)
list(APPEND TIFF_LIBRARY_DEPS ${JPEG12_LIBRARIES})
endif()
@@ -359,7 +375,7 @@ endif()
set(LIBTIFF_MAJOR_VERSION "4")
set(LIBTIFF_MINOR_VERSION "7")
set(LIBTIFF_MICRO_VERSION "1")
set(LIBTIFF_MICRO_VERSION "2")
set(LIBTIFF_VERSION "${LIBTIFF_MAJOR_VERSION}.${LIBTIFF_MINOR_VERSION}.${LIBTIFF_MICRO_VERSION}")
file(READ "RELEASE-DATE" LIBTIFF_RELEASE_DATE content)
@@ -462,6 +478,9 @@ ocv_warnings_disable(CMAKE_C_FLAGS /wd4267 /wd4244 /wd4018 /wd4311 /wd4312)
add_library(${TIFF_LIBRARY} STATIC ${OPENCV_3RDPARTY_EXCLUDE_FROM_ALL} ${lib_srcs})
target_link_libraries(${TIFF_LIBRARY} ${ZLIB_LIBRARIES})
if(HAVE_WEBP)
target_link_libraries(${TIFF_LIBRARY} ${WEBP_LIBRARY})
endif()
set_target_properties(${TIFF_LIBRARY}
PROPERTIES

2336
3rdparty/libtiff/ChangeLog vendored
View File

File diff suppressed because it is too large Load Diff

2
3rdparty/libtiff/RELEASE-DATE vendored
View File

@@ -1 +1 @@
20250911
20260627

127
3rdparty/libtiff/tif_aux.c vendored
View File

@@ -56,6 +56,21 @@ uint64_t _TIFFMultiply64(TIFF *tif, uint64_t first, uint64_t second,
return first * second;
}
uint64_t _TIFFAdd64(TIFF *tif, uint64_t first, uint64_t second,
const char *where)
{
if (first > UINT64_MAX - second)
{
if (tif != NULL && where != NULL)
{
TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
}
return 0;
}
return first + second;
}
tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
const char *where)
{
@@ -81,6 +96,30 @@ tmsize_t _TIFFMultiplySSize(TIFF *tif, tmsize_t first, tmsize_t second,
return first * second;
}
tmsize_t _TIFFAddSSize(TIFF *tif, tmsize_t first, tmsize_t second,
const char *where)
{
if (first < 0 || second < 0)
{
if (tif != NULL && where != NULL)
{
TIFFErrorExtR(tif, where,
"Invalid argument to _TIFFAddSSize() in %s", where);
}
return 0;
}
if (first > TIFF_TMSIZE_T_MAX - second)
{
if (tif != NULL && where != NULL)
{
TIFFErrorExtR(tif, where, "Integer overflow in %s", where);
}
return 0;
}
return first + second;
}
tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
{
if (val > (uint64_t)TIFF_TMSIZE_T_MAX)
@@ -94,6 +133,55 @@ tmsize_t _TIFFCastUInt64ToSSize(TIFF *tif, uint64_t val, const char *module)
return (tmsize_t)val;
}
uint32_t _TIFFCastUInt64ToUInt32(TIFF *tif, uint64_t val, const char *module)
{
if (val > UINT32_MAX)
{
if (tif != NULL && module != NULL)
{
TIFFErrorExtR(tif, module, "Integer overflow");
}
return 0;
}
return (uint32_t)val;
}
tmsize_t _TIFFComputeRowOffset(TIFF *tif, tmsize_t rowstride, uint32_t row,
const char *where)
{
if (row == 0)
return 0;
return _TIFFMultiplySSize(tif, rowstride, (tmsize_t)row, where);
}
uint64_t _TIFFComputeBitOffset(TIFF *tif, uint32_t col, uint16_t spp,
uint16_t bps, const char *where)
{
uint64_t samples = _TIFFMultiply64(tif, col, spp, where);
if (samples == 0 && col != 0)
return 0;
return _TIFFMultiply64(tif, samples, bps, where);
}
/*
* Returns 0 on overflow or invalid zero-sized row inputs. Callers that
* intentionally allow empty rows should not use this helper directly.
*/
uint64_t _TIFFComputeRowSize64(TIFF *tif, uint32_t width, uint16_t spp,
uint16_t bps, const char *where)
{
uint64_t samples = _TIFFMultiply64(tif, width, spp, where);
uint64_t bits;
if (samples == 0)
return 0;
bits = _TIFFMultiply64(tif, samples, bps, where);
if (bits == 0)
return 0;
return TIFFhowmany8_64(bits);
}
void *_TIFFCheckRealloc(TIFF *tif, void *buffer, tmsize_t nmemb,
tmsize_t elem_size, const char *what)
{
@@ -137,8 +225,8 @@ static int TIFFDefaultTransferFunction(TIFF *tif, TIFFDirectory *td)
if (td->td_bitspersample > 24)
return 0;
n = ((tmsize_t)1) << td->td_bitspersample;
nbytes = n * sizeof(uint16_t);
n = (tmsize_t)(1ULL << td->td_bitspersample);
nbytes = (tmsize_t)((uint64_t)n * sizeof(uint16_t));
tf[0] = (uint16_t *)_TIFFmallocExt(tif, nbytes);
if (tf[0] == NULL)
return 0;
@@ -186,10 +274,10 @@ static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
* YCbCr (Class Y) images must have the ReferenceBlackWhite
* tag set. Fix the broken images, which lacks that tag.
*/
td->td_refblackwhite[0] = 0.0F;
td->td_refblackwhite[0] = 0.0f;
td->td_refblackwhite[1] = td->td_refblackwhite[3] =
td->td_refblackwhite[5] = 255.0F;
td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0F;
td->td_refblackwhite[5] = 255.0f;
td->td_refblackwhite[2] = td->td_refblackwhite[4] = 128.0f;
}
else
{
@@ -199,8 +287,11 @@ static int TIFFDefaultRefBlackWhite(TIFF *tif, TIFFDirectory *td)
for (i = 0; i < 3; i++)
{
td->td_refblackwhite[2 * i + 0] = 0;
td->td_refblackwhite[2 * i + 1] =
(float)((1L << td->td_bitspersample) - 1L);
if (td->td_bitspersample < 64)
td->td_refblackwhite[2 * i + 1] =
(float)((1ULL << td->td_bitspersample) - 1ULL);
else
td->td_refblackwhite[2 * i + 1] = (float)UINT64_MAX;
}
}
return 1;
@@ -258,8 +349,8 @@ int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
* 65535 even if td_bitspersamle is > 16 */
if (td->td_bitspersample <= 16)
{
maxsamplevalue = (1 << td->td_bitspersample) -
1; /* 2**(BitsPerSample) - 1 */
maxsamplevalue = (uint16_t)((1U << td->td_bitspersample) -
1); /* 2**(BitsPerSample) - 1 */
}
else
{
@@ -295,7 +386,11 @@ int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
}
case TIFFTAG_DOTRANGE:
*va_arg(ap, uint16_t *) = 0;
*va_arg(ap, uint16_t *) = (1 << td->td_bitspersample) - 1;
if (td->td_bitspersample <= 16)
*va_arg(ap, uint16_t *) =
(uint16_t)((1U << td->td_bitspersample) - 1);
else
*va_arg(ap, uint16_t *) = 65535;
return (1);
case TIFFTAG_INKSET:
*va_arg(ap, uint16_t *) = INKSET_CMYK;
@@ -309,14 +404,14 @@ int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
return (1);
case TIFFTAG_MATTEING:
*va_arg(ap, uint16_t *) =
(td->td_extrasamples == 1 &&
(td->td_extrasamples == 1 && td->td_sampleinfo &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
return (1);
case TIFFTAG_TILEDEPTH:
*va_arg(ap, uint32_t *) = td->td_tiledepth;
return (1);
case TIFFTAG_DATATYPE:
*va_arg(ap, uint16_t *) = td->td_sampleformat - 1;
*va_arg(ap, uint16_t *) = (uint16_t)(td->td_sampleformat - 1);
return (1);
case TIFFTAG_SAMPLEFORMAT:
*va_arg(ap, uint16_t *) = td->td_sampleformat;
@@ -369,6 +464,8 @@ int TIFFVGetFieldDefaulted(TIFF *tif, uint32_t tag, va_list ap)
return (0);
*va_arg(ap, const float **) = td->td_refblackwhite;
return (1);
default:
break;
}
return 0;
}
@@ -390,9 +487,9 @@ int TIFFGetFieldDefaulted(TIFF *tif, uint32_t tag, ...)
float _TIFFClampDoubleToFloat(double val)
{
if (val > FLT_MAX)
if (val > (double)FLT_MAX)
return FLT_MAX;
if (val < -FLT_MAX)
if (val < -(double)FLT_MAX)
return -FLT_MAX;
return (float)val;
}
@@ -401,7 +498,7 @@ uint32_t _TIFFClampDoubleToUInt32(double val)
{
if (val < 0)
return 0;
if (val > 0xFFFFFFFFU || val != val)
if (val > 0xFFFFFFFFU || isnan(val))
return 0xFFFFFFFFU;
return (uint32_t)val;
}

6
3rdparty/libtiff/tif_close.c vendored
View File

@@ -88,7 +88,7 @@ void TIFFCleanup(TIFF *tif)
*/
TIFFFieldIsAnonymous(fld))
{
_TIFFfreeExt(tif, fld->field_name);
_TIFFfreeExt(tif, (void *)fld->field_name);
_TIFFfreeExt(tif, fld);
}
}
@@ -121,7 +121,7 @@ void TIFFCleanup(TIFF *tif)
}
/************************************************************************/
/* _TIFFCleanupIFDOffsetAndNumberMaps() */
/* _TIFFCleanupIFDOffsetAndNumberMaps() */
/************************************************************************/
void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif)
@@ -139,7 +139,7 @@ void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif)
}
/************************************************************************/
/* TIFFClose() */
/* TIFFClose() */
/************************************************************************/
/**

81
3rdparty/libtiff/tif_color.c vendored
View File

@@ -55,34 +55,34 @@ void TIFFCIELabToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a, int32_t b,
void TIFFCIELab16ToXYZ(TIFFCIELabToRGB *cielab, uint32_t l, int32_t a,
int32_t b, float *X, float *Y, float *Z)
{
float L = (float)l * 100.0F / 65535.0F;
float L = (float)l * 100.0f / 65535.0f;
float cby, tmp;
if (L < 8.856F)
if (L < 8.856f)
{
*Y = (L * cielab->Y0) / 903.292F;
cby = 7.787F * (*Y / cielab->Y0) + 16.0F / 116.0F;
*Y = (L * cielab->Y0) / 903.292f;
cby = 7.787f * (*Y / cielab->Y0) + 16.0f / 116.0f;
}
else
{
cby = (L + 16.0F) / 116.0F;
cby = (L + 16.0f) / 116.0f;
*Y = cielab->Y0 * cby * cby * cby;
}
tmp = (float)a / 256.0F / 500.0F + cby;
if (tmp < 0.2069F)
*X = cielab->X0 * (tmp - 0.13793F) / 7.787F;
tmp = (float)a / 256.0f / 500.0f + cby;
if (tmp < 0.2069f)
*X = cielab->X0 * (tmp - 0.13793f) / 7.787f;
else
*X = cielab->X0 * tmp * tmp * tmp;
tmp = cby - (float)b / 256.0F / 200.0F;
if (tmp < 0.2069F)
*Z = cielab->Z0 * (tmp - 0.13793F) / 7.787F;
tmp = cby - (float)b / 256.0f / 200.0f;
if (tmp < 0.2069f)
*Z = cielab->Z0 * (tmp - 0.13793f) / 7.787f;
else
*Z = cielab->Z0 * tmp * tmp * tmp;
}
#define RINT(R) ((uint32_t)((R) > 0 ? ((R) + 0.5) : ((R)-0.5)))
#define RINT(R) ((uint32_t)((R) > 0 ? ((R) + 0.5f) : ((R) - 0.5f)))
/*
* Convert color value from the XYZ space to RGB.
*/
@@ -143,32 +143,32 @@ int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *display,
_TIFFmemcpy(&cielab->display, display, sizeof(TIFFDisplay));
/* Red */
dfGamma = 1.0 / cielab->display.d_gammaR;
dfGamma = 1.0 / (double)cielab->display.d_gammaR;
cielab->rstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
(cielab->display.d_YCR - cielab->display.d_Y0R) / (float)cielab->range;
for (i = 0; i <= (size_t)cielab->range; i++)
{
cielab->Yr2r[i] = cielab->display.d_Vrwr *
cielab->Yr2r[i] = (float)cielab->display.d_Vrwr *
((float)pow((double)i / cielab->range, dfGamma));
}
/* Green */
dfGamma = 1.0 / cielab->display.d_gammaG;
dfGamma = 1.0 / (double)cielab->display.d_gammaG;
cielab->gstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
(cielab->display.d_YCR - cielab->display.d_Y0R) / (float)cielab->range;
for (i = 0; i <= (size_t)cielab->range; i++)
{
cielab->Yg2g[i] = cielab->display.d_Vrwg *
cielab->Yg2g[i] = (float)cielab->display.d_Vrwg *
((float)pow((double)i / cielab->range, dfGamma));
}
/* Blue */
dfGamma = 1.0 / cielab->display.d_gammaB;
dfGamma = 1.0 / (double)cielab->display.d_gammaB;
cielab->bstep =
(cielab->display.d_YCR - cielab->display.d_Y0R) / cielab->range;
(cielab->display.d_YCR - cielab->display.d_Y0R) / (float)cielab->range;
for (i = 0; i <= (size_t)cielab->range; i++)
{
cielab->Yb2b[i] = cielab->display.d_Vrwb *
cielab->Yb2b[i] = (float)cielab->display.d_Vrwb *
((float)pow((double)i / cielab->range, dfGamma));
}
@@ -186,11 +186,11 @@ int TIFFCIELabToRGBInit(TIFFCIELabToRGB *cielab, const TIFFDisplay *display,
* see below for more information on how it works.
*/
#define SHIFT 16
#define FIX(x) ((int32_t)((x) * (1L << SHIFT) + 0.5))
#define FIX(x) ((int32_t)((double)(x) * (1L << SHIFT) + 0.5))
#define ONE_HALF ((int32_t)(1 << (SHIFT - 1)))
#define Code2V(c, RB, RW, CR) \
((((c) - (int32_t)(RB)) * (float)(CR)) / \
(float)(((RW) - (RB) != 0) ? ((RW) - (RB)) : 1))
(((float)((c) - (int32_t)(RB)) * (float)(CR)) / \
((!TIFF_FLOAT_EQ((RW), (RB))) ? ((RW) - (RB)) : 1.0f))
/* !((f)>=(min)) written that way to deal with NaN */
#define CLAMP(f, min, max) \
((!((f) >= (min))) ? (min) : (f) > (max) ? (max) : (f))
@@ -207,12 +207,12 @@ void TIFFYCbCrtoRGB(TIFFYCbCrToRGB *ycbcr, uint32_t Y, int32_t Cb, int32_t Cr,
Cr = CLAMP(Cr, 0, 255);
i = ycbcr->Y_tab[Y] + ycbcr->Cr_r_tab[Cr];
*r = CLAMP(i, 0, 255);
*r = (uint32_t)CLAMP(i, 0, 255);
i = ycbcr->Y_tab[Y] +
(int)((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
*g = CLAMP(i, 0, 255);
((ycbcr->Cb_g_tab[Cb] + ycbcr->Cr_g_tab[Cr]) >> SHIFT);
*g = (uint32_t)CLAMP(i, 0, 255);
i = ycbcr->Y_tab[Y] + ycbcr->Cb_b_tab[Cb];
*b = CLAMP(i, 0, 255);
*b = (uint32_t)CLAMP(i, 0, 255);
}
/* Clamp function for sanitization purposes. Normally clamping should not */
@@ -258,8 +258,7 @@ int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
#define LumaBlue luma[2]
clamptab =
(TIFFRGBValue *)((uint8_t *)ycbcr +
TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long)));
(uint8_t *)ycbcr + TIFFroundup_32(sizeof(TIFFYCbCrToRGB), sizeof(long));
_TIFFmemset(clamptab, 0, 256); /* v < 0 => 0 */
ycbcr->clamptab = (clamptab += 256);
for (i = 0; i < 256; i++)
@@ -273,13 +272,13 @@ int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
{
float f1 = 2 - 2 * LumaRed;
int32_t D1 = FIX(CLAMP(f1, 0.0F, 2.0F));
int32_t D1 = FIX(CLAMP(f1, 0.0f, 2.0f));
float f2 = LumaRed * f1 / LumaGreen;
int32_t D2 = -FIX(CLAMP(f2, 0.0F, 2.0F));
int32_t D2 = -FIX(CLAMP(f2, 0.0f, 2.0f));
float f3 = 2 - 2 * LumaBlue;
int32_t D3 = FIX(CLAMP(f3, 0.0F, 2.0F));
int32_t D3 = FIX(CLAMP(f3, 0.0f, 2.0f));
float f4 = LumaBlue * f3 / LumaGreen;
int32_t D4 = -FIX(CLAMP(f4, 0.0F, 2.0F));
int32_t D4 = -FIX(CLAMP(f4, 0.0f, 2.0f));
int x;
#undef LumaBlue
@@ -295,12 +294,12 @@ int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
*/
for (i = 0, x = -128; i < 256; i++, x++)
{
int32_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0F,
refBlackWhite[5] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0F,
refBlackWhite[3] - 128.0F, 127),
-128.0F * 32, 128.0F * 32);
int32_t Cr = (int32_t)CLAMPw(Code2V(x, refBlackWhite[4] - 128.0f,
refBlackWhite[5] - 128.0f, 127),
-128.0f * 32, 128.0f * 32);
int32_t Cb = (int32_t)CLAMPw(Code2V(x, refBlackWhite[2] - 128.0f,
refBlackWhite[3] - 128.0f, 127),
-128.0f * 32, 128.0f * 32);
ycbcr->Cr_r_tab[i] = (int32_t)((D1 * Cr + ONE_HALF) >> SHIFT);
ycbcr->Cb_b_tab[i] = (int32_t)((D3 * Cb + ONE_HALF) >> SHIFT);
@@ -308,7 +307,7 @@ int TIFFYCbCrToRGBInit(TIFFYCbCrToRGB *ycbcr, float *luma, float *refBlackWhite)
ycbcr->Cb_g_tab[i] = D4 * Cb + ONE_HALF;
ycbcr->Y_tab[i] = (int32_t)CLAMPw(
Code2V(x + 128, refBlackWhite[0], refBlackWhite[1], 255),
-128.0F * 32, 128.0F * 32);
-128.0f * 32, 128.0f * 32);
}
}

48
3rdparty/libtiff/tif_compress.c vendored
View File

@@ -139,6 +139,18 @@ static int _TIFFtrue(TIFF *tif)
}
static void _TIFFvoid(TIFF *tif) { (void)tif; }
static uint64_t _TIFFDefaultGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
return 0; /* unknown */
}
static uint64_t _TIFFGetMaxCompressionRatioOne(TIFF *tif)
{
(void)tif;
return 1; /* no compression */
}
void _TIFFSetDefaultCompressionState(TIFF *tif)
{
tif->tif_fixuptags = _TIFFNoFixupTags;
@@ -160,6 +172,7 @@ void _TIFFSetDefaultCompressionState(TIFF *tif)
tif->tif_cleanup = _TIFFvoid;
tif->tif_defstripsize = _TIFFDefaultStripSize;
tif->tif_deftilesize = _TIFFDefaultTileSize;
tif->tif_getmaxcompressionratio = _TIFFDefaultGetMaxCompressionRatio;
tif->tif_flags &= ~(TIFF_NOBITREV | TIFF_NOREADRAW);
}
@@ -168,6 +181,8 @@ int TIFFSetCompressionScheme(TIFF *tif, int scheme)
const TIFFCodec *c = TIFFFindCODEC((uint16_t)scheme);
_TIFFSetDefaultCompressionState(tif);
if (scheme == COMPRESSION_NONE)
tif->tif_getmaxcompressionratio = _TIFFGetMaxCompressionRatioOne;
/*
* Don't treat an unknown compression scheme as an error.
* This permits applications to open files with data that
@@ -177,6 +192,13 @@ int TIFFSetCompressionScheme(TIFF *tif, int scheme)
return (c ? (*c->init)(tif, scheme) : 1);
}
uint64_t TIFFGetMaxCompressionRatio(TIFF *tif)
{
if (tif->tif_getmaxcompressionratio)
return tif->tif_getmaxcompressionratio(tif);
return 0;
}
/*
* Other compression schemes may be registered. Registered
* schemes can also override the builtin versions provided
@@ -200,7 +222,7 @@ const TIFFCodec *TIFFFindCODEC(uint16_t scheme)
for (c = _TIFFBuiltinCODECS; c->name; c++)
if (c->scheme == scheme)
return (c);
return ((const TIFFCodec *)0);
return NULL;
}
TIFFCodec *TIFFRegisterCODEC(uint16_t scheme, const char *name,
@@ -212,9 +234,11 @@ TIFFCodec *TIFFRegisterCODEC(uint16_t scheme, const char *name,
if (cd != NULL)
{
char *codec_name;
cd->info = (TIFFCodec *)((uint8_t *)cd + sizeof(codec_t));
cd->info->name = (char *)((uint8_t *)cd->info + sizeof(TIFFCodec));
strcpy(cd->info->name, name);
codec_name = (char *)((uint8_t *)cd->info + sizeof(TIFFCodec));
strcpy(codec_name, name);
cd->info->name = codec_name;
cd->info->scheme = scheme;
cd->info->init = init;
cd->next = registeredCODECS;
@@ -247,7 +271,7 @@ void TIFFUnRegisterCODEC(TIFFCodec *c)
}
/************************************************************************/
/* TIFFGetConfisuredCODECs() */
/* TIFFGetConfiguredCODECs() */
/************************************************************************/
/**
@@ -258,7 +282,7 @@ void TIFFUnRegisterCODEC(TIFFCodec *c)
* or NULL if function failed.
*/
TIFFCodec *TIFFGetConfiguredCODECs()
TIFFCodec *TIFFGetConfiguredCODECs(void)
{
int i = 1;
codec_t *cd;
@@ -268,8 +292,8 @@ TIFFCodec *TIFFGetConfiguredCODECs()
for (cd = registeredCODECS; cd; cd = cd->next)
{
new_codecs =
(TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
new_codecs = (TIFFCodec *)_TIFFreallocExt(
NULL, codecs, (tmsize_t)((size_t)i * sizeof(TIFFCodec)));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
@@ -283,21 +307,21 @@ TIFFCodec *TIFFGetConfiguredCODECs()
{
if (TIFFIsCODECConfigured(c->scheme))
{
new_codecs = (TIFFCodec *)_TIFFreallocExt(NULL, codecs,
i * sizeof(TIFFCodec));
new_codecs = (TIFFCodec *)_TIFFreallocExt(
NULL, codecs, (tmsize_t)((size_t)i * sizeof(TIFFCodec)));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);
return NULL;
}
codecs = new_codecs;
_TIFFmemcpy(codecs + i - 1, (const void *)c, sizeof(TIFFCodec));
_TIFFmemcpy(codecs + i - 1, c, sizeof(TIFFCodec));
i++;
}
}
new_codecs =
(TIFFCodec *)_TIFFreallocExt(NULL, codecs, i * sizeof(TIFFCodec));
new_codecs = (TIFFCodec *)_TIFFreallocExt(
NULL, codecs, (tmsize_t)((size_t)i * sizeof(TIFFCodec)));
if (!new_codecs)
{
_TIFFfreeExt(NULL, codecs);

145
3rdparty/libtiff/tif_dir.c vendored
View File

@@ -31,6 +31,7 @@
#include "tiffiop.h"
#include <float.h> /*--: for Rational2Double */
#include <limits.h>
#include <math.h>
/*
* These are used in the backwards compatibility code...
@@ -50,7 +51,8 @@ static void setByteArray(TIFF *tif, void **vpp, const void *vp, size_t nmemb,
}
if (vp)
{
tmsize_t bytes = _TIFFMultiplySSize(NULL, nmemb, elem_size, NULL);
tmsize_t bytes = _TIFFMultiplySSize(NULL, (tmsize_t)nmemb,
(tmsize_t)elem_size, NULL);
if (bytes)
*vpp = (void *)_TIFFmallocExt(tif, bytes);
if (*vpp)
@@ -121,7 +123,8 @@ static void setDoubleArrayOneValue(TIFF *tif, double **vpp, double value,
{
if (*vpp)
_TIFFfreeExt(tif, *vpp);
*vpp = _TIFFmallocExt(tif, nmemb * sizeof(double));
*vpp = (double *)_TIFFmallocExt(tif,
(tmsize_t)nmemb * (tmsize_t)sizeof(double));
if (*vpp)
{
while (nmemb--)
@@ -294,7 +297,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
/*
* Setup new compression routine state.
*/
if ((status = TIFFSetCompressionScheme(tif, v)) != 0)
if ((status = TIFFSetCompressionScheme(tif, (int)v)) != 0)
td->td_compression = (uint16_t)v;
else
status = 0;
@@ -402,13 +405,13 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
break;
case TIFFTAG_XRESOLUTION:
dblval = va_arg(ap, double);
if (dblval != dblval || dblval < 0)
if (isnan(dblval) || dblval < 0)
goto badvaluedouble;
td->td_xresolution = _TIFFClampDoubleToFloat(dblval);
break;
case TIFFTAG_YRESOLUTION:
dblval = va_arg(ap, double);
if (dblval != dblval || dblval < 0)
if (isnan(dblval) || dblval < 0)
goto badvaluedouble;
td->td_yresolution = _TIFFClampDoubleToFloat(dblval);
break;
@@ -439,7 +442,12 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
td->td_halftonehints[1] = (uint16_t)va_arg(ap, uint16_vap);
break;
case TIFFTAG_COLORMAP:
v32 = (uint32_t)(1L << td->td_bitspersample);
if (td->td_bitspersample >= 32)
{
v = td->td_bitspersample;
goto badvalue;
}
v32 = 1U << td->td_bitspersample;
_TIFFsetShortArrayExt(tif, &td->td_colormap[0],
va_arg(ap, uint16_t *), v32);
_TIFFsetShortArrayExt(tif, &td->td_colormap[1],
@@ -557,11 +565,17 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
case TIFFTAG_TRANSFERFUNCTION:
{
uint32_t i;
uint32_t count;
if (td->td_bitspersample >= 32)
{
v = td->td_bitspersample;
goto badvalue;
}
count = 1U << td->td_bitspersample;
v = (td->td_samplesperpixel - td->td_extrasamples) > 1 ? 3 : 1;
for (i = 0; i < v; i++)
_TIFFsetShortArrayExt(tif, &td->td_transferfunction[i],
va_arg(ap, uint16_t *),
1U << td->td_bitspersample);
va_arg(ap, uint16_t *), count);
break;
}
case TIFFTAG_REFERENCEBLACKWHITE:
@@ -579,7 +593,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
if (ninksinstring > 0)
{
_TIFFsetNString(tif, &td->td_inknames, s, v);
td->td_inknameslen = v;
td->td_inknameslen = (int)v;
/* Set NumberOfInks to the value ninksinstring */
if (TIFFFieldSet(tif, FIELD_NUMBEROFINKS))
{
@@ -725,7 +739,8 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
new_customValues = (TIFFTagValue *)_TIFFreallocExt(
tif, td->td_customValues,
sizeof(TIFFTagValue) * (td->td_customValueCount + 1));
(tmsize_t)(sizeof(TIFFTagValue) *
(size_t)(td->td_customValueCount + 1)));
if (!new_customValues)
{
TIFFErrorExtR(tif, module,
@@ -754,7 +769,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
if (tv_size == 0)
{
status = 0;
TIFFErrorExtR(tif, module, "%s: Bad field type %d for \"%s\"",
TIFFErrorExtR(tif, module, "%s: Bad field type %u for \"%s\"",
tif->tif_name, fip->field_type, fip->field_name);
goto end;
}
@@ -784,7 +799,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
}
ma = (uint32_t)len;
}
tv->count = ma;
tv->count = (int)ma;
setByteArray(tif, &tv->value, mb, ma, 1);
}
else
@@ -792,9 +807,9 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
if (fip->field_passcount)
{
if (fip->field_writecount == TIFF_VARIABLE2)
tv->count = (uint32_t)va_arg(ap, uint32_t);
tv->count = (int)va_arg(ap, uint32_t);
else
tv->count = (int)va_arg(ap, int);
tv->count = va_arg(ap, int);
}
else if (fip->field_writecount == TIFF_VARIABLE ||
fip->field_writecount == TIFF_VARIABLE2)
@@ -808,7 +823,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
{
TIFFWarningExtR(tif, module,
"%s: Null count for \"%s\" (type "
"%d, writecount %d, passcount %d)",
"%u, writecount %d, passcount %d)",
tif->tif_name, fip->field_name,
fip->field_type, fip->field_writecount,
fip->field_passcount);
@@ -845,11 +860,12 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
* 4 or 8 according to fip->set_get_field_type! */
_TIFFmemcpy(tv->value, va_arg(ap, void *),
tv->count * tv_size);
/* Test here for too big values for LONG8, SLONG8 in
/* Test here for too big values for LONG8, IFD8, SLONG8 in
* ClassicTIFF and delete custom field from custom list */
if (!(tif->tif_flags & TIFF_BIGTIFF))
{
if (tv->info->field_type == TIFF_LONG8)
if (tv->info->field_type == TIFF_LONG8 ||
tv->info->field_type == TIFF_IFD8)
{
uint64_t *pui64 = (uint64_t *)tv->value;
for (int i = 0; i < tv->count; i++)
@@ -858,12 +874,15 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
{
TIFFErrorExtR(
tif, module,
"%s: Bad LONG8 value %" PRIu64
"%s: Bad %s value %" PRIu64
" at %d. array position for \"%s\" tag "
"%d in ClassicTIFF. Tag won't be "
"%u in ClassicTIFF. Tag won't be "
"written to file",
tif->tif_name, pui64[i], i,
fip->field_name, tag);
tif->tif_name,
(tv->info->field_type == TIFF_LONG8
? "LONG8"
: "IFD8"),
pui64[i], i, fip->field_name, tag);
goto badvalueifd8long8;
}
}
@@ -880,7 +899,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
tif, module,
"%s: Bad SLONG8 value %" PRIi64
" at %d. array position for \"%s\" tag "
"%d in ClassicTIFF. Tag won't be "
"%u in ClassicTIFF. Tag won't be "
"written to file",
tif->tif_name, pi64[i], i,
fip->field_name, tag);
@@ -948,7 +967,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
TIFFErrorExtR(
tif, module,
"%s: Bad LONG8 or IFD8 value %" PRIu64
" for \"%s\" tag %d in ClassicTIFF. Tag "
" for \"%s\" tag %u in ClassicTIFF. Tag "
"won't be written to file",
tif->tif_name, v2, fip->field_name, tag);
goto badvalueifd8long8;
@@ -967,7 +986,7 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
TIFFErrorExtR(
tif, module,
"%s: Bad SLONG8 value %" PRIi64
" for \"%s\" tag %d in ClassicTIFF. Tag "
" for \"%s\" tag %u in ClassicTIFF. Tag "
"won't be written to file",
tif->tif_name, v2, fip->field_name, tag);
goto badvalueifd8long8;
@@ -1018,6 +1037,8 @@ static int _TIFFVSetField(TIFF *tif, uint32_t tag, va_list ap)
_TIFFmemcpy(val, &v2, tv_size);
}
break;
case TIFF_NOTYPE:
case TIFF_ASCII:
default:
_TIFFmemset(val, 0, tv_size);
status = 0;
@@ -1345,7 +1366,7 @@ static int _TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap)
break;
case TIFFTAG_MATTEING:
*va_arg(ap, uint16_t *) =
(td->td_extrasamples == 1 &&
(td->td_extrasamples == 1 && td->td_sampleinfo &&
td->td_sampleinfo[0] == EXTRASAMPLE_ASSOCALPHA);
break;
case TIFFTAG_EXTRASAMPLES:
@@ -1376,6 +1397,8 @@ static int _TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap)
case SAMPLEFORMAT_VOID:
*va_arg(ap, uint16_t *) = DATATYPE_VOID;
break;
default:
break;
}
break;
case TIFFTAG_SAMPLEFORMAT:
@@ -1562,6 +1585,8 @@ static int _TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap)
*va_arg(ap, double *) = *(double *)val;
ret_val = 1;
break;
case TIFF_NOTYPE:
case TIFF_ASCII:
default:
ret_val = 0;
break;
@@ -1613,6 +1638,21 @@ int TIFFVGetField(TIFF *tif, uint32_t tag, va_list ap)
} \
}
/*
* Reset tif->tif_dir structure to zero and
* initialize some IFD strile counter and index parameters.
*/
void _TIFFResetTifDirAndInitStrileCounters(TIFFDirectory *td)
{
_TIFFmemset(td, 0, sizeof(*td));
td->td_curstrip = NOSTRIP; /* invalid strip = NOSTRIP */
td->td_row = (uint32_t)-1; /* read/write pre-increment */
td->td_col = (uint32_t)-1; /* read/write pre-increment */
td->td_scanlinesize = 0; /* initialize to zero */
td->td_curtile = NOTILE; /* invalid tile = NOTILE */
td->td_tilesize = (tmsize_t)-1; /* invalidate tilezize */
}
/*
* Release storage associated with a directory.
*/
@@ -1664,6 +1704,7 @@ void TIFFFreeDirectory(TIFF *tif)
tif->tif_dir.td_dirdatasize_Noffsets = 0;
}
tif->tif_dir.td_iswrittentofile = FALSE;
/* Note: tif->tif_dir structure is set to zero in TIFFDefaultDirectory() */
}
#undef CleanupField
@@ -1694,10 +1735,7 @@ int TIFFCreateDirectory(TIFF *tif)
tif->tif_diroff = 0;
tif->tif_nextdiroff = 0;
tif->tif_curoff = 0;
tif->tif_row = (uint32_t)-1;
tif->tif_curstrip = (uint32_t)-1;
tif->tif_dir.td_iswrittentofile = FALSE;
return 0;
}
@@ -1717,15 +1755,12 @@ int TIFFCreateCustomDirectory(TIFF *tif, const TIFFFieldArray *infoarray)
tif->tif_diroff = 0;
tif->tif_nextdiroff = 0;
tif->tif_curoff = 0;
tif->tif_row = (uint32_t)-1;
tif->tif_curstrip = (uint32_t)-1;
/* invalidate directory index */
tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER;
/* invalidate IFD loop lists */
_TIFFCleanupIFDOffsetAndNumberMaps(tif);
/* To be able to return from SubIFD or custom-IFD to main-IFD */
tif->tif_setdirectory_force_absolute = TRUE;
return 0;
}
@@ -1751,13 +1786,14 @@ int TIFFCreateGPSDirectory(TIFF *tif)
*/
int TIFFDefaultDirectory(TIFF *tif)
{
register TIFFDirectory *td = &tif->tif_dir;
TIFFDirectory *td = &tif->tif_dir;
const TIFFFieldArray *tiffFieldArray;
tiffFieldArray = _TIFFGetFields();
_TIFFSetupFields(tif, tiffFieldArray);
_TIFFmemset(td, 0, sizeof(*td));
/* Reset tif->tif_dir structure to zero and
* initialize some IFD strile counter and index parameters. */
_TIFFResetTifDirAndInitStrileCounters(td);
td->td_fillorder = FILLORDER_MSB2LSB;
td->td_bitspersample = 1;
td->td_threshholding = THRESHHOLD_BILEVEL;
@@ -1860,10 +1896,8 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
tmsize_t poffa, poffb, poffc, poffd;
uint16_t dircount;
uint32_t nextdir32;
poffa = (tmsize_t)poff;
poffb = poffa + sizeof(uint16_t);
if (((uint64_t)poffa != poff) || (poffb < poffa) ||
(poffb < (tmsize_t)sizeof(uint16_t)) || (poffb > tif->tif_size))
if (poff > (uint64_t)TIFF_TMSIZE_T_MAX - sizeof(uint16_t) ||
poff > (uint64_t)tif->tif_size - sizeof(uint16_t))
{
TIFFErrorExtR(tif, module,
"%s:%d: %s: Error fetching directory count",
@@ -1871,13 +1905,20 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
*nextdiroff = 0;
return (0);
}
poffa = (tmsize_t)poff;
poffb = poffa + (tmsize_t)sizeof(uint16_t);
_TIFFmemcpy(&dircount, tif->tif_base + poffa, sizeof(uint16_t));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
if (poffb >
TIFF_TMSIZE_T_MAX - dircount * 12 - (tmsize_t)sizeof(uint32_t))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
return (0);
}
poffc = poffb + dircount * 12;
poffd = poffc + sizeof(uint32_t);
if ((poffc < poffb) || (poffc < dircount * 12) || (poffd < poffc) ||
(poffd < (tmsize_t)sizeof(uint32_t)) || (poffd > tif->tif_size))
poffd = poffc + (tmsize_t)sizeof(uint32_t);
if (poffd > tif->tif_size)
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
return (0);
@@ -1893,7 +1934,6 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
{
tmsize_t poffa, poffb, poffc, poffd;
uint64_t dircount64;
uint16_t dircount16;
if (poff > (uint64_t)TIFF_TMSIZE_T_MAX - sizeof(uint64_t))
{
TIFFErrorExtR(tif, module,
@@ -1902,7 +1942,7 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
return (0);
}
poffa = (tmsize_t)poff;
poffb = poffa + sizeof(uint64_t);
poffb = poffa + (tmsize_t)sizeof(uint64_t);
if (poffb > tif->tif_size)
{
TIFFErrorExtR(tif, module,
@@ -1919,15 +1959,14 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
"Sanity check on directory count failed");
return (0);
}
dircount16 = (uint16_t)dircount64;
if (poffb > TIFF_TMSIZE_T_MAX - (tmsize_t)(dircount16 * 20) -
if (poffb > TIFF_TMSIZE_T_MAX - (tmsize_t)(dircount64 * 20) -
(tmsize_t)sizeof(uint64_t))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
return (0);
}
poffc = poffb + dircount16 * 20;
poffd = poffc + sizeof(uint64_t);
poffc = poffb + (tmsize_t)(dircount64 * 20);
poffd = poffc + (tmsize_t)sizeof(uint64_t);
if (poffd > tif->tif_size)
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
@@ -1957,9 +1996,9 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
if (off != NULL)
*off = TIFFSeekFile(tif, dircount * 12, SEEK_CUR);
*off = TIFFSeekFile(tif, dircount * 12U, SEEK_CUR);
else
(void)TIFFSeekFile(tif, dircount * 12, SEEK_CUR);
(void)TIFFSeekFile(tif, dircount * 12U, SEEK_CUR);
if (!ReadOK(tif, &nextdir32, sizeof(uint32_t)))
{
TIFFErrorExtR(tif, module, "%s: Error fetching directory link",
@@ -1973,7 +2012,6 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
else
{
uint64_t dircount64;
uint16_t dircount16;
if (!SeekOK(tif, *nextdiroff) ||
!ReadOK(tif, &dircount64, sizeof(uint64_t)))
{
@@ -1991,11 +2029,10 @@ static int TIFFAdvanceDirectory(TIFF *tif, uint64_t *nextdiroff, uint64_t *off,
__FILE__, __LINE__, tif->tif_name);
return (0);
}
dircount16 = (uint16_t)dircount64;
if (off != NULL)
*off = TIFFSeekFile(tif, dircount16 * 20, SEEK_CUR);
*off = TIFFSeekFile(tif, dircount64 * 20, SEEK_CUR);
else
(void)TIFFSeekFile(tif, dircount16 * 20, SEEK_CUR);
(void)TIFFSeekFile(tif, dircount64 * 20, SEEK_CUR);
if (!ReadOK(tif, nextdiroff, sizeof(uint64_t)))
{
TIFFErrorExtR(tif, module, "%s: Error fetching directory link",
@@ -2354,8 +2391,6 @@ int TIFFUnlinkDirectory(TIFF *tif, tdir_t dirn)
tif->tif_nextdiroff = 0; /* next write must be at end */
tif->tif_lastdiroff = 0; /* will be updated on next link */
tif->tif_curoff = 0;
tif->tif_row = (uint32_t)-1;
tif->tif_curstrip = (uint32_t)-1;
tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER;
if (tif->tif_curdircount > 0)
tif->tif_curdircount--;

16
3rdparty/libtiff/tif_dir.h vendored
View File

@@ -104,6 +104,16 @@ typedef struct
uint16_t td_halftonehints[2];
uint16_t td_extrasamples;
uint16_t *td_sampleinfo;
/* strip support */
uint32_t td_row; /* current scanline */
uint32_t td_curstrip; /* current strip for read/write */
tmsize_t td_scanlinesize; /* # of bytes in a scanline */
#define NOSTRIP ((uint32_t)(-1)) /* undefined state */
/* tiling support */
uint32_t td_col; /* current column (offset by row too) */
uint32_t td_curtile; /* current tile for read/write */
tmsize_t td_tilesize; /* # of bytes in a tile */
#define NOTILE ((uint32_t)(-1)) /* undefined state */
/* even though the name is misleading, td_stripsperimage is the number
* of striles (=strips or tiles) per plane, and td_nstrips the total
* number of striles */
@@ -164,6 +174,8 @@ typedef struct
entries. */
} TIFFDirectory;
extern void _TIFFResetTifDirAndInitStrileCounters(TIFFDirectory *td);
/*
* Field flags used to indicate fields that have been set in a directory, and
* to reference fields when manipulating a directory.
@@ -231,7 +243,7 @@ typedef struct
#define FIELD_LAST (32 * FIELDSET_ITEMS - 1)
#define BITn(n) (((uint32_t)1L) << ((n)&0x1f))
#define BITn(n) (1U << ((n) & 0x1f))
#define BITFIELDn(tif, n) ((tif)->tif_dir.td_fieldsset[(n) / 32])
#define TIFFFieldSet(tif, field) (BITFIELDn(tif, field) & BITn(field))
#define TIFFSetFieldBit(tif, field) (BITFIELDn(tif, field) |= BITn(field))
@@ -340,7 +352,7 @@ extern "C"
unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */
const char *field_name; /* ASCII name */
TIFFFieldArray *field_subfields; /* if field points to child ifds, child
ifd field definition array */
};

154
3rdparty/libtiff/tif_dirinfo.c vendored
View File

@@ -40,17 +40,47 @@
* values accordingly.
*/
/* const object should be initialized */
#ifdef _MSC_VER
/* Forward declarations - definition follows after field arrays.
* Note: In C, we can forward declare static const objects and define them
* later. In C++, we need extern for the declaration, then define without
* extern. Since these are only used within this file via pointers, we use a
* workaround that works in both C and C++: declare as extern here, define as
* static later, but actually we need a different approach for C++
* compatibility.
*
* For C/C++ compatibility, we define a simple struct that holds the pointer
* and initialize it after the arrays are defined.
*/
#ifdef __cplusplus
/* C++ doesn't allow forward declaration of const objects, so we use extern */
extern const TIFFFieldArray tiffFieldArray;
extern const TIFFFieldArray exifFieldArray;
extern const TIFFFieldArray gpsFieldArray;
#else
/* C allows forward declaration of const objects, but C++ doesn't.
* We disable the C++-compat warning for this section since these circular
* dependencies are unavoidable with static initialization. */
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++-compat"
#elif defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++-compat"
#elif defined(_MSC_VER)
#pragma warning(push)
#pragma warning(disable : 4132)
#endif
static const TIFFFieldArray tiffFieldArray;
static const TIFFFieldArray exifFieldArray;
static const TIFFFieldArray gpsFieldArray;
#ifdef _MSC_VER
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#elif defined(_MSC_VER)
#pragma warning(pop)
#endif
#endif
/*--: Rational2Double: --
* The Rational2Double upgraded libtiff functionality allows the definition and
* achievement of true double-precision accuracy for TIFF tags of RATIONAL type
@@ -152,9 +182,9 @@ static const TIFFField tiffFields[] = {
/*--: EXIFIFD and GPSIFD specified as TIFF_LONG by Aware-Systems and not TIFF_IFD8 as in original LibTiff. However, for IFD-like tags,
* libtiff uses the data type TIFF_IFD8 in tiffFields[]-tag definition combined with a special handling procedure in order to write either
* a 32-bit value and the TIFF_IFD type-id into ClassicTIFF files or a 64-bit value and the TIFF_IFD8 type-id into BigTIFF files. */
{TIFFTAG_EXIFIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, FIELD_CUSTOM, 1, 0, "EXIFIFDOffset", (TIFFFieldArray *)&exifFieldArray},
{TIFFTAG_EXIFIFD, 1, 1, TIFF_LONG8, 0, TIFF_SETGET_UINT64, FIELD_CUSTOM, 1, 0, "EXIFIFDOffset", (TIFFFieldArray *)&exifFieldArray},
{TIFFTAG_ICCPROFILE, -3, -3, TIFF_UNDEFINED, 0, TIFF_SETGET_C32_UINT8, FIELD_CUSTOM, 1, 1, "ICC Profile", NULL},
{TIFFTAG_GPSIFD, 1, 1, TIFF_IFD8, 0, TIFF_SETGET_IFD8, FIELD_CUSTOM, 1, 0, "GPSIFDOffset", (TIFFFieldArray *)&gpsFieldArray},
{TIFFTAG_GPSIFD, 1, 1, TIFF_LONG8, 0, TIFF_SETGET_UINT64, FIELD_CUSTOM, 1, 0, "GPSIFDOffset", (TIFFFieldArray *)&gpsFieldArray},
{TIFFTAG_FAXRECVPARAMS, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvParams", NULL},
{TIFFTAG_FAXSUBADDRESS, -1, -1, TIFF_ASCII, 0, TIFF_SETGET_ASCII, FIELD_CUSTOM, TRUE, FALSE, "FaxSubAddress", NULL},
{TIFFTAG_FAXRECVTIME, 1, 1, TIFF_LONG, 0, TIFF_SETGET_UINT32, FIELD_CUSTOM, TRUE, FALSE, "FaxRecvTime", NULL},
@@ -479,12 +509,36 @@ static const TIFFField gpsFields[] = {
{GPSTAG_GPSHPOSITIONINGERROR, 1, 1, TIFF_RATIONAL, 0, TIFF_SETGET_DOUBLE, FIELD_CUSTOM, 1, 0, "HorizontalPositioningError", NULL}};
/* clang-format on */ /* was off for better readability of tag comments */
#ifdef __cplusplus
/* In C++, the forward declaration used extern, so definitions must not be
* static */
const TIFFFieldArray tiffFieldArray = {
tfiatImage, 0, TIFFArrayCount(tiffFields), (TIFFField *)tiffFields};
const TIFFFieldArray exifFieldArray = {tfiatExif, 0, TIFFArrayCount(exifFields),
(TIFFField *)exifFields};
const TIFFFieldArray gpsFieldArray = {tfiatGps, 0, TIFFArrayCount(gpsFields),
(TIFFField *)gpsFields};
#else
/* Suppress C++-compat warning for the definitions as well */
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++-compat"
#elif defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wc++-compat"
#endif
static const TIFFFieldArray tiffFieldArray = {
tfiatImage, 0, TIFFArrayCount(tiffFields), (TIFFField *)tiffFields};
static const TIFFFieldArray exifFieldArray = {
tfiatExif, 0, TIFFArrayCount(exifFields), (TIFFField *)exifFields};
static const TIFFFieldArray gpsFieldArray = {
tfiatGps, 0, TIFFArrayCount(gpsFields), (TIFFField *)gpsFields};
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#elif defined(__clang__)
#pragma clang diagnostic pop
#endif
#endif
/*
* We have our own local lfind() equivalent to avoid subtle differences
@@ -523,7 +577,7 @@ void _TIFFSetupFields(TIFF *tif, const TIFFFieldArray *fieldarray)
{
if (fld->field_bit == FIELD_CUSTOM && TIFFFieldIsAnonymous(fld))
{
_TIFFfreeExt(tif, fld->field_name);
_TIFFfreeExt(tif, (void *)fld->field_name);
/* caution: tif_fields[i] must not be the beginning of a
* fields-array. Otherwise the following tags are also freed
* with the first free().
@@ -579,22 +633,26 @@ int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32_t n)
tif->tif_foundfield = NULL;
TIFFField **tif_newfields = NULL;
if (tif->tif_fields && tif->tif_nfields > 0)
{
tif->tif_fields = (TIFFField **)_TIFFCheckRealloc(
tif, tif->tif_fields, (tif->tif_nfields + n), sizeof(TIFFField *),
reason);
tif_newfields = (TIFFField **)_TIFFCheckRealloc(
tif, tif->tif_fields, (tmsize_t)tif->tif_nfields + n,
(tmsize_t)sizeof(TIFFField *), reason);
}
else
{
tif->tif_fields =
tif_newfields =
(TIFFField **)_TIFFCheckMalloc(tif, n, sizeof(TIFFField *), reason);
}
if (!tif->tif_fields)
if (!tif_newfields)
{
tif->tif_nfields = 0;
TIFFErrorExtR(tif, module, "Failed to allocate fields array");
return 0;
}
tif->tif_fields = tif_newfields;
/* tp = tif->tif_fields + tif->tif_nfields; */
for (i = 0; i < n; i++)
@@ -612,7 +670,7 @@ int _TIFFMergeFields(TIFF *tif, const TIFFField info[], uint32_t n)
/* Sort the field info by tag number */
qsort(tif->tif_fields, tif->tif_nfields, sizeof(TIFFField *), tagCompare);
return n;
return (int)n;
}
void _TIFFPrintFieldInfo(TIFF *tif, FILE *fd)
@@ -623,7 +681,7 @@ void _TIFFPrintFieldInfo(TIFF *tif, FILE *fd)
for (i = 0; i < tif->tif_nfields; i++)
{
const TIFFField *fip = tif->tif_fields[i];
fprintf(fd, "field[%2d] %5lu, %2d, %2d, %d, %2d, %5s, %5s, %s\n",
fprintf(fd, "field[%2d] %5lu, %2d, %2d, %u, %2d, %5s, %5s, %s\n",
(int)i, (unsigned long)fip->field_tag, fip->field_readcount,
fip->field_writecount, fip->field_type, fip->field_bit,
fip->field_oktochange ? "TRUE" : "FALSE",
@@ -787,6 +845,34 @@ int TIFFFieldSetGetCountSize(const TIFFField *fip)
case TIFF_SETGET_C32_DOUBLE:
case TIFF_SETGET_C32_IFD8:
return 4;
case TIFF_SETGET_UNDEFINED:
case TIFF_SETGET_ASCII:
case TIFF_SETGET_UINT8:
case TIFF_SETGET_SINT8:
case TIFF_SETGET_UINT16:
case TIFF_SETGET_SINT16:
case TIFF_SETGET_UINT32:
case TIFF_SETGET_SINT32:
case TIFF_SETGET_UINT64:
case TIFF_SETGET_SINT64:
case TIFF_SETGET_FLOAT:
case TIFF_SETGET_DOUBLE:
case TIFF_SETGET_IFD8:
case TIFF_SETGET_INT:
case TIFF_SETGET_UINT16_PAIR:
case TIFF_SETGET_C0_ASCII:
case TIFF_SETGET_C0_UINT8:
case TIFF_SETGET_C0_SINT8:
case TIFF_SETGET_C0_UINT16:
case TIFF_SETGET_C0_SINT16:
case TIFF_SETGET_C0_UINT32:
case TIFF_SETGET_C0_SINT32:
case TIFF_SETGET_C0_UINT64:
case TIFF_SETGET_C0_SINT64:
case TIFF_SETGET_C0_FLOAT:
case TIFF_SETGET_C0_DOUBLE:
case TIFF_SETGET_C0_IFD8:
case TIFF_SETGET_OTHER:
default:
return 0;
}
@@ -794,7 +880,8 @@ int TIFFFieldSetGetCountSize(const TIFFField *fip)
const TIFFField *TIFFFindField(TIFF *tif, uint32_t tag, TIFFDataType dt)
{
TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, NULL, NULL};
TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, TIFF_SETGET_UNDEFINED,
0, 0, 0, NULL, NULL};
TIFFField *pkey = &key;
const TIFFField **ret;
if (tif->tif_foundfield && tif->tif_foundfield->field_tag == tag &&
@@ -818,7 +905,8 @@ const TIFFField *TIFFFindField(TIFF *tif, uint32_t tag, TIFFDataType dt)
static const TIFFField *_TIFFFindFieldByName(TIFF *tif, const char *field_name,
TIFFDataType dt)
{
TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, 0, 0, 0, 0, NULL, NULL};
TIFFField key = {0, 0, 0, TIFF_NOTYPE, 0, TIFF_SETGET_UNDEFINED,
0, 0, 0, NULL, NULL};
TIFFField *pkey = &key;
const TIFFField **ret;
if (tif->tif_foundfield &&
@@ -876,7 +964,10 @@ int TIFFFieldReadCount(const TIFFField *fip) { return fip->field_readcount; }
int TIFFFieldWriteCount(const TIFFField *fip) { return fip->field_writecount; }
int TIFFFieldIsAnonymous(const TIFFField *fip) { return fip->field_anonymous; }
int TIFFFieldIsAnonymous(const TIFFField *fip)
{
return (int)fip->field_anonymous;
}
const TIFFField *_TIFFFindOrRegisterField(TIFF *tif, uint32_t tag,
TIFFDataType dt)
@@ -954,6 +1045,7 @@ TIFFField *_TIFFCreateAnonField(TIFF *tif, uint32_t tag,
case TIFF_SLONG8:
fld->set_get_field_type = TIFF_SETGET_C32_SINT64;
break;
case TIFF_NOTYPE:
default:
fld->set_get_field_type = TIFF_SETGET_UNDEFINED;
break;
@@ -961,8 +1053,8 @@ TIFFField *_TIFFCreateAnonField(TIFF *tif, uint32_t tag,
fld->field_bit = FIELD_CUSTOM;
fld->field_oktochange = TRUE;
fld->field_passcount = TRUE;
fld->field_name = (char *)_TIFFmallocExt(tif, 32);
if (fld->field_name == NULL)
char *field_name_buf = (char *)_TIFFmallocExt(tif, 32);
if (field_name_buf == NULL)
{
_TIFFfreeExt(tif, fld);
return NULL;
@@ -975,7 +1067,8 @@ TIFFField *_TIFFCreateAnonField(TIFF *tif, uint32_t tag,
* Update:
* This special sign is replaced by fld->field_anonymous flag.
*/
(void)snprintf(fld->field_name, 32, "Tag %d", (int)tag);
(void)snprintf(field_name_buf, 32, "Tag %d", (int)tag);
fld->field_name = field_name_buf;
return fld;
}
@@ -1025,6 +1118,7 @@ static TIFFSetGetFieldType _TIFFSetGetType(TIFFDataType type, short count,
return TIFF_SETGET_UINT64;
case TIFF_SLONG8:
return TIFF_SETGET_SINT64;
case TIFF_NOTYPE:
default:
return TIFF_SETGET_UNDEFINED;
}
@@ -1062,6 +1156,7 @@ static TIFFSetGetFieldType _TIFFSetGetType(TIFFDataType type, short count,
return TIFF_SETGET_C0_UINT64;
case TIFF_SLONG8:
return TIFF_SETGET_C0_SINT64;
case TIFF_NOTYPE:
default:
return TIFF_SETGET_UNDEFINED;
}
@@ -1099,6 +1194,7 @@ static TIFFSetGetFieldType _TIFFSetGetType(TIFFDataType type, short count,
return TIFF_SETGET_C16_UINT64;
case TIFF_SLONG8:
return TIFF_SETGET_C16_SINT64;
case TIFF_NOTYPE:
default:
return TIFF_SETGET_UNDEFINED;
}
@@ -1136,6 +1232,7 @@ static TIFFSetGetFieldType _TIFFSetGetType(TIFFDataType type, short count,
return TIFF_SETGET_C32_UINT64;
case TIFF_SLONG8:
return TIFF_SETGET_C32_SINT64;
case TIFF_NOTYPE:
default:
return TIFF_SETGET_UNDEFINED;
}
@@ -1152,22 +1249,25 @@ int TIFFMergeFieldInfo(TIFF *tif, const TIFFFieldInfo info[], uint32_t n)
size_t nfields;
uint32_t i;
TIFFFieldArray *tif_newfieldscompat = NULL;
if (tif->tif_nfieldscompat > 0)
{
tif->tif_fieldscompat = (TIFFFieldArray *)_TIFFCheckRealloc(
tif, tif->tif_fieldscompat, tif->tif_nfieldscompat + 1,
sizeof(TIFFFieldArray), reason);
tif_newfieldscompat = (TIFFFieldArray *)_TIFFCheckRealloc(
tif, tif->tif_fieldscompat, (tmsize_t)tif->tif_nfieldscompat + 1,
(tmsize_t)sizeof(TIFFFieldArray), reason);
}
else
{
tif->tif_fieldscompat = (TIFFFieldArray *)_TIFFCheckMalloc(
tif_newfieldscompat = (TIFFFieldArray *)_TIFFCheckMalloc(
tif, 1, sizeof(TIFFFieldArray), reason);
}
if (!tif->tif_fieldscompat)
if (!tif_newfieldscompat)
{
TIFFErrorExtR(tif, module, "Failed to allocate fields array");
return -1;
}
tif->tif_fieldscompat = tif_newfieldscompat;
nfields = tif->tif_nfieldscompat++;
tif->tif_fieldscompat[nfields].type = tfiatOther;
@@ -1309,6 +1409,8 @@ int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
case TIFFTAG_JPEGPROC:
case TIFFTAG_JPEGRESTARTINTERVAL:
return 1;
default:
break;
}
break;
case COMPRESSION_CCITTRLE:
@@ -1329,6 +1431,8 @@ int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
if (tif->tif_dir.td_compression == COMPRESSION_CCITTFAX4)
return 1;
break;
default:
break;
}
break;
case COMPRESSION_JBIG:
@@ -1359,6 +1463,8 @@ int _TIFFCheckFieldIsValidForCodec(TIFF *tif, ttag_t tag)
if (tag == TIFFTAG_LERC_PARAMETERS)
return 1;
break;
default:
break;
}
return 0;
}

323
3rdparty/libtiff/tif_dirread.c vendored
View File

@@ -597,7 +597,7 @@ TIFFReadDirEntrySshort(TIFF *tif, TIFFDirEntry *direntry, int16_t *value)
err = TIFFReadDirEntryCheckRangeSshortShort(m);
if (err != TIFFReadDirEntryErrOk)
return (err);
*value = (uint16_t)m;
*value = (int16_t)m;
return (TIFFReadDirEntryErrOk);
}
case TIFF_SSHORT:
@@ -695,6 +695,7 @@ TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
return (TIFFReadDirEntryErrOk);
}
case TIFF_LONG:
case TIFF_IFD:
TIFFReadDirEntryCheckedLong(tif, direntry, value);
return (TIFFReadDirEntryErrOk);
case TIFF_SLONG:
@@ -708,6 +709,7 @@ TIFFReadDirEntryLong(TIFF *tif, TIFFDirEntry *direntry, uint32_t *value)
return (TIFFReadDirEntryErrOk);
}
case TIFF_LONG8:
case TIFF_IFD8:
{
uint64_t m;
err = TIFFReadDirEntryCheckedLong8(tif, direntry, &m);
@@ -857,6 +859,7 @@ TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
return (TIFFReadDirEntryErrOk);
}
case TIFF_LONG:
case TIFF_IFD:
{
uint32_t m;
TIFFReadDirEntryCheckedLong(tif, direntry, &m);
@@ -874,6 +877,7 @@ TIFFReadDirEntryLong8(TIFF *tif, TIFFDirEntry *direntry, uint64_t *value)
return (TIFFReadDirEntryErrOk);
}
case TIFF_LONG8:
case TIFF_IFD8:
err = TIFFReadDirEntryCheckedLong8(tif, direntry, value);
return (err);
case TIFF_SLONG8:
@@ -1058,7 +1062,7 @@ TIFFReadDirEntryFloat(TIFF *tif, TIFFDirEntry *direntry, float *value)
err = TIFFReadDirEntryCheckedDouble(tif, direntry, &m);
if (err != TIFFReadDirEntryErrOk)
return (err);
if ((m > FLT_MAX) || (m < -FLT_MAX))
if ((m > (double)FLT_MAX) || (m < -(double)FLT_MAX))
return (TIFFReadDirEntryErrRange);
*value = (float)m;
return (TIFFReadDirEntryErrOk);
@@ -1237,6 +1241,8 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryDataAndRealloc(TIFF *tif,
*pdest = new_dest;
bytes_read = TIFFReadFile(tif, (char *)*pdest + already_read, to_read);
if (bytes_read < 0)
return TIFFReadDirEntryErrIo;
already_read += bytes_read;
if (bytes_read != to_read)
{
@@ -1260,7 +1266,7 @@ TIFFReadDirEntryArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
void *data;
uint64_t target_count64;
int original_datasize_clamped;
typesize = TIFFDataWidth(direntry->tdir_type);
typesize = TIFFDataWidth((TIFFDataType)direntry->tdir_type);
target_count64 =
(direntry->tdir_count > maxcount) ? maxcount : direntry->tdir_count;
@@ -1284,13 +1290,13 @@ TIFFReadDirEntryArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
* in either the current data type or the dest data type. This also
* avoids problems with overflow of tmsize_t on 32bit systems.
*/
if ((uint64_t)(MAX_SIZE_TAG_DATA / typesize) < target_count64)
if ((uint64_t)(MAX_SIZE_TAG_DATA / (unsigned int)typesize) < target_count64)
return (TIFFReadDirEntryErrSizesan);
if ((uint64_t)(MAX_SIZE_TAG_DATA / desttypesize) < target_count64)
return (TIFFReadDirEntryErrSizesan);
*count = (uint32_t)target_count64;
datasize = (*count) * typesize;
datasize = (uint32_t)(*count) * (unsigned int)typesize;
assert((tmsize_t)datasize > 0);
if (datasize > 100 * 1024 * 1024)
@@ -1440,6 +1446,8 @@ TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8_t **value)
*value = (uint8_t *)origdata;
return (TIFFReadDirEntryErrOk);
}
default:
break;
}
data = (uint8_t *)_TIFFmallocExt(tif, count);
if (data == 0)
@@ -1557,6 +1565,8 @@ TIFFReadDirEntryByteArray(TIFF *tif, TIFFDirEntry *direntry, uint8_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -1620,6 +1630,8 @@ TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8_t **value)
case TIFF_SBYTE:
*value = (int8_t *)origdata;
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (int8_t *)_TIFFmallocExt(tif, count);
if (data == 0)
@@ -1737,6 +1749,8 @@ TIFFReadDirEntrySbyteArray(TIFF *tif, TIFFDirEntry *direntry, int8_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -1802,6 +1816,8 @@ TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value)
*value = (uint16_t *)origdata;
return (TIFFReadDirEntryErrOk);
}
default:
break;
}
data = (uint16_t *)_TIFFmallocExt(tif, count * 2);
if (data == 0)
@@ -1910,6 +1926,8 @@ TIFFReadDirEntryShortArray(TIFF *tif, TIFFDirEntry *direntry, uint16_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -1975,6 +1993,8 @@ TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16_t **value)
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfShort((uint16_t *)(*value), count);
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (int16_t *)_TIFFmallocExt(tif, count * 2);
if (data == 0)
@@ -2078,6 +2098,8 @@ TIFFReadDirEntrySshortArray(TIFF *tif, TIFFDirEntry *direntry, int16_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -2106,6 +2128,8 @@ TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
case TIFF_SLONG:
case TIFF_LONG8:
case TIFF_SLONG8:
case TIFF_IFD:
case TIFF_IFD8:
break;
default:
return (TIFFReadDirEntryErrType);
@@ -2119,6 +2143,7 @@ TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
switch (direntry->tdir_type)
{
case TIFF_LONG:
case TIFF_IFD:
*value = (uint32_t *)origdata;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong(*value, count);
@@ -2143,6 +2168,8 @@ TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
*value = (uint32_t *)origdata;
return (TIFFReadDirEntryErrOk);
}
default:
break;
}
data = (uint32_t *)_TIFFmallocExt(tif, count * 4);
if (data == 0)
@@ -2213,6 +2240,7 @@ TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
}
break;
case TIFF_LONG8:
case TIFF_IFD8:
{
uint64_t *ma;
uint32_t *mb;
@@ -2248,6 +2276,8 @@ TIFFReadDirEntryLongArray(TIFF *tif, TIFFDirEntry *direntry, uint32_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -2313,6 +2343,8 @@ TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32_t **value)
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong((uint32_t *)(*value), count);
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (int32_t *)_TIFFmallocExt(tif, count * 4);
if (data == 0)
@@ -2410,6 +2442,8 @@ TIFFReadDirEntrySlongArray(TIFF *tif, TIFFDirEntry *direntry, int32_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -2439,6 +2473,8 @@ TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
case TIFF_SLONG:
case TIFF_LONG8:
case TIFF_SLONG8:
case TIFF_IFD:
case TIFF_IFD8:
break;
default:
return (TIFFReadDirEntryErrType);
@@ -2453,6 +2489,7 @@ TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
switch (direntry->tdir_type)
{
case TIFF_LONG8:
case TIFF_IFD8:
*value = (uint64_t *)origdata;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong8(*value, count);
@@ -2477,6 +2514,8 @@ TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
*value = (uint64_t *)origdata;
return (TIFFReadDirEntryErrOk);
}
default:
break;
}
data = (uint64_t *)_TIFFmallocExt(tif, count * 8);
if (data == 0)
@@ -2547,6 +2586,7 @@ TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
}
break;
case TIFF_LONG:
case TIFF_IFD:
{
uint32_t *ma;
uint64_t *mb;
@@ -2579,6 +2619,8 @@ TIFFReadDirEntryLong8ArrayWithLimit(TIFF *tif, TIFFDirEntry *direntry,
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
if (err != TIFFReadDirEntryErrOk)
@@ -2651,6 +2693,8 @@ TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64_t **value)
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong8((uint64_t *)(*value), count);
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (int64_t *)_TIFFmallocExt(tif, count * 8);
if (data == 0)
@@ -2742,6 +2786,8 @@ TIFFReadDirEntrySlong8Array(TIFF *tif, TIFFDirEntry *direntry, int64_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
*value = data;
@@ -2787,8 +2833,11 @@ TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value)
TIFFCvtIEEEFloatToNative(tif, count, (float *)origdata);
*value = (float *)origdata;
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (float *)_TIFFmallocExt(tif, count * sizeof(float));
data =
(float *)_TIFFmallocExt(tif, (tmsize_t)((size_t)count * sizeof(float)));
if (data == 0)
{
_TIFFfreeExt(tif, origdata);
@@ -2970,14 +3019,16 @@ TIFFReadDirEntryFloatArray(TIFF *tif, TIFFDirEntry *direntry, float **value)
for (n = 0; n < count; n++)
{
double val = *ma++;
if (val > FLT_MAX)
val = FLT_MAX;
else if (val < -FLT_MAX)
val = -FLT_MAX;
if (val > (double)FLT_MAX)
val = (double)FLT_MAX;
else if (val < -(double)FLT_MAX)
val = -(double)FLT_MAX;
*mb++ = (float)val;
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
*value = data;
@@ -3023,8 +3074,11 @@ TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
TIFFCvtIEEEDoubleToNative(tif, count, (double *)origdata);
*value = (double *)origdata;
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (double *)_TIFFmallocExt(tif, count * sizeof(double));
data = (double *)_TIFFmallocExt(tif,
(tmsize_t)((size_t)count * sizeof(double)));
if (data == 0)
{
_TIFFfreeExt(tif, origdata);
@@ -3207,6 +3261,8 @@ TIFFReadDirEntryDoubleArray(TIFF *tif, TIFFDirEntry *direntry, double **value)
*mb++ = (double)(*ma++);
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
*value = data;
@@ -3244,6 +3300,8 @@ TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong8(*value, count);
return (TIFFReadDirEntryErrOk);
default:
break;
}
data = (uint64_t *)_TIFFmallocExt(tif, count * 8);
if (data == 0)
@@ -3269,6 +3327,8 @@ TIFFReadDirEntryIfd8Array(TIFF *tif, TIFFDirEntry *direntry, uint64_t **value)
}
}
break;
default:
break;
}
_TIFFfreeExt(tif, origdata);
*value = data;
@@ -3283,13 +3343,42 @@ TIFFReadDirEntryPersampleShort(TIFF *tif, TIFFDirEntry *direntry,
uint16_t *m;
uint16_t *na;
uint16_t nb;
if (direntry->tdir_count < (uint64_t)tif->tif_dir.td_samplesperpixel)
return (TIFFReadDirEntryErrCount);
if (direntry->tdir_count != (uint64_t)tif->tif_dir.td_samplesperpixel)
{
const TIFFField *fip = TIFFFieldWithTag(tif, direntry->tdir_tag);
if (direntry->tdir_count == 0)
{
return TIFFReadDirEntryErrCount;
}
else if (direntry->tdir_count <
(uint64_t)tif->tif_dir.td_samplesperpixel)
{
TIFFWarningExtR(
tif, "TIFFReadDirEntryPersampleShort",
"Tag %s entry count is %" PRIu64
" , whereas it should be SamplesPerPixel=%d. Assuming that "
"missing entries are all at the value of the first one",
fip ? fip->field_name : "unknown tagname", direntry->tdir_count,
tif->tif_dir.td_samplesperpixel);
}
else
{
TIFFWarningExtR(tif, "TIFFReadDirEntryPersampleShort",
"Tag %s entry count is %" PRIu64
" , whereas it should be SamplesPerPixel=%d. "
"Ignoring extra entries",
fip ? fip->field_name : "unknown tagname",
direntry->tdir_count,
tif->tif_dir.td_samplesperpixel);
}
}
err = TIFFReadDirEntryShortArray(tif, direntry, &m);
if (err != TIFFReadDirEntryErrOk || m == NULL)
return (err);
na = m;
nb = tif->tif_dir.td_samplesperpixel;
if (direntry->tdir_count < nb)
nb = (uint16_t)direntry->tdir_count;
*value = *na++;
nb--;
while (nb > 0)
@@ -3908,7 +3997,7 @@ static enum TIFFReadDirEntryErr TIFFReadDirEntryData(TIFF *tif, uint64_t offset,
{
return TIFFReadDirEntryErrIo;
}
mb = ma + size;
mb = (uint64_t)ma + (uint64_t)size;
if (mb > (uint64_t)tif->tif_size)
return (TIFFReadDirEntryErrIo);
_TIFFmemcpy(dest, tif->tif_base + ma, size);
@@ -3955,6 +4044,7 @@ static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err,
TIFFErrorExtR(tif, module, "Out of memory reading of \"%s\"",
tagname);
break;
case TIFFReadDirEntryErrOk:
default:
assert(0); /* we should never get here */
break;
@@ -4001,6 +4091,7 @@ static void TIFFReadDirEntryOutputErr(TIFF *tif, enum TIFFReadDirEntryErr err,
"Out of memory reading of \"%s\"; tag ignored",
tagname);
break;
case TIFFReadDirEntryErrOk:
default:
assert(0); /* we should never get here */
break;
@@ -4086,7 +4177,8 @@ static int ByteCountLooksBad(TIFF *tif)
*/
static bool EvaluateIFDdatasizeReading(TIFF *tif, TIFFDirEntry *dp)
{
const uint64_t data_width = TIFFDataWidth(dp->tdir_type);
const uint64_t data_width =
(uint64_t)TIFFDataWidth((TIFFDataType)dp->tdir_type);
if (data_width != 0 && dp->tdir_count > UINT64_MAX / data_width)
{
TIFFErrorExtR(tif, "EvaluateIFDdatasizeReading",
@@ -4173,9 +4265,9 @@ static void CalcFinalIFDdatasizeReading(TIFF *tif, uint16_t dircount)
/* Get offset of end of IFD entry space. */
uint64_t IFDendoffset;
if (!(tif->tif_flags & TIFF_BIGTIFF))
IFDendoffset = tif->tif_diroff + 2 + dircount * 12 + 4;
IFDendoffset = tif->tif_diroff + 2 + (uint64_t)dircount * 12 + 4;
else
IFDendoffset = tif->tif_diroff + 8 + dircount * 20 + 8;
IFDendoffset = tif->tif_diroff + 8 + (uint64_t)dircount * 20 + 8;
/* Check which offsets are right behind IFD entries. However, LibTIFF
* increments the writing address for every external data to an even offset.
@@ -4224,9 +4316,9 @@ static void CalcFinalIFDdatasizeReading(TIFF *tif, uint16_t dircount)
/* Finally, add the size of the IFD tag entries themselves. */
if (!(tif->tif_flags & TIFF_BIGTIFF))
tif->tif_dir.td_dirdatasize_read = 2 + dircount * 12 + 4 + size;
tif->tif_dir.td_dirdatasize_read = 2U + dircount * 12U + 4U + size;
else
tif->tif_dir.td_dirdatasize_read = 8 + dircount * 20 + 8 + size;
tif->tif_dir.td_dirdatasize_read = 8U + dircount * 20U + 8U + size;
} /*-- CalcFinalIFDdatasizeReading() --*/
/*
@@ -4298,7 +4390,8 @@ int TIFFReadDirectory(TIFF *tif)
{
TIFFDirEntry *na;
uint16_t nb;
for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
for (na = ma + 1, nb = (uint16_t)(mb + 1); nb < dircount;
na++, nb++)
{
if (ma->tdir_tag == na->tdir_tag)
{
@@ -4312,7 +4405,15 @@ int TIFFReadDirectory(TIFF *tif)
tif->tif_flags &= ~TIFF_BUF4WRITE; /* reset before new dir */
tif->tif_flags &= ~TIFF_CHOPPEDUPARRAYS;
/* free any old stuff and reinit */
/* When changing directory, in deferred strile loading mode, we must also
* unset the TIFF_LAZYSTRILELOAD_DONE bit if it was initially set,
* to make sure the strile offset/bytecount are read again (when they fit
* in the tag data area).
*/
tif->tif_flags &= ~TIFF_LAZYSTRILELOAD_DONE;
/* Free any old stuff and reinit i/o and other parameters within
* TIFFDefaultDirectory() since we are starting on a new directory. */
TIFFFreeDirectory(tif);
TIFFDefaultDirectory(tif);
@@ -4325,7 +4426,8 @@ int TIFFReadDirectory(TIFF *tif)
* checking. Note: Counter are reset within TIFFFreeDirectory(). */
tif->tif_dir.td_dirdatasize_offsets =
(TIFFEntryOffsetAndLength *)_TIFFmallocExt(
tif, dircount * sizeof(TIFFEntryOffsetAndLength));
tif,
(tmsize_t)((size_t)dircount * sizeof(TIFFEntryOffsetAndLength)));
if (tif->tif_dir.td_dirdatasize_offsets == NULL)
{
TIFFErrorExtR(
@@ -4788,8 +4890,8 @@ int TIFFReadDirectory(TIFF *tif)
(void)TIFFFetchNormalTag(tif, dp, TRUE);
break;
} /* -- switch (dp->tdir_tag) -- */
} /* -- if (!dp->tdir_ignore) */
} /* -- for-loop -- */
} /* -- if (!dp->tdir_ignore) */
} /* -- for-loop -- */
/* Evaluate final IFD data size. */
CalcFinalIFDdatasizeReading(tif, dircount);
@@ -5098,7 +5200,7 @@ int TIFFReadDirectory(TIFF *tif)
tif->tif_dir.td_maxsamplevalue = 0xFFFF;
else
tif->tif_dir.td_maxsamplevalue =
(uint16_t)((1L << tif->tif_dir.td_bitspersample) - 1);
(uint16_t)((1 << tif->tif_dir.td_bitspersample) - 1);
}
#ifdef STRIPBYTECOUNTSORTED_UNUSED
@@ -5164,16 +5266,10 @@ int TIFFReadDirectory(TIFF *tif)
tif->tif_flags &= ~TIFF_DIRTYSTRIP;
/*
* Reinitialize i/o since we are starting on a new directory.
* Reinitialize some further i/o since we are starting on a new directory.
*/
tif->tif_row = (uint32_t)-1;
tif->tif_curstrip = (uint32_t)-1;
tif->tif_col = (uint32_t)-1;
tif->tif_curtile = (uint32_t)-1;
tif->tif_tilesize = (tmsize_t)-1;
tif->tif_scanlinesize = TIFFScanlineSize(tif);
if (!tif->tif_scanlinesize)
tif->tif_dir.td_scanlinesize = TIFFScanlineSize(tif);
if (!tif->tif_dir.td_scanlinesize)
{
TIFFErrorExtR(tif, module, "Cannot handle zero scanline size");
return (0);
@@ -5181,8 +5277,8 @@ int TIFFReadDirectory(TIFF *tif)
if (isTiled(tif))
{
tif->tif_tilesize = TIFFTileSize(tif);
if (!tif->tif_tilesize)
tif->tif_dir.td_tilesize = TIFFTileSize(tif);
if (!tif->tif_dir.td_tilesize)
{
TIFFErrorExtR(tif, module, "Cannot handle zero tile size");
return (0);
@@ -5220,7 +5316,7 @@ static void TIFFReadDirectoryCheckOrder(TIFF *tif, TIFFDirEntry *dir,
"ascending order");
break;
}
m = o->tdir_tag + 1;
m = o->tdir_tag + 1U;
}
}
@@ -5268,7 +5364,7 @@ static void TIFFReadDirectoryFindFieldInfo(TIFF *tif, uint16_t tagid,
break;
mb--;
}
*fii = mb;
*fii = (uint32_t)mb;
}
/*
@@ -5308,7 +5404,8 @@ int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
{
TIFFDirEntry *na;
uint16_t nb;
for (na = ma + 1, nb = mb + 1; nb < dircount; na++, nb++)
for (na = ma + 1, nb = (uint16_t)(mb + 1); nb < dircount;
na++, nb++)
{
if (ma->tdir_tag == na->tdir_tag)
{
@@ -5333,7 +5430,8 @@ int TIFFReadCustomDirectory(TIFF *tif, toff_t diroff,
* checking. Note: Counter are reset within TIFFFreeDirectory(). */
tif->tif_dir.td_dirdatasize_offsets =
(TIFFEntryOffsetAndLength *)_TIFFmallocExt(
tif, dircount * sizeof(TIFFEntryOffsetAndLength));
tif,
(tmsize_t)((size_t)dircount * sizeof(TIFFEntryOffsetAndLength)));
if (tif->tif_dir.td_dirdatasize_offsets == NULL)
{
TIFFErrorExtR(
@@ -5515,15 +5613,17 @@ static int EstimateStripByteCounts(TIFF *tif, TIFFDirEntry *dir,
uint64_t space;
uint16_t n;
if (!(tif->tif_flags & TIFF_BIGTIFF))
space = sizeof(TIFFHeaderClassic) + 2 + dircount * 12 + 4;
space = sizeof(TIFFHeaderClassic) + 2 +
(unsigned long)dircount * 12 + 4;
else
space = sizeof(TIFFHeaderBig) + 8 + dircount * 20 + 8;
space =
sizeof(TIFFHeaderBig) + 8 + (unsigned long)dircount * 20 + 8;
/* calculate amount of space used by indirect values */
for (dp = dir, n = dircount; n > 0; n--, dp++)
{
uint32_t typewidth;
uint64_t datasize;
typewidth = TIFFDataWidth((TIFFDataType)dp->tdir_type);
typewidth = (uint32_t)TIFFDataWidth((TIFFDataType)dp->tdir_type);
if (typewidth == 0)
{
TIFFErrorExtR(
@@ -5786,7 +5886,7 @@ int _TIFFCheckDirNumberAndOffset(TIFF *tif, tdir_t dirn, uint64_t diroff)
{
TIFFErrorExtR(tif, "_TIFFCheckDirNumberAndOffset",
"Cannot handle more than %u TIFF directories",
TIFF_MAX_DIR_COUNT);
(unsigned)TIFF_MAX_DIR_COUNT);
return 0;
}
@@ -6048,7 +6148,7 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
"to read TIFF directory");
if (origdir == NULL)
return 0;
if (!ReadOK(tif, origdir, (tmsize_t)(dircount16 * dirsize)))
if (!ReadOK(tif, origdir, (tmsize_t)dircount16 * dirsize))
{
TIFFErrorExtR(tif, module, "%.100s: Can not read TIFF directory",
tif->tif_name);
@@ -6101,9 +6201,9 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
*/
if (!(tif->tif_flags & TIFF_BIGTIFF))
{
m = off + sizeof(uint16_t);
if ((m < off) || (m < (tmsize_t)sizeof(uint16_t)) ||
(m > tif->tif_size))
m = (tmsize_t)((uint64_t)off + sizeof(uint16_t));
if ((m < off) || ((uint64_t)m < sizeof(uint16_t)) ||
((uint64_t)m > (uint64_t)tif->tif_size))
{
TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
return 0;
@@ -6112,7 +6212,7 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
{
_TIFFmemcpy(&dircount16, tif->tif_base + off, sizeof(uint16_t));
}
off += sizeof(uint16_t);
off = (tmsize_t)((uint64_t)off + sizeof(uint16_t));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount16);
if (dircount16 > 4096)
@@ -6127,9 +6227,9 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
else
{
uint64_t dircount64;
m = off + sizeof(uint64_t);
if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
(m > tif->tif_size))
m = (tmsize_t)((uint64_t)off + sizeof(uint64_t));
if ((m < off) || ((uint64_t)m < sizeof(uint64_t)) ||
((uint64_t)m > (uint64_t)tif->tif_size))
{
TIFFErrorExtR(tif, module, "Can not read TIFF directory count");
return 0;
@@ -6138,7 +6238,7 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
{
_TIFFmemcpy(&dircount64, tif->tif_base + off, sizeof(uint64_t));
}
off += sizeof(uint64_t);
off = (tmsize_t)((uint64_t)off + sizeof(uint64_t));
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong8(&dircount64);
if (dircount64 > 4096)
@@ -6177,7 +6277,7 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
if (origdir == NULL)
return 0;
m = off + dircount16 * dirsize;
if ((m < off) || (m < (tmsize_t)(dircount16 * dirsize)) ||
if ((m < off) || (m < (tmsize_t)dircount16 * (tmsize_t)dirsize) ||
(m > tif->tif_size))
{
TIFFErrorExtR(tif, module, "Can not read TIFF directory");
@@ -6186,7 +6286,8 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
}
else
{
_TIFFmemcpy(origdir, tif->tif_base + off, dircount16 * dirsize);
_TIFFmemcpy(origdir, tif->tif_base + off,
(tmsize_t)dircount16 * dirsize);
}
if (nextdiroff)
{
@@ -6194,9 +6295,9 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
if (!(tif->tif_flags & TIFF_BIGTIFF))
{
uint32_t nextdiroff32;
m = off + sizeof(uint32_t);
if ((m < off) || (m < (tmsize_t)sizeof(uint32_t)) ||
(m > tif->tif_size))
m = (tmsize_t)((uint64_t)off + sizeof(uint32_t));
if ((m < off) || ((uint64_t)m < sizeof(uint32_t)) ||
((uint64_t)m > (uint64_t)tif->tif_size))
nextdiroff32 = 0;
else
_TIFFmemcpy(&nextdiroff32, tif->tif_base + off,
@@ -6207,9 +6308,9 @@ static uint16_t TIFFFetchDirectory(TIFF *tif, uint64_t diroff,
}
else
{
m = off + sizeof(uint64_t);
if ((m < off) || (m < (tmsize_t)sizeof(uint64_t)) ||
(m > tif->tif_size))
m = (tmsize_t)((uint64_t)off + sizeof(uint64_t));
if ((m < off) || ((uint64_t)m < sizeof(uint64_t)) ||
((uint64_t)m > (uint64_t)tif->tif_size))
*nextdiroff = 0;
else
_TIFFmemcpy(nextdiroff, tif->tif_base + off,
@@ -6355,8 +6456,8 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
/* TIFFReadDirEntryArrayWithLimit() ensures this can't be
* larger than MAX_SIZE_TAG_DATA */
assert((uint32_t)dp->tdir_count + 1 == dp->tdir_count + 1);
uint8_t *o =
_TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
uint8_t *o = (uint8_t *)_TIFFmallocExt(
tif, (uint32_t)dp->tdir_count + 1);
if (o == NULL)
{
if (data != NULL)
@@ -6498,7 +6599,7 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
{
if (!EvaluateIFDdatasizeReading(tif, dp))
return 0;
if (!TIFFSetField(tif, dp->tdir_tag, data))
if (!TIFFSetField(tif, dp->tdir_tag, (double)data))
return (0);
}
}
@@ -6910,6 +7011,41 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
}
}
break;
case TIFF_SETGET_C0_IFD8:
{
uint64_t *data;
assert(fip->field_readcount >= 1);
assert(fip->field_passcount == 0);
if (dp->tdir_count != (uint64_t)fip->field_readcount)
{
TIFFWarningExtR(tif, module,
"incorrect count for field \"%s\", expected "
"%d, got %" PRIu64,
fip->field_name, (int)fip->field_readcount,
dp->tdir_count);
return (0);
}
else
{
err = TIFFReadDirEntryIfd8Array(tif, dp, &data);
if (err == TIFFReadDirEntryErrOk)
{
if (!EvaluateIFDdatasizeReading(tif, dp))
{
if (data != 0)
_TIFFfreeExt(tif, data);
return 0;
}
int m;
m = TIFFSetField(tif, dp->tdir_tag, data);
if (data != 0)
_TIFFfreeExt(tif, data);
if (!m)
return (0);
}
}
}
break;
case TIFF_SETGET_C16_ASCII:
{
uint8_t *data;
@@ -6938,8 +7074,8 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
"byte. Forcing it to be null",
fip->field_name);
/* Enlarge buffer and add terminating null. */
uint8_t *o =
_TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
uint8_t *o = (uint8_t *)_TIFFmallocExt(
tif, (uint32_t)dp->tdir_count + 1);
if (o == NULL)
{
if (data != NULL)
@@ -7309,8 +7445,8 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
"in null byte. Forcing it to be null",
fip->field_name);
/* Enlarge buffer and add terminating null. */
uint8_t *o =
_TIFFmallocExt(tif, (uint32_t)dp->tdir_count + 1);
uint8_t *o = (uint8_t *)_TIFFmallocExt(
tif, (uint32_t)dp->tdir_count + 1);
if (o == NULL)
{
if (data != NULL)
@@ -7624,6 +7760,11 @@ static int TIFFFetchNormalTag(TIFF *tif, TIFFDirEntry *dp, int recover)
}
}
break;
case TIFF_SETGET_INT:
case TIFF_SETGET_C0_ASCII:
case TIFF_SETGET_OTHER:
assert(0); /* these should not arrive here */
break;
default:
assert(0); /* we should never get here */
break;
@@ -7700,9 +7841,10 @@ static int TIFFFetchStripThing(TIFF *tif, TIFFDirEntry *dir, uint32_t nstrips,
}
if (dir->tdir_count)
_TIFFmemcpy(resizeddata, data,
(uint32_t)dir->tdir_count * sizeof(uint64_t));
(tmsize_t)((size_t)dir->tdir_count * sizeof(uint64_t)));
_TIFFmemset(resizeddata + (uint32_t)dir->tdir_count, 0,
(nstrips - (uint32_t)dir->tdir_count) * sizeof(uint64_t));
(tmsize_t)((size_t)(nstrips - (uint32_t)dir->tdir_count) *
sizeof(uint64_t)));
_TIFFfreeExt(tif, data);
data = resizeddata;
}
@@ -7866,7 +8008,7 @@ static void allocChoppedUpStripArrays(TIFF *tif, uint32_t nstrips,
*/
static void ChopUpSingleUncompressedStrip(TIFF *tif)
{
register TIFFDirectory *td = &tif->tif_dir;
TIFFDirectory *td = &tif->tif_dir;
uint64_t bytecount;
uint64_t offset;
uint32_t rowblock;
@@ -7881,7 +8023,7 @@ static void ChopUpSingleUncompressedStrip(TIFF *tif)
/* later ( StripOffsets and StripByteCounts improperly filled) . */
if (bytecount == 0 && tif->tif_mode != O_RDONLY)
return;
offset = TIFFGetStrileByteCount(tif, 0);
offset = TIFFGetStrileOffset(tif, 0);
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
if ((td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
rowblock = td->td_ycbcrsubsampling[1];
@@ -8032,7 +8174,7 @@ static void TryChopUpUncompressedBigTiff(TIFF *tif)
TIFF_NOSANITIZE_UNSIGNED_INT_OVERFLOW
static uint64_t _TIFFUnsanitizedAddUInt64AndInt(uint64_t a, int b)
{
return a + b;
return a + (uint64_t)b;
}
/* Read the value of [Strip|Tile]Offset or [Strip|Tile]ByteCount around
@@ -8111,7 +8253,7 @@ static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent,
panVals[strile] = 0;
return 0;
}
nOffset = nBaseOffset + sizeofval * strile;
nOffset = nBaseOffset + (uint64_t)sizeofval * (uint64_t)strile;
nOffsetStartPage = (nOffset / IO_CACHE_PAGE_SIZE) * IO_CACHE_PAGE_SIZE;
nOffsetEndPage = nOffsetStartPage + IO_CACHE_PAGE_SIZE;
@@ -8119,7 +8261,7 @@ static int _TIFFPartialReadStripArray(TIFF *tif, TIFFDirEntry *dirent,
nOffsetEndPage += IO_CACHE_PAGE_SIZE;
#undef IO_CACHE_PAGE_SIZE
nLastStripOffset = nBaseOffset + arraySize * sizeofval;
nLastStripOffset = nBaseOffset + (uint64_t)arraySize * sizeofval;
if (nLastStripOffset < nOffsetEndPage)
nOffsetEndPage = nLastStripOffset;
if (nOffsetStartPage >= nOffsetEndPage)
@@ -8254,9 +8396,9 @@ static int _TIFFFetchStrileValue(TIFF *tif, uint32_t strile,
}
#endif
offsetArray = (uint64_t *)(_TIFFreallocExt(tif, td->td_stripoffset_p,
nArraySize));
(tmsize_t)nArraySize));
bytecountArray = (uint64_t *)(_TIFFreallocExt(
tif, td->td_stripbytecount_p, nArraySize));
tif, td->td_stripbytecount_p, (tmsize_t)nArraySize));
if (offsetArray)
td->td_stripoffset_p = offsetArray;
if (bytecountArray)
@@ -8290,7 +8432,7 @@ static int _TIFFFetchStrileValue(TIFF *tif, uint32_t strile,
if (~((*parray)[strile]) == 0)
{
if (!_TIFFPartialReadStripArray(tif, dirent, strile, *parray))
if (!_TIFFPartialReadStripArray(tif, dirent, (int)strile, *parray))
{
(*parray)[strile] = 0;
return 0;
@@ -8308,10 +8450,26 @@ static uint64_t _TIFFGetStrileOffsetOrByteCountValue(TIFF *tif, uint32_t strile,
TIFFDirectory *td = &tif->tif_dir;
if (pbErr)
*pbErr = 0;
/* Avoid the "dirent->tdir_count <= 4" code path for one of
* StripOffsets/StripByteCounts, and the other code path for the other one,
* which will lead to inconsistencies and potential out-of-bounds reads.
*/
if ((td->td_stripoffset_entry.tdir_count <= 4) !=
(td->td_stripbytecount_entry.tdir_count <= 4))
{
TIFFErrorExtR(tif, "_TIFFGetStrileOffsetOrByteCountValue",
"Inconsistent directory count between StripOffsets and "
"StripByteCounts");
if (pbErr)
*pbErr = 1;
return 0;
}
if ((tif->tif_flags & TIFF_DEFERSTRILELOAD) &&
!(tif->tif_flags & TIFF_CHOPPEDUPARRAYS))
{
if (!(tif->tif_flags & TIFF_LAZYSTRILELOAD) ||
if (!(tif->tif_flags & TIFF_LAZYSTRILELOAD_ASKED) ||
/* If the values may fit in the toff_long/toff_long8 member */
/* then use _TIFFFillStriles to simplify _TIFFFetchStrileValue */
dirent->tdir_count <= 4)
@@ -8382,7 +8540,7 @@ int _TIFFFillStriles(TIFF *tif) { return _TIFFFillStrilesInternal(tif, 1); }
static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
{
register TIFFDirectory *td = &tif->tif_dir;
TIFFDirectory *td = &tif->tif_dir;
int return_value = 1;
/* Do not do anything if TIFF_DEFERSTRILELOAD is not set */
@@ -8390,7 +8548,8 @@ static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
(tif->tif_flags & TIFF_CHOPPEDUPARRAYS) != 0)
return 1;
if (tif->tif_flags & TIFF_LAZYSTRILELOAD)
if ((tif->tif_flags & TIFF_LAZYSTRILELOAD_ASKED) &&
!(tif->tif_flags & TIFF_LAZYSTRILELOAD_DONE))
{
/* In case of lazy loading, reload completely the arrays */
_TIFFfreeExt(tif, td->td_stripoffset_p);
@@ -8398,7 +8557,7 @@ static int _TIFFFillStrilesInternal(TIFF *tif, int loadStripByteCount)
td->td_stripoffset_p = NULL;
td->td_stripbytecount_p = NULL;
td->td_stripoffsetbyteallocsize = 0;
tif->tif_flags &= ~TIFF_LAZYSTRILELOAD;
tif->tif_flags |= TIFF_LAZYSTRILELOAD_DONE;
}
/* If stripoffset array is already loaded, exit with success */

364
3rdparty/libtiff/tif_dirwrite.c vendored
View File

@@ -365,7 +365,7 @@ static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12U, SEEK_SET);
if (!ReadOK(tif, &nextnextdir, 4))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
@@ -377,7 +377,7 @@ static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
uint32_t m;
m = 0;
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12,
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12U,
SEEK_SET);
if (!WriteOK(tif, &m, 4))
{
@@ -417,7 +417,6 @@ static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
while (1)
{
uint64_t dircount64;
uint16_t dircount;
uint64_t nextnextdir;
if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount64, 8))
@@ -435,8 +434,8 @@ static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
"corrupt TIFF");
return (0);
}
dircount = (uint16_t)dircount64;
(void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 8 + dircount64 * 20,
SEEK_SET);
if (!ReadOK(tif, &nextnextdir, 8))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
@@ -448,7 +447,7 @@ static int TIFFRewriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
uint64_t m;
m = 0;
(void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20,
(void)TIFFSeekFile(tif, nextdir + 8 + dircount64 * 20,
SEEK_SET);
if (!WriteOK(tif, &m, 8))
{
@@ -592,24 +591,24 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
}
if (TIFFFieldSet(tif, FIELD_RESOLUTION))
{
if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
TIFFTAG_XRESOLUTION,
tif->tif_dir.td_xresolution))
if (!TIFFWriteDirectoryTagRational(
tif, &ndir, dir, TIFFTAG_XRESOLUTION,
(double)tif->tif_dir.td_xresolution))
goto bad;
if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
TIFFTAG_YRESOLUTION,
tif->tif_dir.td_yresolution))
if (!TIFFWriteDirectoryTagRational(
tif, &ndir, dir, TIFFTAG_YRESOLUTION,
(double)tif->tif_dir.td_yresolution))
goto bad;
}
if (TIFFFieldSet(tif, FIELD_POSITION))
{
if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
TIFFTAG_XPOSITION,
tif->tif_dir.td_xposition))
if (!TIFFWriteDirectoryTagRational(
tif, &ndir, dir, TIFFTAG_XPOSITION,
(double)tif->tif_dir.td_xposition))
goto bad;
if (!TIFFWriteDirectoryTagRational(tif, &ndir, dir,
TIFFTAG_YPOSITION,
tif->tif_dir.td_yposition))
if (!TIFFWriteDirectoryTagRational(
tif, &ndir, dir, TIFFTAG_YPOSITION,
(double)tif->tif_dir.td_yposition))
goto bad;
}
if (TIFFFieldSet(tif, FIELD_SUBFILETYPE))
@@ -712,6 +711,14 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
}
if (TIFFFieldSet(tif, FIELD_STRIPBYTECOUNTS))
{
/* Check td_stripbytecount_p for NULL pointer (bug#749) */
if (tif->tif_dir.td_stripbytecount_p == NULL)
{
TIFFErrorExtR(
tif, module,
"StripByteCount array is not set, pointer is NULL");
goto bad;
}
if (!isTiled(tif))
{
if (!TIFFWriteDirectoryTagLongLong8Array(
@@ -731,6 +738,14 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
}
if (TIFFFieldSet(tif, FIELD_STRIPOFFSETS))
{
/* Check td_stripoffset_p for NULL pointer (bug#749) */
if (tif->tif_dir.td_stripoffset_p == NULL)
{
TIFFErrorExtR(
tif, module,
"StripByteOffset array is not set, pointer is NULL");
goto bad;
}
if (!isTiled(tif))
{
/* td_stripoffset_p might be NULL in an odd OJPEG case. See
@@ -851,7 +866,8 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
if (!TIFFWriteDirectoryTagAscii(
tif, &ndir, dir, TIFFTAG_INKNAMES,
tif->tif_dir.td_inknameslen, tif->tif_dir.td_inknames))
(uint32_t)tif->tif_dir.td_inknameslen,
tif->tif_dir.td_inknames))
goto bad;
}
if (TIFFFieldSet(tif, FIELD_NUMBEROFINKS))
@@ -932,10 +948,58 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
TIFFGetField(tif, o->field_tag, &pa, &pb);
if (!TIFFWriteDirectoryTagUndefinedArray(
tif, &ndir, dir, (uint16_t)o->field_tag,
pa, pb))
pa, (uint8_t *)pb))
goto bad;
}
break;
case TIFF_SETGET_UNDEFINED:
case TIFF_SETGET_SINT8:
case TIFF_SETGET_SINT16:
case TIFF_SETGET_SINT32:
case TIFF_SETGET_UINT64:
case TIFF_SETGET_SINT64:
case TIFF_SETGET_FLOAT:
case TIFF_SETGET_DOUBLE:
case TIFF_SETGET_IFD8:
case TIFF_SETGET_INT:
case TIFF_SETGET_UINT16_PAIR:
case TIFF_SETGET_C0_ASCII:
case TIFF_SETGET_C0_UINT8:
case TIFF_SETGET_C0_SINT8:
case TIFF_SETGET_C0_UINT16:
case TIFF_SETGET_C0_SINT16:
case TIFF_SETGET_C0_UINT32:
case TIFF_SETGET_C0_SINT32:
case TIFF_SETGET_C0_UINT64:
case TIFF_SETGET_C0_SINT64:
case TIFF_SETGET_C0_FLOAT:
case TIFF_SETGET_C0_DOUBLE:
case TIFF_SETGET_C0_IFD8:
case TIFF_SETGET_C16_ASCII:
case TIFF_SETGET_C16_UINT8:
case TIFF_SETGET_C16_SINT8:
case TIFF_SETGET_C16_UINT16:
case TIFF_SETGET_C16_SINT16:
case TIFF_SETGET_C16_UINT32:
case TIFF_SETGET_C16_SINT32:
case TIFF_SETGET_C16_UINT64:
case TIFF_SETGET_C16_SINT64:
case TIFF_SETGET_C16_FLOAT:
case TIFF_SETGET_C16_DOUBLE:
case TIFF_SETGET_C16_IFD8:
case TIFF_SETGET_C32_ASCII:
case TIFF_SETGET_C32_SINT8:
case TIFF_SETGET_C32_UINT16:
case TIFF_SETGET_C32_SINT16:
case TIFF_SETGET_C32_UINT32:
case TIFF_SETGET_C32_SINT32:
case TIFF_SETGET_C32_UINT64:
case TIFF_SETGET_C32_SINT64:
case TIFF_SETGET_C32_FLOAT:
case TIFF_SETGET_C32_DOUBLE:
case TIFF_SETGET_C32_IFD8:
case TIFF_SETGET_UINT8:
case TIFF_SETGET_OTHER:
default:
TIFFErrorExtR(
tif, module,
@@ -954,67 +1018,67 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
uint16_t tag =
(uint16_t)tif->tif_dir.td_customValues[m].info->field_tag;
uint32_t count = tif->tif_dir.td_customValues[m].count;
uint32_t count = (uint32_t)tif->tif_dir.td_customValues[m].count;
switch (tif->tif_dir.td_customValues[m].info->field_type)
{
case TIFF_ASCII:
if (!TIFFWriteDirectoryTagAscii(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(char *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_UNDEFINED:
if (!TIFFWriteDirectoryTagUndefinedArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint8_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_BYTE:
if (!TIFFWriteDirectoryTagByteArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint8_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_SBYTE:
if (!TIFFWriteDirectoryTagSbyteArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(int8_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_SHORT:
if (!TIFFWriteDirectoryTagShortArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint16_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_SSHORT:
if (!TIFFWriteDirectoryTagSshortArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(int16_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_LONG:
if (!TIFFWriteDirectoryTagLongArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint32_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_SLONG:
if (!TIFFWriteDirectoryTagSlongArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(int32_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_LONG8:
if (!TIFFWriteDirectoryTagLong8Array(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint64_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_SLONG8:
if (!TIFFWriteDirectoryTagSlong8Array(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(int64_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_RATIONAL:
@@ -1029,7 +1093,8 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
if (!TIFFWriteDirectoryTagRationalDoubleArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(double *)tif->tif_dir.td_customValues[m]
.value))
goto bad;
}
else
@@ -1037,7 +1102,7 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
/*-- default should be tv_size == 4 */
if (!TIFFWriteDirectoryTagRationalArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(float *)tif->tif_dir.td_customValues[m].value))
goto bad;
/*-- ToDo: After Testing, this should be removed and
* tv_size==4 should be set as default. */
@@ -1064,7 +1129,8 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
if (!TIFFWriteDirectoryTagSrationalDoubleArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(double *)tif->tif_dir.td_customValues[m]
.value))
goto bad;
}
else
@@ -1072,7 +1138,7 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
/*-- default should be tv_size == 4 */
if (!TIFFWriteDirectoryTagSrationalArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(float *)tif->tif_dir.td_customValues[m].value))
goto bad;
/*-- ToDo: After Testing, this should be removed and
* tv_size==4 should be set as default. */
@@ -1090,27 +1156,28 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
case TIFF_FLOAT:
if (!TIFFWriteDirectoryTagFloatArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(float *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_DOUBLE:
if (!TIFFWriteDirectoryTagDoubleArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(double *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_IFD:
if (!TIFFWriteDirectoryTagIfdArray(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint32_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_IFD8:
if (!TIFFWriteDirectoryTagIfdIfd8Array(
tif, &ndir, dir, tag, count,
tif->tif_dir.td_customValues[m].value))
(uint64_t *)tif->tif_dir.td_customValues[m].value))
goto bad;
break;
case TIFF_NOTYPE:
default:
assert(0); /* we should never get here */
break;
@@ -1128,7 +1195,8 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
tif->tif_dir.td_dirdatasize_write += 8 + ndir * 20 + 8;
/* Setup a new directory within first pass. */
dir = _TIFFmallocExt(tif, ndir * sizeof(TIFFDirEntry));
dir = (TIFFDirEntry *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)ndir * sizeof(TIFFDirEntry)));
if (dir == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1238,7 +1306,7 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
uint8_t *n;
uint32_t nTmp;
TIFFDirEntry *o;
n = dirmem;
n = (uint8_t *)dirmem;
*(uint16_t *)n = (uint16_t)ndir;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort((uint16_t *)n);
@@ -1274,7 +1342,7 @@ static int TIFFWriteDirectorySec(TIFF *tif, int isimage, int imagedone,
{
uint8_t *n;
TIFFDirEntry *o;
n = dirmem;
n = (uint8_t *)dirmem;
*(uint64_t *)n = ndir;
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabLong8((uint64_t *)n);
@@ -1405,7 +1473,7 @@ static int8_t TIFFClampDoubleToInt8(double val)
{
if (val > 127)
return 127;
if (val < -128 || val != val)
if (val < -128 || isnan(val))
return -128;
return (int8_t)val;
}
@@ -1414,7 +1482,7 @@ static int16_t TIFFClampDoubleToInt16(double val)
{
if (val > 32767)
return 32767;
if (val < -32768 || val != val)
if (val < -32768 || isnan(val))
return -32768;
return (int16_t)val;
}
@@ -1423,7 +1491,7 @@ static int32_t TIFFClampDoubleToInt32(double val)
{
if (val > 0x7FFFFFFF)
return 0x7FFFFFFF;
if (val < -0x7FFFFFFF - 1 || val != val)
if (val < -0x7FFFFFFF - 1 || isnan(val))
return -0x7FFFFFFF - 1;
return (int32_t)val;
}
@@ -1432,7 +1500,7 @@ static uint8_t TIFFClampDoubleToUInt8(double val)
{
if (val < 0)
return 0;
if (val > 255 || val != val)
if (val > 255 || isnan(val))
return 255;
return (uint8_t)val;
}
@@ -1441,7 +1509,7 @@ static uint16_t TIFFClampDoubleToUInt16(double val)
{
if (val < 0)
return 0;
if (val > 65535 || val != val)
if (val > 65535 || isnan(val))
return 65535;
return (uint16_t)val;
}
@@ -1450,7 +1518,7 @@ static uint32_t TIFFClampDoubleToUInt32(double val)
{
if (val < 0)
return 0;
if (val > 0xFFFFFFFFU || val != val)
if (val > 0xFFFFFFFFU || isnan(val))
return 0xFFFFFFFFU;
return (uint32_t)val;
}
@@ -1464,7 +1532,7 @@ static int TIFFWriteDirectoryTagSampleformatArray(TIFF *tif, uint32_t *ndir,
void *conv;
uint32_t i;
int ok;
conv = _TIFFmallocExt(tif, count * sizeof(double));
conv = _TIFFmallocExt(tif, (tmsize_t)((size_t)count * sizeof(double)));
if (conv == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1603,7 +1671,9 @@ static int TIFFWriteDirectoryTagShortPerSample(TIFF *tif, uint32_t *ndir,
return (TIFFWriteDirectoryTagCheckedShortArray(
tif, ndir, dir, tag, tif->tif_dir.td_samplesperpixel, NULL));
}
m = _TIFFmallocExt(tif, tif->tif_dir.td_samplesperpixel * sizeof(uint16_t));
m = (uint16_t *)_TIFFmallocExt(
tif,
(tmsize_t)((size_t)tif->tif_dir.td_samplesperpixel * sizeof(uint16_t)));
if (m == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1664,14 +1734,6 @@ static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir,
uint32_t *q;
int o;
/* is this just a counting pass? */
if (dir == NULL)
{
/* only evaluate IFD data size and inc. ndir */
return (TIFFWriteDirectoryTagCheckedLong8Array(tif, ndir, dir, tag,
count, value));
}
/* We always write Long8 for BigTIFF, no checking needed. */
if (tif->tif_flags & TIFF_BIGTIFF)
return (TIFFWriteDirectoryTagCheckedLong8Array(tif, ndir, dir, tag,
@@ -1681,7 +1743,8 @@ static int TIFFWriteDirectoryTagLong8Array(TIFF *tif, uint32_t *ndir,
** For classic tiff we want to verify everything is in range for long
** and convert to long format.
*/
p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
p = (uint32_t *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)count * sizeof(uint32_t)));
if (p == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1725,13 +1788,6 @@ static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir,
int32_t *q;
int o;
/* is this just a counting pass? */
if (dir == NULL)
{
/* only evaluate IFD data size and inc. ndir */
return (TIFFWriteDirectoryTagCheckedSlong8Array(tif, ndir, dir, tag,
count, value));
}
/* We always write SLong8 for BigTIFF, no checking needed. */
if (tif->tif_flags & TIFF_BIGTIFF)
return (TIFFWriteDirectoryTagCheckedSlong8Array(tif, ndir, dir, tag,
@@ -1741,7 +1797,8 @@ static int TIFFWriteDirectoryTagSlong8Array(TIFF *tif, uint32_t *ndir,
** For classic tiff we want to verify everything is in range for signed-long
** and convert to signed-long format.
*/
p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
p = (int32_t *)_TIFFmallocExt(tif,
(tmsize_t)((size_t)count * sizeof(uint32_t)));
if (p == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1960,7 +2017,8 @@ static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir,
** and convert to long format.
*/
uint32_t *p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
uint32_t *p = (uint32_t *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)count * sizeof(uint32_t)));
uint32_t *q;
uint64_t *ma;
uint32_t mb;
@@ -1990,7 +2048,8 @@ static int TIFFWriteDirectoryTagLongLong8Array(TIFF *tif, uint32_t *ndir,
}
else
{
uint16_t *p = _TIFFmallocExt(tif, count * sizeof(uint16_t));
uint16_t *p = (uint16_t *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)count * sizeof(uint16_t)));
uint16_t *q;
uint64_t *ma;
uint32_t mb;
@@ -2050,7 +2109,8 @@ static int TIFFWriteDirectoryTagIfdIfd8Array(TIFF *tif, uint32_t *ndir,
** and convert to long format.
*/
p = _TIFFmallocExt(tif, count * sizeof(uint32_t));
p = (uint32_t *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)count * sizeof(uint32_t)));
if (p == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2101,26 +2161,45 @@ static int TIFFWriteDirectoryTagColormap(TIFF *tif, uint32_t *ndir,
{
static const char module[] = "TIFFWriteDirectoryTagColormap";
uint32_t m;
uint32_t count;
uint64_t count64;
tmsize_t total_values;
tmsize_t plane_bytes;
uint16_t *n;
int o;
m = (1 << tif->tif_dir.td_bitspersample);
if (tif->tif_dir.td_bitspersample >= 32)
{
TIFFErrorExtR(tif, module, "BitsPerSample too large for Colormap");
return (0);
}
m = 1U << tif->tif_dir.td_bitspersample;
count64 = _TIFFMultiply64(tif, 3U, m, module);
if (count64 == 0)
return (0);
count = _TIFFCastUInt64ToUInt32(tif, count64, module);
total_values = _TIFFCastUInt64ToSSize(tif, count64, module);
plane_bytes = _TIFFCastUInt64ToSSize(
tif, _TIFFMultiply64(tif, m, sizeof(uint16_t), module), module);
if (count == 0 || total_values == 0 || plane_bytes == 0)
return (0);
if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
{
EvaluateIFDdatasizeWrite(tif, 3 * m, sizeof(uint16_t), ndir);
EvaluateIFDdatasizeWrite(tif, count, sizeof(uint16_t), ndir);
return 1;
}
n = _TIFFmallocExt(tif, 3 * m * sizeof(uint16_t));
n = (uint16_t *)_TIFFCheckMalloc(tif, total_values, sizeof(uint16_t),
module);
if (n == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
return (0);
}
_TIFFmemcpy(&n[0], tif->tif_dir.td_colormap[0], m * sizeof(uint16_t));
_TIFFmemcpy(&n[m], tif->tif_dir.td_colormap[1], m * sizeof(uint16_t));
_TIFFmemcpy(&n[2 * m], tif->tif_dir.td_colormap[2], m * sizeof(uint16_t));
_TIFFmemcpy(&n[0], tif->tif_dir.td_colormap[0], plane_bytes);
_TIFFmemcpy(&n[m], tif->tif_dir.td_colormap[1], plane_bytes);
_TIFFmemcpy(&n[2 * m], tif->tif_dir.td_colormap[2], plane_bytes);
o = TIFFWriteDirectoryTagCheckedShortArray(tif, ndir, dir, TIFFTAG_COLORMAP,
3 * m, n);
count, n);
_TIFFfreeExt(tif, n);
return (o);
}
@@ -2130,13 +2209,27 @@ static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir,
{
static const char module[] = "TIFFWriteDirectoryTagTransferfunction";
uint32_t m;
uint32_t count;
uint64_t count64;
tmsize_t total_values;
tmsize_t plane_bytes;
uint16_t n;
uint16_t *o;
int p;
/* TIFFTAG_TRANSFERFUNCTION expects (1 or 3) pointer to arrays with
* (1 << BitsPerSample) * uint16_t values.
* 2**BitsPerSample uint16_t values.
*/
m = (1 << tif->tif_dir.td_bitspersample);
if (tif->tif_dir.td_bitspersample >= 32)
{
TIFFErrorExtR(tif, module,
"BitsPerSample too large for TransferFunction");
return (0);
}
m = 1U << tif->tif_dir.td_bitspersample;
plane_bytes = _TIFFCastUInt64ToSSize(
tif, _TIFFMultiply64(tif, m, sizeof(uint16_t), module), module);
if (plane_bytes == 0)
return (0);
/* clang-format off */
n = (tif->tif_dir.td_samplesperpixel - tif->tif_dir.td_extrasamples) > 1 ? 3 : 1;
/* clang-format on */
@@ -2161,35 +2254,39 @@ static int TIFFWriteDirectoryTagTransferfunction(TIFF *tif, uint32_t *ndir,
if (n == 3)
{
if (!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],
tif->tif_dir.td_transferfunction[2],
m * sizeof(uint16_t)) &&
tif->tif_dir.td_transferfunction[2], plane_bytes) &&
!_TIFFmemcmp(tif->tif_dir.td_transferfunction[0],
tif->tif_dir.td_transferfunction[1],
m * sizeof(uint16_t)))
tif->tif_dir.td_transferfunction[1], plane_bytes))
n = 1;
}
count64 = _TIFFMultiply64(tif, n, m, module);
if (count64 == 0)
return (0);
count = _TIFFCastUInt64ToUInt32(tif, count64, module);
total_values = _TIFFCastUInt64ToSSize(tif, count64, module);
if (count == 0 || total_values == 0)
return (0);
if (dir == NULL) /* Just evaluate IFD data size and increment ndir. */
{
EvaluateIFDdatasizeWrite(tif, n * m, 2, ndir);
EvaluateIFDdatasizeWrite(tif, count, 2, ndir);
return 1;
}
o = _TIFFmallocExt(tif, n * m * sizeof(uint16_t));
o = (uint16_t *)_TIFFCheckMalloc(tif, total_values, sizeof(uint16_t),
module);
if (o == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
return (0);
}
_TIFFmemcpy(&o[0], tif->tif_dir.td_transferfunction[0],
m * sizeof(uint16_t));
_TIFFmemcpy(&o[0], tif->tif_dir.td_transferfunction[0], plane_bytes);
if (n > 1)
_TIFFmemcpy(&o[m], tif->tif_dir.td_transferfunction[1],
m * sizeof(uint16_t));
_TIFFmemcpy(&o[m], tif->tif_dir.td_transferfunction[1], plane_bytes);
if (n > 2)
_TIFFmemcpy(&o[2 * m], tif->tif_dir.td_transferfunction[2],
m * sizeof(uint16_t));
plane_bytes);
p = TIFFWriteDirectoryTagCheckedShortArray(
tif, ndir, dir, TIFFTAG_TRANSFERFUNCTION, n * m, o);
tif, ndir, dir, TIFFTAG_TRANSFERFUNCTION, count, o);
_TIFFfreeExt(tif, o);
return (p);
}
@@ -2209,7 +2306,9 @@ static int TIFFWriteDirectoryTagSubifd(TIFF *tif, uint32_t *ndir,
uint64_t *pa;
uint32_t *pb;
uint16_t p;
o = _TIFFmallocExt(tif, tif->tif_dir.td_nsubifd * sizeof(uint32_t));
o = (uint32_t *)_TIFFmallocExt(
tif,
(tmsize_t)((size_t)tif->tif_dir.td_nsubifd * sizeof(uint32_t)));
if (o == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2494,7 +2593,7 @@ static int TIFFWriteDirectoryTagCheckedRational(TIFF *tif, uint32_t *ndir,
TIFFErrorExtR(tif, module, "Negative value is illegal");
return 0;
}
else if (value != value)
else if (isnan(value))
{
TIFFErrorExtR(tif, module, "Not-a-number value is illegal");
return 0;
@@ -2537,7 +2636,8 @@ static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir,
EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(uint32_t), ndir);
return 1;
}
m = _TIFFmallocExt(tif, count * 2 * sizeof(uint32_t));
m = (uint32_t *)_TIFFCheckMalloc(tif, count, 2 * sizeof(uint32_t),
"for rational array");
if (m == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2545,7 +2645,7 @@ static int TIFFWriteDirectoryTagCheckedRationalArray(TIFF *tif, uint32_t *ndir,
}
for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
{
DoubleToRational(*na, &nb[0], &nb[1]);
DoubleToRational((double)*na, &nb[0], &nb[1]);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong(m, count * 2);
@@ -2573,7 +2673,8 @@ static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir,
EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(int32_t), ndir);
return 1;
}
m = _TIFFmallocExt(tif, count * 2 * sizeof(int32_t));
m = (int32_t *)_TIFFCheckMalloc(tif, count, 2 * sizeof(int32_t),
"for srational array");
if (m == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2581,7 +2682,7 @@ static int TIFFWriteDirectoryTagCheckedSrationalArray(TIFF *tif, uint32_t *ndir,
}
for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
{
DoubleToSrational(*na, &nb[0], &nb[1]);
DoubleToSrational((double)*na, &nb[0], &nb[1]);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong((uint32_t *)m, count * 2);
@@ -2610,7 +2711,8 @@ TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir,
EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(uint32_t), ndir);
return 1;
}
m = _TIFFmallocExt(tif, count * 2 * sizeof(uint32_t));
m = (uint32_t *)_TIFFCheckMalloc(tif, count, 2 * sizeof(uint32_t),
"for rational double array");
if (m == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2618,7 +2720,7 @@ TIFFWriteDirectoryTagCheckedRationalDoubleArray(TIFF *tif, uint32_t *ndir,
}
for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
{
DoubleToRational(*na, &nb[0], &nb[1]);
DoubleToRational((double)*na, &nb[0], &nb[1]);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong(m, count * 2);
@@ -2645,7 +2747,8 @@ static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(
EvaluateIFDdatasizeWrite(tif, count * 2, sizeof(int32_t), ndir);
return 1;
}
m = _TIFFmallocExt(tif, count * 2 * sizeof(int32_t));
m = (int32_t *)_TIFFCheckMalloc(tif, count, 2 * sizeof(int32_t),
"for srational double array");
if (m == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2653,7 +2756,7 @@ static int TIFFWriteDirectoryTagCheckedSrationalDoubleArray(
}
for (na = value, nb = m, nc = 0; nc < count; na++, nb += 2, nc++)
{
DoubleToSrational(*na, &nb[0], &nb[1]);
DoubleToSrational((double)*na, &nb[0], &nb[1]);
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabArrayOfLong((uint32_t *)m, count * 2);
@@ -2744,7 +2847,8 @@ static void ToRationalEuclideanGCD(double value, int blnUseSignedRange,
*the double-value of it reaches an integer number without fractional part.
*/
bigDenom = 1;
while ((value != floor(value)) && (value < fMax) && (bigDenom < nMax))
while ((!TIFF_DOUBLE_EQ(value, floor(value))) && (value < fMax) &&
(bigDenom < nMax))
{
bigDenom <<= 1;
value *= 2;
@@ -2836,7 +2940,7 @@ static void DoubleToRational(double value, uint32_t *num, uint32_t *denom)
return;
}
/*-- Check for easy integer numbers -- */
if (value == (uint32_t)(value))
if (TIFF_DOUBLE_EQ(value, (double)(uint32_t)value))
{
*num = (uint32_t)value;
*denom = 1;
@@ -2911,7 +3015,7 @@ static void DoubleToSrational(double value, int32_t *num, int32_t *denom)
return;
}
/*-- Check for easy numbers -- */
if (value == (int32_t)(value))
if (TIFF_DOUBLE_EQ(value, (double)(int32_t)value))
{
*num = (int32_t)(neg * value);
*denom = 1;
@@ -3231,6 +3335,14 @@ static int TIFFLinkDirectory(TIFF *tif)
uint16_t dircount;
uint32_t nextnextdir;
/* Update IDF loop list and check for IFD loop.
* ndir is IFD ID plus one. */
if (!_TIFFCheckDirNumberAndOffset(tif, ndir - 1, nextdir))
{
TIFFErrorExtR(tif, module, "Error IFD loop detected");
return 0; /* bad offset (IFD looping or more than
TIFF_MAX_DIR_COUNT IFDs) */
}
if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount, 2))
{
TIFFErrorExtR(tif, module, "Error fetching directory count");
@@ -3238,7 +3350,7 @@ static int TIFFLinkDirectory(TIFF *tif)
}
if (tif->tif_flags & TIFF_SWAB)
TIFFSwabShort(&dircount);
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12U, SEEK_SET);
if (!ReadOK(tif, &nextnextdir, 4))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
@@ -3248,7 +3360,7 @@ static int TIFFLinkDirectory(TIFF *tif)
TIFFSwabLong(&nextnextdir);
if (nextnextdir == 0)
{
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 2 + dircount * 12U, SEEK_SET);
if (!WriteOK(tif, &m, 4))
{
TIFFErrorExtR(tif, module, "Error writing directory link");
@@ -3306,9 +3418,15 @@ static int TIFFLinkDirectory(TIFF *tif)
while (1)
{
uint64_t dircount64;
uint16_t dircount;
uint64_t nextnextdir;
/* Update IDF loop list and check for IFD loop. */
if (!_TIFFCheckDirNumberAndOffset(tif, ndir - 1, nextdir))
{
TIFFErrorExtR(tif, module, "Error IFD loop detected");
return 0; /* bad offset (IFD looping or more than
TIFF_MAX_DIR_COUNT IFDs) */
}
if (!SeekOK(tif, nextdir) || !ReadOK(tif, &dircount64, 8))
{
TIFFErrorExtR(tif, module, "Error fetching directory count");
@@ -3323,8 +3441,7 @@ static int TIFFLinkDirectory(TIFF *tif)
"likely corrupt TIFF");
return (0);
}
dircount = (uint16_t)dircount64;
(void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 8 + dircount64 * 20, SEEK_SET);
if (!ReadOK(tif, &nextnextdir, 8))
{
TIFFErrorExtR(tif, module, "Error fetching directory link");
@@ -3334,7 +3451,8 @@ static int TIFFLinkDirectory(TIFF *tif)
TIFFSwabLong8(&nextnextdir);
if (nextnextdir == 0)
{
(void)TIFFSeekFile(tif, nextdir + 8 + dircount * 20, SEEK_SET);
(void)TIFFSeekFile(tif, nextdir + 8 + dircount64 * 20,
SEEK_SET);
if (!WriteOK(tif, &m, 8))
{
TIFFErrorExtR(tif, module, "Error writing directory link");
@@ -3475,7 +3593,7 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
if (entry_tag == tag)
break;
read_offset += dirsize;
read_offset += (uint64_t)dirsize;
}
if (entry_tag != tag)
@@ -3584,13 +3702,13 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
if (in_datatype == TIFF_LONG8 &&
(entry_type == TIFF_SHORT || entry_type == TIFF_LONG ||
entry_type == TIFF_LONG8))
datatype = entry_type;
datatype = (TIFFDataType)entry_type;
else if (in_datatype == TIFF_SLONG8 &&
(entry_type == TIFF_SLONG || entry_type == TIFF_SLONG8))
datatype = entry_type;
datatype = (TIFFDataType)entry_type;
else if (in_datatype == TIFF_IFD8 &&
(entry_type == TIFF_IFD || entry_type == TIFF_IFD8))
datatype = entry_type;
datatype = (TIFFDataType)entry_type;
else
datatype = in_datatype;
}
@@ -3605,7 +3723,8 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
return 0;
if (datatype == in_datatype)
memcpy(buf_to_write, data, count * TIFFDataWidth(datatype));
memcpy(buf_to_write, data,
(size_t)count * (size_t)TIFFDataWidth(datatype));
else if (datatype == TIFF_SLONG && in_datatype == TIFF_SLONG8)
{
tmsize_t i;
@@ -3698,8 +3817,8 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
tif->tif_dir.td_stripoffset_entry.tdir_type == 0 &&
tif->tif_dir.td_stripoffset_entry.tdir_offset.toff_long8 == 0)
{
tif->tif_dir.td_stripoffset_entry.tdir_type = datatype;
tif->tif_dir.td_stripoffset_entry.tdir_count = count;
tif->tif_dir.td_stripoffset_entry.tdir_type = (uint16_t)datatype;
tif->tif_dir.td_stripoffset_entry.tdir_count = (uint64_t)count;
}
else if ((tag == TIFFTAG_TILEBYTECOUNTS ||
tag == TIFFTAG_STRIPBYTECOUNTS) &&
@@ -3707,8 +3826,8 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
tif->tif_dir.td_stripbytecount_entry.tdir_type == 0 &&
tif->tif_dir.td_stripbytecount_entry.tdir_offset.toff_long8 == 0)
{
tif->tif_dir.td_stripbytecount_entry.tdir_type = datatype;
tif->tif_dir.td_stripbytecount_entry.tdir_count = count;
tif->tif_dir.td_stripbytecount_entry.tdir_type = (uint16_t)datatype;
tif->tif_dir.td_stripbytecount_entry.tdir_count = (uint64_t)count;
}
/* -------------------------------------------------------------------- */
@@ -3756,13 +3875,14 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
if (count * TIFFDataWidth(datatype) == 4)
{
uint32_t value;
memcpy(&value, buf_to_write, count * TIFFDataWidth(datatype));
memcpy(&value, buf_to_write,
(size_t)count * (size_t)TIFFDataWidth(datatype));
entry_offset = value;
}
else
{
memcpy(&entry_offset, buf_to_write,
count * TIFFDataWidth(datatype));
(size_t)count * (size_t)TIFFDataWidth(datatype));
}
}
@@ -3772,7 +3892,7 @@ int _TIFFRewriteField(TIFF *tif, uint16_t tag, TIFFDataType in_datatype,
/* -------------------------------------------------------------------- */
/* Adjust the directory entry. */
/* -------------------------------------------------------------------- */
entry_type = datatype;
entry_type = (uint16_t)datatype;
entry_count = (uint64_t)count;
memcpy(direntry_raw + 2, &entry_type, sizeof(uint16_t));
if (tif->tif_flags & TIFF_SWAB)

21
3rdparty/libtiff/tif_dumpmode.c vendored
View File

@@ -80,7 +80,7 @@ static int DumpModeDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
"Not enough data for scanline %" PRIu32
", expected a request for at most %" TIFF_SSIZE_FORMAT
" bytes, got a request for %" TIFF_SSIZE_FORMAT " bytes",
tif->tif_row, tif->tif_rawcc, cc);
tif->tif_dir.td_row, tif->tif_rawcc, cc);
return (0);
}
/*
@@ -99,8 +99,23 @@ static int DumpModeDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
*/
static int DumpModeSeek(TIFF *tif, uint32_t nrows)
{
tif->tif_rawcp += nrows * tif->tif_scanlinesize;
tif->tif_rawcc -= nrows * tif->tif_scanlinesize;
tmsize_t seek_size;
if (nrows > 0 &&
tif->tif_dir.td_scanlinesize > (tmsize_t)(TIFF_TMSIZE_T_MAX / nrows))
{
TIFFErrorExtR(tif, "DumpModeSeek",
"Integer overflow computing seek size");
return (0);
}
seek_size = (tmsize_t)nrows * tif->tif_dir.td_scanlinesize;
if (seek_size > tif->tif_rawcc)
{
TIFFErrorExtR(tif, "DumpModeSeek",
"Seek beyond end of raw data buffer");
return (0);
}
tif->tif_rawcp += seek_size;
tif->tif_rawcc -= seek_size;
return (1);
}

253
3rdparty/libtiff/tif_fax3.c vendored
View File

@@ -123,7 +123,7 @@ typedef struct
static const char module[] = mod; \
Fax3CodecState *sp = DecoderState(tif); \
int a0; /* reference element */ \
int lastx = sp->b.rowpixels; /* last element in row */ \
int lastx = (int)sp->b.rowpixels; /* last element in row */ \
uint32_t BitAcc; /* bit accumulator */ \
int BitsAvail; /* # valid bits in BitAcc */ \
int RunLength; /* length of current run */ \
@@ -209,61 +209,68 @@ static int Fax3PreDecode(TIFF *tif, uint16_t s)
static void Fax3Unexpected(const char *module, TIFF *tif, uint32_t line,
uint32_t a0)
{
TIFFErrorExtR(tif, module,
"Bad code word at line %" PRIu32 " of %s %" PRIu32
" (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), a0);
TIFFErrorExtR(
tif, module,
"Bad code word at line %" PRIu32 " of %s %" PRIu32 " (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_dir.td_curtile : tif->tif_dir.td_curstrip),
a0);
}
#define unexpected(table, a0) \
do \
{ \
Fax3Unexpected(module, tif, sp->line, a0); \
Fax3Unexpected(module, tif, (uint32_t)sp->line, (uint32_t)(a0)); \
++sp->unexpectedReachedCount; \
} while (0)
static void Fax3Extension(const char *module, TIFF *tif, uint32_t line,
uint32_t a0)
{
TIFFErrorExtR(tif, module,
"Uncompressed data (not supported) at line %" PRIu32
" of %s %" PRIu32 " (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), a0);
TIFFErrorExtR(
tif, module,
"Uncompressed data (not supported) at line %" PRIu32 " of %s %" PRIu32
" (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_dir.td_curtile : tif->tif_dir.td_curstrip),
a0);
}
#define extension(a0) Fax3Extension(module, tif, sp->line, a0)
#define extension(a0) \
Fax3Extension(module, tif, (uint32_t)sp->line, (uint32_t)(a0))
static void Fax3BadLength(const char *module, TIFF *tif, uint32_t line,
uint32_t a0, uint32_t lastx)
{
TIFFWarningExtR(tif, module,
"%s at line %" PRIu32 " of %s %" PRIu32 " (got %" PRIu32
", expected %" PRIu32 ")",
a0 < lastx ? "Premature EOL" : "Line length mismatch", line,
isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), a0,
lastx);
TIFFWarningExtR(
tif, module,
"%s at line %" PRIu32 " of %s %" PRIu32 " (got %" PRIu32
", expected %" PRIu32 ")",
a0 < lastx ? "Premature EOL" : "Line length mismatch", line,
isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_dir.td_curtile : tif->tif_dir.td_curstrip), a0,
lastx);
}
#define badlength(a0, lastx) \
do \
{ \
Fax3BadLength(module, tif, sp->line, a0, lastx); \
Fax3BadLength(module, tif, (uint32_t)sp->line, (uint32_t)(a0), \
(uint32_t)(lastx)); \
++sp->eolReachedCount; \
} while (0)
static void Fax3PrematureEOF(const char *module, TIFF *tif, uint32_t line,
uint32_t a0)
{
TIFFWarningExtR(tif, module,
"Premature EOF at line %" PRIu32 " of %s %" PRIu32
" (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), a0);
TIFFWarningExtR(
tif, module,
"Premature EOF at line %" PRIu32 " of %s %" PRIu32 " (x %" PRIu32 ")",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_dir.td_curtile : tif->tif_dir.td_curstrip),
a0);
}
#define prematureEOF(a0) \
do \
{ \
Fax3PrematureEOF(module, tif, sp->line, a0); \
Fax3PrematureEOF(module, tif, (uint32_t)sp->line, (uint32_t)(a0)); \
++sp->eofReachedCount; \
} while (0)
@@ -275,16 +282,15 @@ static void Fax3TryG3WithoutEOL(const char *module, TIFF *tif, uint32_t line,
"Try to decode (read) fax Group 3 data without EOL at line %" PRIu32
" of %s %" PRIu32 " (x %" PRIu32 "). Please check result",
line, isTiled(tif) ? "tile" : "strip",
(isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip), a0);
(isTiled(tif) ? tif->tif_dir.td_curtile : tif->tif_dir.td_curstrip),
a0);
}
#define tryG3WithoutEOL(a0) \
do \
{ \
Fax3TryG3WithoutEOL(module, tif, sp->line, a0); \
Fax3TryG3WithoutEOL(module, tif, (uint32_t)sp->line, (uint32_t)(a0)); \
} while (0)
#define Nop
static int CheckReachedCounters(TIFF *tif, const char *module,
Fax3CodecState *sp)
{
@@ -344,12 +350,12 @@ RETRY_WITHOUT_EOL_1D:
pa = thisrun;
#ifdef FAX3_DEBUG
printf("\nBitAcc=%08" PRIX32 ", BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %" PRIu32 "\n", tif->tif_row);
printf("-------------------- %" PRIu32 "\n", tif->tif_dir.td_row);
fflush(stdout);
#endif
SYNC_EOL(EOF1D, RETRY_WITHOUT_EOL_1D);
EXPAND1D(EOF1Da);
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
buf += sp->b.rowbytes;
occ -= sp->b.rowbytes;
sp->line++;
@@ -357,7 +363,7 @@ RETRY_WITHOUT_EOL_1D:
EOF1D: /* premature EOF */
CLEANUP_RUNS();
EOF1Da: /* premature EOF */
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
UNCACHE_STATE(tif, sp);
return (-1);
}
@@ -404,16 +410,16 @@ RETRY_WITHOUT_EOL_2D:
ClrBits(1);
#ifdef FAX3_DEBUG
printf(" %s\n-------------------- %" PRIu32 "\n", is1D ? "1D" : "2D",
tif->tif_row);
tif->tif_dir.td_row);
fflush(stdout);
#endif
pb = sp->refruns;
b1 = *pb++;
b1 = (int)*pb++;
if (is1D)
EXPAND1D(EOF2Da);
else
EXPAND2D(EOF2Da);
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
if (pa < thisrun + sp->nruns)
{
SETVALUE(0); /* imaginary change for reference */
@@ -426,7 +432,7 @@ RETRY_WITHOUT_EOL_2D:
EOF2D: /* premature EOF */
CLEANUP_RUNS();
EOF2Da: /* premature EOF */
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
UNCACHE_STATE(tif, sp);
return (-1);
}
@@ -479,12 +485,12 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
{
if (bx)
{ /* align to byte boundary */
*cp++ &= 0xff << (8 - bx);
*cp++ &= (unsigned char)(0xff << (8 - bx));
run -= 8 - bx;
}
if ((n = run >> 3) != 0)
if ((n = (int32_t)(run >> 3)) != 0)
{ /* multiple bytes to fill */
if ((n / sizeof(int64_t)) > 1)
if (((size_t)n / sizeof(int64_t)) > 1)
{
/*
* Align to int64_tword boundary and fill.
@@ -492,8 +498,8 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
for (; n && !isAligned(cp, int64_t); n--)
*cp++ = 0x00;
lp = (int64_t *)cp;
nw = (int32_t)(n / sizeof(int64_t));
n -= nw * sizeof(int64_t);
nw = (int32_t)((size_t)n / sizeof(int64_t));
n -= (int32_t)((size_t)nw * sizeof(int64_t));
do
{
*lp++ = 0L;
@@ -504,10 +510,10 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
run &= 7;
}
if (run)
cp[0] &= 0xff >> run;
cp[0] &= (unsigned char)(0xff >> run);
}
else
cp[0] &= ~(_fillmasks[run] >> bx);
cp[0] &= (unsigned char)~(_fillmasks[run] >> bx);
x += runs[0];
}
run = runs[1];
@@ -521,12 +527,12 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
{
if (bx)
{ /* align to byte boundary */
*cp++ |= 0xff >> bx;
*cp++ |= (unsigned char)(0xff >> bx);
run -= 8 - bx;
}
if ((n = run >> 3) != 0)
if ((n = (int32_t)(run >> 3)) != 0)
{ /* multiple bytes to fill */
if ((n / sizeof(int64_t)) > 1)
if (((size_t)n / sizeof(int64_t)) > 1)
{
/*
* Align to int64_t boundary and fill.
@@ -534,8 +540,8 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
for (; n && !isAligned(cp, int64_t); n--)
*cp++ = 0xff;
lp = (int64_t *)cp;
nw = (int32_t)(n / sizeof(int64_t));
n -= nw * sizeof(int64_t);
nw = (int32_t)((size_t)n / sizeof(int64_t));
n -= (int32_t)((size_t)nw * sizeof(int64_t));
do
{
*lp++ = -1L;
@@ -550,7 +556,7 @@ void _TIFFFax3fillruns(unsigned char *buf, uint32_t *runs, uint32_t *erun,
cp[0] = (unsigned char)((cp[0] | (0xff00 >> run)) & 0xff);
}
else
cp[0] |= _fillmasks[run] >> bx;
cp[0] |= (unsigned char)(_fillmasks[run] >> bx);
x += runs[1];
}
}
@@ -726,12 +732,13 @@ static const int _msbmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f,
{ \
while (length > bit) \
{ \
data |= bits >> (length - bit); \
data |= (int)((unsigned int)bits >> (length - bit)); \
length -= bit; \
_FlushBits(tif); \
} \
assert(length < 9); \
data |= (bits & _msbmask[length]) << (bit - length); \
data |= (int)(((unsigned int)bits & (unsigned int)_msbmask[length]) \
<< (unsigned int)(bit - length)); \
bit -= length; \
if (bit == 0) \
_FlushBits(tif); \
@@ -745,13 +752,13 @@ static const int _msbmask[9] = {0x00, 0x01, 0x03, 0x07, 0x0f,
static int Fax3PutBits(TIFF *tif, unsigned int bits, unsigned int length)
{
Fax3CodecState *sp = EncoderState(tif);
unsigned int bit = sp->bit;
int data = sp->data;
unsigned int bit = (unsigned int)sp->bit;
int data = (int)sp->data;
_PutBits(tif, bits, length);
sp->data = data;
sp->bit = bit;
sp->data = (uint32_t)data;
sp->bit = (int)bit;
return 1;
}
@@ -782,8 +789,8 @@ static int Fax3PutBits(TIFF *tif, unsigned int bits, unsigned int length)
static int putspan(TIFF *tif, int32_t span, const tableentry *tab)
{
Fax3CodecState *sp = EncoderState(tif);
unsigned int bit = sp->bit;
int data = sp->data;
unsigned int bit = (unsigned int)sp->bit;
int data = (int)sp->data;
unsigned int code, length;
while (span >= 2624)
@@ -816,8 +823,8 @@ static int putspan(TIFF *tif, int32_t span, const tableentry *tab)
#endif
_PutBits(tif, code, length);
sp->data = data;
sp->bit = bit;
sp->data = (uint32_t)data;
sp->bit = (int)bit;
return 1;
}
@@ -831,8 +838,8 @@ static int putspan(TIFF *tif, int32_t span, const tableentry *tab)
static int Fax3PutEOL(TIFF *tif)
{
Fax3CodecState *sp = EncoderState(tif);
unsigned int bit = sp->bit;
int data = sp->data;
unsigned int bit = (unsigned int)sp->bit;
int data = (int)sp->data;
unsigned int code, length, tparm;
if (sp->b.groupoptions & GROUP3OPT_FILLBITS)
@@ -849,7 +856,7 @@ static int Fax3PutEOL(TIFF *tif)
align = sp->bit + (8 - align);
else
align = sp->bit - align;
tparm = align;
tparm = (unsigned int)align;
_PutBits(tif, 0, tparm);
}
}
@@ -862,8 +869,8 @@ static int Fax3PutEOL(TIFF *tif)
}
_PutBits(tif, code, length);
sp->data = data;
sp->bit = bit;
sp->data = (uint32_t)data;
sp->bit = (int)bit;
return 1;
}
@@ -991,10 +998,10 @@ static inline int32_t find0span(unsigned char *bp, int32_t bs, int32_t be)
bp++;
}
lp = (int64_t *)bp;
while ((bits >= (int32_t)(8 * sizeof(int64_t))) && (0 == *lp))
while ((bits >= (int32_t)(size_t)(8 * sizeof(int64_t))) && (0 == *lp))
{
span += 8 * sizeof(int64_t);
bits -= 8 * sizeof(int64_t);
span += (int32_t)(size_t)(8 * sizeof(int64_t));
bits -= (int32_t)(size_t)(8 * sizeof(int64_t));
lp++;
}
bp = (unsigned char *)lp;
@@ -1059,11 +1066,11 @@ static inline int32_t find1span(unsigned char *bp, int32_t bs, int32_t be)
bp++;
}
lp = (int64_t *)bp;
while ((bits >= (int32_t)(8 * sizeof(int64_t))) &&
while ((bits >= (int32_t)(size_t)(8 * sizeof(int64_t))) &&
(~((uint64_t)0) == (uint64_t)*lp))
{
span += 8 * sizeof(int64_t);
bits -= 8 * sizeof(int64_t);
span += (int32_t)(size_t)(8 * sizeof(int64_t));
bits -= (int32_t)(size_t)(8 * sizeof(int64_t));
lp++;
}
bp = (unsigned char *)lp;
@@ -1118,16 +1125,16 @@ static int Fax3Encode1DRow(TIFF *tif, unsigned char *bp, uint32_t bits)
for (;;)
{
span = find0span(bp, bs, bits); /* white span */
span = find0span(bp, (int32_t)bs, (int32_t)bits); /* white span */
if (!putspan(tif, span, TIFFFaxWhiteCodes))
return 0;
bs += span;
bs += (uint32_t)span;
if (bs >= bits)
break;
span = find1span(bp, bs, bits); /* black span */
span = find1span(bp, (int32_t)bs, (int32_t)bits); /* black span */
if (!putspan(tif, span, TIFFFaxBlackCodes))
return 0;
bs += span;
bs += (uint32_t)span;
if (bs >= bits)
break;
}
@@ -1161,15 +1168,20 @@ static const tableentry vcodes[7] = {
static int Fax3Encode2DRow(TIFF *tif, unsigned char *bp, unsigned char *rp,
uint32_t bits)
{
#define PIXEL(buf, ix) ((((buf)[(ix) >> 3]) >> (7 - ((ix)&7))) & 1)
#define PIXEL(buf, ix) ((((buf)[(ix) >> 3]) >> (7 - ((ix) & 7))) & 1)
uint32_t a0 = 0;
uint32_t a1 = (PIXEL(bp, 0) != 0 ? 0 : finddiff(bp, 0, bits, 0));
uint32_t b1 = (PIXEL(rp, 0) != 0 ? 0 : finddiff(rp, 0, bits, 0));
uint32_t a1 = (PIXEL(bp, 0) != 0
? 0
: (uint32_t)finddiff(bp, (int32_t)0, (int32_t)bits, 0));
uint32_t b1 = (PIXEL(rp, 0) != 0
? 0
: (uint32_t)finddiff(rp, (int32_t)0, (int32_t)bits, 0));
uint32_t a2, b2;
for (;;)
{
b2 = finddiff2(rp, b1, bits, PIXEL(rp, b1));
b2 = (uint32_t)finddiff2(rp, (int32_t)b1, (int32_t)bits,
(int32_t)PIXEL(rp, b1));
if (b2 >= a1)
{
/* Naive computation triggers
@@ -1182,21 +1194,22 @@ static int Fax3Encode2DRow(TIFF *tif, unsigned char *bp, unsigned char *rp,
: 0x7FFFFFFF;
if (!(-3 <= d && d <= 3))
{ /* horizontal mode */
a2 = finddiff2(bp, a1, bits, PIXEL(bp, a1));
a2 = (uint32_t)finddiff2(bp, (int32_t)a1, (int32_t)bits,
(int32_t)PIXEL(bp, a1));
if (!putcode(tif, &horizcode))
return 0;
if (a0 + a1 == 0 || PIXEL(bp, a0) == 0)
{
if (!putspan(tif, a1 - a0, TIFFFaxWhiteCodes))
if (!putspan(tif, (int32_t)(a1 - a0), TIFFFaxWhiteCodes))
return 0;
if (!putspan(tif, a2 - a1, TIFFFaxBlackCodes))
if (!putspan(tif, (int32_t)(a2 - a1), TIFFFaxBlackCodes))
return 0;
}
else
{
if (!putspan(tif, a1 - a0, TIFFFaxBlackCodes))
if (!putspan(tif, (int32_t)(a1 - a0), TIFFFaxBlackCodes))
return 0;
if (!putspan(tif, a2 - a1, TIFFFaxWhiteCodes))
if (!putspan(tif, (int32_t)(a2 - a1), TIFFFaxWhiteCodes))
return 0;
}
a0 = a2;
@@ -1216,9 +1229,12 @@ static int Fax3Encode2DRow(TIFF *tif, unsigned char *bp, unsigned char *rp,
}
if (a0 >= bits)
break;
a1 = finddiff(bp, a0, bits, PIXEL(bp, a0));
b1 = finddiff(rp, a0, bits, !PIXEL(bp, a0));
b1 = finddiff(rp, b1, bits, PIXEL(bp, a0));
a1 = (uint32_t)finddiff(bp, (int32_t)a0, (int32_t)bits,
(int32_t)PIXEL(bp, a0));
b1 = (uint32_t)finddiff(rp, (int32_t)a0, (int32_t)bits,
(int32_t)!PIXEL(bp, a0));
b1 = (uint32_t)finddiff(rp, (int32_t)b1, (int32_t)bits,
(int32_t)PIXEL(bp, a0));
}
return (1);
#undef PIXEL
@@ -1487,6 +1503,8 @@ static void Fax3PrintDir(TIFF *tif, FILE *fd, long flags)
case CLEANFAXDATA_UNCLEAN:
fprintf(fd, " uncorrected errors");
break;
default:
break;
}
fprintf(fd, " (%" PRIu16 " = 0x%" PRIx16 ")\n", sp->cleanfaxdata,
sp->cleanfaxdata);
@@ -1500,6 +1518,22 @@ static void Fax3PrintDir(TIFF *tif, FILE *fd, long flags)
(*sp->printdir)(tif, fd, flags);
}
static uint64_t Fax3GetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* 1024x1024: 36 */
/* 4096x4096: 100 */
/* 16383x16383: 163 */
/* 65536x65536: 200 */
/* 200000x200000: 208 */
return 250;
}
static int InitCCITTFax3(TIFF *tif)
{
static const char module[] = "InitCCITTFax3";
@@ -1564,6 +1598,7 @@ static int InitCCITTFax3(TIFF *tif)
tif->tif_encodetile = Fax3Encode;
tif->tif_close = Fax3Close;
tif->tif_cleanup = Fax3Cleanup;
tif->tif_getmaxcompressionratio = Fax3GetMaxCompressionRatio;
return (1);
}
@@ -1626,10 +1661,10 @@ static int Fax4Decode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
RunLength = 0;
pa = thisrun = sp->curruns;
pb = sp->refruns;
b1 = *pb++;
b1 = (int)*pb++;
#ifdef FAX3_DEBUG
printf("\nBitAcc=%08" PRIX32 ", BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %d\n", tif->tif_row);
printf("-------------------- %d\n", tif->tif_dir.td_row);
fflush(stdout);
#endif
EXPAND2D(EOFG4);
@@ -1643,7 +1678,7 @@ static int Fax4Decode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
occ, lastx);
return -1;
}
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
SETVALUE(0); /* imaginary change for reference */
SWAP(uint32_t *, sp->curruns, sp->refruns);
buf += sp->b.rowbytes;
@@ -1666,7 +1701,7 @@ static int Fax4Decode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
occ, lastx);
return -1;
}
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
UNCACHE_STATE(tif, sp);
return (sp->line != start
? 1
@@ -1713,6 +1748,16 @@ static int Fax4PostEncode(TIFF *tif)
return (1);
}
static uint64_t Fax4GetMaxCompressionRatio(TIFF *tif)
{
/* FAX4 can compress up to almost one byte per line, so the compression
* ratio can be up to the tile/strip width.
* See README_for_libtiff_developpers.md for raw data
*/
return isTiled(tif) ? tif->tif_dir.td_tilewidth
: tif->tif_dir.td_imagewidth;
}
int TIFFInitCCITTFax4(TIFF *tif, int scheme)
{
(void)scheme;
@@ -1735,6 +1780,7 @@ int TIFFInitCCITTFax4(TIFF *tif, int scheme)
tif->tif_encodestrip = Fax4Encode;
tif->tif_encodetile = Fax4Encode;
tif->tif_postencode = Fax4PostEncode;
tif->tif_getmaxcompressionratio = Fax4GetMaxCompressionRatio;
/*
* Suppress RTC at the end of each strip.
*/
@@ -1773,11 +1819,11 @@ static int Fax3DecodeRLE(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
pa = thisrun;
#ifdef FAX3_DEBUG
printf("\nBitAcc=%08" PRIX32 ", BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %" PRIu32 "\n", tif->tif_row);
printf("-------------------- %" PRIu32 "\n", tif->tif_dir.td_row);
fflush(stdout);
#endif
EXPAND1D(EOFRLE);
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
/*
* Cleanup at the end of the row.
*/
@@ -1798,7 +1844,7 @@ static int Fax3DecodeRLE(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
sp->line++;
continue;
EOFRLE: /* premature EOF */
(*sp->fill)(buf, thisrun, pa, lastx);
(*sp->fill)(buf, thisrun, pa, (uint32_t)lastx);
UNCACHE_STATE(tif, sp);
return (-1);
}
@@ -1806,6 +1852,21 @@ static int Fax3DecodeRLE(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
return (1);
}
static uint64_t Fax3RLEGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* 1024x1024: 43 */
/* 4096x4096: 128 */
/* 16383x16383: 171 */
/* 65536x65536: 205 */
/* 200000x200000: 211 */
return 250;
}
int TIFFInitCCITTRLE(TIFF *tif, int scheme)
{
(void)scheme;
@@ -1814,6 +1875,7 @@ int TIFFInitCCITTRLE(TIFF *tif, int scheme)
tif->tif_decoderow = Fax3DecodeRLE;
tif->tif_decodestrip = Fax3DecodeRLE;
tif->tif_decodetile = Fax3DecodeRLE;
tif->tif_getmaxcompressionratio = Fax3RLEGetMaxCompressionRatio;
/*
* Suppress RTC+EOLs when encoding and byte-align data.
*/
@@ -1832,6 +1894,7 @@ int TIFFInitCCITTRLEW(TIFF *tif, int scheme)
tif->tif_decoderow = Fax3DecodeRLE;
tif->tif_decodestrip = Fax3DecodeRLE;
tif->tif_decodetile = Fax3DecodeRLE;
tif->tif_getmaxcompressionratio = Fax3RLEGetMaxCompressionRatio;
/*
* Suppress RTC+EOLs when encoding and word-align data.
*/

138
3rdparty/libtiff/tif_fax3.h vendored
View File

@@ -267,14 +267,14 @@ static const char *StateNames[] = {
{ \
if (pa >= thisrun + sp->nruns) \
{ \
TIFFErrorExtR(tif, module, "Buffer overflow at line %u of %s %u", \
TIFFErrorExtR(tif, module, "Buffer overflow at line %d of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
*pa++ = RunLength + (x); \
a0 += (x); \
*pa++ = (uint32_t)((uint32_t)RunLength + (uint32_t)(x)); \
a0 += (int)(uint32_t)(x); \
RunLength = 0; \
} while (0)
#endif
@@ -334,20 +334,20 @@ static const char *StateNames[] = {
{ \
if (RunLength) \
SETVALUE(0); \
if (a0 != lastx) \
if (a0 != (int)lastx) \
{ \
badlength(a0, lastx); \
while (a0 > lastx && pa > thisrun) \
a0 -= *--pa; \
if (a0 < lastx) \
while (a0 > (int)lastx && pa > thisrun) \
a0 -= (int)*--pa; \
if (a0 < (int)lastx) \
{ \
if (a0 < 0) \
a0 = 0; \
if ((pa - thisrun) & 1) \
SETVALUE(0); \
SETVALUE(lastx - a0); \
SETVALUE((uint32_t)((int)lastx - a0)); \
} \
else if (a0 > lastx) \
else if (a0 > (int)lastx) \
{ \
SETVALUE(lastx); \
SETVALUE(0); \
@@ -385,8 +385,9 @@ static const char *StateNames[] = {
goto doneWhite1d; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 = (int)((uint32_t)a0 + TabEnt->Param); \
RunLength = \
(int)((uint32_t)RunLength + TabEnt->Param); \
break; \
default: \
unexpected("WhiteTable", a0); \
@@ -394,7 +395,7 @@ static const char *StateNames[] = {
} \
} \
doneWhite1d: \
if (a0 >= lastx) \
if (a0 >= (int)lastx) \
goto done1d; \
for (;;) \
{ \
@@ -409,8 +410,8 @@ static const char *StateNames[] = {
goto doneBlack1d; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 += (int)TabEnt->Param; \
RunLength += (int)TabEnt->Param; \
break; \
default: \
unexpected("BlackTable", a0); \
@@ -418,7 +419,7 @@ static const char *StateNames[] = {
} \
} \
doneBlack1d: \
if (a0 >= lastx) \
if (a0 >= (int)lastx) \
goto done1d; \
if (*(pa - 1) == 0 && *(pa - 2) == 0) \
pa -= 2; \
@@ -439,17 +440,18 @@ static const char *StateNames[] = {
do \
{ \
if (pa != thisrun) \
while (b1 <= a0 && b1 < lastx) \
while (b1 <= a0 && b1 < (int)lastx) \
{ \
if (pb + 1 >= sp->refruns + sp->nruns) \
{ \
TIFFErrorExtR( \
tif, module, "Buffer overflow at line %u of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
TIFFErrorExtR(tif, module, \
"Buffer overflow at line %d of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
b1 += pb[0] + pb[1]; \
b1 += (int)(pb[0] + pb[1]); \
pb += 2; \
} \
} while (0)
@@ -460,14 +462,15 @@ static const char *StateNames[] = {
#define EXPAND2D(eoflab) \
do \
{ \
while (a0 < lastx) \
while (a0 < (int)lastx) \
{ \
if (pa >= thisrun + sp->nruns) \
{ \
TIFFErrorExtR( \
tif, module, "Buffer overflow at line %u of %s %u", \
sp->line, isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip); \
TIFFErrorExtR(tif, module, \
"Buffer overflow at line %d of %s %u", sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
LOOKUP8(7, TIFFFaxMainTable, eof2d); \
@@ -477,18 +480,19 @@ static const char *StateNames[] = {
CHECK_b1; \
if (pb + 1 >= sp->refruns + sp->nruns) \
{ \
TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
TIFFErrorExtR( \
tif, module, \
"Buffer overflow at line %d of %s %u", sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
b1 += *pb++; \
RunLength += b1 - a0; \
b1 = b1 + (int)*pb++; \
RunLength = \
(int)((uint32_t)RunLength + (uint32_t)(b1 - a0)); \
a0 = b1; \
b1 += *pb++; \
b1 = b1 + (int)*pb++; \
break; \
case S_Horiz: \
if ((pa - thisrun) & 1) \
@@ -503,8 +507,9 @@ static const char *StateNames[] = {
goto doneWhite2da; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 = (int)((uint32_t)a0 + TabEnt->Param); \
RunLength = (int)((uint32_t)RunLength + \
TabEnt->Param); \
break; \
default: \
goto badBlack2d; \
@@ -521,8 +526,9 @@ static const char *StateNames[] = {
goto doneBlack2da; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 = (int)((uint32_t)a0 + TabEnt->Param); \
RunLength = (int)((uint32_t)RunLength + \
TabEnt->Param); \
break; \
default: \
goto badWhite2d; \
@@ -542,8 +548,9 @@ static const char *StateNames[] = {
goto doneWhite2db; \
case S_MakeUpW: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 = (int)((uint32_t)a0 + TabEnt->Param); \
RunLength = (int)((uint32_t)RunLength + \
TabEnt->Param); \
break; \
default: \
goto badWhite2d; \
@@ -560,8 +567,9 @@ static const char *StateNames[] = {
goto doneBlack2db; \
case S_MakeUpB: \
case S_MakeUp: \
a0 += TabEnt->Param; \
RunLength += TabEnt->Param; \
a0 = (int)((uint32_t)a0 + TabEnt->Param); \
RunLength = (int)((uint32_t)RunLength + \
TabEnt->Param); \
break; \
default: \
goto badBlack2d; \
@@ -576,47 +584,47 @@ static const char *StateNames[] = {
SETVALUE(b1 - a0); \
if (pb >= sp->refruns + sp->nruns) \
{ \
TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
TIFFErrorExtR( \
tif, module, \
"Buffer overflow at line %d of %s %u", sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
b1 += *pb++; \
b1 = b1 + (int)*pb++; \
break; \
case S_VR: \
CHECK_b1; \
SETVALUE(b1 - a0 + TabEnt->Param); \
SETVALUE((int)((uint32_t)(b1 - a0) + TabEnt->Param)); \
if (pb >= sp->refruns + sp->nruns) \
{ \
TIFFErrorExtR(tif, module, \
"Buffer overflow at line %u of %s %u", \
sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_curtile \
: tif->tif_curstrip); \
TIFFErrorExtR( \
tif, module, \
"Buffer overflow at line %d of %s %u", sp->line, \
isTiled(tif) ? "tile" : "strip", \
isTiled(tif) ? tif->tif_dir.td_curtile \
: tif->tif_dir.td_curstrip); \
return (-1); \
} \
b1 += *pb++; \
b1 = b1 + (int)*pb++; \
break; \
case S_VL: \
CHECK_b1; \
if (b1 < (int)(a0 + TabEnt->Param)) \
if (b1 < (int)((uint32_t)a0 + TabEnt->Param)) \
{ \
unexpected("VL", a0); \
goto eol2d; \
} \
SETVALUE(b1 - a0 - TabEnt->Param); \
b1 -= *--pb; \
SETVALUE((int)((uint32_t)(b1 - a0) - TabEnt->Param)); \
b1 = b1 - (int)*--pb; \
break; \
case S_Ext: \
*pa++ = lastx - a0; \
*pa++ = (uint32_t)((int)lastx - a0); \
extension(a0); \
goto eol2d; \
case S_EOL: \
*pa++ = lastx - a0; \
*pa++ = (uint32_t)((int)lastx - a0); \
NeedBits8(4, eof2d); \
if (GetBits(4)) \
unexpected("EOL", a0); \

432
3rdparty/libtiff/tif_getimage.c vendored
View File

File diff suppressed because it is too large Load Diff

43
3rdparty/libtiff/tif_hash_set.c vendored
View File

@@ -76,7 +76,7 @@ static const int anPrimes[] = {
100663319, 201326611, 402653189, 805306457, 1610612741};
/************************************************************************/
/* TIFFHashSetHashPointer() */
/* TIFFHashSetHashPointer() */
/************************************************************************/
/**
@@ -93,7 +93,7 @@ static unsigned long TIFFHashSetHashPointer(const void *elt)
}
/************************************************************************/
/* TIFFHashSetEqualPointer() */
/* TIFFHashSetEqualPointer() */
/************************************************************************/
/**
@@ -111,7 +111,7 @@ static bool TIFFHashSetEqualPointer(const void *elt1, const void *elt2)
}
/************************************************************************/
/* TIFFHashSetNew() */
/* TIFFHashSetNew() */
/************************************************************************/
/**
@@ -164,7 +164,7 @@ TIFFHashSet *TIFFHashSetNew(TIFFHashSetHashFunc fnHashFunc,
}
/************************************************************************/
/* TIFFHashSetSize() */
/* TIFFHashSetSize() */
/************************************************************************/
/**
@@ -184,7 +184,7 @@ int TIFFHashSetSize(const TIFFHashSet *set)
}
/************************************************************************/
/* TIFFHashSetGetNewListElt() */
/* TIFFHashSetGetNewListElt() */
/************************************************************************/
static TIFFList *TIFFHashSetGetNewListElt(TIFFHashSet *set)
@@ -202,7 +202,7 @@ static TIFFList *TIFFHashSetGetNewListElt(TIFFHashSet *set)
}
/************************************************************************/
/* TIFFHashSetReturnListElt() */
/* TIFFHashSetReturnListElt() */
/************************************************************************/
static void TIFFHashSetReturnListElt(TIFFHashSet *set, TIFFList *psList)
@@ -220,7 +220,7 @@ static void TIFFHashSetReturnListElt(TIFFHashSet *set, TIFFList *psList)
}
/************************************************************************/
/* TIFFHashSetClearInternal() */
/* TIFFHashSetClearInternal() */
/************************************************************************/
static void TIFFHashSetClearInternal(TIFFHashSet *set, bool bFinalize)
@@ -246,7 +246,7 @@ static void TIFFHashSetClearInternal(TIFFHashSet *set, bool bFinalize)
}
/************************************************************************/
/* TIFFListDestroy() */
/* TIFFListDestroy() */
/************************************************************************/
/**
@@ -270,7 +270,7 @@ static void TIFFListDestroy(TIFFList *psList)
}
/************************************************************************/
/* TIFFHashSetDestroy() */
/* TIFFHashSetDestroy() */
/************************************************************************/
/**
@@ -295,7 +295,7 @@ void TIFFHashSetDestroy(TIFFHashSet *set)
#ifdef notused
/************************************************************************/
/* TIFFHashSetClear() */
/* TIFFHashSetClear() */
/************************************************************************/
/**
@@ -319,7 +319,7 @@ void TIFFHashSetClear(TIFFHashSet *set)
}
/************************************************************************/
/* TIFFHashSetForeach() */
/* TIFFHashSetForeach() */
/************************************************************************/
/**
@@ -360,14 +360,14 @@ void TIFFHashSetForeach(TIFFHashSet *set, TIFFHashSetIterEltFunc fnIterFunc,
#endif
/************************************************************************/
/* TIFFHashSetRehash() */
/* TIFFHashSetRehash() */
/************************************************************************/
static bool TIFFHashSetRehash(TIFFHashSet *set)
{
int nNewAllocatedSize = anPrimes[set->nIndiceAllocatedSize];
TIFFList **newTabList =
(TIFFList **)(calloc(nNewAllocatedSize, sizeof(TIFFList *)));
(TIFFList **)(calloc((size_t)nNewAllocatedSize, sizeof(TIFFList *)));
if (newTabList == NULL)
return false;
#ifdef HASH_DEBUG
@@ -384,7 +384,7 @@ static bool TIFFHashSetRehash(TIFFHashSet *set)
while (cur)
{
const unsigned long nNewHashVal =
set->fnHashFunc(cur->pData) % nNewAllocatedSize;
set->fnHashFunc(cur->pData) % (unsigned long)nNewAllocatedSize;
#ifdef HASH_DEBUG
if (newTabList[nNewHashVal])
set->nCollisions++;
@@ -403,12 +403,13 @@ static bool TIFFHashSetRehash(TIFFHashSet *set)
}
/************************************************************************/
/* TIFFHashSetFindPtr() */
/* TIFFHashSetFindPtr() */
/************************************************************************/
static void **TIFFHashSetFindPtr(TIFFHashSet *set, const void *elt)
{
const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
const unsigned long nHashVal =
set->fnHashFunc(elt) % (unsigned long)set->nAllocatedSize;
TIFFList *cur = set->tabList[nHashVal];
while (cur)
{
@@ -464,7 +465,8 @@ bool TIFFHashSetInsert(TIFFHashSet *set, void *elt)
}
}
const unsigned long nHashVal = set->fnHashFunc(elt) % set->nAllocatedSize;
const unsigned long nHashVal =
set->fnHashFunc(elt) % (unsigned long)set->nAllocatedSize;
#ifdef HASH_DEBUG
if (set->tabList[nHashVal])
set->nCollisions++;
@@ -486,7 +488,7 @@ bool TIFFHashSetInsert(TIFFHashSet *set, void *elt)
}
/************************************************************************/
/* TIFFHashSetLookup() */
/* TIFFHashSetLookup() */
/************************************************************************/
/**
@@ -532,7 +534,8 @@ static bool TIFFHashSetRemoveInternal(TIFFHashSet *set, const void *elt,
}
}
int nHashVal = (int)(set->fnHashFunc(elt) % set->nAllocatedSize);
int nHashVal =
(int)(set->fnHashFunc(elt) % (unsigned long)set->nAllocatedSize);
TIFFList *cur = set->tabList[nHashVal];
TIFFList *prev = NULL;
while (cur)
@@ -581,7 +584,7 @@ bool TIFFHashSetRemove(TIFFHashSet *set, const void *elt)
#ifdef notused
/************************************************************************/
/* TIFFHashSetRemoveDeferRehash() */
/* TIFFHashSetRemoveDeferRehash() */
/************************************************************************/
/**

11
3rdparty/libtiff/tif_jbig.c vendored
View File

@@ -33,7 +33,14 @@
#include "tiffiop.h"
#ifdef JBIG_SUPPORT
#ifdef __cplusplus
extern "C"
{
#endif
#include "jbig.h"
#ifdef __cplusplus
}
#endif
static int JBIGSetupDecode(TIFF *tif)
{
@@ -100,7 +107,7 @@ static int JBIGDecode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
decodedSize = jbg_dec_getsize(&decoder);
if ((tmsize_t)decodedSize < size)
{
memset(buffer + decodedSize, 0, (size_t)(size - decodedSize));
memset(buffer + decodedSize, 0, (size_t)(size - (tmsize_t)decodedSize));
TIFFWarningExtR(tif, "JBIG",
"Only decoded %lu bytes, whereas %" TIFF_SSIZE_FORMAT
" requested",
@@ -116,7 +123,7 @@ static int JBIGDecode(TIFF *tif, uint8_t *buffer, tmsize_t size, uint16_t s)
return 0;
}
pImage = jbg_dec_getimage(&decoder, 0);
_TIFFmemcpy(buffer, pImage, decodedSize);
_TIFFmemcpy(buffer, pImage, (tmsize_t)decodedSize);
jbg_dec_free(&decoder);
tif->tif_rawcp += tif->tif_rawcc;

392
3rdparty/libtiff/tif_jpeg.c vendored
View File

@@ -22,9 +22,6 @@
* OF THIS SOFTWARE.
*/
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#include "tiffiop.h"
#include <stdlib.h>
@@ -146,20 +143,9 @@ int TIFFJPEGIsFullStripRequired_12(TIFF *tif);
#define LONGJMP(jbuf, code) longjmp(jbuf, code)
#define JMP_BUF jmp_buf
#ifndef TIFF_jpeg_destination_mgr_defined
#define TIFF_jpeg_destination_mgr_defined
typedef struct jpeg_destination_mgr jpeg_destination_mgr;
#endif
#ifndef TIFF_jpeg_source_mgr_defined
#define TIFF_jpeg_source_mgr_defined
typedef struct jpeg_source_mgr jpeg_source_mgr;
#endif
#ifndef TIFF_jpeg_error_mgr_defined
#define TIFF_jpeg_error_mgr_defined
typedef struct jpeg_error_mgr jpeg_error_mgr;
#endif
typedef struct jpeg_destination_mgr tiff_jpeg_destination_mgr;
typedef struct jpeg_source_mgr tiff_jpeg_source_mgr;
typedef struct jpeg_error_mgr tiff_jpeg_error_mgr;
/*
* State block for each open TIFF file using
@@ -174,6 +160,10 @@ typedef struct jpeg_error_mgr jpeg_error_mgr;
* so we can safely cast JPEGState* -> jpeg_xxx_struct*
* and vice versa!
*/
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4324) /* structure padding due to alignment */
#endif
typedef struct
{
union
@@ -184,22 +174,24 @@ typedef struct
} cinfo; /* NB: must be first */
int cinfo_initialized;
jpeg_error_mgr err; /* libjpeg error manager */
JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
tiff_jpeg_error_mgr err; /* libjpeg error manager */
JMP_BUF exit_jmpbuf; /* for catching libjpeg failures */
struct jpeg_progress_mgr progress;
/*
* The following two members could be a union, but
* they're small enough that it's not worth the effort.
*/
jpeg_destination_mgr dest; /* data dest for compression */
jpeg_source_mgr src; /* data source for decompression */
/* private state */
TIFF *tif; /* back link needed by some code */
uint16_t photometric; /* copy of PhotometricInterpretation */
uint16_t h_sampling; /* luminance sampling factors */
tiff_jpeg_destination_mgr dest; /* data dest for compression */
tiff_jpeg_source_mgr src; /* data source for decompression */
/* private state */
TIFF *tif; /* back link needed by some code */
uint16_t photometric; /* copy of PhotometricInterpretation */
uint16_t h_sampling; /* luminance sampling factors */
uint16_t v_sampling;
tmsize_t bytesperline; /* decompressed bytes per scanline */
uint32_t strile_width;
uint32_t strile_height;
/* pointers to intermediate buffers when processing downsampled data */
TIFF_JSAMPARRAY ds_buffer[MAX_COMPONENTS];
int scancount; /* number of "scanlines" accumulated */
@@ -209,6 +201,9 @@ typedef struct
int encode_raw_error;
} JPEGState;
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#define JState(tif) ((JPEGState *)(tif)->tif_data)
@@ -559,7 +554,7 @@ static boolean tables_empty_output_buffer(j_compress_ptr cinfo)
/* the entire buffer has been filled; enlarge it by 1000 bytes */
newbuf =
_TIFFreallocExt(sp->tif, (void *)sp->otherSettings.jpegtables,
(tmsize_t)(sp->otherSettings.jpegtables_length + 1000));
(tmsize_t)sp->otherSettings.jpegtables_length + 1000);
if (newbuf == NULL)
ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, 100);
sp->dest.next_output_byte =
@@ -912,7 +907,7 @@ JPEGFixupTagsSubsamplingSec(struct JPEGFixupTagsSubsamplingData *data)
return (0);
if (n < 2)
return (0);
n -= 2;
n = (uint16_t)(n - 2);
if (n > 0)
JPEGFixupTagsSubsamplingSkip(data, n);
}
@@ -1016,7 +1011,7 @@ JPEGFixupTagsSubsamplingReadByte(struct JPEGFixupTagsSubsamplingData *data,
assert(m < 0x80000000UL);
if (TIFFReadFile(data->tif, data->buffer, (tmsize_t)m) != (tmsize_t)m)
return (0);
data->buffercurrentbyte = data->buffer;
data->buffercurrentbyte = (uint8_t *)data->buffer;
data->bufferbytesleft = m;
data->fileoffset += m;
data->filebytesleft -= m;
@@ -1037,7 +1032,7 @@ JPEGFixupTagsSubsamplingReadWord(struct JPEGFixupTagsSubsamplingData *data,
return (0);
if (!JPEGFixupTagsSubsamplingReadByte(data, &mb))
return (0);
*result = (ma << 8) | mb;
*result = (uint16_t)((ma << 8) | mb);
return (1);
}
@@ -1159,6 +1154,47 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
return ret;
}
static int JPEGComputeStrileWidthHeightBytesPerLine(TIFF *tif, uint16_t s)
{
JPEGState *sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
/*
* Check image parameters and set decompression parameters.
*/
if (isTiled(tif))
{
sp->strile_width = td->td_tilewidth;
sp->strile_height = td->td_tilelength;
sp->bytesperline = TIFFTileRowSize(tif);
}
else
{
sp->strile_width = td->td_imagewidth;
sp->strile_height = td->td_imagelength - tif->tif_dir.td_row;
if (sp->strile_height > td->td_rowsperstrip)
sp->strile_height = td->td_rowsperstrip;
sp->bytesperline = TIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0)
{
/*
* For PC 2, scale down the expected strip/tile size
* to match a downsampled component
*/
if (sp->h_sampling == 0 || sp->v_sampling == 0)
{
TIFFErrorExtR(tif, "JPEGComputeStrileWidthHeightBytesPerLine",
"JPEG horizontal or vertical sampling is zero");
return (0);
}
sp->strile_width = TIFFhowmany_32(sp->strile_width, sp->h_sampling);
sp->strile_height = TIFFhowmany_32(sp->strile_height, sp->v_sampling);
}
return 1;
}
/*
* Set up for decoding a strip or tile.
*/
@@ -1167,7 +1203,6 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
JPEGState *sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
static const char module[] = "JPEGPreDecode";
uint32_t segment_width, segment_height;
int downsampled_output;
int ci;
@@ -1193,52 +1228,24 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
return (0);
tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
tif->tif_rawcc = sp->src.bytes_in_buffer;
tif->tif_rawcc = (tmsize_t)sp->src.bytes_in_buffer;
/*
* Check image parameters and set decompression parameters.
*/
if (isTiled(tif))
{
segment_width = td->td_tilewidth;
segment_height = td->td_tilelength;
sp->bytesperline = TIFFTileRowSize(tif);
}
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
sp->bytesperline = TIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0)
{
/*
* For PC 2, scale down the expected strip/tile size
* to match a downsampled component
*/
if (sp->h_sampling == 0 || sp->v_sampling == 0)
{
TIFFErrorExtR(tif, module,
"JPEG horizontal or vertical sampling is zero");
return (0);
}
segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
}
if (sp->cinfo.d.image_width < segment_width ||
sp->cinfo.d.image_height < segment_height)
if (!JPEGComputeStrileWidthHeightBytesPerLine(tif, s))
return 0;
if (sp->cinfo.d.image_width < sp->strile_width ||
sp->cinfo.d.image_height < sp->strile_height)
{
TIFFWarningExtR(tif, module,
"Improper JPEG strip/tile size, "
"expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
segment_width, segment_height, sp->cinfo.d.image_width,
sp->cinfo.d.image_height);
sp->strile_width, sp->strile_height,
sp->cinfo.d.image_width, sp->cinfo.d.image_height);
}
if (sp->cinfo.d.image_width == segment_width &&
sp->cinfo.d.image_height > segment_height &&
tif->tif_row + segment_height == td->td_imagelength && !isTiled(tif))
if (sp->cinfo.d.image_width == sp->strile_width &&
sp->cinfo.d.image_height > sp->strile_height &&
tif->tif_dir.td_row + sp->strile_height == td->td_imagelength &&
!isTiled(tif))
{
/* Some files have a last strip, that should be truncated, */
/* but their JPEG codestream has still the maximum strip */
@@ -1247,11 +1254,11 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
TIFFWarningExtR(tif, module,
"JPEG strip size exceeds expected dimensions,"
" expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
segment_width, segment_height, sp->cinfo.d.image_width,
sp->cinfo.d.image_height);
sp->strile_width, sp->strile_height,
sp->cinfo.d.image_width, sp->cinfo.d.image_height);
}
else if (sp->cinfo.d.image_width > segment_width ||
sp->cinfo.d.image_height > segment_height)
else if (sp->cinfo.d.image_width > sp->strile_width ||
sp->cinfo.d.image_height > sp->strile_height)
{
/*
* This case could be dangerous, if the strip or tile size has
@@ -1262,8 +1269,8 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
TIFFErrorExtR(tif, module,
"JPEG strip/tile size exceeds expected dimensions,"
" expected %" PRIu32 "x%" PRIu32 ", got %ux%u",
segment_width, segment_height, sp->cinfo.d.image_width,
sp->cinfo.d.image_height);
sp->strile_width, sp->strile_height,
sp->cinfo.d.image_width, sp->cinfo.d.image_height);
return (0);
}
if (sp->cinfo.d.num_components !=
@@ -1282,7 +1289,8 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
sp->cinfo.d.data_precision = td->td_bitspersample;
sp->cinfo.d.bits_in_jsample = td->td_bitspersample;
#else
if (sp->cinfo.d.data_precision != td->td_bitspersample)
if (td->td_bitspersample != BITS_IN_JSAMPLE ||
sp->cinfo.d.data_precision != td->td_bitspersample)
{
TIFFErrorExtR(tif, module, "Improper JPEG data precision");
return (0);
@@ -1319,11 +1327,12 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
if (compptr->h_samp_factor > 0 && compptr->v_samp_factor > 0)
{
nRequiredMemory +=
(toff_t)(((compptr->width_in_blocks +
compptr->h_samp_factor - 1) /
compptr->h_samp_factor)) *
((compptr->height_in_blocks + compptr->v_samp_factor - 1) /
compptr->v_samp_factor) *
(toff_t)((JDIMENSION)(((int)compptr->width_in_blocks +
compptr->h_samp_factor - 1) /
compptr->h_samp_factor)) *
(JDIMENSION)(((int)compptr->height_in_blocks +
compptr->v_samp_factor - 1) /
compptr->v_samp_factor) *
sizeof(JBLOCK);
}
}
@@ -1439,7 +1448,7 @@ int TIFFJPEGIsFullStripRequired(TIFF *tif)
* Decode a chunk of pixels.
* "Standard" case: returned data is not downsampled.
*/
#if !JPEG_LIB_MK1_OR_12BIT
#if !defined(JPEG_LIB_MK1_OR_12BIT)
static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
{
JPEGState *sp = JState(tif);
@@ -1464,7 +1473,18 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
TIFFWarningExtR(tif, tif->tif_name, "fractional scanline not read");
if (nrows > (tmsize_t)sp->cinfo.d.image_height)
{
/* Initialize the output buffer if the JPEG image is smaller than the
* strile height. */
memset(buf, 0, (size_t)cc);
nrows = sp->cinfo.d.image_height;
}
else if (sp->strile_width > sp->cinfo.d.image_width)
{
/* Initialize the output buffer if the JPEG image is smaller than the
* strile width. */
memset(buf, 0, (size_t)cc);
}
/* data is expected to be read in multiples of a scanline */
if (nrows)
@@ -1483,7 +1503,7 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
return (0);
}
++tif->tif_row;
++tif->tif_dir.td_row;
buf += sp->bytesperline;
cc -= sp->bytesperline;
} while (--nrows > 0);
@@ -1491,15 +1511,15 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
/* Update information on consumed data */
tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
tif->tif_rawcc = sp->src.bytes_in_buffer;
tif->tif_rawcc = (tmsize_t)sp->src.bytes_in_buffer;
/* Close down the decompressor if we've finished the strip or tile. */
return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height ||
TIFFjpeg_finish_decompress(sp);
}
#endif /* !JPEG_LIB_MK1_OR_12BIT */
#endif /* !defined(JPEG_LIB_MK1_OR_12BIT) */
#if JPEG_LIB_MK1_OR_12BIT
#if defined(JPEG_LIB_MK1_OR_12BIT)
/*ARGSUSED*/ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc,
uint16_t s)
{
@@ -1525,7 +1545,18 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
TIFFWarningExtR(tif, tif->tif_name, "fractional scanline not read");
if (nrows > (tmsize_t)sp->cinfo.d.image_height)
{
/* Initialize the output buffer if the JPEG image is smaller than the
* strile height. */
memset(buf, 0, (size_t)cc);
nrows = sp->cinfo.d.image_height;
}
else if (sp->strile_width > sp->cinfo.d.image_width)
{
/* Initialize the output buffer if the JPEG image is smaller than the
* strile width. */
memset(buf, 0, (size_t)cc);
}
/* data is expected to be read in multiples of a scanline */
if (nrows)
@@ -1539,8 +1570,9 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
if (sp->cinfo.d.data_precision == 12)
{
line_work_buf = (TIFF_JSAMPROW)_TIFFmallocExt(
tif, sizeof(short) * sp->cinfo.d.output_width *
sp->cinfo.d.num_components);
tif, (tmsize_t)((size_t)sizeof(short) *
(size_t)sp->cinfo.d.output_width *
(size_t)sp->cinfo.d.num_components));
}
do
@@ -1556,14 +1588,16 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
if (TIFFjpeg_read_scanlines(sp, &line_work_buf, 1) != 1)
{
memset(buf, 0, (size_t)cc);
_TIFFfreeExt(tif, line_work_buf);
return (0);
}
if (sp->cinfo.d.data_precision == 12)
{
int value_pairs = (sp->cinfo.d.output_width *
sp->cinfo.d.num_components) /
2;
int value_pairs =
(int)((JDIMENSION)sp->cinfo.d.output_width *
(JDIMENSION)sp->cinfo.d.num_components) /
2;
int iPair;
for (iPair = 0; iPair < value_pairs; iPair++)
@@ -1582,18 +1616,19 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
else if (sp->cinfo.d.data_precision == 8)
{
int value_count =
(sp->cinfo.d.output_width * sp->cinfo.d.num_components);
(int)((JDIMENSION)sp->cinfo.d.output_width *
(JDIMENSION)sp->cinfo.d.num_components);
int iValue;
for (iValue = 0; iValue < value_count; iValue++)
{
((unsigned char *)buf)[iValue] =
line_work_buf[iValue] & 0xff;
(unsigned char)(line_work_buf[iValue] & 0xff);
}
}
}
++tif->tif_row;
++tif->tif_dir.td_row;
buf += sp->bytesperline;
cc -= sp->bytesperline;
} while (--nrows > 0);
@@ -1604,13 +1639,13 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
/* Update information on consumed data */
tif->tif_rawcp = (uint8_t *)sp->src.next_input_byte;
tif->tif_rawcc = sp->src.bytes_in_buffer;
tif->tif_rawcc = (tmsize_t)sp->src.bytes_in_buffer;
/* Close down the decompressor if we've finished the strip or tile. */
return sp->cinfo.d.output_scanline < sp->cinfo.d.output_height ||
TIFFjpeg_finish_decompress(sp);
}
#endif /* JPEG_LIB_MK1_OR_12BIT */
#endif /* defined(JPEG_LIB_MK1_OR_12BIT) */
/*ARGSUSED*/ static int DecodeRowError(TIFF *tif, uint8_t *buf, tmsize_t cc,
uint16_t s)
@@ -1644,8 +1679,16 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
/* For last strip, limit number of rows to its truncated height */
/* even if the codestream height is larger (which is not compliant, */
/* but that we tolerate) */
if ((uint32_t)nrows > td->td_imagelength - tif->tif_row && !isTiled(tif))
nrows = td->td_imagelength - tif->tif_row;
if ((uint32_t)nrows > td->td_imagelength - tif->tif_dir.td_row &&
!isTiled(tif))
nrows = td->td_imagelength - tif->tif_dir.td_row;
/* The downsampled-data decode loop below only writes up to the JPEG
* codestream dimensions (and, due to the clump stride, may not cover the
* full caller buffer even for compliant files). Zero the whole buffer so
* no uninitialised heap is ever returned, mirroring the guard JPEGDecode
* received in 65759931ab6e (#826). */
memset(buf, 0, (size_t)cc);
#if defined(JPEG_LIB_MK1_OR_12BIT)
unsigned short *tmpbuf = NULL;
@@ -1660,9 +1703,10 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
int samples_per_clump = sp->samplesperclump;
#if defined(JPEG_LIB_MK1_OR_12BIT)
tmpbuf = _TIFFmallocExt(tif, sizeof(unsigned short) *
sp->cinfo.d.output_width *
sp->cinfo.d.num_components);
tmpbuf = (unsigned short *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)sizeof(unsigned short) *
(size_t)sp->cinfo.d.output_width *
(size_t)sp->cinfo.d.num_components));
if (tmpbuf == NULL)
{
TIFFErrorExtR(tif, "JPEGDecodeRaw", "Out of memory");
@@ -1755,18 +1799,20 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
if (sp->cinfo.d.data_precision == 8)
{
int i = 0;
int len =
sp->cinfo.d.output_width * sp->cinfo.d.num_components;
int len = (int)((JDIMENSION)sp->cinfo.d.output_width *
(JDIMENSION)sp->cinfo.d.num_components);
for (i = 0; i < len; i++)
{
((unsigned char *)buf)[i] = tmpbuf[i] & 0xff;
((unsigned char *)buf)[i] =
(unsigned char)(tmpbuf[i] & 0xff);
}
}
else
{ /* 12-bit */
int value_pairs = (sp->cinfo.d.output_width *
sp->cinfo.d.num_components) /
2;
int value_pairs =
(int)((JDIMENSION)sp->cinfo.d.output_width *
(JDIMENSION)sp->cinfo.d.num_components) /
2;
int iPair;
for (iPair = 0; iPair < value_pairs; iPair++)
{
@@ -1785,7 +1831,7 @@ static int JPEGDecode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
#endif
sp->scancount++;
tif->tif_row += sp->v_sampling;
tif->tif_dir.td_row += sp->v_sampling;
buf += sp->bytesperline;
cc -= sp->bytesperline;
@@ -2024,9 +2070,9 @@ static int JPEGSetupEncode(TIFF *tif)
if (!TIFFGetField(tif, TIFFTAG_REFERENCEBLACKWHITE, &ref))
{
float refbw[6];
long top = 1L << td->td_bitspersample;
uint32_t top = 1U << td->td_bitspersample;
refbw[0] = 0;
refbw[1] = (float)(top - 1L);
refbw[1] = (float)(top - 1);
refbw[2] = (float)(top >> 1);
refbw[3] = refbw[1];
refbw[4] = refbw[2];
@@ -2074,30 +2120,30 @@ static int JPEGSetupEncode(TIFF *tif)
#endif
if (isTiled(tif))
{
if ((td->td_tilelength % (sp->v_sampling * DCTSIZE)) != 0)
if ((td->td_tilelength % ((uint32_t)sp->v_sampling * DCTSIZE)) != 0)
{
TIFFErrorExtR(tif, module,
"JPEG tile height must be multiple of %" PRIu32,
(uint32_t)(sp->v_sampling * DCTSIZE));
(uint32_t)sp->v_sampling * DCTSIZE);
return (0);
}
if ((td->td_tilewidth % (sp->h_sampling * DCTSIZE)) != 0)
if ((td->td_tilewidth % ((uint32_t)sp->h_sampling * DCTSIZE)) != 0)
{
TIFFErrorExtR(tif, module,
"JPEG tile width must be multiple of %" PRIu32,
(uint32_t)(sp->h_sampling * DCTSIZE));
(uint32_t)sp->h_sampling * DCTSIZE);
return (0);
}
}
else
{
if (td->td_rowsperstrip < td->td_imagelength &&
(td->td_rowsperstrip % (sp->v_sampling * DCTSIZE)) != 0)
(td->td_rowsperstrip % ((uint32_t)sp->v_sampling * DCTSIZE)) != 0)
{
TIFFErrorExtR(tif, module,
"RowsPerStrip must be multiple of %" PRIu32
" for JPEG",
(uint32_t)(sp->v_sampling * DCTSIZE));
(uint32_t)sp->v_sampling * DCTSIZE);
return (0);
}
}
@@ -2153,7 +2199,6 @@ static int JPEGPreEncode(TIFF *tif, uint16_t s)
JPEGState *sp = JState(tif);
TIFFDirectory *td = &tif->tif_dir;
static const char module[] = "JPEGPreEncode";
uint32_t segment_width, segment_height;
int downsampled_input;
assert(sp != NULL);
@@ -2164,47 +2209,20 @@ static int JPEGPreEncode(TIFF *tif, uint16_t s)
}
assert(!sp->cinfo.comm.is_decompressor);
/*
* Set encoding parameters for this strip/tile.
*/
if (isTiled(tif))
{
segment_width = td->td_tilewidth;
segment_height = td->td_tilelength;
sp->bytesperline = TIFFTileRowSize(tif);
}
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
sp->bytesperline = TIFFScanlineSize(tif);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE && s > 0)
{
/* for PC 2, scale down the strip/tile size
* to match a downsampled component
*/
if (sp->h_sampling == 0 || sp->v_sampling == 0)
{
TIFFErrorExtR(tif, module,
"JPEG horizontal or vertical sampling is zero");
return (0);
}
segment_width = TIFFhowmany_32(segment_width, sp->h_sampling);
segment_height = TIFFhowmany_32(segment_height, sp->v_sampling);
}
if (segment_width > (uint32_t)JPEG_MAX_DIMENSION ||
segment_height > (uint32_t)JPEG_MAX_DIMENSION)
if (!JPEGComputeStrileWidthHeightBytesPerLine(tif, s))
return 0;
if (sp->strile_width > (uint32_t)JPEG_MAX_DIMENSION ||
sp->strile_height > (uint32_t)JPEG_MAX_DIMENSION)
{
TIFFErrorExtR(tif, module,
"Strip/tile too large for JPEG. Maximum dimension is %d",
(int)JPEG_MAX_DIMENSION);
return (0);
}
sp->cinfo.c.image_width = segment_width;
sp->cinfo.c.image_height = segment_height;
sp->cinfo.c.image_width = sp->strile_width;
sp->cinfo.c.image_height = sp->strile_height;
downsampled_input = FALSE;
if (td->td_planarconfig == PLANARCONFIG_CONTIG)
{
@@ -2276,7 +2294,13 @@ static int JPEGPreEncode(TIFF *tif, uint16_t s)
/* an existing file */
suppress_huff_table(sp, 0);
suppress_huff_table(sp, 1);
sp->cinfo.c.optimize_coding = FALSE;
/* We want to keep optimize_coding = TRUE for 12-bit JPEG */
/* See lengthy explanation at
* https://gitlab.com/libtiff/libtiff/-/work_items/773#note_3009836854
*/
if (sp->cinfo.c.data_precision == 8)
sp->cinfo.c.optimize_coding = FALSE;
}
else
sp->cinfo.c.optimize_coding = TRUE;
@@ -2332,13 +2356,15 @@ static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
TIFFWarningExtR(tif, tif->tif_name, "fractional scanline discarded");
/* The last strip will be limited to image size */
if (!isTiled(tif) && tif->tif_row + nrows > tif->tif_dir.td_imagelength)
nrows = tif->tif_dir.td_imagelength - tif->tif_row;
if (!isTiled(tif) &&
tif->tif_dir.td_row + nrows > tif->tif_dir.td_imagelength)
nrows = tif->tif_dir.td_imagelength - tif->tif_dir.td_row;
if (sp->cinfo.c.data_precision == 12)
{
line16_count = (int)((sp->bytesperline * 2) / 3);
line16 = (short *)_TIFFmallocExt(tif, sizeof(short) * line16_count);
line16 = (short *)_TIFFmallocExt(
tif, (tmsize_t)(sizeof(short) * (size_t)line16_count));
if (!line16)
{
TIFFErrorExtR(tif, "JPEGEncode", "Failed to allocate memory");
@@ -2363,8 +2389,10 @@ static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
unsigned char *in_ptr = ((unsigned char *)buf) + iPair * 3;
TIFF_JSAMPLE *out_ptr = (TIFF_JSAMPLE *)(line16 + iPair * 2);
out_ptr[0] = (in_ptr[0] << 4) | ((in_ptr[1] & 0xf0) >> 4);
out_ptr[1] = ((in_ptr[1] & 0x0f) << 8) | in_ptr[2];
out_ptr[0] = (TIFF_JSAMPLE)((in_ptr[0] << 4) |
((in_ptr[1] & 0xf0) >> 4));
out_ptr[1] =
(TIFF_JSAMPLE)(((in_ptr[1] & 0x0f) << 8) | in_ptr[2]);
}
}
else
@@ -2374,7 +2402,7 @@ static int JPEGEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
if (TIFFjpeg_write_scanlines(sp, bufptr, 1) != 1)
return (0);
if (nrows > 0)
tif->tif_row++;
tif->tif_dir.td_row++;
buf += sp->bytesperline;
}
@@ -2443,8 +2471,9 @@ static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
{
int hsamp = compptr->h_samp_factor;
int vsamp = compptr->v_samp_factor;
int padding = (int)(compptr->width_in_blocks * DCTSIZE -
clumps_per_line * hsamp);
int padding =
(int)(compptr->width_in_blocks * DCTSIZE -
(JDIMENSION)clumps_per_line * (JDIMENSION)hsamp);
for (ypos = 0; ypos < vsamp; ypos++)
{
inptr = ((TIFF_JSAMPLE *)buf) + clumpoffset;
@@ -2488,7 +2517,7 @@ static int JPEGEncodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
}
sp->scancount = 0;
}
tif->tif_row += sp->v_sampling;
tif->tif_dir.td_row += sp->v_sampling;
buf += bytesperclumpline;
nrows -= sp->v_sampling;
}
@@ -2582,10 +2611,11 @@ static void JPEGResetUpsampled(TIFF *tif)
* Must recalculate cached tile size in case sampling state changed.
* Should we really be doing this now if image size isn't set?
*/
if (tif->tif_tilesize > 0)
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
if (tif->tif_scanlinesize > 0)
tif->tif_scanlinesize = TIFFScanlineSize(tif);
if (tif->tif_dir.td_tilesize > 0)
tif->tif_dir.td_tilesize =
isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
if (tif->tif_dir.td_scanlinesize > 0)
tif->tif_dir.td_scanlinesize = TIFFScanlineSize(tif);
}
static int JPEGVSetField(TIFF *tif, uint32_t tag, va_list ap)
@@ -2793,6 +2823,33 @@ static int JPEGInitializeLibJPEG(TIFF *tif, int decompress)
return 1;
}
static uint64_t JPEGGetMaxCompressionRatio(TIFF *tif)
{
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
const JPEGState *sp = JState(tif);
if ((tif->tif_dir.td_photometric == PHOTOMETRIC_YCBCR) &&
(tif->tif_dir.td_planarconfig == PLANARCONFIG_CONTIG) &&
(tif->tif_dir.td_samplesperpixel == 3))
{
if (sp->h_sampling == 2 && sp->v_sampling == 2)
{
if (tif->tif_dir.td_bitspersample == 12)
return 768;
else
return 512;
}
return 0; /* unknown */
}
if (tif->tif_dir.td_bitspersample == 12)
return 384;
else
return 256;
}
/* Common to tif_jpeg.c and tif_jpeg_12.c */
static void TIFFInitJPEGCommon(TIFF *tif)
{
@@ -2829,6 +2886,7 @@ static void TIFFInitJPEGCommon(TIFF *tif)
tif->tif_encoderow = JPEGEncode;
tif->tif_encodestrip = JPEGEncode;
tif->tif_encodetile = JPEGEncode;
tif->tif_getmaxcompressionratio = JPEGGetMaxCompressionRatio;
tif->tif_cleanup = JPEGCleanup;
tif->tif_defstripsize = JPEGDefaultStripSize;

148
3rdparty/libtiff/tif_lerc.c vendored
View File

@@ -33,6 +33,7 @@
#include "Lerc_c_api.h"
#include "zlib.h"
#include <math.h>
#ifdef ZSTD_SUPPORT
#include "zstd.h"
#endif
@@ -188,7 +189,7 @@ static int SetupBuffers(TIFF *tif, LERCState *sp, const char *module)
else
{
sp->segment_width = td->td_imagewidth;
sp->segment_height = td->td_imagelength - tif->tif_row;
sp->segment_height = td->td_imagelength - tif->tif_dir.td_row;
if (sp->segment_height > td->td_rowsperstrip)
sp->segment_height = td->td_rowsperstrip;
}
@@ -242,7 +243,7 @@ static int SetupBuffers(TIFF *tif, LERCState *sp, const char *module)
}
if ((td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_extrasamples > 0 &&
td->td_extrasamples > 0 && td->td_sampleinfo &&
td->td_sampleinfo[td->td_extrasamples - 1] == EXTRASAMPLE_UNASSALPHA &&
GetLercDataType(tif) == 1) ||
(td->td_sampleformat == SAMPLEFORMAT_IEEEFP &&
@@ -343,7 +344,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
if (res != LIBDEFLATE_SUCCESS)
{
TIFFErrorExtR(tif, module, "Decoding error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
return 0;
}
assert(lerc_data_sizet == (unsigned int)lerc_data_sizet);
@@ -387,7 +388,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
size_t zstd_ret;
zstd_ret = ZSTD_decompress(sp->compressed_buffer, sp->compressed_size,
tif->tif_rawcp, tif->tif_rawcc);
tif->tif_rawcp, (size_t)tif->tif_rawcc);
if (ZSTD_isError(zstd_ret))
{
TIFFErrorExtR(tif, module, "Error in ZSTD_decompress(): %s",
@@ -420,6 +421,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
/* LERC info has dim == samplesperpixel - 1, then there is a LERC */
/* mask. */
if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_extrasamples > 0 &&
td->td_sampleinfo &&
td->td_sampleinfo[td->td_extrasamples - 1] == EXTRASAMPLE_UNASSALPHA &&
GetLercDataType(tif) == 1 &&
infoArray[2] == td->td_samplesperpixel - 1U)
@@ -432,7 +434,8 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
use_mask = 1;
}
ndims = td->td_planarconfig == PLANARCONFIG_CONTIG ? nomask_bands : 1;
ndims =
(int)(td->td_planarconfig == PLANARCONFIG_CONTIG ? nomask_bands : 1);
/* Info returned in infoArray is { version, dataType, nDim/nDepth, nCols,
nRows, nBands, nValidPixels, blobSize,
@@ -440,12 +443,12 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
if (infoArray[0] != (unsigned)sp->lerc_version)
{
TIFFWarningExtR(tif, module,
"Unexpected version number: %d. Expected: %d",
"Unexpected version number: %u. Expected: %d",
infoArray[0], sp->lerc_version);
}
if (infoArray[1] != (unsigned)lerc_data_type)
{
TIFFErrorExtR(tif, module, "Unexpected dataType: %d. Expected: %d",
TIFFErrorExtR(tif, module, "Unexpected dataType: %u. Expected: %d",
infoArray[1], lerc_data_type);
return 0;
}
@@ -458,7 +461,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
{
if (nFoundDims != 1 && nFoundDims != (unsigned)ndims)
{
TIFFErrorExtR(tif, module, "Unexpected nDim: %d. Expected: 1 or %d",
TIFFErrorExtR(tif, module, "Unexpected nDim: %u. Expected: 1 or %d",
nFoundDims, ndims);
return 0;
}
@@ -467,20 +470,20 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
#endif
if (nFoundDims != (unsigned)ndims)
{
TIFFErrorExtR(tif, module, "Unexpected nDim: %d. Expected: %d",
TIFFErrorExtR(tif, module, "Unexpected nDim: %u. Expected: %d",
nFoundDims, ndims);
return 0;
}
if (infoArray[3] != sp->segment_width)
{
TIFFErrorExtR(tif, module, "Unexpected nCols: %d. Expected: %du",
TIFFErrorExtR(tif, module, "Unexpected nCols: %u. Expected: %u",
infoArray[3], sp->segment_width);
return 0;
}
if (infoArray[4] != sp->segment_height)
{
TIFFErrorExtR(tif, module, "Unexpected nRows: %d. Expected: %u",
TIFFErrorExtR(tif, module, "Unexpected nRows: %u. Expected: %u",
infoArray[4], sp->segment_height);
return 0;
}
@@ -504,28 +507,28 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
#endif
if (nFoundBands != td->td_samplesperpixel)
{
TIFFErrorExtR(tif, module, "Unexpected nBands: %d. Expected: %d",
TIFFErrorExtR(tif, module, "Unexpected nBands: %u. Expected: %d",
nFoundBands, td->td_samplesperpixel);
return 0;
}
}
else if (nFoundBands != 1)
{
TIFFErrorExtR(tif, module, "Unexpected nBands: %d. Expected: %d",
TIFFErrorExtR(tif, module, "Unexpected nBands: %u. Expected: %d",
nFoundBands, 1);
return 0;
}
if (infoArray[7] != lerc_data_size)
{
TIFFErrorExtR(tif, module, "Unexpected blobSize: %d. Expected: %u",
TIFFErrorExtR(tif, module, "Unexpected blobSize: %u. Expected: %u",
infoArray[7], lerc_data_size);
return 0;
}
int nRequestedMasks = use_mask ? 1 : 0;
#if LERC_AT_LEAST_VERSION(3, 0, 0)
const int nFoundMasks = infoArray[8];
const int nFoundMasks = (int)infoArray[8];
if (td->td_sampleformat == SAMPLEFORMAT_IEEEFP &&
td->td_planarconfig == PLANARCONFIG_CONTIG &&
td->td_samplesperpixel > 1 && nFoundDims == 1)
@@ -576,21 +579,22 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
sp->uncompressed_buffer_multiband_alloc = num_bytes_needed;
}
lerc_ret = lerc_decode(lerc_data, lerc_data_size, nRequestedMasks,
sp->mask_buffer, nFoundDims, sp->segment_width,
sp->segment_height, nFoundBands, lerc_data_type,
sp->mask_buffer, (int)nFoundDims,
(int)sp->segment_width, (int)sp->segment_height,
(int)nFoundBands, (unsigned int)lerc_data_type,
sp->uncompressed_buffer_multiband);
}
else
#endif
{
lerc_ret =
lerc_decode(lerc_data, lerc_data_size,
lerc_ret = lerc_decode(
lerc_data, lerc_data_size,
#if LERC_AT_LEAST_VERSION(3, 0, 0)
nRequestedMasks,
nRequestedMasks,
#endif
use_mask ? sp->mask_buffer : NULL, nFoundDims,
sp->segment_width, sp->segment_height, nFoundBands,
lerc_data_type, sp->uncompressed_buffer);
use_mask ? sp->mask_buffer : NULL, (int)nFoundDims,
(int)sp->segment_width, (int)sp->segment_height, (int)nFoundBands,
(unsigned int)lerc_data_type, sp->uncompressed_buffer);
}
if (lerc_ret != 0)
{
@@ -601,17 +605,17 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
/* Interleave alpha mask with other samples. */
if (use_mask && GetLercDataType(tif) == 1)
{
unsigned src_stride =
(td->td_samplesperpixel - 1) * (td->td_bitspersample / 8);
unsigned src_stride = (unsigned int)((td->td_samplesperpixel - 1) *
(td->td_bitspersample / 8));
unsigned dst_stride =
td->td_samplesperpixel * (td->td_bitspersample / 8);
(unsigned int)(td->td_samplesperpixel * (td->td_bitspersample / 8));
unsigned i = sp->segment_width * sp->segment_height;
/* Operate from end to begin to be able to move in place */
while (i > 0 && i > nomask_bands)
{
i--;
sp->uncompressed_buffer[i * dst_stride + td->td_samplesperpixel -
1] = 255 * sp->mask_buffer[i];
1] = (uint8_t)(255 * sp->mask_buffer[i]);
memcpy(sp->uncompressed_buffer + i * dst_stride,
sp->uncompressed_buffer + i * src_stride, src_stride);
}
@@ -620,7 +624,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
{
i--;
sp->uncompressed_buffer[i * dst_stride + td->td_samplesperpixel -
1] = 255 * sp->mask_buffer[i];
1] = (uint8_t)(255 * sp->mask_buffer[i]);
memmove(sp->uncompressed_buffer + i * dst_stride,
sp->uncompressed_buffer + i * src_stride, src_stride);
}
@@ -649,7 +653,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
}
else
{
const double nan_float64 = nan_float32;
const double nan_float64 = (double)nan_float32;
for (i = 0; i < nb_pixels; i++)
{
if (sp->mask_buffer[i] == 0)
@@ -677,7 +681,7 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
}
else
{
const double nan_float64 = nan_float32;
const double nan_float64 = (double)nan_float32;
for (i = 0; i < nb_pixels; i++)
{
for (int j = 0; j < td->td_samplesperpixel; j++)
@@ -704,30 +708,32 @@ static int LERCPreDecode(TIFF *tif, uint16_t s)
{
for (int j = 0; j < td->td_samplesperpixel; j++)
{
if (sp->mask_buffer[i + j * nb_pixels] == 0)
if (sp->mask_buffer[i + (unsigned int)j * nb_pixels] ==
0)
((float *)sp->uncompressed_buffer)[k] = nan_float32;
else
((float *)sp->uncompressed_buffer)[k] =
((float *)sp->uncompressed_buffer_multiband)
[i + j * nb_pixels];
[i + (unsigned int)j * nb_pixels];
++k;
}
}
}
else
{
const double nan_float64 = nan_float32;
const double nan_float64 = (double)nan_float32;
for (i = 0; i < nb_pixels; i++)
{
for (int j = 0; j < td->td_samplesperpixel; j++)
{
if (sp->mask_buffer[i + j * nb_pixels] == 0)
if (sp->mask_buffer[i + (unsigned int)j * nb_pixels] ==
0)
((double *)sp->uncompressed_buffer)[k] =
nan_float64;
else
((double *)sp->uncompressed_buffer)[k] =
((double *)sp->uncompressed_buffer_multiband)
[i + j * nb_pixels];
[i + (unsigned int)j * nb_pixels];
++k;
}
}
@@ -766,8 +772,8 @@ static int LERCDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
return 0;
}
memcpy(op, sp->uncompressed_buffer + sp->uncompressed_offset, occ);
sp->uncompressed_offset += (unsigned)occ;
memcpy(op, sp->uncompressed_buffer + sp->uncompressed_offset, (size_t)occ);
sp->uncompressed_offset += (unsigned int)occ;
return 1;
}
@@ -832,8 +838,8 @@ static int LERCEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
return 0;
}
memcpy(sp->uncompressed_buffer + sp->uncompressed_offset, bp, cc);
sp->uncompressed_offset += (unsigned)cc;
memcpy(sp->uncompressed_buffer + sp->uncompressed_offset, bp, (size_t)cc);
sp->uncompressed_offset += (unsigned int)cc;
return 1;
}
@@ -863,13 +869,15 @@ static int LERCPostEncode(TIFF *tif)
/* Extract alpha mask (if containing only 0 and 255 values, */
/* and compact array of regular bands */
if (td->td_planarconfig == PLANARCONFIG_CONTIG && td->td_extrasamples > 0 &&
td->td_sampleinfo &&
td->td_sampleinfo[td->td_extrasamples - 1] == EXTRASAMPLE_UNASSALPHA &&
GetLercDataType(tif) == 1)
{
const unsigned dst_stride =
(td->td_samplesperpixel - 1) * (td->td_bitspersample / 8);
(unsigned int)((td->td_samplesperpixel - 1) *
(td->td_bitspersample / 8));
const unsigned src_stride =
td->td_samplesperpixel * (td->td_bitspersample / 8);
(unsigned int)(td->td_samplesperpixel * (td->td_bitspersample / 8));
unsigned i = 0;
use_mask = 1;
@@ -923,7 +931,7 @@ static int LERCPostEncode(TIFF *tif)
{
const float val = ((float *)sp->uncompressed_buffer)[k];
++k;
if (val != val)
if (isnan(val))
{
++count_nan;
}
@@ -944,7 +952,7 @@ static int LERCPostEncode(TIFF *tif)
for (i = 0; i < nb_pixels; i++)
{
const float val = ((float *)sp->uncompressed_buffer)[i];
if (val != val)
if (isnan(val))
{
use_mask = 1;
break;
@@ -965,7 +973,7 @@ static int LERCPostEncode(TIFF *tif)
const double val =
((double *)sp->uncompressed_buffer)[k];
++k;
if (val != val)
if (isnan(val))
{
++count_nan;
}
@@ -986,7 +994,7 @@ static int LERCPostEncode(TIFF *tif)
for (i = 0; i < nb_pixels; i++)
{
const double val = ((double *)sp->uncompressed_buffer)[i];
if (val != val)
if (isnan(val))
{
use_mask = 1;
break;
@@ -1025,10 +1033,10 @@ static int LERCPostEncode(TIFF *tif)
const float val =
((float *)sp->uncompressed_buffer)[k];
((float *)sp->uncompressed_buffer_multiband)
[i + j * nb_pixels] = val;
[i + (unsigned int)j * nb_pixels] = val;
++k;
sp->mask_buffer[i + j * nb_pixels] =
(val == val) ? 255 : 0;
sp->mask_buffer[i + (unsigned int)j * nb_pixels] =
!isnan(val) ? 255 : 0;
}
}
}
@@ -1041,10 +1049,10 @@ static int LERCPostEncode(TIFF *tif)
const double val =
((double *)sp->uncompressed_buffer)[k];
((double *)sp->uncompressed_buffer_multiband)
[i + j * nb_pixels] = val;
[i + (unsigned int)j * nb_pixels] = val;
++k;
sp->mask_buffer[i + j * nb_pixels] =
(val == val) ? 255 : 0;
sp->mask_buffer[i + (unsigned int)j * nb_pixels] =
!isnan(val) ? 255 : 0;
}
}
}
@@ -1064,7 +1072,7 @@ static int LERCPostEncode(TIFF *tif)
{
const float val =
((float *)sp->uncompressed_buffer)[i * dst_nbands];
sp->mask_buffer[i] = (val == val) ? 255 : 0;
sp->mask_buffer[i] = !isnan(val) ? 255 : 0;
}
}
else
@@ -1073,7 +1081,7 @@ static int LERCPostEncode(TIFF *tif)
{
const double val =
((double *)sp->uncompressed_buffer)[i * dst_nbands];
sp->mask_buffer[i] = (val == val) ? 255 : 0;
sp->mask_buffer[i] = !isnan(val) ? 255 : 0;
}
}
}
@@ -1084,7 +1092,7 @@ static int LERCPostEncode(TIFF *tif)
for (i = 0; i < nb_pixels; i++)
{
const float val = ((float *)sp->uncompressed_buffer)[i];
sp->mask_buffer[i] = (val == val) ? 255 : 0;
sp->mask_buffer[i] = !isnan(val) ? 255 : 0;
}
}
else
@@ -1093,7 +1101,7 @@ static int LERCPostEncode(TIFF *tif)
{
const double val =
((double *)sp->uncompressed_buffer)[i];
sp->mask_buffer[i] = (val == val) ? 255 : 0;
sp->mask_buffer[i] = !isnan(val) ? 255 : 0;
}
}
}
@@ -1104,7 +1112,8 @@ static int LERCPostEncode(TIFF *tif)
#if LERC_AT_LEAST_VERSION(3, 0, 0)
if (mask_count > 1)
{
estimated_compressed_size += nb_pixels * mask_count / 8;
estimated_compressed_size +=
(unsigned int)(nb_pixels * (unsigned int)mask_count / 8);
}
#endif
@@ -1125,8 +1134,9 @@ static int LERCPostEncode(TIFF *tif)
{
lerc_ret = lerc_encodeForVersion(
sp->uncompressed_buffer_multiband, sp->lerc_version,
GetLercDataType(tif), 1, sp->segment_width, sp->segment_height,
dst_nbands, dst_nbands, sp->mask_buffer, sp->maxzerror,
(unsigned int)GetLercDataType(tif), 1, (int)sp->segment_width,
(int)sp->segment_height, (int)dst_nbands, (int)dst_nbands,
sp->mask_buffer, sp->maxzerror,
(unsigned char *)sp->compressed_buffer, sp->compressed_size,
&numBytesWritten);
}
@@ -1134,9 +1144,10 @@ static int LERCPostEncode(TIFF *tif)
#endif
{
lerc_ret = lerc_encodeForVersion(
sp->uncompressed_buffer, sp->lerc_version, GetLercDataType(tif),
td->td_planarconfig == PLANARCONFIG_CONTIG ? dst_nbands : 1,
sp->segment_width, sp->segment_height, 1,
sp->uncompressed_buffer, sp->lerc_version,
(unsigned int)GetLercDataType(tif),
(int)(td->td_planarconfig == PLANARCONFIG_CONTIG ? dst_nbands : 1),
(int)sp->segment_width, (int)sp->segment_height, 1,
#if LERC_AT_LEAST_VERSION(3, 0, 0)
use_mask ? 1 : 0,
#endif
@@ -1179,14 +1190,14 @@ static int LERCPostEncode(TIFF *tif)
return 0;
}
tif->tif_rawcc = libdeflate_zlib_compress(
tif->tif_rawcc = (tmsize_t)libdeflate_zlib_compress(
sp->libdeflate_enc, sp->compressed_buffer, numBytesWritten,
sp->uncompressed_buffer, sp->uncompressed_alloc);
if (tif->tif_rawcc == 0)
{
TIFFErrorExtR(tif, module, "Encoder error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
return 0;
}
#else
@@ -1252,7 +1263,7 @@ static int LERCPostEncode(TIFF *tif)
int ret;
uint8_t *tif_rawdata_backup = tif->tif_rawdata;
tif->tif_rawdata = sp->uncompressed_buffer;
tif->tif_rawcc = zstd_ret;
tif->tif_rawcc = (tmsize_t)zstd_ret;
ret = TIFFFlushData1(tif);
tif->tif_rawdata = tif_rawdata_backup;
if (!ret)
@@ -1350,7 +1361,7 @@ static int LERCVSetField(TIFF *tif, uint32_t tag, va_list ap)
{
case TIFFTAG_LERC_PARAMETERS:
{
uint32_t count = va_arg(ap, int);
uint32_t count = (uint32_t)va_arg(ap, int);
int *params = va_arg(ap, int *);
if (count < 2)
{
@@ -1529,6 +1540,13 @@ int TIFFInitLERC(TIFF *tif, int scheme)
#endif
tif->tif_cleanup = LERCCleanup;
/* LERC compression ratio can grow to several millions */
/* eg. 5703725 for Lerc deflate on 16383x16383 array */
/* or 3829644 for regular Lerc */
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* so we don't define tif->tif_getmaxcompressionratio */
/* Default values for codec-specific fields */
TIFFSetField(tif, TIFFTAG_LERC_VERSION, LERC_VERSION_2_4);
TIFFSetField(tif, TIFFTAG_LERC_ADD_COMPRESSION, LERC_ADD_COMPRESSION_NONE);

165
3rdparty/libtiff/tif_luv.c vendored
View File

@@ -212,7 +212,7 @@ static int LogL16Decode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
}
tp = (int16_t *)sp->tbuf;
}
_TIFFmemset((void *)tp, 0, npixels * sizeof(tp[0]));
_TIFFmemset((void *)tp, 0, (tmsize_t)((size_t)npixels * sizeof(tp[0])));
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
@@ -235,7 +235,7 @@ static int LogL16Decode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{ /* non-run */
rc = *bp++; /* nul is noop */
while (--cc && rc-- && i < npixels)
tp[i++] |= (int16_t)*bp++ << shft;
tp[i++] |= (int16_t)(*bp++ << shft);
}
}
if (i != npixels)
@@ -243,7 +243,7 @@ static int LogL16Decode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at row %" PRIu32
" (short %" TIFF_SSIZE_FORMAT " pixels)",
tif->tif_row, npixels - i);
tif->tif_dir.td_row, npixels - i);
tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc;
return (0);
@@ -290,7 +290,7 @@ static int LogLuvDecode24(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
cc = tif->tif_rawcc;
for (i = 0; i < npixels && cc >= 3; i++)
{
tp[i] = bp[0] << 16 | bp[1] << 8 | bp[2];
tp[i] = (uint32_t)bp[0] << 16 | (uint32_t)bp[1] << 8 | bp[2];
bp += 3;
cc -= 3;
}
@@ -301,7 +301,7 @@ static int LogLuvDecode24(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at row %" PRIu32
" (short %" TIFF_SSIZE_FORMAT " pixels)",
tif->tif_row, npixels - i);
tif->tif_dir.td_row, npixels - i);
return (0);
}
(*sp->tfunc)(sp, op, npixels);
@@ -342,7 +342,7 @@ static int LogLuvDecode32(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
}
tp = (uint32_t *)sp->tbuf;
}
_TIFFmemset((void *)tp, 0, npixels * sizeof(tp[0]));
_TIFFmemset((void *)tp, 0, (tmsize_t)((size_t)npixels * sizeof(tp[0])));
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
@@ -373,7 +373,7 @@ static int LogLuvDecode32(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at row %" PRIu32
" (short %" TIFF_SSIZE_FORMAT " pixels)",
tif->tif_row, npixels - i);
tif->tif_dir.td_row, npixels - i);
tif->tif_rawcp = (uint8_t *)bp;
tif->tif_rawcc = cc;
return (0);
@@ -767,25 +767,21 @@ static int LogLuvEncodeTile(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
#undef log2 /* Conflict with C'99 function */
#define log2(x) ((1. / M_LN2) * log(x))
#undef exp2 /* Conflict with C'99 function */
#define exp2(x) exp(M_LN2 *(x))
#define TIFF_RAND_MAX 32767
// From POSIX.1-2001 as an example of an implementation of rand()
static uint32_t _TIFFRand()
static uint32_t _TIFFRand(void)
{
static uint32_t nCounter = 0;
if (!nCounter)
nCounter = (uint32_t)(time(NULL) & UINT32_MAX);
++nCounter;
uint32_t nCounterLocal =
(uint32_t)(((uint64_t)(nCounter)*1103515245U + 12345U) & UINT32_MAX);
(uint32_t)(((uint64_t)(nCounter) * 1103515245U + 12345U) & UINT32_MAX);
nCounter = nCounterLocal;
return (nCounterLocal / 65536U) % (TIFF_RAND_MAX + 1);
};
}
static int tiff_itrunc(double x, int m)
{
@@ -797,8 +793,7 @@ static int tiff_itrunc(double x, int m)
#if !LOGLUV_PUBLIC
static
#endif
double
LogL16toY(int p16) /* compute luminance from 16-bit LogL */
double LogL16toY(int p16) /* compute luminance from 16-bit LogL */
{
int Le = p16 & 0x7fff;
double Y;
@@ -812,8 +807,7 @@ static
#if !LOGLUV_PUBLIC
static
#endif
int
LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */
int LogL16fromY(double Y, int em) /* get 16-bit LogL from Y */
{
if (Y >= 1.8371976e19)
return (0x7fff);
@@ -855,20 +849,22 @@ static void L16fromY(LogLuvState *sp, uint8_t *op, tmsize_t n)
float *yp = (float *)op;
while (n-- > 0)
*l16++ = (int16_t)(LogL16fromY(*yp++, sp->encode_meth));
*l16++ = (int16_t)(LogL16fromY((double)*yp++, sp->encode_meth));
}
#if !LOGLUV_PUBLIC
static
#endif
void
XYZtoRGB24(float *xyz, uint8_t *rgb)
void XYZtoRGB24(float *xyz, uint8_t *rgb)
{
double r, g, b;
/* assume CCIR-709 primaries */
r = 2.690 * xyz[0] + -1.276 * xyz[1] + -0.414 * xyz[2];
g = -1.022 * xyz[0] + 1.978 * xyz[1] + 0.044 * xyz[2];
b = 0.061 * xyz[0] + -0.224 * xyz[1] + 1.163 * xyz[2];
r = 2.690 * (double)xyz[0] + -1.276 * (double)xyz[1] +
-0.414 * (double)xyz[2];
g = -1.022 * (double)xyz[0] + 1.978 * (double)xyz[1] +
0.044 * (double)xyz[2];
b = 0.061 * (double)xyz[0] + -0.224 * (double)xyz[1] +
1.163 * (double)xyz[2];
/* assume 2.0 gamma for speed */
/* could use integer sqrt approx., but this is probably faster */
rgb[0] = (uint8_t)((r <= 0.) ? 0 : (r >= 1.) ? 255 : (int)(256. * sqrt(r)));
@@ -879,8 +875,7 @@ static
#if !LOGLUV_PUBLIC
static
#endif
double
LogL10toY(int p10) /* compute luminance from 10-bit LogL */
double LogL10toY(int p10) /* compute luminance from 10-bit LogL */
{
if (p10 == 0)
return (0.);
@@ -890,8 +885,7 @@ static
#if !LOGLUV_PUBLIC
static
#endif
int
LogL10fromY(double Y, int em) /* get 10-bit LogL from Y */
int LogL10fromY(double Y, int em) /* get 10-bit LogL from Y */
{
if (Y >= 15.742)
return (0x3ff);
@@ -903,13 +897,14 @@ static
#define NANGLES 100
#define uv2ang(u, v) \
((NANGLES * .499999999 / M_PI) * atan2((v)-V_NEU, (u)-U_NEU) + .5 * NANGLES)
((NANGLES * .499999999 / M_PI) * atan2((v) - V_NEU, (u) - U_NEU) + \
.5 * NANGLES)
static int oog_encode(double u, double v) /* encode out-of-gamut chroma */
{
static int oog_table[NANGLES];
static int initialized = 0;
register int i;
int i;
if (!initialized)
{ /* set up perimeter table */
@@ -919,13 +914,14 @@ static int oog_encode(double u, double v) /* encode out-of-gamut chroma */
eps[i] = 2.;
for (vi = UV_NVS; vi--;)
{
va = UV_VSTART + (vi + .5) * UV_SQSIZ;
va = (double)UV_VSTART + ((double)vi + .5) * (double)UV_SQSIZ;
ustep = uv_row[vi].nus - 1;
if (vi == UV_NVS - 1 || vi == 0 || ustep <= 0)
ustep = 1;
for (ui = uv_row[vi].nus - 1; ui >= 0; ui -= ustep)
{
ua = uv_row[vi].ustart + (ui + .5) * UV_SQSIZ;
ua = (double)uv_row[vi].ustart +
((double)ui + .5) * (double)UV_SQSIZ;
ang = uv2ang(ua, va);
i = (int)ang;
epsa = fabs(ang - (i + .5));
@@ -963,27 +959,28 @@ static int oog_encode(double u, double v) /* encode out-of-gamut chroma */
#if !LOGLUV_PUBLIC
static
#endif
int
uv_encode(double u, double v, int em) /* encode (u',v') coordinates */
int uv_encode(double u, double v, int em) /* encode (u',v') coordinates */
{
unsigned int vi;
int ui;
/* check for NaN */
if (u != u || v != v)
if (isnan(u) || isnan(v))
{
u = U_NEU;
v = V_NEU;
}
if (v < UV_VSTART)
if ((double)v < (double)UV_VSTART)
return oog_encode(u, v);
vi = tiff_itrunc((v - UV_VSTART) * (1. / UV_SQSIZ), em);
vi = (unsigned int)tiff_itrunc(
((double)v - (double)UV_VSTART) * (1. / (double)UV_SQSIZ), em);
if (vi >= UV_NVS)
return oog_encode(u, v);
if (u < uv_row[vi].ustart)
if ((double)u < (double)uv_row[vi].ustart)
return oog_encode(u, v);
ui = tiff_itrunc((u - uv_row[vi].ustart) * (1. / UV_SQSIZ), em);
ui = tiff_itrunc(
((double)u - (double)uv_row[vi].ustart) * (1. / (double)UV_SQSIZ), em);
if (ui >= uv_row[vi].nus)
return oog_encode(u, v);
@@ -993,8 +990,7 @@ static
#if !LOGLUV_PUBLIC
static
#endif
int
uv_decode(double *up, double *vp, int c) /* decode (u',v') index */
int uv_decode(double *up, double *vp, int c) /* decode (u',v') index */
{
unsigned int upper, lower;
int ui;
@@ -1020,16 +1016,15 @@ static
}
vi = lower;
ui = c - uv_row[vi].ncum;
*up = uv_row[vi].ustart + (ui + .5) * UV_SQSIZ;
*vp = UV_VSTART + (vi + .5) * UV_SQSIZ;
*up = (double)uv_row[vi].ustart + ((double)ui + .5) * (double)UV_SQSIZ;
*vp = (double)UV_VSTART + ((double)vi + .5) * (double)UV_SQSIZ;
return (0);
}
#if !LOGLUV_PUBLIC
static
#endif
void
LogLuv24toXYZ(uint32_t p, float *XYZ)
void LogLuv24toXYZ(uint32_t p, float *XYZ)
{
int Ce;
double L, u, v, s, x, y;
@@ -1059,15 +1054,14 @@ static
#if !LOGLUV_PUBLIC
static
#endif
uint32_t
LogLuv24fromXYZ(float *XYZ, int em)
uint32_t LogLuv24fromXYZ(float *XYZ, int em)
{
int Le, Ce;
double u, v, s;
/* encode luminance */
Le = LogL10fromY(XYZ[1], em);
Le = LogL10fromY((double)XYZ[1], em);
/* encode color */
s = XYZ[0] + 15. * XYZ[1] + 3. * XYZ[2];
s = (double)XYZ[0] + 15. * (double)XYZ[1] + 3. * (double)XYZ[2];
if (!Le || s <= 0.)
{
u = U_NEU;
@@ -1075,14 +1069,14 @@ static
}
else
{
u = 4. * XYZ[0] / s;
v = 9. * XYZ[1] / s;
u = 4. * (double)XYZ[0] / s;
v = 9. * (double)XYZ[1] / s;
}
Ce = uv_encode(u, v, em);
if (Ce < 0) /* never happens */
Ce = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
/* combine encodings */
return (Le << 14 | Ce);
return (uint32_t)Le << 14 | (uint32_t)Ce;
}
static void Luv24toXYZ(LogLuvState *sp, uint8_t *op, tmsize_t n)
@@ -1113,8 +1107,8 @@ static void Luv24toLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
u = U_NEU;
v = V_NEU;
}
*luv3++ = (int16_t)(u * (1L << 15));
*luv3++ = (int16_t)(v * (1L << 15));
*luv3++ = (int16_t)(u * (1 << 15));
*luv3++ = (int16_t)(v * (1 << 15));
luv++;
}
}
@@ -1168,7 +1162,7 @@ static void Luv24fromLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
sp->encode_meth);
if (Ce < 0) /* never happens */
Ce = uv_encode(U_NEU, V_NEU, SGILOGENCODE_NODITHER);
*luv++ = (uint32_t)Le << 14 | Ce;
*luv++ = (uint32_t)Le << 14 | (uint32_t)Ce;
luv3 += 3;
}
}
@@ -1176,8 +1170,7 @@ static void Luv24fromLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
#if !LOGLUV_PUBLIC
static
#endif
void
LogLuv32toXYZ(uint32_t p, float *XYZ)
void LogLuv32toXYZ(uint32_t p, float *XYZ)
{
double L, u, v, s, x, y;
/* decode luminance */
@@ -1202,15 +1195,14 @@ static
#if !LOGLUV_PUBLIC
static
#endif
uint32_t
LogLuv32fromXYZ(float *XYZ, int em)
uint32_t LogLuv32fromXYZ(float *XYZ, int em)
{
unsigned int Le, ue, ve;
double u, v, s;
/* encode luminance */
Le = (unsigned int)LogL16fromY(XYZ[1], em);
Le = (unsigned int)LogL16fromY((double)XYZ[1], em);
/* encode color */
s = XYZ[0] + 15. * XYZ[1] + 3. * XYZ[2];
s = (double)XYZ[0] + 15. * (double)XYZ[1] + 3. * (double)XYZ[2];
if (!Le || s <= 0.)
{
u = U_NEU;
@@ -1218,19 +1210,19 @@ static
}
else
{
u = 4. * XYZ[0] / s;
v = 9. * XYZ[1] / s;
u = 4. * (double)XYZ[0] / s;
v = 9. * (double)XYZ[1] / s;
}
if (u <= 0.)
ue = 0;
else
ue = tiff_itrunc(UVSCALE * u, em);
ue = (unsigned int)tiff_itrunc(UVSCALE * u, em);
if (ue > 255)
ue = 255;
if (v <= 0.)
ve = 0;
else
ve = tiff_itrunc(UVSCALE * v, em);
ve = (unsigned int)tiff_itrunc(UVSCALE * v, em);
if (ve > 255)
ve = 255;
/* combine encodings */
@@ -1261,8 +1253,8 @@ static void Luv32toLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
*luv3++ = (int16_t)(*luv >> 16);
u = 1. / UVSCALE * ((*luv >> 8 & 0xff) + .5);
v = 1. / UVSCALE * ((*luv & 0xff) + .5);
*luv3++ = (int16_t)(u * (1L << 15));
*luv3++ = (int16_t)(v * (1L << 15));
*luv3++ = (int16_t)(u * (1 << 15));
*luv3++ = (int16_t)(v * (1 << 15));
luv++;
}
}
@@ -1303,22 +1295,24 @@ static void Luv32fromLuv48(LogLuvState *sp, uint8_t *op, tmsize_t n)
{
while (n-- > 0)
{
*luv++ = (uint32_t)luv3[0] << 16 |
(luv3[1] * (uint32_t)(UVSCALE + .5) >> 7 & 0xff00) |
(luv3[2] * (uint32_t)(UVSCALE + .5) >> 15 & 0xff);
*luv++ =
(uint32_t)luv3[0] << 16 |
((uint32_t)luv3[1] * (uint32_t)(UVSCALE + .5) >> 7 & 0xff00) |
((uint32_t)luv3[2] * (uint32_t)(UVSCALE + .5) >> 15 & 0xff);
luv3 += 3;
}
return;
}
while (n-- > 0)
{
*luv++ =
(uint32_t)luv3[0] << 16 |
(tiff_itrunc(luv3[1] * (UVSCALE / (1 << 15)), sp->encode_meth)
<< 8 &
0xff00) |
(tiff_itrunc(luv3[2] * (UVSCALE / (1 << 15)), sp->encode_meth) &
0xff);
*luv++ = (uint32_t)luv3[0] << 16 |
((uint32_t)tiff_itrunc(luv3[1] * (UVSCALE / (1 << 15)),
sp->encode_meth)
<< 8 &
0xff00) |
((uint32_t)tiff_itrunc(luv3[2] * (UVSCALE / (1 << 15)),
sp->encode_meth) &
0xff);
luv3 += 3;
}
}
@@ -1345,6 +1339,8 @@ static int LogL16GuessDataFmt(TIFFDirectory *td)
case PACK(1, 8, SAMPLEFORMAT_VOID):
case PACK(1, 8, SAMPLEFORMAT_UINT):
return (SGILOGDATAFMT_8BIT);
default:
break;
}
#undef PACK
return (SGILOGDATAFMT_UNKNOWN);
@@ -1399,7 +1395,7 @@ static int LogL16InitState(TIFF *tif)
sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
if (multiply_ms(sp->tbuflen, sizeof(int16_t)) == 0 ||
(sp->tbuf = (uint8_t *)_TIFFmallocExt(
tif, sp->tbuflen * sizeof(int16_t))) == NULL)
tif, (tmsize_t)((size_t)sp->tbuflen * sizeof(int16_t)))) == NULL)
{
TIFFErrorExtR(tif, module, "No space for SGILog translation buffer");
return (0);
@@ -1506,7 +1502,7 @@ static int LogLuvInitState(TIFF *tif)
sp->tbuflen = multiply_ms(td->td_imagewidth, td->td_imagelength);
if (multiply_ms(sp->tbuflen, sizeof(uint32_t)) == 0 ||
(sp->tbuf = (uint8_t *)_TIFFmallocExt(
tif, sp->tbuflen * sizeof(uint32_t))) == NULL)
tif, (tmsize_t)((size_t)sp->tbuflen * sizeof(uint32_t)))) == NULL)
{
TIFFErrorExtR(tif, module, "No space for SGILog translation buffer");
return (0);
@@ -1546,6 +1542,8 @@ static int LogLuvSetupDecode(TIFF *tif)
case SGILOGDATAFMT_8BIT:
sp->tfunc = Luv24toRGB;
break;
default:
break;
}
}
else
@@ -1562,6 +1560,8 @@ static int LogLuvSetupDecode(TIFF *tif)
case SGILOGDATAFMT_8BIT:
sp->tfunc = Luv32toRGB;
break;
default:
break;
}
}
return (1);
@@ -1577,6 +1577,8 @@ static int LogLuvSetupDecode(TIFF *tif)
case SGILOGDATAFMT_8BIT:
sp->tfunc = L16toGry;
break;
default:
break;
}
return (1);
default:
@@ -1755,8 +1757,9 @@ static int LogLuvVSetField(TIFF *tif, uint32_t tag, va_list ap)
/*
* Must recalculate sizes should bits/sample change.
*/
tif->tif_tilesize = isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)-1;
tif->tif_scanlinesize = TIFFScanlineSize(tif);
tif->tif_dir.td_tilesize =
isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)-1;
tif->tif_dir.td_scanlinesize = TIFFScanlineSize(tif);
return (1);
case TIFFTAG_SGILOGENCODE:
sp->encode_meth = (int)va_arg(ap, int);

65
3rdparty/libtiff/tif_lzma.c vendored
View File

@@ -95,6 +95,17 @@ static const char *LZMAStrerror(lzma_ret ret)
return "no progress is possible (stream is truncated or corrupt)";
case LZMA_PROG_ERROR:
return "programming error";
#if LZMA_VERSION >= 50040000 /* 5.4.0 */
case LZMA_SEEK_NEEDED:
case LZMA_RET_INTERNAL1:
case LZMA_RET_INTERNAL2:
case LZMA_RET_INTERNAL3:
case LZMA_RET_INTERNAL4:
case LZMA_RET_INTERNAL5:
case LZMA_RET_INTERNAL6:
case LZMA_RET_INTERNAL7:
case LZMA_RET_INTERNAL8:
#endif
default:
return "unidentified liblzma error";
}
@@ -179,7 +190,7 @@ static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"LZMADecode: Scanline %" PRIu32 " cannot be read due to "
"previous error",
tif->tif_row);
tif->tif_dir.td_row);
return 0;
}
@@ -231,7 +242,7 @@ static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
TIFFErrorExtR(tif, module,
"Decoding error at scanline %" PRIu32 ", %s",
tif->tif_row, LZMAStrerror(ret));
tif->tif_dir.td_row, LZMAStrerror(ret));
break;
}
} while (sp->stream.avail_out > 0);
@@ -242,12 +253,12 @@ static int LZMADecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at scanline %" PRIu32
" (short %" TIFF_SIZE_FORMAT " bytes)",
tif->tif_row, sp->stream.avail_out);
tif->tif_dir.td_row, sp->stream.avail_out);
return 0;
}
tif->tif_rawcp = (uint8_t *)sp->stream.next_in; /* cast away const */
tif->tif_rawcc = sp->stream.avail_in;
tif->tif_rawcc = (tmsize_t)sp->stream.avail_in;
return 1;
}
@@ -326,7 +337,7 @@ static int LZMAEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
{
TIFFErrorExtR(tif, module,
"Encoding error at scanline %" PRIu32 ", %s",
tif->tif_row, LZMAStrerror(ret));
tif->tif_dir.td_row, LZMAStrerror(ret));
return 0;
}
if (sp->stream.avail_out == 0)
@@ -365,7 +376,7 @@ static int LZMAPostEncode(TIFF *tif)
if ((tmsize_t)sp->stream.avail_out != tif->tif_rawdatasize)
{
tif->tif_rawcc =
tif->tif_rawdatasize - sp->stream.avail_out;
tif->tif_rawdatasize - (tmsize_t)sp->stream.avail_out;
if (!TIFFFlushData1(tif))
return 0;
sp->stream.next_out = tif->tif_rawdata;
@@ -376,6 +387,27 @@ static int LZMAPostEncode(TIFF *tif)
ZIPPreEncode */
}
break;
case LZMA_NO_CHECK:
case LZMA_UNSUPPORTED_CHECK:
case LZMA_GET_CHECK:
case LZMA_MEM_ERROR:
case LZMA_MEMLIMIT_ERROR:
case LZMA_FORMAT_ERROR:
case LZMA_OPTIONS_ERROR:
case LZMA_DATA_ERROR:
case LZMA_BUF_ERROR:
case LZMA_PROG_ERROR:
#if LZMA_VERSION >= 50040000 /* 5.4.0 */
case LZMA_SEEK_NEEDED:
case LZMA_RET_INTERNAL1:
case LZMA_RET_INTERNAL2:
case LZMA_RET_INTERNAL3:
case LZMA_RET_INTERNAL4:
case LZMA_RET_INTERNAL5:
case LZMA_RET_INTERNAL6:
case LZMA_RET_INTERNAL7:
case LZMA_RET_INTERNAL8:
#endif
default:
TIFFErrorExtR(tif, module, "Liblzma error: %s",
LZMAStrerror(ret));
@@ -416,7 +448,7 @@ static int LZMAVSetField(TIFF *tif, uint32_t tag, va_list ap)
{
case TIFFTAG_LZMAPRESET:
sp->preset = (int)va_arg(ap, int);
lzma_lzma_preset(&sp->opt_lzma, sp->preset);
lzma_lzma_preset(&sp->opt_lzma, (uint32_t)sp->preset);
if (sp->state & LSTATE_INIT_ENCODE)
{
lzma_ret ret =
@@ -454,6 +486,21 @@ static const TIFFField lzmaFields[] = {
FALSE, "LZMA2 Compression Preset", NULL},
};
static uint64_t LZMAGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* 1024x1024: 3800 */
/* 4096x4096: 6534 */
/* 16383x16383: 6846 */
/* 65536x65536: 6874 */
return 7000;
}
int TIFFInitLZMA(TIFF *tif, int scheme)
{
static const char module[] = "TIFFInitLZMA";
@@ -506,7 +553,7 @@ int TIFFInitLZMA(TIFF *tif, int scheme)
sp->filters[0].id = LZMA_FILTER_DELTA;
sp->filters[0].options = &sp->opt_delta;
lzma_lzma_preset(&sp->opt_lzma, sp->preset);
lzma_lzma_preset(&sp->opt_lzma, (uint32_t)sp->preset);
sp->filters[1].id = LZMA_FILTER_LZMA2;
sp->filters[1].options = &sp->opt_lzma;
@@ -529,6 +576,8 @@ int TIFFInitLZMA(TIFF *tif, int scheme)
tif->tif_encodestrip = LZMAEncode;
tif->tif_encodetile = LZMAEncode;
tif->tif_cleanup = LZMACleanup;
tif->tif_getmaxcompressionratio = LZMAGetMaxCompressionRatio;
/*
* Setup predictor setup.
*/

82
3rdparty/libtiff/tif_lzw.c vendored
View File

@@ -60,7 +60,7 @@ typedef size_t WordType;
*/
#define LZW_COMPAT /* include backwards compatibility code */
#define MAXCODE(n) ((1L << (n)) - 1)
#define MAXCODE(n) ((1 << (n)) - 1)
/*
* The TIFF spec specifies that encoded bit
* strings range from 9 to 12 bits.
@@ -72,7 +72,7 @@ typedef size_t WordType;
#define CODE_EOI 257 /* end-of-information code */
#define CODE_FIRST 258 /* first free code entry */
#define CODE_MAX MAXCODE(BITS_MAX)
#define HSIZE 9001L /* 91% occupancy */
#define HSIZE 9001 /* 91% occupancy */
#define HSHIFT (13 - 8)
#ifdef LZW_COMPAT
/* NB: +1024 is for compatibility with old files */
@@ -325,7 +325,7 @@ static int LZWPreDecode(TIFF *tif, uint16_t s)
*/
/* Get the next 32 or 64-bit from the input data */
#ifdef WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
#define GetNextData(nextdata, bp) memcpy(&nextdata, bp, sizeof(nextdata))
#elif SIZEOF_WORDTYPE == 8
#if defined(_M_X64)
@@ -372,7 +372,7 @@ static int LZWPreDecode(TIFF *tif, uint16_t s)
nextbits += 8 * SIZEOF_WORDTYPE; \
dec_bitsleft -= 8 * SIZEOF_WORDTYPE; \
code = (WordType)((codetmp | (nextdata >> nextbits)) & \
nbitsmask); \
(WordType)nbitsmask); \
break; \
} \
else \
@@ -396,7 +396,7 @@ static int LZWPreDecode(TIFF *tif, uint16_t s)
} \
} \
} \
code = (WordType)((nextdata >> nextbits) & nbitsmask); \
code = (WordType)((nextdata >> nextbits) & (WordType)nbitsmask); \
} while (0)
static int LZWDecode(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
@@ -420,7 +420,7 @@ static int LZWDecode(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
TIFFErrorExtR(tif, module,
"LZWDecode: Scanline %" PRIu32 " cannot be read due to "
"previous error",
tif->tif_row);
tif->tif_dir.td_row);
return 0;
}
@@ -472,7 +472,8 @@ static int LZWDecode(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
}
bp = (uint8_t *)tif->tif_rawcp;
sp->dec_bitsleft += (((uint64_t)tif->tif_rawcc - sp->old_tif_rawcc) << 3);
sp->dec_bitsleft +=
(((uint64_t)tif->tif_rawcc - (uint64_t)sp->old_tif_rawcc) << 3);
uint64_t dec_bitsleft = sp->dec_bitsleft;
nbits = sp->lzw_nbits;
nextdata = sp->lzw_nextdata;
@@ -493,7 +494,7 @@ begin:
{
WordType code;
GetNextCodeLZW();
codep = dec_codetab + code;
codep = dec_codetab + (unsigned long)code;
if (code >= CODE_FIRST)
goto code_above_or_equal_to_258;
if (code < 256)
@@ -508,7 +509,7 @@ code_below_256:
goto error_code;
free_entp->next = oldcodep;
free_entp->firstchar = oldcodep->firstchar;
free_entp->length = oldcodep->length + 1;
free_entp->length = (uint16_t)(oldcodep->length + 1);
free_entp->value = (uint8_t)code;
free_entp->repeated =
(bool)(oldcodep->repeated & (oldcodep->value == code));
@@ -556,7 +557,7 @@ code_above_or_equal_to_258:
free_entp->next = oldcodep;
free_entp->firstchar = oldcodep->firstchar;
free_entp->length = oldcodep->length + 1;
free_entp->length = (uint16_t)(oldcodep->length + 1);
if (++free_entp > maxcodep)
{
if (++nbits > BITS_MAX) /* should not happen for a conformant encoder */
@@ -673,7 +674,7 @@ code_clear:
free_entp = dec_codetab + CODE_FIRST;
nbits = BITS_MIN;
nbitsmask = MAXCODE(BITS_MIN);
maxcodep = dec_codetab + nbitsmask - 1;
maxcodep = dec_codetab + (unsigned long)nbitsmask - 1;
do
{
GetNextCodeLZW();
@@ -736,7 +737,7 @@ after_loop:
TIFFErrorExtR(tif, module,
"Not enough data at scanline %" PRIu32 " (short %" PRIu64
" bytes)",
tif->tif_row, (uint64_t)occ);
tif->tif_dir.td_row, (uint64_t)occ);
return (0);
}
return (1);
@@ -746,7 +747,7 @@ no_eoi:
sp->read_error = 1;
TIFFErrorExtR(tif, module,
"LZWDecode: Strip %" PRIu32 " not terminated with EOI code",
tif->tif_curstrip);
tif->tif_dir.td_curstrip);
return 0;
error_code:
memset(op, 0, (size_t)occ);
@@ -768,13 +769,13 @@ error_code:
TIFFWarningExtR(_tif, module, \
"LZWDecode: Strip %" PRIu32 \
" not terminated with EOI code", \
_tif->tif_curstrip); \
_tif->tif_dir.td_curstrip); \
_code = CODE_EOI; \
} \
else \
{ \
_get(_sp, _bp, _code); \
dec_bitsleft -= nbits; \
dec_bitsleft -= (uint64_t)nbits; \
} \
}
@@ -790,7 +791,7 @@ error_code:
nextdata |= (unsigned long)*(bp)++ << nextbits; \
nextbits += 8; \
} \
code = (hcode_t)(nextdata & nbitsmask); \
code = (hcode_t)(nextdata & (unsigned long)nbitsmask); \
nextdata >>= nbits; \
nextbits -= nbits; \
}
@@ -858,7 +859,8 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
bp = (uint8_t *)tif->tif_rawcp;
sp->dec_bitsleft += (((uint64_t)tif->tif_rawcc - sp->old_tif_rawcc) << 3);
sp->dec_bitsleft +=
(((uint64_t)tif->tif_rawcc - (uint64_t)sp->old_tif_rawcc) << 3);
uint64_t dec_bitsleft = sp->dec_bitsleft;
nbits = sp->lzw_nbits;
@@ -893,7 +895,7 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
TIFFErrorExtR(
tif, tif->tif_name,
"LZWDecode: Corrupted LZW table at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
*op++ = (uint8_t)code;
@@ -911,7 +913,7 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
{
TIFFErrorExtR(tif, module,
"Corrupted LZW table at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
@@ -921,11 +923,11 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
{
TIFFErrorExtR(tif, module,
"Corrupted LZW table at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
free_entp->firstchar = free_entp->next->firstchar;
free_entp->length = free_entp->next->length + 1;
free_entp->length = (uint16_t)(free_entp->next->length + 1);
free_entp->value =
(codep < free_entp) ? codep->firstchar : free_entp->firstchar;
if (++free_entp > maxcodep)
@@ -948,7 +950,7 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
tif, module,
"Wrong length of decoded "
"string: data probably corrupted at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
if (codep->length > occ)
@@ -1010,7 +1012,7 @@ static int LZWDecodeCompat(TIFF *tif, uint8_t *op0, tmsize_t occ0, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at scanline %" PRIu32 " (short %" PRIu64
" bytes)",
tif->tif_row, (uint64_t)occ);
tif->tif_dir.td_row, (uint64_t)occ);
return (0);
}
return (1);
@@ -1116,10 +1118,10 @@ static int LZWPreEncode(TIFF *tif, uint16_t s)
*/
static int LZWEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
{
register LZWCodecState *sp = LZWEncoderState(tif);
register long fcode;
register hash_t *hp;
register int h, c;
LZWCodecState *sp = LZWEncoderState(tif);
long fcode;
hash_t *hp;
int h, c;
hcode_t ent;
long disp;
tmsize_t incount, outcount, checkpoint;
@@ -1196,7 +1198,7 @@ static int LZWEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
* Avoid pointer arithmetic because of
* wraparound problems with segments.
*/
if ((h -= disp) < 0)
if ((h -= (int)disp) < 0)
h += HSIZE;
hp = &sp->enc_hashtab[h];
if (hp->hash == fcode)
@@ -1301,7 +1303,7 @@ static int LZWEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
*/
static int LZWPostEncode(TIFF *tif)
{
register LZWCodecState *sp = LZWEncoderState(tif);
LZWCodecState *sp = LZWEncoderState(tif);
uint8_t *op = tif->tif_rawcp;
long nextbits = sp->lzw_nextbits;
WordType nextdata = sp->lzw_nextdata;
@@ -1319,7 +1321,7 @@ static int LZWPostEncode(TIFF *tif)
{
int free_ent = sp->lzw_free_ent;
PutNextCode(op, sp->enc_oldcode);
PutNextCode(op, (WordType)sp->enc_oldcode);
sp->enc_oldcode = (hcode_t)-1;
free_ent++;
@@ -1357,8 +1359,8 @@ static int LZWPostEncode(TIFF *tif)
*/
static void cl_hash(LZWCodecState *sp)
{
register hash_t *hp = &sp->enc_hashtab[HSIZE - 1];
register long i = HSIZE - 8;
hash_t *hp = &sp->enc_hashtab[HSIZE - 1];
long i = HSIZE - 8;
do
{
@@ -1397,6 +1399,21 @@ static void LZWCleanup(TIFF *tif)
_TIFFSetDefaultCompressionState(tif);
}
static uint64_t LZWGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* 1024x1024: 562 */
/* 4096x4096: 1243 */
/* 16383x16383: 1353 */
/* 65536x65536: 1362 */
return 1400;
}
int TIFFInitLZW(TIFF *tif, int scheme)
{
static const char module[] = "TIFFInitLZW";
@@ -1430,6 +1447,7 @@ int TIFFInitLZW(TIFF *tif, int scheme)
tif->tif_encodestrip = LZWEncode;
tif->tif_encodetile = LZWEncode;
#endif
tif->tif_getmaxcompressionratio = LZWGetMaxCompressionRatio;
tif->tif_cleanup = LZWCleanup;
/*
* Setup predictor setup.

15
3rdparty/libtiff/tif_next.c vendored
View File

@@ -38,21 +38,22 @@
op[0] = (unsigned char)((v) << 6); \
break; \
case 1: \
op[0] |= (v) << 4; \
op[0] |= (unsigned char)((v) << 4); \
break; \
case 2: \
op[0] |= (v) << 2; \
op[0] |= (unsigned char)((v) << 2); \
break; \
case 3: \
*op++ |= (v); \
*op++ |= (unsigned char)(v); \
op_offset++; \
break; \
default: \
break; \
} \
}
#define LITERALROW 0x00
#define LITERALSPAN 0x40
#define WHITE ((1 << 2) - 1)
static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
{
@@ -73,7 +74,7 @@ static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
bp = (unsigned char *)tif->tif_rawcp;
cc = tif->tif_rawcc;
scanline = tif->tif_scanlinesize;
scanline = tif->tif_dir.td_scanlinesize;
if (occ % scanline)
{
TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
@@ -146,7 +147,7 @@ static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
{
TIFFErrorExtR(tif, module,
"Invalid data for scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
if (cc == 0)
@@ -163,7 +164,7 @@ static int NeXTDecode(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
return (1);
bad:
TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}

302
3rdparty/libtiff/tif_ojpeg.c vendored
View File

@@ -122,9 +122,6 @@
restarting of LibJpeg decoding session.
*/
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#include "tiffiop.h"
#ifdef OJPEG_SUPPORT
@@ -209,18 +206,12 @@ static const TIFFField ojpegFields[] = {
#include "jerror.h"
#include "jpeglib.h"
#ifndef TIFF_jpeg_source_mgr_defined
#define TIFF_jpeg_source_mgr_defined
typedef struct jpeg_source_mgr jpeg_source_mgr;
#endif
typedef struct jpeg_source_mgr tiff_ojpeg_source_mgr;
#ifndef TIFF_jpeg_error_mgr_defined
#define TIFF_jpeg_error_mgr_defined
typedef struct jpeg_error_mgr jpeg_error_mgr;
#endif
typedef struct jpeg_error_mgr tiff_ojpeg_error_mgr;
typedef struct jpeg_common_struct jpeg_common_struct;
typedef struct jpeg_decompress_struct jpeg_decompress_struct;
typedef struct jpeg_common_struct tiff_ojpeg_common_struct;
typedef struct jpeg_decompress_struct tiff_ojpeg_decompress_struct;
typedef enum
{
@@ -316,9 +307,9 @@ typedef struct
uint32_t write_curstrile;
uint8_t libjpeg_session_active;
uint8_t libjpeg_jpeg_query_style;
jpeg_error_mgr libjpeg_jpeg_error_mgr;
jpeg_decompress_struct libjpeg_jpeg_decompress_struct;
jpeg_source_mgr libjpeg_jpeg_source_mgr;
tiff_ojpeg_error_mgr libjpeg_jpeg_error_mgr;
tiff_ojpeg_decompress_struct libjpeg_jpeg_decompress_struct;
tiff_ojpeg_source_mgr libjpeg_jpeg_source_mgr;
uint8_t subsampling_convert_log;
uint32_t subsampling_convert_ylinelen;
uint32_t subsampling_convert_ylines;
@@ -413,46 +404,51 @@ static void OJPEGWriteStreamEoi(TIFF *tif, void **mem, uint32_t *len);
#ifdef LIBJPEG_ENCAP_EXTERNAL
extern int jpeg_create_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo);
extern int jpeg_read_header_encap(OJPEGState *sp, jpeg_decompress_struct *cinfo,
tiff_ojpeg_decompress_struct *cinfo);
extern int jpeg_read_header_encap(OJPEGState *sp,
tiff_ojpeg_decompress_struct *cinfo,
uint8_t require_image);
extern int jpeg_start_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo);
tiff_ojpeg_decompress_struct *cinfo);
extern int jpeg_read_scanlines_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo,
tiff_ojpeg_decompress_struct *cinfo,
void *scanlines, uint32_t max_lines);
extern int jpeg_read_raw_data_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo, void *data,
uint32_t max_lines);
tiff_ojpeg_decompress_struct *cinfo,
void *data, uint32_t max_lines);
extern void jpeg_encap_unwind(TIFF *tif);
#else
static int jpeg_create_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *j);
static int jpeg_read_header_encap(OJPEGState *sp, jpeg_decompress_struct *cinfo,
tiff_ojpeg_decompress_struct *j);
static int jpeg_read_header_encap(OJPEGState *sp,
tiff_ojpeg_decompress_struct *cinfo,
uint8_t require_image);
static int jpeg_start_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo);
tiff_ojpeg_decompress_struct *cinfo);
static int jpeg_read_scanlines_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo,
tiff_ojpeg_decompress_struct *cinfo,
void *scanlines, uint32_t max_lines);
static int jpeg_read_raw_data_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo, void *data,
uint32_t max_lines);
tiff_ojpeg_decompress_struct *cinfo,
void *data, uint32_t max_lines);
static void jpeg_encap_unwind(TIFF *tif);
#endif
static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct *cinfo);
static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct *cinfo);
static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct *cinfo);
static boolean
OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct *cinfo);
static void
OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct *cinfo,
OJPEGLibjpegJpegErrorMgrOutputMessage(tiff_ojpeg_common_struct *cinfo);
static void OJPEGLibjpegJpegErrorMgrErrorExit(tiff_ojpeg_common_struct *cinfo);
static void
OJPEGLibjpegJpegSourceMgrInitSource(tiff_ojpeg_decompress_struct *cinfo);
static boolean
OJPEGLibjpegJpegSourceMgrFillInputBuffer(tiff_ojpeg_decompress_struct *cinfo);
static void
OJPEGLibjpegJpegSourceMgrSkipInputData(tiff_ojpeg_decompress_struct *cinfo,
long num_bytes);
static boolean
OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct *cinfo,
OJPEGLibjpegJpegSourceMgrResyncToRestart(tiff_ojpeg_decompress_struct *cinfo,
int desired);
static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct *cinfo);
static void
OJPEGLibjpegJpegSourceMgrTermSource(tiff_ojpeg_decompress_struct *cinfo);
int TIFFInitOJPEG(TIFF *tif, int scheme)
{
@@ -473,7 +469,7 @@ int TIFFInitOJPEG(TIFF *tif, int scheme)
}
/* state block */
sp = _TIFFmallocExt(tif, sizeof(OJPEGState));
sp = (OJPEGState *)_TIFFmallocExt(tif, sizeof(OJPEGState));
if (sp == NULL)
{
TIFFErrorExtR(tif, module, "No space for OJPEG state block");
@@ -724,9 +720,9 @@ static int OJPEGPreDecode(TIFF *tif, uint16_t s)
return (0);
}
if (isTiled(tif))
m = tif->tif_curtile;
m = tif->tif_dir.td_curtile;
else
m = tif->tif_curstrip;
m = tif->tif_dir.td_curstrip;
if ((sp->writeheader_done != 0) &&
((sp->write_cursample != s) || (sp->write_curstrile > m)))
{
@@ -797,7 +793,7 @@ static int OJPEGPreDecodeSkipRaw(TIFF *tif)
{
if (jpeg_read_raw_data_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),
sp->subsampling_convert_ycbcrimage,
sp->subsampling_ver * 8) == 0)
(uint32_t)sp->subsampling_ver * 8) == 0)
return (0);
m -= sp->subsampling_convert_clines;
}
@@ -805,7 +801,7 @@ static int OJPEGPreDecodeSkipRaw(TIFF *tif)
{
if (jpeg_read_raw_data_encap(sp, &(sp->libjpeg_jpeg_decompress_struct),
sp->subsampling_convert_ycbcrimage,
sp->subsampling_ver * 8) == 0)
(uint32_t)sp->subsampling_ver * 8) == 0)
return (0);
sp->subsampling_convert_state = m;
}
@@ -819,7 +815,7 @@ static int OJPEGPreDecodeSkipScanlines(TIFF *tif)
uint32_t m;
if (sp->skip_buffer == NULL)
{
sp->skip_buffer = _TIFFmallocExt(tif, sp->bytes_per_line);
sp->skip_buffer = (uint8_t *)_TIFFmallocExt(tif, sp->bytes_per_line);
if (sp->skip_buffer == NULL)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -910,10 +906,10 @@ static int OJPEGDecodeRaw(TIFF *tif, uint8_t *buf, tmsize_t cc)
{
if (sp->subsampling_convert_state == 0)
{
if (jpeg_read_raw_data_encap(sp,
&(sp->libjpeg_jpeg_decompress_struct),
sp->subsampling_convert_ycbcrimage,
sp->subsampling_ver * 8) == 0)
if (jpeg_read_raw_data_encap(
sp, &(sp->libjpeg_jpeg_decompress_struct),
sp->subsampling_convert_ycbcrimage,
(uint32_t)sp->subsampling_ver * 8) == 0)
{
sp->error_in_raw_data_decoding = 1;
return (0);
@@ -1225,7 +1221,7 @@ static int OJPEGReadHeaderInfo(TIFF *tif)
TIFFErrorExtR(tif, module, "Invalid subsampling values");
return (0);
}
if (sp->strile_length % (sp->subsampling_ver * 8) != 0)
if (sp->strile_length % ((uint32_t)sp->subsampling_ver * 8) != 0)
{
TIFFErrorExtR(tif, module,
"Incompatible vertical subsampling and image "
@@ -1233,9 +1229,11 @@ static int OJPEGReadHeaderInfo(TIFF *tif)
return (0);
}
sp->restart_interval =
(uint16_t)(((sp->strile_width + sp->subsampling_hor * 8 - 1) /
(sp->subsampling_hor * 8)) *
(sp->strile_length / (sp->subsampling_ver * 8)));
(uint16_t)(((sp->strile_width + (uint32_t)sp->subsampling_hor * 8 -
1) /
((uint32_t)sp->subsampling_hor * 8)) *
(sp->strile_length /
((uint32_t)sp->subsampling_ver * 8)));
}
if (OJPEGReadHeaderInfoSec(tif) == 0)
return (0);
@@ -1358,20 +1356,43 @@ static int OJPEGWriteHeaderInfo(TIFF *tif)
/* Check for division by zero. */
if (sp->subsampling_hor == 0 || sp->subsampling_ver == 0)
return (0);
/* Check for potential overflow in subsampling_convert_ylinelen
* computation.
*/
if (sp->strile_width >
UINT32_MAX - ((uint32_t)sp->subsampling_hor * 8 - 1))
return (0);
sp->subsampling_convert_ylinelen =
((sp->strile_width + sp->subsampling_hor * 8 - 1) /
(sp->subsampling_hor * 8) * sp->subsampling_hor * 8);
sp->subsampling_convert_ylines = sp->subsampling_ver * 8;
((sp->strile_width + (uint32_t)sp->subsampling_hor * 8 - 1) /
((uint32_t)sp->subsampling_hor * 8) *
((uint32_t)sp->subsampling_hor * 8));
sp->subsampling_convert_ylines = (uint32_t)sp->subsampling_ver * 8;
sp->subsampling_convert_clinelen =
sp->subsampling_convert_ylinelen / sp->subsampling_hor;
sp->subsampling_convert_clines = 8;
sp->subsampling_convert_ybuflen = sp->subsampling_convert_ylinelen *
sp->subsampling_convert_ylines;
sp->subsampling_convert_cbuflen = sp->subsampling_convert_clinelen *
sp->subsampling_convert_clines;
sp->subsampling_convert_ycbcrbuflen =
sp->subsampling_convert_ybuflen +
2 * sp->subsampling_convert_cbuflen;
/* Check for potential overflow in buffer length computations.
* Use 64-bit intermediates to detect uint32_t overflow in
* ylinelen * ylines, clinelen * clines, and their sum.
*/
{
uint64_t ybuflen64 =
(uint64_t)sp->subsampling_convert_ylinelen *
sp->subsampling_convert_ylines;
uint64_t cbuflen64 =
(uint64_t)sp->subsampling_convert_clinelen *
sp->subsampling_convert_clines;
uint64_t ycbcrbuflen64 = ybuflen64 + 2 * cbuflen64;
if (ybuflen64 > UINT32_MAX || cbuflen64 > UINT32_MAX ||
ycbcrbuflen64 > UINT32_MAX)
{
TIFFErrorExtR(tif, module,
"Integer overflow in OJPEG buffer size");
return (0);
}
sp->subsampling_convert_ybuflen = (uint32_t)ybuflen64;
sp->subsampling_convert_cbuflen = (uint32_t)cbuflen64;
sp->subsampling_convert_ycbcrbuflen = (uint32_t)ycbcrbuflen64;
}
/* The calloc is not normally necessary, except in some edge/broken
* cases */
/* for example for a tiled image of height 1 with a tile height of 1
@@ -1383,8 +1404,8 @@ static int OJPEGWriteHeaderInfo(TIFF *tif)
/* Even if this case is allowed (?), its handling is broken because
* OJPEGPreDecode() should also likely */
/* reset subsampling_convert_state to 0 when changing tile. */
sp->subsampling_convert_ycbcrbuf =
_TIFFcallocExt(tif, 1, sp->subsampling_convert_ycbcrbuflen);
sp->subsampling_convert_ycbcrbuf = (uint8_t *)_TIFFcallocExt(
tif, 1, sp->subsampling_convert_ycbcrbuflen);
if (sp->subsampling_convert_ycbcrbuf == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1398,8 +1419,9 @@ static int OJPEGWriteHeaderInfo(TIFF *tif)
sp->subsampling_convert_ycbcrimagelen =
3 + sp->subsampling_convert_ylines +
2 * sp->subsampling_convert_clines;
sp->subsampling_convert_ycbcrimage = _TIFFmallocExt(
tif, sp->subsampling_convert_ycbcrimagelen * sizeof(uint8_t *));
sp->subsampling_convert_ycbcrimage = (uint8_t **)_TIFFmallocExt(
tif, (tmsize_t)((size_t)sp->subsampling_convert_ycbcrimagelen *
sizeof(uint8_t *)));
if (sp->subsampling_convert_ycbcrimage == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1426,9 +1448,14 @@ static int OJPEGWriteHeaderInfo(TIFF *tif)
((sp->strile_width % sp->subsampling_hor) != 0 ? 1 : 0);
sp->subsampling_convert_state = 0;
sp->error_in_raw_data_decoding = 0;
sp->bytes_per_line =
sp->subsampling_convert_clinelenout *
(sp->subsampling_ver * sp->subsampling_hor + 2);
const uint64_t bpl =
(uint64_t)sp->subsampling_convert_clinelenout *
((uint64_t)sp->subsampling_ver * sp->subsampling_hor + 2);
if (bpl > UINT32_MAX)
return (0);
sp->bytes_per_line = (uint32_t)bpl;
sp->lines_per_strile =
sp->strile_length / sp->subsampling_ver +
((sp->strile_length % sp->subsampling_ver) != 0 ? 1 : 0);
@@ -1478,7 +1505,8 @@ static void OJPEGLibjpegSessionAbort(TIFF *tif)
{
OJPEGState *sp = (OJPEGState *)tif->tif_data;
assert(sp->libjpeg_session_active != 0);
jpeg_destroy((jpeg_common_struct *)(&(sp->libjpeg_jpeg_decompress_struct)));
jpeg_destroy(
(tiff_ojpeg_common_struct *)(&(sp->libjpeg_jpeg_decompress_struct)));
sp->libjpeg_session_active = 0;
}
@@ -1560,7 +1588,7 @@ static int OJPEGReadHeaderInfoSec(TIFF *tif)
return (0);
}
if (n > 2)
OJPEGReadSkip(sp, n - 2);
OJPEGReadSkip(sp, (uint16_t)(n - 2));
break;
case JPEG_MARKER_DRI:
if (OJPEGReadHeaderInfoSecStreamDri(tif) == 0)
@@ -1603,8 +1631,9 @@ static int OJPEGReadHeaderInfoSec(TIFF *tif)
return (0);
sp->sof_marker_id = JPEG_MARKER_SOF0;
for (o = 0; o < sp->samples_per_pixel; o++)
sp->sof_c[o] = o;
sp->sof_hv[0] = ((sp->subsampling_hor << 4) | sp->subsampling_ver);
sp->sof_c[o] = (uint8_t)o;
sp->sof_hv[0] =
(uint8_t)((sp->subsampling_hor << 4) | sp->subsampling_ver);
for (o = 1; o < sp->samples_per_pixel; o++)
sp->sof_hv[o] = 17;
sp->sof_x = sp->strile_width;
@@ -1659,10 +1688,10 @@ static int OJPEGReadHeaderInfoSecStreamDqt(TIFF *tif)
return (0);
}
if (sp->subsamplingcorrect != 0)
OJPEGReadSkip(sp, m - 2);
OJPEGReadSkip(sp, (uint16_t)(m - 2));
else
{
m -= 2;
m = (uint16_t)(m - 2);
do
{
if (m < 65)
@@ -1671,7 +1700,7 @@ static int OJPEGReadHeaderInfoSecStreamDqt(TIFF *tif)
return (0);
}
na = sizeof(uint32_t) + 69;
nb = _TIFFmallocExt(tif, na);
nb = (uint8_t *)_TIFFmallocExt(tif, na);
if (nb == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1697,7 +1726,7 @@ static int OJPEGReadHeaderInfoSecStreamDqt(TIFF *tif)
if (sp->qtable[o] != 0)
_TIFFfreeExt(tif, sp->qtable[o]);
sp->qtable[o] = nb;
m -= 65;
m = (uint16_t)(m - 65);
} while (m > 0);
}
return (1);
@@ -1725,12 +1754,12 @@ static int OJPEGReadHeaderInfoSecStreamDht(TIFF *tif)
}
if (sp->subsamplingcorrect != 0)
{
OJPEGReadSkip(sp, m - 2);
OJPEGReadSkip(sp, (uint16_t)(m - 2));
}
else
{
na = sizeof(uint32_t) + 2 + m;
nb = _TIFFmallocExt(tif, na);
na = (uint32_t)(sizeof(uint32_t) + 2 + m);
nb = (uint8_t *)_TIFFmallocExt(tif, na);
if (nb == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -1739,9 +1768,10 @@ static int OJPEGReadHeaderInfoSecStreamDht(TIFF *tif)
*(uint32_t *)nb = na;
nb[sizeof(uint32_t)] = 255;
nb[sizeof(uint32_t) + 1] = JPEG_MARKER_DHT;
nb[sizeof(uint32_t) + 2] = (m >> 8);
nb[sizeof(uint32_t) + 3] = (m & 255);
if (OJPEGReadBlock(sp, m - 2, &nb[sizeof(uint32_t) + 4]) == 0)
nb[sizeof(uint32_t) + 2] = (uint8_t)(m >> 8);
nb[sizeof(uint32_t) + 3] = (uint8_t)(m & 255);
if (OJPEGReadBlock(sp, (uint16_t)(m - 2), &nb[sizeof(uint32_t) + 4]) ==
0)
{
_TIFFfreeExt(tif, nb);
return (0);
@@ -1809,7 +1839,7 @@ static int OJPEGReadHeaderInfoSecStreamSof(TIFF *tif, uint8_t marker_id)
TIFFErrorExtR(tif, module, "Corrupt SOF marker in JPEG data");
return (0);
}
m -= 8;
m = (uint16_t)(m - 8);
if (m % 3 != 0)
{
if (sp->subsamplingcorrect == 0)
@@ -2030,7 +2060,7 @@ static int OJPEGReadHeaderInfoSecTablesQTable(TIFF *tif)
}
}
oa = sizeof(uint32_t) + 69;
ob = _TIFFmallocExt(tif, oa);
ob = (uint8_t *)_TIFFmallocExt(tif, oa);
if (ob == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2098,8 +2128,8 @@ static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF *tif)
q = 0;
for (n = 0; n < 16; n++)
q += o[n];
ra = sizeof(uint32_t) + 21 + q;
rb = _TIFFmallocExt(tif, ra);
ra = (uint32_t)(sizeof(uint32_t) + 21 + q);
rb = (uint8_t *)_TIFFmallocExt(tif, ra);
if (rb == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2122,7 +2152,7 @@ static int OJPEGReadHeaderInfoSecTablesDcTable(TIFF *tif)
if (sp->dctable[m] != 0)
_TIFFfreeExt(tif, sp->dctable[m]);
sp->dctable[m] = rb;
sp->sos_tda[m] = (m << 4);
sp->sos_tda[m] = (uint8_t)(m << 4);
}
else
sp->sos_tda[m] = sp->sos_tda[m - 1];
@@ -2168,8 +2198,8 @@ static int OJPEGReadHeaderInfoSecTablesAcTable(TIFF *tif)
q = 0;
for (n = 0; n < 16; n++)
q += o[n];
ra = sizeof(uint32_t) + 21 + q;
rb = _TIFFmallocExt(tif, ra);
ra = (uint32_t)(sizeof(uint32_t) + 21 + q);
rb = (uint8_t *)_TIFFmallocExt(tif, ra);
if (rb == 0)
{
TIFFErrorExtR(tif, module, "Out of memory");
@@ -2220,7 +2250,7 @@ static int OJPEGReadBufferFill(OJPEGState *sp)
if ((uint64_t)m > sp->in_buffer_file_togo)
m = (uint16_t)sp->in_buffer_file_togo;
n = TIFFReadFile(sp->tif, sp->in_buffer, (tmsize_t)m);
if (n == 0)
if (n <= 0)
return (0);
assert(n > 0);
assert(n <= OJPEG_BUFFER);
@@ -2286,6 +2316,7 @@ static int OJPEGReadBufferFill(OJPEGState *sp)
sp->in_buffer_next_strile++;
}
break;
case osibsEof:
default:
return (0);
}
@@ -2331,7 +2362,7 @@ static int OJPEGReadWord(OJPEGState *sp, uint16_t *word)
uint8_t m;
if (OJPEGReadByte(sp, &m) == 0)
return (0);
*word = (m << 8);
*word = (uint16_t)(m << 8);
if (OJPEGReadByte(sp, &m) == 0)
return (0);
*word |= m;
@@ -2345,7 +2376,7 @@ static int OJPEGReadBlock(OJPEGState *sp, uint16_t len, void *mem)
uint16_t n;
assert(len > 0);
mlen = len;
mmem = mem;
mmem = (uint8_t *)mem;
do
{
if (sp->in_buffer_togo == 0)
@@ -2359,8 +2390,8 @@ static int OJPEGReadBlock(OJPEGState *sp, uint16_t len, void *mem)
n = sp->in_buffer_togo;
_TIFFmemcpy(mmem, sp->in_buffer_cur, n);
sp->in_buffer_cur += n;
sp->in_buffer_togo -= n;
mlen -= n;
sp->in_buffer_togo = (uint16_t)(sp->in_buffer_togo - n);
mlen = (uint16_t)(mlen - n);
mmem += n;
} while (mlen > 0);
return (1);
@@ -2375,8 +2406,8 @@ static void OJPEGReadSkip(OJPEGState *sp, uint16_t len)
if (n > sp->in_buffer_togo)
n = sp->in_buffer_togo;
sp->in_buffer_cur += n;
sp->in_buffer_togo -= n;
m -= n;
sp->in_buffer_togo = (uint16_t)(sp->in_buffer_togo - n);
m = (uint16_t)(m - n);
if (m > 0)
{
assert(sp->in_buffer_togo == 0);
@@ -2462,6 +2493,8 @@ static int OJPEGWriteStream(TIFF *tif, void **mem, uint32_t *len)
case ososEoi:
OJPEGWriteStreamEoi(tif, mem, len);
break;
default:
break;
}
} while (*len == 0);
return (1);
@@ -2475,7 +2508,7 @@ static void OJPEGWriteStreamSoi(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[1] = JPEG_MARKER_SOI;
*len = 2;
*mem = (void *)sp->out_buffer;
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamQTable(TIFF *tif, uint8_t table_index, void **mem,
@@ -2485,9 +2518,10 @@ static void OJPEGWriteStreamQTable(TIFF *tif, uint8_t table_index, void **mem,
if (sp->qtable[table_index] != 0)
{
*mem = (void *)(sp->qtable[table_index] + sizeof(uint32_t));
*len = *((uint32_t *)sp->qtable[table_index]) - sizeof(uint32_t);
*len = (uint32_t)(*((uint32_t *)sp->qtable[table_index]) -
sizeof(uint32_t));
}
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamDcTable(TIFF *tif, uint8_t table_index, void **mem,
@@ -2497,9 +2531,10 @@ static void OJPEGWriteStreamDcTable(TIFF *tif, uint8_t table_index, void **mem,
if (sp->dctable[table_index] != 0)
{
*mem = (void *)(sp->dctable[table_index] + sizeof(uint32_t));
*len = *((uint32_t *)sp->dctable[table_index]) - sizeof(uint32_t);
*len = (uint32_t)(*((uint32_t *)sp->dctable[table_index]) -
sizeof(uint32_t));
}
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamAcTable(TIFF *tif, uint8_t table_index, void **mem,
@@ -2509,9 +2544,10 @@ static void OJPEGWriteStreamAcTable(TIFF *tif, uint8_t table_index, void **mem,
if (sp->actable[table_index] != 0)
{
*mem = (void *)(sp->actable[table_index] + sizeof(uint32_t));
*len = *((uint32_t *)sp->actable[table_index]) - sizeof(uint32_t);
*len = (uint32_t)(*((uint32_t *)sp->actable[table_index]) -
sizeof(uint32_t));
}
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamDri(TIFF *tif, void **mem, uint32_t *len)
@@ -2524,12 +2560,12 @@ static void OJPEGWriteStreamDri(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[1] = JPEG_MARKER_DRI;
sp->out_buffer[2] = 0;
sp->out_buffer[3] = 4;
sp->out_buffer[4] = (sp->restart_interval >> 8);
sp->out_buffer[5] = (sp->restart_interval & 255);
sp->out_buffer[4] = (uint8_t)(sp->restart_interval >> 8);
sp->out_buffer[5] = (uint8_t)(sp->restart_interval & 255);
*len = 6;
*mem = (void *)sp->out_buffer;
}
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamSof(TIFF *tif, void **mem, uint32_t *len)
@@ -2542,15 +2578,15 @@ static void OJPEGWriteStreamSof(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[1] = sp->sof_marker_id;
/* Lf */
sp->out_buffer[2] = 0;
sp->out_buffer[3] = 8 + sp->samples_per_pixel_per_plane * 3;
sp->out_buffer[3] = (uint8_t)(8 + sp->samples_per_pixel_per_plane * 3);
/* P */
sp->out_buffer[4] = 8;
/* Y */
sp->out_buffer[5] = (uint8_t)(sp->sof_y >> 8);
sp->out_buffer[6] = (sp->sof_y & 255);
sp->out_buffer[6] = (uint8_t)(sp->sof_y & 255);
/* X */
sp->out_buffer[7] = (uint8_t)(sp->sof_x >> 8);
sp->out_buffer[8] = (sp->sof_x & 255);
sp->out_buffer[8] = (uint8_t)(sp->sof_x & 255);
/* Nf */
sp->out_buffer[9] = sp->samples_per_pixel_per_plane;
for (m = 0; m < sp->samples_per_pixel_per_plane; m++)
@@ -2564,9 +2600,9 @@ static void OJPEGWriteStreamSof(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[10 + m * 3 + 2] =
sp->sof_tq[sp->plane_sample_offset + m];
}
*len = 10 + sp->samples_per_pixel_per_plane * 3;
*len = 10 + (uint32_t)sp->samples_per_pixel_per_plane * 3;
*mem = (void *)sp->out_buffer;
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static void OJPEGWriteStreamSos(TIFF *tif, void **mem, uint32_t *len)
@@ -2579,7 +2615,7 @@ static void OJPEGWriteStreamSos(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[1] = JPEG_MARKER_SOS;
/* Ls */
sp->out_buffer[2] = 0;
sp->out_buffer[3] = 6 + sp->samples_per_pixel_per_plane * 2;
sp->out_buffer[3] = (uint8_t)(6 + sp->samples_per_pixel_per_plane * 2);
/* Ns */
sp->out_buffer[4] = sp->samples_per_pixel_per_plane;
for (m = 0; m < sp->samples_per_pixel_per_plane; m++)
@@ -2596,9 +2632,9 @@ static void OJPEGWriteStreamSos(TIFF *tif, void **mem, uint32_t *len)
sp->out_buffer[5 + sp->samples_per_pixel_per_plane * 2 + 1] = 63;
/* Ah and Al */
sp->out_buffer[5 + sp->samples_per_pixel_per_plane * 2 + 2] = 0;
*len = 8 + sp->samples_per_pixel_per_plane * 2;
*len = 8 + (uint32_t)sp->samples_per_pixel_per_plane * 2;
*mem = (void *)sp->out_buffer;
sp->out_state++;
sp->out_state = (OJPEGStateOutState)(sp->out_state + 1);
}
static int OJPEGWriteStreamCompressed(TIFF *tif, void **mem, uint32_t *len)
@@ -2626,6 +2662,8 @@ static int OJPEGWriteStreamCompressed(TIFF *tif, void **mem, uint32_t *len)
case osibsEof:
sp->out_state = ososEoi;
break;
case osibsNotSetYet:
case osibsJpegInterchangeFormat:
default:
break;
}
@@ -2638,7 +2676,7 @@ static void OJPEGWriteStreamRst(TIFF *tif, void **mem, uint32_t *len)
OJPEGState *sp = (OJPEGState *)tif->tif_data;
assert(OJPEG_BUFFER >= 2);
sp->out_buffer[0] = 255;
sp->out_buffer[1] = JPEG_MARKER_RST0 + sp->restart_index;
sp->out_buffer[1] = (uint8_t)(JPEG_MARKER_RST0 + sp->restart_index);
sp->restart_index++;
if (sp->restart_index == 8)
sp->restart_index = 0;
@@ -2659,7 +2697,7 @@ static void OJPEGWriteStreamEoi(TIFF *tif, void **mem, uint32_t *len)
#ifndef LIBJPEG_ENCAP_EXTERNAL
static int jpeg_create_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo)
tiff_ojpeg_decompress_struct *cinfo)
{
if (SETJMP(sp->exit_jmpbuf))
return 0;
@@ -2672,7 +2710,8 @@ static int jpeg_create_decompress_encap(OJPEGState *sp,
#endif
#ifndef LIBJPEG_ENCAP_EXTERNAL
static int jpeg_read_header_encap(OJPEGState *sp, jpeg_decompress_struct *cinfo,
static int jpeg_read_header_encap(OJPEGState *sp,
tiff_ojpeg_decompress_struct *cinfo,
uint8_t require_image)
{
if (SETJMP(sp->exit_jmpbuf))
@@ -2687,7 +2726,7 @@ static int jpeg_read_header_encap(OJPEGState *sp, jpeg_decompress_struct *cinfo,
#ifndef LIBJPEG_ENCAP_EXTERNAL
static int jpeg_start_decompress_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo)
tiff_ojpeg_decompress_struct *cinfo)
{
if (SETJMP(sp->exit_jmpbuf))
return 0;
@@ -2701,14 +2740,14 @@ static int jpeg_start_decompress_encap(OJPEGState *sp,
#ifndef LIBJPEG_ENCAP_EXTERNAL
static int jpeg_read_scanlines_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo,
tiff_ojpeg_decompress_struct *cinfo,
void *scanlines, uint32_t max_lines)
{
if (SETJMP(sp->exit_jmpbuf))
return 0;
else
{
jpeg_read_scanlines(cinfo, scanlines, max_lines);
jpeg_read_scanlines(cinfo, (JSAMPARRAY)scanlines, max_lines);
return 1;
}
}
@@ -2716,14 +2755,14 @@ static int jpeg_read_scanlines_encap(OJPEGState *sp,
#ifndef LIBJPEG_ENCAP_EXTERNAL
static int jpeg_read_raw_data_encap(OJPEGState *sp,
jpeg_decompress_struct *cinfo, void *data,
uint32_t max_lines)
tiff_ojpeg_decompress_struct *cinfo,
void *data, uint32_t max_lines)
{
if (SETJMP(sp->exit_jmpbuf))
return 0;
else
{
jpeg_read_raw_data(cinfo, data, max_lines);
jpeg_read_raw_data(cinfo, (JSAMPIMAGE)data, max_lines);
return 1;
}
}
@@ -2737,14 +2776,15 @@ static void jpeg_encap_unwind(TIFF *tif)
}
#endif
static void OJPEGLibjpegJpegErrorMgrOutputMessage(jpeg_common_struct *cinfo)
static void
OJPEGLibjpegJpegErrorMgrOutputMessage(tiff_ojpeg_common_struct *cinfo)
{
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message)(cinfo, buffer);
TIFFWarningExtR(((TIFF *)(cinfo->client_data)), "LibJpeg", "%s", buffer);
}
static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct *cinfo)
static void OJPEGLibjpegJpegErrorMgrErrorExit(tiff_ojpeg_common_struct *cinfo)
{
char buffer[JMSG_LENGTH_MAX];
(*cinfo->err->format_message)(cinfo, buffer);
@@ -2752,13 +2792,14 @@ static void OJPEGLibjpegJpegErrorMgrErrorExit(jpeg_common_struct *cinfo)
jpeg_encap_unwind((TIFF *)(cinfo->client_data));
}
static void OJPEGLibjpegJpegSourceMgrInitSource(jpeg_decompress_struct *cinfo)
static void
OJPEGLibjpegJpegSourceMgrInitSource(tiff_ojpeg_decompress_struct *cinfo)
{
(void)cinfo;
}
static boolean
OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct *cinfo)
OJPEGLibjpegJpegSourceMgrFillInputBuffer(tiff_ojpeg_decompress_struct *cinfo)
{
TIFF *tif = (TIFF *)cinfo->client_data;
OJPEGState *sp = (OJPEGState *)tif->tif_data;
@@ -2770,12 +2811,12 @@ OJPEGLibjpegJpegSourceMgrFillInputBuffer(jpeg_decompress_struct *cinfo)
jpeg_encap_unwind(tif);
}
sp->libjpeg_jpeg_source_mgr.bytes_in_buffer = len;
sp->libjpeg_jpeg_source_mgr.next_input_byte = mem;
sp->libjpeg_jpeg_source_mgr.next_input_byte = (const JOCTET *)mem;
return (1);
}
static void
OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct *cinfo,
OJPEGLibjpegJpegSourceMgrSkipInputData(tiff_ojpeg_decompress_struct *cinfo,
long num_bytes)
{
TIFF *tif = (TIFF *)cinfo->client_data;
@@ -2789,7 +2830,7 @@ OJPEGLibjpegJpegSourceMgrSkipInputData(jpeg_decompress_struct *cinfo,
#pragma warning(disable : 4702) /* unreachable code */
#endif
static boolean
OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct *cinfo,
OJPEGLibjpegJpegSourceMgrResyncToRestart(tiff_ojpeg_decompress_struct *cinfo,
int desired)
{
TIFF *tif = (TIFF *)cinfo->client_data;
@@ -2802,7 +2843,8 @@ OJPEGLibjpegJpegSourceMgrResyncToRestart(jpeg_decompress_struct *cinfo,
#pragma warning(pop)
#endif
static void OJPEGLibjpegJpegSourceMgrTermSource(jpeg_decompress_struct *cinfo)
static void
OJPEGLibjpegJpegSourceMgrTermSource(tiff_ojpeg_decompress_struct *cinfo)
{
(void)cinfo;
}

35
3rdparty/libtiff/tif_open.c vendored
View File

@@ -77,7 +77,7 @@ int _TIFFgetMode(TIFFOpenOptions *opts, thandle_t clientdata, const char *mode,
return (m);
}
TIFFOpenOptions *TIFFOpenOptionsAlloc()
TIFFOpenOptions *TIFFOpenOptionsAlloc(void)
{
TIFFOpenOptions *opts =
(TIFFOpenOptions *)_TIFFcalloc(1, sizeof(TIFFOpenOptions));
@@ -308,6 +308,7 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
TIFF *tif;
int m;
const char *cp;
tmsize_t size_to_alloc;
/* The following are configuration checks. They should be redundant, but
* should not compile to any actual code in an optimised release build
@@ -330,7 +331,7 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
n.a8[0] = 1;
n.a8[1] = 0;
(void)n;
#ifdef WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
assert(n.a16 == 256);
#else
assert(n.a16 == 1);
@@ -340,7 +341,7 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
m = _TIFFgetMode(opts, clientdata, mode, module);
if (m == -1)
goto bad2;
tmsize_t size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
size_to_alloc = (tmsize_t)(sizeof(TIFF) + strlen(name) + 1);
if (opts && opts->max_single_mem_alloc > 0 &&
size_to_alloc > opts->max_single_mem_alloc)
{
@@ -377,8 +378,6 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
tif->tif_curdir = TIFF_NON_EXISTENT_DIR_NUMBER; /* non-existent directory */
tif->tif_curdircount = TIFF_NON_EXISTENT_DIR_NUMBER;
tif->tif_curoff = 0;
tif->tif_curstrip = (uint32_t)-1; /* invalid strip */
tif->tif_row = (uint32_t)-1; /* read/write pre-increment */
tif->tif_clientdata = clientdata;
tif->tif_readproc = readproc;
tif->tif_writeproc = writeproc;
@@ -398,6 +397,10 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
tif->tif_warn_about_unknown_tags = opts->warn_about_unknown_tags;
}
/* Reset tif->tif_dir structure to zero and
* initialize some IFD strile counter and index parameters. */
_TIFFResetTifDirAndInitStrileCounters(&tif->tif_dir);
if (!readproc || !writeproc || !seekproc || !closeproc || !sizeproc)
{
TIFFErrorExtR(tif, module,
@@ -480,13 +483,13 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
switch (*cp)
{
case 'b':
#ifndef WORDS_BIGENDIAN
#if !WORDS_BIGENDIAN
if (m & O_CREAT)
tif->tif_flags |= TIFF_SWAB;
#endif
break;
case 'l':
#ifdef WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
if ((m & O_CREAT))
tif->tif_flags |= TIFF_SWAB;
#endif
@@ -536,7 +539,9 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
case 'O':
if (m == O_RDONLY)
tif->tif_flags |=
(TIFF_LAZYSTRILELOAD | TIFF_DEFERSTRILELOAD);
(TIFF_LAZYSTRILELOAD_ASKED | TIFF_DEFERSTRILELOAD);
break;
default:
break;
}
@@ -561,7 +566,7 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
/*
* Setup header and write.
*/
#ifdef WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
tif->tif_header.common.tiff_magic =
(tif->tif_flags & TIFF_SWAB) ? TIFF_LITTLEENDIAN : TIFF_BIGENDIAN;
#else
@@ -654,13 +659,13 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
}
if (tif->tif_header.common.tiff_magic == TIFF_BIGENDIAN)
{
#ifndef WORDS_BIGENDIAN
#if !WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
}
else
{
#ifdef WORDS_BIGENDIAN
#if WORDS_BIGENDIAN
tif->tif_flags |= TIFF_SWAB;
#endif
}
@@ -780,6 +785,8 @@ TIFF *TIFFClientOpenExt(const char *name, const char *mode,
if (!TIFFDefaultDirectory(tif))
goto bad;
return (tif);
default:
break;
}
bad:
tif->tif_mode = O_RDONLY; /* XXX avoid flush */
@@ -861,7 +868,7 @@ int TIFFIsTiled(TIFF *tif) { return (isTiled(tif)); }
/*
* Return current row being read/written.
*/
uint32_t TIFFCurrentRow(TIFF *tif) { return (tif->tif_row); }
uint32_t TIFFCurrentRow(TIFF *tif) { return (tif->tif_dir.td_row); }
/*
* Return index of the current directory.
@@ -871,12 +878,12 @@ tdir_t TIFFCurrentDirectory(TIFF *tif) { return (tif->tif_curdir); }
/*
* Return current strip.
*/
uint32_t TIFFCurrentStrip(TIFF *tif) { return (tif->tif_curstrip); }
uint32_t TIFFCurrentStrip(TIFF *tif) { return (tif->tif_dir.td_curstrip); }
/*
* Return current tile.
*/
uint32_t TIFFCurrentTile(TIFF *tif) { return (tif->tif_curtile); }
uint32_t TIFFCurrentTile(TIFF *tif) { return (tif->tif_dir.td_curtile); }
/*
* Return nonzero if the file has byte-swapped data.

21
3rdparty/libtiff/tif_packbits.c vendored
View File

@@ -194,12 +194,17 @@ static int PackBitsEncode(TIFF *tif, uint8_t *buf, tmsize_t cc, uint16_t s)
*/
if (n == 1 && op[-2] == (uint8_t)-1 && *lastliteral < 126)
{
state = (((*lastliteral) += 2) == 127 ? BASE : LITERAL);
state =
(((*lastliteral) = (uint8_t)(*lastliteral + 2)) == 127
? BASE
: LITERAL);
op[-2] = op[-1]; /* replicate */
}
else
state = RUN;
goto again;
default:
break;
}
}
tif->tif_rawcc += (tmsize_t)(op - tif->tif_rawcp);
@@ -306,12 +311,22 @@ static int PackBitsDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
memset(op, 0, (size_t)occ);
TIFFErrorExtR(tif, module, "Not enough data for scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
return (0);
}
return (1);
}
static uint64_t PackBitsGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
return 64;
}
int TIFFInitPackBits(TIFF *tif, int scheme)
{
(void)scheme;
@@ -325,6 +340,8 @@ int TIFFInitPackBits(TIFF *tif, int scheme)
tif->tif_encodestrip = PackBitsEncodeChunk;
tif->tif_encodetile = PackBitsEncodeChunk;
#endif
tif->tif_getmaxcompressionratio = PackBitsGetMaxCompressionRatio;
return (1);
}
#endif /* PACKBITS_SUPPORT */

237
3rdparty/libtiff/tif_pixarlog.c vendored
View File

@@ -117,11 +117,11 @@ static float LogK1, LogK2;
} while (i > 0); \
}
static void horizontalAccumulateF(uint16_t *wp, int n, int stride, float *op,
float *ToLinearF)
static void horizontalAccumulateF(uint16_t *wp, tmsize_t n, int stride,
float *op, float *ToLinearF)
{
register unsigned int cr, cg, cb, ca, mask;
register float t0, t1, t2, t3;
unsigned int cr, cg, cb, ca, mask;
float t0, t1, t2, t3;
if (n >= stride)
{
@@ -180,22 +180,22 @@ static void horizontalAccumulateF(uint16_t *wp, int n, int stride, float *op,
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp; *op = ToLinearF[*wp & mask];
wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
*op = ToLinearF[*wp & mask]; wp++; op++)
n -= stride;
}
}
}
}
static void horizontalAccumulate12(uint16_t *wp, int n, int stride, int16_t *op,
float *ToLinearF)
static void horizontalAccumulate12(uint16_t *wp, tmsize_t n, int stride,
int16_t *op, float *ToLinearF)
{
register unsigned int cr, cg, cb, ca, mask;
register float t0, t1, t2, t3;
unsigned int cr, cg, cb, ca, mask;
float t0, t1, t2, t3;
#define SCALE12 2048.0F
#define CLAMP12(t) (((t) < 3071) ? (uint16_t)(t) : 3071)
#define SCALE12 2048.0f
#define CLAMP12(t) (((t) < 3071) ? (int16_t)(uint16_t)(t) : (int16_t)3071)
if (n >= stride)
{
@@ -255,19 +255,19 @@ static void horizontalAccumulate12(uint16_t *wp, int n, int stride, int16_t *op,
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp;
t0 = ToLinearF[wp[stride] & mask] * SCALE12;
*op = CLAMP12(t0); wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
t0 = ToLinearF[*wp & mask] * SCALE12; *op = CLAMP12(t0);
wp++; op++)
n -= stride;
}
}
}
}
static void horizontalAccumulate16(uint16_t *wp, int n, int stride,
static void horizontalAccumulate16(uint16_t *wp, tmsize_t n, int stride,
uint16_t *op, uint16_t *ToLinear16)
{
register unsigned int cr, cg, cb, ca, mask;
unsigned int cr, cg, cb, ca, mask;
if (n >= stride)
{
@@ -312,8 +312,8 @@ static void horizontalAccumulate16(uint16_t *wp, int n, int stride,
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp; *op = ToLinear16[*wp & mask];
wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
*op = ToLinear16[*wp & mask]; wp++; op++)
n -= stride;
}
}
@@ -324,10 +324,10 @@ static void horizontalAccumulate16(uint16_t *wp, int n, int stride,
* Returns the log encoded 11-bit values with the horizontal
* differencing undone.
*/
static void horizontalAccumulate11(uint16_t *wp, int n, int stride,
static void horizontalAccumulate11(uint16_t *wp, tmsize_t n, int stride,
uint16_t *op)
{
register unsigned int cr, cg, cb, ca, mask;
unsigned int cr, cg, cb, ca, mask;
if (n >= stride)
{
@@ -375,21 +375,22 @@ static void horizontalAccumulate11(uint16_t *wp, int n, int stride,
}
else
{
REPEAT(stride, *op = *wp & mask; wp++; op++)
REPEAT(stride, *op = (uint16_t)(*wp & mask); wp++; op++)
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp; *op = *wp & mask; wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
*op = (uint16_t)(*wp & mask); wp++; op++)
n -= stride;
}
}
}
}
static void horizontalAccumulate8(uint16_t *wp, int n, int stride,
static void horizontalAccumulate8(uint16_t *wp, tmsize_t n, int stride,
unsigned char *op, unsigned char *ToLinear8)
{
register unsigned int cr, cg, cb, ca, mask;
unsigned int cr, cg, cb, ca, mask;
if (n >= stride)
{
@@ -434,20 +435,20 @@ static void horizontalAccumulate8(uint16_t *wp, int n, int stride,
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp; *op = ToLinear8[*wp & mask];
wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
*op = ToLinear8[*wp & mask]; wp++; op++)
n -= stride;
}
}
}
}
static void horizontalAccumulate8abgr(uint16_t *wp, int n, int stride,
static void horizontalAccumulate8abgr(uint16_t *wp, tmsize_t n, int stride,
unsigned char *op,
unsigned char *ToLinear8)
{
register unsigned int cr, cg, cb, ca, mask;
register unsigned char t0, t1, t2, t3;
unsigned int cr, cg, cb, ca, mask;
unsigned char t0, t1, t2, t3;
if (n >= stride)
{
@@ -508,8 +509,8 @@ static void horizontalAccumulate8abgr(uint16_t *wp, int n, int stride,
n -= stride;
while (n > 0)
{
REPEAT(stride, wp[stride] += *wp; *op = ToLinear8[*wp & mask];
wp++; op++)
REPEAT(stride, *wp = (uint16_t)(*wp + wp[-stride]);
*op = ToLinear8[*wp & mask]; wp++; op++)
n -= stride;
}
}
@@ -577,7 +578,8 @@ static int PixarLogMakeTables(TIFF *tif, PixarLogState *sp)
LogK1 = (float)(1. / c); /* if (v >= 2) token = k1*log(v*k2) */
LogK2 = (float)(1. / b);
lt2size = (int)(2. / linstep) + 1;
FromLT2 = (uint16_t *)_TIFFmallocExt(tif, lt2size * sizeof(uint16_t));
FromLT2 = (uint16_t *)_TIFFmallocExt(
tif, (tmsize_t)((size_t)lt2size * sizeof(uint16_t)));
From14 = (uint16_t *)_TIFFmallocExt(tif, 16384 * sizeof(uint16_t));
From8 = (uint16_t *)_TIFFmallocExt(tif, 256 * sizeof(uint16_t));
ToLinearF = (float *)_TIFFmallocExt(tif, TSIZEP1 * sizeof(float));
@@ -623,16 +625,17 @@ static int PixarLogMakeTables(TIFF *tif, PixarLogState *sp)
for (i = 0; i < TSIZEP1; i++)
{
v = ToLinearF[i] * 65535.0 + 0.5;
v = (double)ToLinearF[i] * 65535.0 + 0.5;
ToLinear16[i] = (v > 65535.0) ? 65535 : (uint16_t)v;
v = ToLinearF[i] * 255.0 + 0.5;
v = (double)ToLinearF[i] * 255.0 + 0.5;
ToLinear8[i] = (v > 255.0) ? 255 : (unsigned char)v;
}
j = 0;
for (i = 0; i < lt2size; i++)
{
if ((i * linstep) * (i * linstep) > ToLinearF[j] * ToLinearF[j + 1])
if ((i * linstep) * (i * linstep) >
(double)ToLinearF[j] * (double)ToLinearF[j + 1])
j++;
FromLT2[i] = (uint16_t)j;
}
@@ -645,7 +648,8 @@ static int PixarLogMakeTables(TIFF *tif, PixarLogState *sp)
j = 0;
for (i = 0; i < 16384; i++)
{
while ((i / 16383.) * (i / 16383.) > ToLinearF[j] * ToLinearF[j + 1])
while ((i / 16383.) * (i / 16383.) >
(double)ToLinearF[j] * (double)ToLinearF[j + 1])
j++;
From14[i] = (uint16_t)j;
}
@@ -653,7 +657,8 @@ static int PixarLogMakeTables(TIFF *tif, PixarLogState *sp)
j = 0;
for (i = 0; i < 256; i++)
{
while ((i / 255.) * (i / 255.) > ToLinearF[j] * ToLinearF[j + 1])
while ((i / 255.) * (i / 255.) >
(double)ToLinearF[j] * (double)ToLinearF[j + 1])
j++;
From8[i] = (uint16_t)j;
}
@@ -708,6 +713,8 @@ static int PixarLogGuessDataFmt(TIFFDirectory *td)
if (format == SAMPLEFORMAT_VOID || format == SAMPLEFORMAT_UINT)
guess = PIXARLOGDATAFMT_8BIT;
break;
default:
break;
}
return guess;
@@ -769,7 +776,8 @@ static int PixarLogSetupDecode(TIFF *tif)
multiply_ms(multiply_ms(sp->stride, td->td_imagewidth), strip_height),
sizeof(uint16_t));
/* add one more stride in case input ends mid-stride */
tbuf_size = add_ms(tbuf_size, sizeof(uint16_t) * sp->stride);
tbuf_size =
add_ms(tbuf_size, (tmsize_t)(sizeof(uint16_t) * (size_t)sp->stride));
if (tbuf_size == 0)
return (0); /* TODO: this is an error return without error report
through TIFFErrorExt */
@@ -838,18 +846,21 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
PixarLogState *sp = PixarLogDecoderState(tif);
tmsize_t i;
tmsize_t nsamples;
int llen;
tmsize_t llen;
uint16_t *up;
switch (sp->user_datafmt)
{
case PIXARLOGDATAFMT_FLOAT:
nsamples = occ / sizeof(float); /* XXX float == 32 bits */
nsamples = (tmsize_t)((uint64_t)occ /
sizeof(float)); /* XXX float == 32 bits */
break;
case PIXARLOGDATAFMT_16BIT:
case PIXARLOGDATAFMT_12BITPICIO:
case PIXARLOGDATAFMT_11BITLOG:
nsamples = occ / sizeof(uint16_t); /* XXX uint16_t == 16 bits */
nsamples =
(tmsize_t)((uint64_t)occ /
sizeof(uint16_t)); /* XXX uint16_t == 16 bits */
break;
case PIXARLOGDATAFMT_8BIT:
case PIXARLOGDATAFMT_8BITABGR:
@@ -863,7 +874,55 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
return 0;
}
llen = sp->stride * td->td_imagewidth;
llen = (tmsize_t)sp->stride * td->td_imagewidth;
/* Fix: ABGR with stride=3 expands 3 samples to 4 output bytes per pixel */
if (sp->user_datafmt == PIXARLOGDATAFMT_8BITABGR && sp->stride == 3)
{
tmsize_t required = (tmsize_t)td->td_imagewidth * 4;
tmsize_t max_rows;
tmsize_t max_nsamples;
/*
* Ensure at least one expanded output row fits.
*/
if (occ < required)
{
TIFFErrorExtR(tif, module,
"Output buffer too small for PixarLog ABGR data");
memset(op, 0, (size_t)occ);
return (0);
}
/*
* The caller-provided output buffer size must represent a whole
* number of expanded ABGR scanlines.
*/
if (occ % required)
{
TIFFErrorExtR(
tif, module,
"Fractional scanline not supported for PixarLog ABGR data");
memset(op, 0, (size_t)occ);
return (0);
}
/*
* PixarLogDecode() may process multiple rows per call
* (e.g. strip decoding). Limit nsamples so the total
* output written by the loop below never exceeds occ.
*/
max_rows = occ / required;
max_nsamples = max_rows * llen;
if (nsamples > max_nsamples)
{
TIFFErrorExtR(tif, module,
"Output buffer too small for PixarLog ABGR data");
memset(op, 0, (size_t)occ);
return (0);
}
}
(void)s;
assert(sp != NULL);
@@ -876,8 +935,8 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */
sp->stream.avail_out = (uInt)(nsamples * sizeof(uint16_t));
if (sp->stream.avail_out != nsamples * sizeof(uint16_t))
sp->stream.avail_out = (uInt)((unsigned long)nsamples * sizeof(uint16_t));
if (sp->stream.avail_out != (unsigned long)nsamples * sizeof(uint16_t))
{
TIFFErrorExtR(tif, module, "ZLib cannot deal with buffers this size");
memset(op, 0, (size_t)occ);
@@ -899,9 +958,10 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
}
if (state == Z_DATA_ERROR)
{
TIFFErrorExtR(
tif, module, "Decoding error at scanline %" PRIu32 ", %s",
tif->tif_row, sp->stream.msg ? sp->stream.msg : "(null)");
TIFFErrorExtR(tif, module,
"Decoding error at scanline %" PRIu32 ", %s",
tif->tif_dir.td_row,
sp->stream.msg ? sp->stream.msg : "(null)");
memset(op, 0, (size_t)occ);
return (0);
}
@@ -920,7 +980,7 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at scanline %" PRIu32
" (short %u bytes)",
tif->tif_row, sp->stream.avail_out);
tif->tif_dir.td_row, sp->stream.avail_out);
memset(op, 0, (size_t)occ);
return (0);
}
@@ -941,7 +1001,8 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
if (nsamples % llen)
{
TIFFWarningExtR(tif, module,
"stride %d is not a multiple of sample count, "
"stride %" TIFF_SSIZE_FORMAT
" is not a multiple of sample count, "
"%" TIFF_SSIZE_FORMAT ", data truncated.",
llen, nsamples);
nsamples -= nsamples % llen;
@@ -954,31 +1015,37 @@ static int PixarLogDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
case PIXARLOGDATAFMT_FLOAT:
horizontalAccumulateF(up, llen, sp->stride, (float *)op,
sp->ToLinearF);
op += llen * sizeof(float);
op += (unsigned long)llen * sizeof(float);
break;
case PIXARLOGDATAFMT_16BIT:
horizontalAccumulate16(up, llen, sp->stride, (uint16_t *)op,
sp->ToLinear16);
op += llen * sizeof(uint16_t);
op += (unsigned long)llen * sizeof(uint16_t);
break;
case PIXARLOGDATAFMT_12BITPICIO:
horizontalAccumulate12(up, llen, sp->stride, (int16_t *)op,
sp->ToLinearF);
op += llen * sizeof(int16_t);
op += (unsigned long)llen * sizeof(int16_t);
break;
case PIXARLOGDATAFMT_11BITLOG:
horizontalAccumulate11(up, llen, sp->stride, (uint16_t *)op);
op += llen * sizeof(uint16_t);
op += (unsigned long)llen * sizeof(uint16_t);
break;
case PIXARLOGDATAFMT_8BIT:
horizontalAccumulate8(up, llen, sp->stride, (unsigned char *)op,
sp->ToLinear8);
op += llen * sizeof(unsigned char);
op += (unsigned long)llen * sizeof(unsigned char);
break;
case PIXARLOGDATAFMT_8BITABGR:
horizontalAccumulate8abgr(up, llen, sp->stride,
(unsigned char *)op, sp->ToLinear8);
op += llen * sizeof(unsigned char);
/* For stride == 3 (RGB), horizontalAccumulate8abgr expands to 4
* bytes/pixel (ABGR) */
if (sp->stride == 3)
op += (unsigned long)td->td_imagewidth * 4;
else
op += (unsigned long)llen * sizeof(unsigned char);
break;
default:
TIFFErrorExtR(tif, module, "Unsupported bits/sample: %" PRIu16,
@@ -1063,17 +1130,18 @@ static int PixarLogPreEncode(TIFF *tif, uint16_t s)
return (deflateReset(&sp->stream) == Z_OK);
}
static void horizontalDifferenceF(float *ip, int n, int stride, uint16_t *wp,
uint16_t *FromLT2)
static void horizontalDifferenceF(float *ip, tmsize_t n, int stride,
uint16_t *wp, uint16_t *FromLT2)
{
int32_t r1, g1, b1, a1, r2, g2, b2, a2, mask;
float fltsize = Fltsize;
#define CLAMP(v) \
((v < (float)0.) ? 0 \
: (v < (float)2.) ? FromLT2[(int)(v * fltsize)] \
: (v > (float)24.2) ? 2047 \
: LogK1 * log(v * LogK2) + 0.5)
((v < (float)0.) ? 0 \
: (v < (float)2.) ? FromLT2[(int)(v * fltsize)] \
: (v > (float)24.2) \
? 2047 \
: (double)LogK1 * log((double)v * (double)LogK2) + 0.5)
mask = CODE_MASK;
if (n >= stride)
@@ -1143,10 +1211,10 @@ static void horizontalDifferenceF(float *ip, int n, int stride, uint16_t *wp,
}
}
static void horizontalDifference16(unsigned short *ip, int n, int stride,
static void horizontalDifference16(unsigned short *ip, tmsize_t n, int stride,
unsigned short *wp, uint16_t *From14)
{
register int r1, g1, b1, a1, r2, g2, b2, a2, mask;
int r1, g1, b1, a1, r2, g2, b2, a2, mask;
/* assumption is unsigned pixel values */
#undef CLAMP
@@ -1219,10 +1287,10 @@ static void horizontalDifference16(unsigned short *ip, int n, int stride,
}
}
static void horizontalDifference8(unsigned char *ip, int n, int stride,
static void horizontalDifference8(unsigned char *ip, tmsize_t n, int stride,
unsigned short *wp, uint16_t *From8)
{
register int r1, g1, b1, a1, r2, g2, b2, a2, mask;
int r1, g1, b1, a1, r2, g2, b2, a2, mask;
#undef CLAMP
#define CLAMP(v) (From8[(v)])
@@ -1304,7 +1372,7 @@ static int PixarLogEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
PixarLogState *sp = PixarLogEncoderState(tif);
tmsize_t i;
tmsize_t n;
int llen;
tmsize_t llen;
unsigned short *up;
(void)s;
@@ -1312,12 +1380,14 @@ static int PixarLogEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
switch (sp->user_datafmt)
{
case PIXARLOGDATAFMT_FLOAT:
n = cc / sizeof(float); /* XXX float == 32 bits */
n = (tmsize_t)((unsigned long)cc /
sizeof(float)); /* XXX float == 32 bits */
break;
case PIXARLOGDATAFMT_16BIT:
case PIXARLOGDATAFMT_12BITPICIO:
case PIXARLOGDATAFMT_11BITLOG:
n = cc / sizeof(uint16_t); /* XXX uint16_t == 16 bits */
n = (tmsize_t)((unsigned long)cc /
sizeof(uint16_t)); /* XXX uint16_t == 16 bits */
break;
case PIXARLOGDATAFMT_8BIT:
case PIXARLOGDATAFMT_8BITABGR:
@@ -1330,7 +1400,7 @@ static int PixarLogEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
return 0;
}
llen = sp->stride * td->td_imagewidth;
llen = (tmsize_t)sp->stride * td->td_imagewidth;
/* Check against the number of elements (of size uint16_t) of sp->tbuf */
if (n > ((tmsize_t)td->td_rowsperstrip * llen))
{
@@ -1345,17 +1415,17 @@ static int PixarLogEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
case PIXARLOGDATAFMT_FLOAT:
horizontalDifferenceF((float *)bp, llen, sp->stride, up,
sp->FromLT2);
bp += llen * sizeof(float);
bp += (unsigned long)llen * sizeof(float);
break;
case PIXARLOGDATAFMT_16BIT:
horizontalDifference16((uint16_t *)bp, llen, sp->stride, up,
sp->From14);
bp += llen * sizeof(uint16_t);
bp += (unsigned long)llen * sizeof(uint16_t);
break;
case PIXARLOGDATAFMT_8BIT:
horizontalDifference8((unsigned char *)bp, llen, sp->stride, up,
sp->From8);
bp += llen * sizeof(unsigned char);
bp += (unsigned long)llen * sizeof(unsigned char);
break;
default:
TIFFErrorExtR(tif, module,
@@ -1370,8 +1440,8 @@ static int PixarLogEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */
sp->stream.avail_in = (uInt)(n * sizeof(uint16_t));
if ((sp->stream.avail_in / sizeof(uint16_t)) != (uInt)n)
sp->stream.avail_in = (uInt)((unsigned long)n * sizeof(uint16_t));
if ((sp->stream.avail_in / sizeof(uint16_t)) != (unsigned long)n)
{
TIFFErrorExtR(tif, module, "ZLib cannot deal with buffers this size");
return (0);
@@ -1562,13 +1632,15 @@ static int PixarLogVSetField(TIFF *tif, uint32_t tag, va_list ap)
TIFFSetField(tif, TIFFTAG_SAMPLEFORMAT,
SAMPLEFORMAT_IEEEFP);
break;
default:
break;
}
/*
* Must recalculate sizes should bits/sample change.
*/
tif->tif_tilesize =
tif->tif_dir.td_tilesize =
isTiled(tif) ? TIFFTileSize(tif) : (tmsize_t)(-1);
tif->tif_scanlinesize = TIFFScanlineSize(tif);
tif->tif_dir.td_scanlinesize = TIFFScanlineSize(tif);
result = 1; /* NB: pseudo tag */
break;
default:
@@ -1601,6 +1673,16 @@ static const TIFFField pixarlogFields[] = {
{TIFFTAG_PIXARLOGQUALITY, 0, 0, TIFF_ANY, 0, TIFF_SETGET_INT, FIELD_PSEUDO,
FALSE, FALSE, "", NULL}};
static uint64_t PixarLogGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* cf https://zlib.net/zlib_tech.html */
const uint64_t MAX_DEFLATE_RATIO = 1032;
/* security margin as I don't understand what this codec does */
return MAX_DEFLATE_RATIO * (uint64_t)4;
}
int TIFFInitPixarLog(TIFF *tif, int scheme)
{
static const char module[] = "TIFFInitPixarLog";
@@ -1648,6 +1730,7 @@ int TIFFInitPixarLog(TIFF *tif, int scheme)
tif->tif_encodetile = PixarLogEncode;
tif->tif_close = PixarLogClose;
tif->tif_cleanup = PixarLogCleanup;
tif->tif_getmaxcompressionratio = PixarLogGetMaxCompressionRatio;
/* Override SetField so we can handle our private pseudo-tag */
sp->vgetparent = tif->tif_tagmethods.vgetfield;

16
3rdparty/libtiff/tif_predict.c vendored
View File

@@ -30,7 +30,7 @@
#include "tif_predict.h"
#include "tiffiop.h"
#if defined(__x86_64__) || defined(_M_X64)
#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC))
#include <emmintrin.h>
#endif
@@ -151,6 +151,8 @@ static int PredictorSetupDecode(TIFF *tif)
case 64:
sp->decodepfunc = horAcc64;
break;
default:
break;
}
/*
* Override default decoding method with one that does the
@@ -247,6 +249,8 @@ static int PredictorSetupEncode(TIFF *tif)
case 64:
sp->encodepfunc = horDiff64;
break;
default:
break;
}
/*
* Override default encoding method with one that does the
@@ -590,7 +594,7 @@ static int fpAcc(TIFF *tif, uint8_t *cp0, tmsize_t cc)
cp = (uint8_t *)cp0;
count = 0;
#if defined(__x86_64__) || defined(_M_X64)
#if defined(__x86_64__) || (defined(_M_X64) && !defined(_M_ARM64EC))
if (bps == 4)
{
/* Optimization of general case */
@@ -972,7 +976,7 @@ static int PredictorEncodeRow(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
(int64_t)cc);
return 0;
}
memcpy(working_copy, bp, cc);
memcpy(working_copy, bp, (size_t)cc);
if (!(*sp->encodepfunc)(tif, working_copy, cc))
{
@@ -1010,7 +1014,7 @@ static int PredictorEncodeTile(TIFF *tif, uint8_t *bp0, tmsize_t cc0,
(int64_t)cc0);
return 0;
}
memcpy(working_copy, bp0, cc0);
memcpy(working_copy, bp0, (size_t)cc0);
bp = working_copy;
rowsize = sp->rowsize;
@@ -1098,8 +1102,10 @@ static void PredictorPrintDir(TIFF *tif, FILE *fd, long flags)
case 3:
fprintf(fd, "floating point predictor ");
break;
default:
break;
}
fprintf(fd, "%d (0x%x)\n", sp->predictor, sp->predictor);
fprintf(fd, "%d (0x%x)\n", sp->predictor, (unsigned)sp->predictor);
}
if (sp->printdir)
(*sp->printdir)(tif, fd, flags);

92
3rdparty/libtiff/tif_print.c vendored
View File

@@ -118,10 +118,10 @@ static void _TIFFPrintField(FILE *fd, const TIFFField *fip,
if (tv_size == 8)
fprintf(fd, "%lf", ((double *)raw_data)[j]);
else
fprintf(fd, "%f", ((float *)raw_data)[j]);
fprintf(fd, "%f", (double)((float *)raw_data)[j]);
}
else if (fip->field_type == TIFF_FLOAT)
fprintf(fd, "%f", ((float *)raw_data)[j]);
fprintf(fd, "%f", (double)((float *)raw_data)[j]);
else if (fip->field_type == TIFF_LONG8)
fprintf(fd, "%" PRIu64, ((uint64_t *)raw_data)[j]);
else if (fip->field_type == TIFF_SLONG8)
@@ -193,8 +193,9 @@ static int _TIFFPrettyPrintField(TIFF *tif, const TIFFField *fip, FILE *fd,
case TIFFTAG_WHITEPOINT:
if (value_count == 2 && fip->field_type == TIFF_RATIONAL)
{
fprintf(fd, " White Point: %g-%g\n", ((float *)raw_data)[0],
((float *)raw_data)[1]);
fprintf(fd, " White Point: %g-%g\n",
(double)((float *)raw_data)[0],
(double)((float *)raw_data)[1]);
return 1;
}
return 0;
@@ -232,6 +233,9 @@ static int _TIFFPrettyPrintField(TIFF *tif, const TIFFField *fip, FILE *fd,
return 1;
}
return 0;
default:
break;
}
return 0;
@@ -244,8 +248,7 @@ static int _TIFFPrettyPrintField(TIFF *tif, const TIFFField *fip, FILE *fd,
void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
{
TIFFDirectory *td = &tif->tif_dir;
char *sep;
long l, n;
const char *sep;
fprintf(fd, "TIFF Directory at offset 0x%" PRIx64 " (%" PRIu64 ")\n",
tif->tif_diroff, tif->tif_diroff);
@@ -286,8 +289,8 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
}
if (TIFFFieldSet(tif, FIELD_RESOLUTION))
{
fprintf(fd, " Resolution: %g, %g", td->td_xresolution,
td->td_yresolution);
fprintf(fd, " Resolution: %g, %g", (double)td->td_xresolution,
(double)td->td_yresolution);
if (TIFFFieldSet(tif, FIELD_RESOLUTIONUNIT))
{
switch (td->td_resolutionunit)
@@ -310,7 +313,8 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
fprintf(fd, "\n");
}
if (TIFFFieldSet(tif, FIELD_POSITION))
fprintf(fd, " Position: %g, %g\n", td->td_xposition, td->td_yposition);
fprintf(fd, " Position: %g, %g\n", (double)td->td_xposition,
(double)td->td_yposition);
if (TIFFFieldSet(tif, FIELD_BITSPERSAMPLE))
fprintf(fd, " Bits/Sample: %" PRIu16 "\n", td->td_bitspersample);
if (TIFFFieldSet(tif, FIELD_SAMPLEFORMAT))
@@ -374,7 +378,8 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
}
}
}
if (TIFFFieldSet(tif, FIELD_EXTRASAMPLES) && td->td_extrasamples)
if (TIFFFieldSet(tif, FIELD_EXTRASAMPLES) && td->td_extrasamples &&
td->td_sampleinfo)
{
uint16_t i;
fprintf(fd, " Extra Samples: %" PRIu16 "<", td->td_extrasamples);
@@ -412,7 +417,8 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
i > 0 && cp < td->td_inknames + td->td_inknameslen;
cp = strchr(cp, '\0') + 1, i--)
{
size_t max_chars = td->td_inknameslen - (cp - td->td_inknames);
size_t max_chars =
(size_t)(td->td_inknameslen - (cp - td->td_inknames));
fputs(sep, fd);
_TIFFprintAsciiBounded(fd, cp, max_chars);
sep = ", ";
@@ -548,17 +554,25 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
if (TIFFFieldSet(tif, FIELD_PAGENUMBER))
fprintf(fd, " Page Number: %" PRIu16 "-%" PRIu16 "\n",
td->td_pagenumber[0], td->td_pagenumber[1]);
if (TIFFFieldSet(tif, FIELD_COLORMAP))
if (TIFFFieldSet(tif, FIELD_COLORMAP) && td->td_colormap[0] &&
td->td_colormap[1] && td->td_colormap[2])
{
fprintf(fd, " Color Map: ");
if (flags & TIFFPRINT_COLORMAP)
{
fprintf(fd, "\n");
n = 1L << td->td_bitspersample;
for (l = 0; l < n; l++)
fprintf(fd, " %5ld: %5" PRIu16 " %5" PRIu16 " %5" PRIu16 "\n",
l, td->td_colormap[0][l], td->td_colormap[1][l],
td->td_colormap[2][l]);
if (td->td_bitspersample >= 64)
fprintf(fd, " (BitsPerSample too large to print safely)\n");
else
{
uint64_t n = 1ULL << td->td_bitspersample;
for (uint64_t l = 0u; l < n; l++)
fprintf(fd,
" %5" PRIu64 ": %5" PRIu16 " %5" PRIu16
" %5" PRIu16 "\n",
l, td->td_colormap[0][l], td->td_colormap[1][l],
td->td_colormap[2][l]);
}
}
else
fprintf(fd, "(present)\n");
@@ -569,26 +583,37 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
fprintf(fd, " Reference Black/White:\n");
for (i = 0; i < 3; i++)
fprintf(fd, " %2d: %5g %5g\n", i,
td->td_refblackwhite[2 * i + 0],
td->td_refblackwhite[2 * i + 1]);
(double)td->td_refblackwhite[2 * i + 0],
(double)td->td_refblackwhite[2 * i + 1]);
}
if (TIFFFieldSet(tif, FIELD_TRANSFERFUNCTION))
if (TIFFFieldSet(tif, FIELD_TRANSFERFUNCTION) &&
td->td_transferfunction[0] &&
((td->td_samplesperpixel - td->td_extrasamples > 1 &&
td->td_transferfunction[1] && td->td_transferfunction[2]) ||
td->td_samplesperpixel - td->td_extrasamples <= 1))
{
fprintf(fd, " Transfer Function: ");
if (flags & TIFFPRINT_CURVES)
{
fprintf(fd, "\n");
n = 1L << td->td_bitspersample;
for (l = 0; l < n; l++)
if (td->td_bitspersample >= 64)
fprintf(fd, " (BitsPerSample too large to print safely)\n");
else
{
uint16_t i;
fprintf(fd, " %2ld: %5" PRIu16, l,
td->td_transferfunction[0][l]);
for (i = 1;
i < td->td_samplesperpixel - td->td_extrasamples && i < 3;
i++)
fprintf(fd, " %5" PRIu16, td->td_transferfunction[i][l]);
fputc('\n', fd);
uint64_t n = 1ULL << td->td_bitspersample;
for (uint64_t l = 0; l < n; l++)
{
uint16_t i;
fprintf(fd, " %2" PRIu64 ": %5" PRIu16, l,
td->td_transferfunction[0][l]);
for (i = 1;
i < td->td_samplesperpixel - td->td_extrasamples &&
i < 3;
i++)
fprintf(fd, " %5" PRIu16,
td->td_transferfunction[i][l]);
fputc('\n', fd);
}
}
}
else
@@ -655,7 +680,7 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
else if (fip->field_readcount == TIFF_SPP)
value_count = td->td_samplesperpixel;
else
value_count = fip->field_readcount;
value_count = (uint32_t)fip->field_readcount;
if (fip->field_tag == TIFFTAG_DOTRANGE &&
strcmp(fip->field_name, "DotRange") == 0)
{
@@ -680,7 +705,8 @@ void TIFFPrintDirectory(TIFF *tif, FILE *fd, long flags)
* "set_get_field_type" to determine internal storage size.
*/
int tv_size = TIFFFieldSetGetSize(fip);
raw_data = _TIFFmallocExt(tif, tv_size * value_count);
raw_data = _TIFFCheckMalloc(tif, value_count, tv_size,
"for tag data");
mem_alloc = 1;
if (TIFFGetField(tif, tag, raw_data) != 1)
{
@@ -744,7 +770,7 @@ static void _TIFFprintAsciiBounded(FILE *fd, const char *cp, size_t max_chars)
if (*tp)
fprintf(fd, "\\%c", *tp);
else
fprintf(fd, "\\%03o", *cp & 0xff);
fprintf(fd, "\\%03o", (unsigned int)(*cp & 0xff));
}
}

370
3rdparty/libtiff/tif_read.c vendored
View File

@@ -27,6 +27,7 @@
* Scanline-oriented Read Support
*/
#include "tiffiop.h"
#include <limits.h>
#include <stdio.h>
int TIFFFillStrip(TIFF *tif, uint32_t strip);
@@ -39,9 +40,6 @@ static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32_t strip, void *buf,
static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32_t tile, void *buf,
tmsize_t size, const char *module);
#define NOSTRIP ((uint32_t)(-1)) /* undefined state */
#define NOTILE ((uint32_t)(-1)) /* undefined state */
#define INITIAL_THRESHOLD (1024 * 1024)
#define THRESHOLD_MULTIPLIER 10
#define MAX_THRESHOLD \
@@ -99,7 +97,9 @@ static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset,
uint8_t *new_rawdata;
assert((tif->tif_flags & TIFF_MYBUFFER) != 0);
tif->tif_rawdatasize = (tmsize_t)TIFFroundup_64(
(uint64_t)already_read + to_read + rawdata_offset, 1024);
(uint64_t)already_read + (uint64_t)to_read +
(uint64_t)rawdata_offset,
1024);
if (tif->tif_rawdatasize == 0)
{
TIFFErrorExtR(tif, module, "Invalid buffer size");
@@ -111,7 +111,7 @@ static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset,
{
TIFFErrorExtR(tif, module,
"No space for data buffer at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
_TIFFfreeExt(tif, tif->tif_rawdata);
tif->tif_rawdata = 0;
tif->tif_rawdatasize = 0;
@@ -127,18 +127,22 @@ static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset,
bytes_read = TIFFReadFile(
tif, tif->tif_rawdata + rawdata_offset + already_read, to_read);
if (bytes_read < 0)
/* Treat read errors as short reads before updating offsets. */
bytes_read = 0;
already_read += bytes_read;
if (bytes_read != to_read)
{
memset(tif->tif_rawdata + rawdata_offset + already_read, 0,
tif->tif_rawdatasize - rawdata_offset - already_read);
memset(
tif->tif_rawdata + rawdata_offset + already_read, 0,
(size_t)(tif->tif_rawdatasize - rawdata_offset - already_read));
if (is_strip)
{
TIFFErrorExtR(tif, module,
"Read error at scanline %" PRIu32
"; got %" TIFF_SSIZE_FORMAT " bytes, "
"expected %" TIFF_SSIZE_FORMAT,
tif->tif_row, already_read, size);
tif->tif_dir.td_row, already_read, size);
}
else
{
@@ -147,8 +151,8 @@ static int TIFFReadAndRealloc(TIFF *tif, tmsize_t size, tmsize_t rawdata_offset,
", tile %" PRIu32 "; "
"got %" TIFF_SSIZE_FORMAT
" bytes, expected %" TIFF_SSIZE_FORMAT "",
tif->tif_row, tif->tif_col, strip_or_tile,
already_read, size);
tif->tif_dir.td_row, tif->tif_dir.td_col,
strip_or_tile, already_read, size);
}
return 0;
}
@@ -160,7 +164,7 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
int restart)
{
static const char module[] = "TIFFFillStripPartial";
register TIFFDirectory *td = &tif->tif_dir;
TIFFDirectory *td = &tif->tif_dir;
tmsize_t unused_data;
uint64_t read_offset;
tmsize_t to_read;
@@ -185,7 +189,7 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
{
assert(restart);
tif->tif_curstrip = NOSTRIP;
tif->tif_dir.td_curstrip = NOSTRIP;
if ((tif->tif_flags & TIFF_MYBUFFER) == 0)
{
TIFFErrorExtR(tif, module,
@@ -214,20 +218,30 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
if (unused_data > 0)
{
assert((tif->tif_flags & TIFF_BUFFERMMAP) == 0);
memmove(tif->tif_rawdata, tif->tif_rawcp, unused_data);
memmove(tif->tif_rawdata, tif->tif_rawcp, (size_t)unused_data);
}
/*
** Seek to the point in the file where more data should be read.
*/
read_offset = TIFFGetStrileOffset(tif, strip) + tif->tif_rawdataoff +
tif->tif_rawdataloaded;
read_offset = TIFFGetStrileOffset(tif, (uint32_t)strip);
if (read_offset > UINT64_MAX - (uint64_t)tif->tif_rawdataoff ||
read_offset + (uint64_t)tif->tif_rawdataoff >
UINT64_MAX - (uint64_t)tif->tif_rawdataloaded)
{
TIFFErrorExtR(tif, module,
"Seek error at scanline %" PRIu32 ", strip %d",
tif->tif_dir.td_row, strip);
return 0;
}
read_offset +=
(uint64_t)tif->tif_rawdataoff + (uint64_t)tif->tif_rawdataloaded;
if (!SeekOK(tif, read_offset))
{
TIFFErrorExtR(tif, module,
"Seek error at scanline %" PRIu32 ", strip %d",
tif->tif_row, strip);
tif->tif_dir.td_row, strip);
return 0;
}
@@ -238,11 +252,13 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
to_read = read_ahead_mod - unused_data;
else
to_read = tif->tif_rawdatasize - unused_data;
if ((uint64_t)to_read > TIFFGetStrileByteCount(tif, strip) -
tif->tif_rawdataoff - tif->tif_rawdataloaded)
if ((uint64_t)to_read > TIFFGetStrileByteCount(tif, (uint32_t)strip) -
(uint64_t)tif->tif_rawdataoff -
(uint64_t)tif->tif_rawdataloaded)
{
to_read = (tmsize_t)TIFFGetStrileByteCount(tif, strip) -
tif->tif_rawdataoff - tif->tif_rawdataloaded;
to_read = (tmsize_t)(TIFFGetStrileByteCount(tif, (uint32_t)strip) -
(uint64_t)tif->tif_rawdataoff -
(uint64_t)tif->tif_rawdataloaded);
}
assert((tif->tif_flags & TIFF_BUFFERMMAP) == 0);
@@ -281,16 +297,17 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
/* For JPEG, if there are multiple scans (can generally be known */
/* with the read_ahead used), we need to read the whole strip */
if (tif->tif_dir.td_compression == COMPRESSION_JPEG &&
(uint64_t)tif->tif_rawcc < TIFFGetStrileByteCount(tif, strip))
(uint64_t)tif->tif_rawcc <
TIFFGetStrileByteCount(tif, (uint32_t)strip))
{
if (TIFFJPEGIsFullStripRequired(tif))
{
return TIFFFillStrip(tif, strip);
return TIFFFillStrip(tif, (uint32_t)strip);
}
}
#endif
return TIFFStartStrip(tif, strip);
return TIFFStartStrip(tif, (uint32_t)strip);
}
else
{
@@ -308,7 +325,7 @@ static int TIFFFillStripPartial(TIFF *tif, int strip, tmsize_t read_ahead,
*/
static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
{
register TIFFDirectory *td = &tif->tif_dir;
TIFFDirectory *td = &tif->tif_dir;
uint32_t strip;
int whole_strip;
tmsize_t read_ahead = 0;
@@ -323,8 +340,16 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
td->td_imagelength);
return (0);
}
if (td->td_rowsperstrip == 0)
{
TIFFErrorExtR(tif, tif->tif_name,
"Cannot compute strip: RowsPerStrip is zero");
return (0);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
uint64_t sample_offset;
uint64_t strip64;
if (sample >= td->td_samplesperpixel)
{
TIFFErrorExtR(tif, tif->tif_name,
@@ -332,16 +357,26 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
sample, td->td_samplesperpixel);
return (0);
}
strip = (uint32_t)sample * td->td_stripsperimage +
row / td->td_rowsperstrip;
sample_offset =
_TIFFMultiply64(tif, sample, td->td_stripsperimage, "TIFFSeek");
if (sample_offset == 0 && sample != 0 && td->td_stripsperimage != 0)
return (0);
strip64 = _TIFFAdd64(tif, sample_offset, row / td->td_rowsperstrip,
"TIFFSeek");
if (strip64 == 0 &&
(sample_offset != 0 || (row / td->td_rowsperstrip) != 0))
return (0);
strip = _TIFFCastUInt64ToUInt32(tif, strip64, "TIFFSeek");
if (strip == 0 && strip64 != 0)
return (0);
}
else
strip = row / td->td_rowsperstrip;
/*
* Do we want to treat this strip as one whole chunk or
* read it a few lines at a time?
*/
/*
* Do we want to treat this strip as one whole chunk or
* read it a few lines at a time?
*/
#if defined(CHUNKY_STRIP_READ_SUPPORT)
whole_strip = TIFFGetStrileByteCount(tif, strip) < 10 || isMapped(tif);
if (td->td_compression == COMPRESSION_LERC ||
@@ -359,14 +394,14 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
/* is some constant value, for example for JPEG tables */
/* coverity[dead_error_line:SUPPRESS] */
if (tif->tif_scanlinesize < TIFF_TMSIZE_T_MAX / 16 &&
tif->tif_scanlinesize * 16 < TIFF_TMSIZE_T_MAX - 5000)
if (tif->tif_dir.td_scanlinesize < TIFF_TMSIZE_T_MAX / 16 &&
tif->tif_dir.td_scanlinesize * 16 < TIFF_TMSIZE_T_MAX - 5000)
{
read_ahead = tif->tif_scanlinesize * 16 + 5000;
read_ahead = tif->tif_dir.td_scanlinesize * 16 + 5000;
}
else
{
read_ahead = tif->tif_scanlinesize;
read_ahead = tif->tif_dir.td_scanlinesize;
}
}
#else
@@ -377,7 +412,7 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
* If we haven't loaded this strip, do so now, possibly
* only reading the first part.
*/
if (strip != tif->tif_curstrip)
if (strip != tif->tif_dir.td_curstrip)
{ /* different strip, refill */
if (whole_strip)
@@ -412,7 +447,7 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
}
#endif
if (row < tif->tif_row)
if (row < tif->tif_dir.td_row)
{
/*
* Moving backwards within the same strip: backup
@@ -425,7 +460,7 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
if (tif->tif_rawdataoff != 0)
{
if (!TIFFFillStripPartial(tif, strip, read_ahead, 1))
if (!TIFFFillStripPartial(tif, (int)strip, read_ahead, 1))
return 0;
}
else
@@ -435,7 +470,7 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
}
}
if (row != tif->tif_row)
if (row != tif->tif_dir.td_row)
{
/*
* Seek forward to the desired row.
@@ -443,9 +478,9 @@ static int TIFFSeek(TIFF *tif, uint32_t row, uint16_t sample)
/* TODO: Will this really work with partial buffers? */
if (!(*tif->tif_seek)(tif, row - tif->tif_row))
if (!(*tif->tif_seek)(tif, row - tif->tif_dir.td_row))
return (0);
tif->tif_row = row;
tif->tif_dir.td_row = row;
}
return (1);
@@ -462,20 +497,21 @@ int TIFFReadScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
/*
* Decompress desired row into user buffer.
*/
e = (*tif->tif_decoderow)(tif, (uint8_t *)buf, tif->tif_scanlinesize,
sample);
e = (*tif->tif_decoderow)(tif, (uint8_t *)buf,
tif->tif_dir.td_scanlinesize, sample);
/* we are now poised at the beginning of the next row */
tif->tif_row = row + 1;
tif->tif_dir.td_row = row + 1;
if (e)
(*tif->tif_postdecode)(tif, (uint8_t *)buf, tif->tif_scanlinesize);
(*tif->tif_postdecode)(tif, (uint8_t *)buf,
tif->tif_dir.td_scanlinesize);
}
else
{
/* See TIFFReadEncodedStrip comment regarding TIFFTAG_FAXFILLFUNC. */
if (buf)
memset(buf, 0, (size_t)tif->tif_scanlinesize);
memset(buf, 0, (size_t)tif->tif_dir.td_scanlinesize);
}
return (e > 0 ? 1 : -1);
}
@@ -553,9 +589,9 @@ tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf,
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(buf, stripsize);
TIFFReverseBits((uint8_t *)buf, stripsize);
(*tif->tif_postdecode)(tif, buf, stripsize);
(*tif->tif_postdecode)(tif, (uint8_t *)buf, stripsize);
return (stripsize);
}
@@ -569,9 +605,9 @@ tmsize_t TIFFReadEncodedStrip(TIFF *tif, uint32_t strip, void *buf,
memset(buf, 0, (size_t)stripsize);
return ((tmsize_t)(-1));
}
if ((*tif->tif_decodestrip)(tif, buf, stripsize, plane) <= 0)
if ((*tif->tif_decodestrip)(tif, (uint8_t *)buf, stripsize, plane) <= 0)
return ((tmsize_t)(-1));
(*tif->tif_postdecode)(tif, buf, stripsize);
(*tif->tif_postdecode)(tif, (uint8_t *)buf, stripsize);
return (stripsize);
}
@@ -603,17 +639,39 @@ tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif, uint32_t strip,
if (!TIFFFillStrip(tif, strip))
return ((tmsize_t)(-1));
*buf = _TIFFmallocExt(tif, bufsizetoalloc);
/* Sanity checks to avoid excessive memory allocation */
/* Max compression ratio experimentally determined. Might be fragile...
* Only apply this heuristics to situations where the memory allocation
* would be big, to avoid breaking nominal use cases.
*/
if (bufsizetoalloc > 100 * 1024 * 1024)
{
const uint64_t maxCompressionRatio = TIFFGetMaxCompressionRatio(tif);
if (maxCompressionRatio > 0 &&
(uint64_t)tif->tif_rawdatasize <
(uint64_t)this_stripsize / maxCompressionRatio)
{
TIFFErrorExtR(tif, TIFFFileName(tif),
"Likely invalid strip byte count for strip %u. "
"Uncompressed strip size is %" PRIu64 ", "
"compressed one is %" PRIu64,
strip, (uint64_t)this_stripsize,
(uint64_t)tif->tif_rawdatasize);
return ((tmsize_t)(-1));
}
}
*buf = _TIFFcallocExt(tif, 1, bufsizetoalloc);
if (*buf == NULL)
{
TIFFErrorExtR(tif, TIFFFileName(tif), "No space for strip buffer");
return ((tmsize_t)(-1));
}
_TIFFmemset(*buf, 0, bufsizetoalloc);
if ((*tif->tif_decodestrip)(tif, *buf, this_stripsize, plane) <= 0)
if ((*tif->tif_decodestrip)(tif, (uint8_t *)*buf, this_stripsize, plane) <=
0)
return ((tmsize_t)(-1));
(*tif->tif_postdecode)(tif, *buf, this_stripsize);
(*tif->tif_postdecode)(tif, (uint8_t *)*buf, this_stripsize);
return (this_stripsize);
}
@@ -629,7 +687,7 @@ static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32_t strip, void *buf,
{
TIFFErrorExtR(tif, module,
"Seek error at scanline %" PRIu32 ", strip %" PRIu32,
tif->tif_row, strip);
tif->tif_dir.td_row, strip);
return ((tmsize_t)(-1));
}
cc = TIFFReadFile(tif, buf, size);
@@ -639,7 +697,7 @@ static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32_t strip, void *buf,
"Read error at scanline %" PRIu32
"; got %" TIFF_SSIZE_FORMAT
" bytes, expected %" TIFF_SSIZE_FORMAT,
tif->tif_row, cc, size);
tif->tif_dir.td_row, cc, size);
return ((tmsize_t)(-1));
}
}
@@ -670,7 +728,7 @@ static tmsize_t TIFFReadRawStrip1(TIFF *tif, uint32_t strip, void *buf,
"Read error at scanline %" PRIu32 ", strip %" PRIu32
"; got %" TIFF_SSIZE_FORMAT
" bytes, expected %" TIFF_SSIZE_FORMAT,
tif->tif_row, strip, n, size);
tif->tif_dir.td_row, strip, n, size);
return ((tmsize_t)(-1));
}
_TIFFmemcpy(buf, tif->tif_base + ma, size);
@@ -691,14 +749,14 @@ static tmsize_t TIFFReadRawStripOrTile2(TIFF *tif, uint32_t strip_or_tile,
{
TIFFErrorExtR(tif, module,
"Seek error at scanline %" PRIu32 ", strip %" PRIu32,
tif->tif_row, strip_or_tile);
tif->tif_dir.td_row, strip_or_tile);
}
else
{
TIFFErrorExtR(tif, module,
"Seek error at row %" PRIu32 ", col %" PRIu32
", tile %" PRIu32,
tif->tif_row, tif->tif_col, strip_or_tile);
TIFFErrorExtR(
tif, module,
"Seek error at row %" PRIu32 ", col %" PRIu32 ", tile %" PRIu32,
tif->tif_dir.td_row, tif->tif_dir.td_col, strip_or_tile);
}
return ((tmsize_t)(-1));
}
@@ -774,22 +832,50 @@ int TIFFFillStrip(TIFF *tif, uint32_t strip)
}
/* To avoid excessive memory allocations: */
/* Byte count should normally not be larger than a number of */
/* times the uncompressed size plus some margin */
if (bytecount > 1024 * 1024)
const tmsize_t stripsize = TIFFStripSize(tif);
if (stripsize > 0)
{
/* 10 and 4096 are just values that could be adjusted. */
/* Hopefully they are safe enough for all codecs */
tmsize_t stripsize = TIFFStripSize(tif);
if (stripsize != 0 && (bytecount - 4096) / 10 > (uint64_t)stripsize)
if (bytecount > 1024 * 1024 &&
(bytecount - 4096) / 10 > (uint64_t)stripsize)
{
/* Byte count should normally not be larger than a number of */
/* times the uncompressed size plus some margin */
/* 10 and 4096 are just values that could be adjusted. */
/* Hopefully they are safe enough for all codecs */
/* What happens next will depend on whether only the bytecount
*/
/* was corrupted to a large value but the strip/tile data is */
/* fine. In that situation most codecs should work fine and */
/* only used part of the tile/strip data. If the strip/tile */
/* data is corrupted too, then codecs will later error out. */
uint64_t newbytecount = (uint64_t)stripsize * 10 + 4096;
TIFFErrorExtR(tif, module,
"Too large strip byte count %" PRIu64
", strip %" PRIu32 ". Limiting to %" PRIu64,
bytecount, strip, newbytecount);
TIFFWarningExtR(tif, module,
"Too large strip byte count %" PRIu64
", strip %" PRIu32 ". Limiting to %" PRIu64,
bytecount, strip, newbytecount);
bytecount = newbytecount;
}
else if (stripsize > 100 * 1024 * 1024)
{
/* Max compression ratio experimentally determined. Might be
* fragile... Only apply this heuristics to situations where the
* memory allocation would be big, to avoid breaking nominal use
* cases.
*/
const uint64_t maxCompressionRatio =
TIFFGetMaxCompressionRatio(tif);
if (maxCompressionRatio > 0 &&
bytecount < (uint64_t)stripsize / maxCompressionRatio)
{
TIFFErrorExtR(
tif, module,
"Likely invalid strip byte count for strip %u. "
"Uncompressed strip size is %" PRIu64 ", "
"compressed one is %" PRIu64,
strip, (uint64_t)stripsize, bytecount);
return 0;
}
}
}
if (isMapped(tif))
@@ -818,10 +904,10 @@ int TIFFFillStrip(TIFF *tif, uint32_t strip)
"Read error on strip %" PRIu32 "; "
"got %" PRIu64 " bytes, expected %" PRIu64,
strip,
NoSanitizeSubUInt64(tif->tif_size,
NoSanitizeSubUInt64((uint64_t)tif->tif_size,
TIFFGetStrileOffset(tif, strip)),
bytecount);
tif->tif_curstrip = NOSTRIP;
tif->tif_dir.td_curstrip = NOSTRIP;
return (0);
}
}
@@ -878,7 +964,7 @@ int TIFFFillStrip(TIFF *tif, uint32_t strip)
}
if (bytecountm > tif->tif_rawdatasize)
{
tif->tif_curstrip = NOSTRIP;
tif->tif_dir.td_curstrip = NOSTRIP;
if ((tif->tif_flags & TIFF_MYBUFFER) == 0)
{
TIFFErrorExtR(
@@ -889,7 +975,7 @@ int TIFFFillStrip(TIFF *tif, uint32_t strip)
}
if (tif->tif_flags & TIFF_BUFFERMMAP)
{
tif->tif_curstrip = NOSTRIP;
tif->tif_dir.td_curstrip = NOSTRIP;
tif->tif_rawdata = NULL;
tif->tif_rawdatasize = 0;
tif->tif_flags &= ~TIFF_BUFFERMMAP;
@@ -954,7 +1040,7 @@ tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf, tmsize_t size)
{
static const char module[] = "TIFFReadEncodedTile";
TIFFDirectory *td = &tif->tif_dir;
tmsize_t tilesize = tif->tif_tilesize;
tmsize_t tilesize = tif->tif_dir.td_tilesize;
if (!TIFFCheckRead(tif, 1))
return ((tmsize_t)(-1));
@@ -976,9 +1062,9 @@ tmsize_t TIFFReadEncodedTile(TIFF *tif, uint32_t tile, void *buf, tmsize_t size)
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits(buf, tilesize);
TIFFReverseBits((uint8_t *)buf, tilesize);
(*tif->tif_postdecode)(tif, buf, tilesize);
(*tif->tif_postdecode)(tif, (uint8_t *)buf, tilesize);
return (tilesize);
}
@@ -1032,7 +1118,7 @@ tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32_t tile,
{
static const char module[] = "_TIFFReadEncodedTileAndAllocBuffer";
TIFFDirectory *td = &tif->tif_dir;
tmsize_t tilesize = tif->tif_tilesize;
tmsize_t tilesize = tif->tif_dir.td_tilesize;
if (*buf != NULL)
{
@@ -1072,25 +1158,22 @@ tmsize_t _TIFFReadEncodedTileAndAllocBuffer(TIFF *tif, uint32_t tile,
* Only apply this heuristics to situations where the memory allocation
* would be big, to avoid breaking nominal use cases.
*/
const int maxCompressionRatio =
td->td_compression == COMPRESSION_ZSTD ? 33000
: td->td_compression == COMPRESSION_JXL
?
/* Evaluated on a 8000x8000 tile */
25000 * (td->td_planarconfig == PLANARCONFIG_CONTIG
? td->td_samplesperpixel
: 1)
: td->td_compression == COMPRESSION_LZMA ? 7000 : 1000;
if (bufsizetoalloc > 100 * 1000 * 1000 &&
tif->tif_rawdatasize < tilesize / maxCompressionRatio)
if (bufsizetoalloc > 100 * 1024 * 1024)
{
TIFFErrorExtR(tif, TIFFFileName(tif),
"Likely invalid tile byte count for tile %u. "
"Uncompressed tile size is %" PRIu64 ", "
"compressed one is %" PRIu64,
tile, (uint64_t)tilesize,
(uint64_t)tif->tif_rawdatasize);
return ((tmsize_t)(-1));
const uint64_t maxCompressionRatio =
TIFFGetMaxCompressionRatio(tif);
if (maxCompressionRatio > 0 &&
(uint64_t)tif->tif_rawdatasize <
(uint64_t)tilesize / maxCompressionRatio)
{
TIFFErrorExtR(tif, TIFFFileName(tif),
"Likely invalid tile byte count for tile %u. "
"Uncompressed tile size is %" PRIu64 ", "
"compressed one is %" PRIu64,
tile, (uint64_t)tilesize,
(uint64_t)tif->tif_rawdatasize);
return ((tmsize_t)(-1));
}
}
}
@@ -1129,7 +1212,7 @@ static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32_t tile, void *buf,
TIFFErrorExtR(tif, module,
"Seek error at row %" PRIu32 ", col %" PRIu32
", tile %" PRIu32,
tif->tif_row, tif->tif_col, tile);
tif->tif_dir.td_row, tif->tif_dir.td_col, tile);
return ((tmsize_t)(-1));
}
cc = TIFFReadFile(tif, buf, size);
@@ -1139,7 +1222,7 @@ static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32_t tile, void *buf,
"Read error at row %" PRIu32 ", col %" PRIu32
"; got %" TIFF_SSIZE_FORMAT
" bytes, expected %" TIFF_SSIZE_FORMAT,
tif->tif_row, tif->tif_col, cc, size);
tif->tif_dir.td_row, tif->tif_dir.td_col, cc, size);
return ((tmsize_t)(-1));
}
}
@@ -1162,7 +1245,8 @@ static tmsize_t TIFFReadRawTile1(TIFF *tif, uint32_t tile, void *buf,
"Read error at row %" PRIu32 ", col %" PRIu32
", tile %" PRIu32 "; got %" TIFF_SSIZE_FORMAT
" bytes, expected %" TIFF_SSIZE_FORMAT,
tif->tif_row, tif->tif_col, tile, n, size);
tif->tif_dir.td_row, tif->tif_dir.td_col, tile, n,
size);
return ((tmsize_t)(-1));
}
_TIFFmemcpy(buf, tif->tif_base + ma, size);
@@ -1229,22 +1313,49 @@ int TIFFFillTile(TIFF *tif, uint32_t tile)
}
/* To avoid excessive memory allocations: */
/* Byte count should normally not be larger than a number of */
/* times the uncompressed size plus some margin */
if (bytecount > 1024 * 1024)
const tmsize_t tilesize = TIFFTileSize(tif);
if (tilesize > 0)
{
/* 10 and 4096 are just values that could be adjusted. */
/* Hopefully they are safe enough for all codecs */
tmsize_t stripsize = TIFFTileSize(tif);
if (stripsize != 0 && (bytecount - 4096) / 10 > (uint64_t)stripsize)
if (bytecount > 1024 * 1024 &&
(bytecount - 4096) / 10 > (uint64_t)tilesize)
{
uint64_t newbytecount = (uint64_t)stripsize * 10 + 4096;
TIFFErrorExtR(tif, module,
"Too large tile byte count %" PRIu64
", tile %" PRIu32 ". Limiting to %" PRIu64,
bytecount, tile, newbytecount);
/* Byte count should normally not be larger than a number of */
/* times the uncompressed size plus some margin */
/* 10 and 4096 are just values that could be adjusted. */
/* Hopefully they are safe enough for all codecs */
/* What happens next will depend on whether only the bytecount
*/
/* was corrupted to a large value but the strip/tile data is */
/* fine. In that situation most codecs should work fine and */
/* only used part of the tile/strip data. If the strip/tile */
/* data is corrupted too, then codecs will later error out. */
uint64_t newbytecount = (uint64_t)tilesize * 10 + 4096;
TIFFWarningExtR(tif, module,
"Too large tile byte count %" PRIu64
", tile %" PRIu32 ". Limiting to %" PRIu64,
bytecount, tile, newbytecount);
bytecount = newbytecount;
}
else if (tilesize > 100 * 1024 * 1024)
{
/* Max compression ratio experimentally determined. Might be
* fragile... Only apply this heuristics to situations where the
* memory allocation would be big, to avoid breaking nominal use
* cases.
*/
const uint64_t maxCompressionRatio =
TIFFGetMaxCompressionRatio(tif);
if (maxCompressionRatio > 0 &&
bytecount < (uint64_t)tilesize / maxCompressionRatio)
{
TIFFErrorExtR(tif, module,
"Likely invalid tile byte count for tile %u. "
"Uncompressed tile size is %" PRIu64 ", "
"compressed one is %" PRIu64,
tile, (uint64_t)tilesize, bytecount);
return 0;
}
}
}
if (isMapped(tif))
@@ -1262,7 +1373,7 @@ int TIFFFillTile(TIFF *tif, uint32_t tile)
TIFFGetStrileOffset(tif, tile) >
(uint64_t)tif->tif_size - bytecount)
{
tif->tif_curtile = NOTILE;
tif->tif_dir.td_curtile = NOTILE;
return (0);
}
}
@@ -1312,7 +1423,7 @@ int TIFFFillTile(TIFF *tif, uint32_t tile)
}
if (bytecountm > tif->tif_rawdatasize)
{
tif->tif_curtile = NOTILE;
tif->tif_dir.td_curtile = NOTILE;
if ((tif->tif_flags & TIFF_MYBUFFER) == 0)
{
TIFFErrorExtR(tif, module,
@@ -1323,7 +1434,7 @@ int TIFFFillTile(TIFF *tif, uint32_t tile)
}
if (tif->tif_flags & TIFF_BUFFERMMAP)
{
tif->tif_curtile = NOTILE;
tif->tif_dir.td_curtile = NOTILE;
tif->tif_rawdata = NULL;
tif->tif_rawdatasize = 0;
tif->tif_flags &= ~TIFF_BUFFERMMAP;
@@ -1410,7 +1521,7 @@ int TIFFReadBufferSetup(TIFF *tif, void *bp, tmsize_t size)
{
TIFFErrorExtR(tif, module,
"No space for data buffer at scanline %" PRIu32,
tif->tif_row);
tif->tif_dir.td_row);
tif->tif_rawdatasize = 0;
return (0);
}
@@ -1431,8 +1542,13 @@ static int TIFFStartStrip(TIFF *tif, uint32_t strip)
return (0);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_curstrip = strip;
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
if (td->td_stripsperimage == 0)
{
TIFFErrorExtR(tif, "TIFFStartStrip", "Zero strips per image");
return 0;
}
tif->tif_dir.td_curstrip = strip;
tif->tif_dir.td_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_flags &= ~TIFF_BUF4WRITE;
if (tif->tif_flags & TIFF_NOREADRAW)
@@ -1456,7 +1572,7 @@ static int TIFFStartStrip(TIFF *tif, uint32_t strip)
*/
/* tif_curstrip, we'd call tif_decoderow() on a possibly invalid */
/* codec state. */
tif->tif_curstrip = NOSTRIP;
tif->tif_dir.td_curstrip = NOSTRIP;
return 0;
}
return 1;
@@ -1478,7 +1594,7 @@ static int TIFFStartTile(TIFF *tif, uint32_t tile)
return (0);
tif->tif_flags |= TIFF_CODERSETUP;
}
tif->tif_curtile = tile;
tif->tif_dir.td_curtile = tile;
if (td->td_tilewidth == 0)
{
TIFFErrorExtR(tif, module, "Zero tilewidth");
@@ -1490,14 +1606,14 @@ static int TIFFStartTile(TIFF *tif, uint32_t tile)
TIFFErrorExtR(tif, module, "Zero tiles");
return 0;
}
tif->tif_row = (tile % howmany32) * td->td_tilelength;
tif->tif_dir.td_row = (tile % howmany32) * td->td_tilelength;
howmany32 = TIFFhowmany_32(td->td_imagelength, td->td_tilelength);
if (howmany32 == 0)
{
TIFFErrorExtR(tif, module, "Zero tiles");
return 0;
}
tif->tif_col = (tile % howmany32) * td->td_tilewidth;
tif->tif_dir.td_col = (tile % howmany32) * td->td_tilewidth;
tif->tif_flags &= ~TIFF_BUF4WRITE;
if (tif->tif_flags & TIFF_NOREADRAW)
{
@@ -1568,14 +1684,14 @@ int TIFFReadFromUserBuffer(TIFF *tif, uint32_t strile, void *inbuf,
tif->tif_flags &= ~TIFF_MYBUFFER;
tif->tif_flags |= TIFF_BUFFERMMAP;
tif->tif_rawdatasize = insize;
tif->tif_rawdata = inbuf;
tif->tif_rawdata = (uint8_t *)inbuf;
tif->tif_rawdataoff = 0;
tif->tif_rawdataloaded = insize;
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
{
TIFFReverseBits(inbuf, insize);
TIFFReverseBits((uint8_t *)inbuf, insize);
}
if (TIFFIsTiled(tif))
@@ -1632,13 +1748,13 @@ int TIFFReadFromUserBuffer(TIFF *tif, uint32_t strile, void *inbuf,
if (!isFillOrder(tif, td->td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
{
TIFFReverseBits(inbuf, insize);
TIFFReverseBits((uint8_t *)inbuf, insize);
}
tif->tif_flags = (old_tif_flags & (TIFF_MYBUFFER | TIFF_BUFFERMMAP)) |
(tif->tif_flags & ~(TIFF_MYBUFFER | TIFF_BUFFERMMAP));
tif->tif_rawdatasize = old_rawdatasize;
tif->tif_rawdata = old_rawdata;
tif->tif_rawdata = (uint8_t *)old_rawdata;
tif->tif_rawdataoff = 0;
tif->tif_rawdataloaded = 0;

56
3rdparty/libtiff/tif_strip.c vendored
View File

@@ -47,6 +47,8 @@ uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
strip = row / td->td_rowsperstrip;
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
uint64_t sample_offset;
uint64_t strip64;
if (sample >= td->td_samplesperpixel)
{
TIFFErrorExtR(tif, module, "%lu: Sample out of range, max %lu",
@@ -54,7 +56,16 @@ uint32_t TIFFComputeStrip(TIFF *tif, uint32_t row, uint16_t sample)
(unsigned long)td->td_samplesperpixel);
return (0);
}
strip += (uint32_t)sample * td->td_stripsperimage;
sample_offset = _TIFFMultiply64(tif, sample, td->td_stripsperimage,
"TIFFComputeStrip");
if (sample_offset == 0 && sample != 0 && td->td_stripsperimage != 0)
return (0);
strip64 = _TIFFAdd64(tif, sample_offset, strip, "TIFFComputeStrip");
if (strip64 == 0 && (sample_offset != 0 || strip != 0))
return (0);
strip = _TIFFCastUInt64ToUInt32(tif, strip64, "TIFFComputeStrip");
if (strip == 0 && strip64 != 0)
return (0);
}
return (strip);
}
@@ -83,14 +94,24 @@ uint32_t TIFFNumberOfStrips(TIFF *tif)
}
/*
* Compute the # bytes in a variable height, row-aligned strip.
* Compute the # bytes in a variable height, row-aligned strip if isStrip is
* TRUE, or in a tile if isStrip is FALSE
*/
uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
uint64_t _TIFFStrileSize64(TIFF *tif, uint32_t nrows, int isStrip)
{
static const char module[] = "TIFFVStripSize64";
static const char module[] = "_TIFFStrileSize64";
TIFFDirectory *td = &tif->tif_dir;
if (nrows == (uint32_t)(-1))
nrows = td->td_imagelength;
if (isStrip)
{
if (nrows == (uint32_t)(-1))
nrows = td->td_imagelength;
}
else
{
if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
td->td_tiledepth == 0)
return (0);
}
if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
(td->td_photometric == PHOTOMETRIC_YCBCR) && (!isUpSampled(tif)))
{
@@ -125,9 +146,10 @@ uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
ycbcrsubsampling[0], ycbcrsubsampling[1]);
return 0;
}
samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblocks_hor =
TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
samplingblock_samples =
(uint16_t)(ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2);
const uint32_t width = isStrip ? td->td_imagewidth : td->td_tilewidth;
samplingblocks_hor = TIFFhowmany_32(width, ycbcrsubsampling[0]);
samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
samplingblock_samples, module);
@@ -137,8 +159,20 @@ uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
_TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
}
else
return (_TIFFMultiply64(tif, nrows, TIFFScanlineSize64(tif), module));
return (_TIFFMultiply64(tif, nrows,
isStrip ? TIFFScanlineSize64(tif)
: TIFFTileRowSize64(tif),
module));
}
/*
* Compute the # bytes in a variable height, row-aligned strip.
*/
uint64_t TIFFVStripSize64(TIFF *tif, uint32_t nrows)
{
return _TIFFStrileSize64(tif, nrows, /* isStrip = */ TRUE);
}
tmsize_t TIFFVStripSize(TIFF *tif, uint32_t nrows)
{
static const char module[] = "TIFFVStripSize";
@@ -286,7 +320,7 @@ uint64_t TIFFScanlineSize64(TIFF *tif)
return 0;
}
samplingblock_samples =
ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
(uint16_t)(ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2);
samplingblocks_hor =
TIFFhowmany_32(td->td_imagewidth, ycbcrsubsampling[0]);
samplingrow_samples = _TIFFMultiply64(

40
3rdparty/libtiff/tif_swab.c vendored
View File

@@ -32,7 +32,7 @@
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabShort)
void TIFFSwabShort(uint16_t *wp)
{
register unsigned char *cp = (unsigned char *)wp;
unsigned char *cp = (unsigned char *)wp;
unsigned char t;
assert(sizeof(uint16_t) == 2);
t = cp[1];
@@ -44,7 +44,7 @@ void TIFFSwabShort(uint16_t *wp)
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong)
void TIFFSwabLong(uint32_t *lp)
{
register unsigned char *cp = (unsigned char *)lp;
unsigned char *cp = (unsigned char *)lp;
unsigned char t;
assert(sizeof(uint32_t) == 4);
t = cp[3];
@@ -59,7 +59,7 @@ void TIFFSwabLong(uint32_t *lp)
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabLong8)
void TIFFSwabLong8(uint64_t *lp)
{
register unsigned char *cp = (unsigned char *)lp;
unsigned char *cp = (unsigned char *)lp;
unsigned char t;
assert(sizeof(uint64_t) == 8);
t = cp[7];
@@ -78,10 +78,10 @@ void TIFFSwabLong8(uint64_t *lp)
#endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfShort)
void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
void TIFFSwabArrayOfShort(uint16_t *wp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
unsigned char *cp;
unsigned char t;
assert(sizeof(uint16_t) == 2);
/* XXX unroll loop some */
while (n-- > 0)
@@ -96,7 +96,7 @@ void TIFFSwabArrayOfShort(register uint16_t *wp, tmsize_t n)
#endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfTriples)
void TIFFSwabArrayOfTriples(register uint8_t *tp, tmsize_t n)
void TIFFSwabArrayOfTriples(uint8_t *tp, tmsize_t n)
{
unsigned char *cp;
unsigned char t;
@@ -114,10 +114,10 @@ void TIFFSwabArrayOfTriples(register uint8_t *tp, tmsize_t n)
#endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong)
void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
void TIFFSwabArrayOfLong(uint32_t *lp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
unsigned char *cp;
unsigned char t;
assert(sizeof(uint32_t) == 4);
/* XXX unroll loop some */
while (n-- > 0)
@@ -135,10 +135,10 @@ void TIFFSwabArrayOfLong(register uint32_t *lp, tmsize_t n)
#endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfLong8)
void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
void TIFFSwabArrayOfLong8(uint64_t *lp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
unsigned char *cp;
unsigned char t;
assert(sizeof(uint64_t) == 8);
/* XXX unroll loop some */
while (n-- > 0)
@@ -164,7 +164,7 @@ void TIFFSwabArrayOfLong8(register uint64_t *lp, tmsize_t n)
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabFloat)
void TIFFSwabFloat(float *fp)
{
register unsigned char *cp = (unsigned char *)fp;
unsigned char *cp = (unsigned char *)fp;
unsigned char t;
assert(sizeof(float) == 4);
t = cp[3];
@@ -177,10 +177,10 @@ void TIFFSwabFloat(float *fp)
#endif
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfFloat)
void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
void TIFFSwabArrayOfFloat(float *fp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
unsigned char *cp;
unsigned char t;
assert(sizeof(float) == 4);
/* XXX unroll loop some */
while (n-- > 0)
@@ -200,7 +200,7 @@ void TIFFSwabArrayOfFloat(register float *fp, tmsize_t n)
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabDouble)
void TIFFSwabDouble(double *dp)
{
register unsigned char *cp = (unsigned char *)dp;
unsigned char *cp = (unsigned char *)dp;
unsigned char t;
assert(sizeof(double) == 8);
t = cp[7];
@@ -221,8 +221,8 @@ void TIFFSwabDouble(double *dp)
#if defined(DISABLE_CHECK_TIFFSWABMACROS) || !defined(TIFFSwabArrayOfDouble)
void TIFFSwabArrayOfDouble(double *dp, tmsize_t n)
{
register unsigned char *cp;
register unsigned char t;
unsigned char *cp;
unsigned char t;
assert(sizeof(double) == 8);
/* XXX unroll loop some */
while (n-- > 0)

22
3rdparty/libtiff/tif_thunder.c vendored
View File

@@ -41,7 +41,7 @@
* or 3-bit delta values are used, with the deltas packed
* into a single byte.
*/
#define THUNDER_DATA 0x3f /* mask for 6-bit data */
// #define THUNDER_DATA 0x3f /* mask for 6-bit data */
#define THUNDER_CODE 0xc0 /* mask for 2-bit code word */
/* code values */
#define THUNDER_RUN 0x00 /* run of pixels w/ encoded count */
@@ -56,11 +56,11 @@ static const int threebitdeltas[8] = {0, 1, 2, 3, 0, -3, -2, -1};
#define SETPIXEL(op, v) \
{ \
lastpixel = (v)&0xf; \
lastpixel = (v) & 0xf; \
if (npixels < maxpixels) \
{ \
if (npixels++ & 1) \
*op++ |= lastpixel; \
*op++ |= (uint8_t)lastpixel; \
else \
op[0] = (uint8_t)(lastpixel << 4); \
} \
@@ -85,8 +85,8 @@ static int ThunderSetupDecode(TIFF *tif)
static int ThunderDecode(TIFF *tif, uint8_t *op0, tmsize_t maxpixels)
{
static const char module[] = "ThunderDecode";
register unsigned char *bp;
register tmsize_t cc;
unsigned char *bp;
tmsize_t cc;
unsigned int lastpixel;
tmsize_t npixels;
uint8_t *op = op0;
@@ -112,7 +112,7 @@ static int ThunderDecode(TIFF *tif, uint8_t *op0, tmsize_t maxpixels)
break;
if (npixels & 1)
{
op[0] |= lastpixel;
op[0] |= (uint8_t)lastpixel;
lastpixel = *op++;
npixels++;
n--;
@@ -150,6 +150,8 @@ static int ThunderDecode(TIFF *tif, uint8_t *op0, tmsize_t maxpixels)
case THUNDER_RAW: /* raw data */
SETPIXEL(op, n);
break;
default:
break;
}
}
tif->tif_rawcp = (uint8_t *)bp;
@@ -161,7 +163,7 @@ static int ThunderDecode(TIFF *tif, uint8_t *op0, tmsize_t maxpixels)
TIFFErrorExtR(tif, module,
"%s data at scanline %lu (%" PRIu64 " != %" PRIu64 ")",
npixels < maxpixels ? "Not enough" : "Too much",
(unsigned long)tif->tif_row, (uint64_t)npixels,
(unsigned long)tif->tif_dir.td_row, (uint64_t)npixels,
(uint64_t)maxpixels);
return (0);
}
@@ -175,7 +177,7 @@ static int ThunderDecodeRow(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
uint8_t *row = buf;
(void)s;
if (occ % tif->tif_scanlinesize)
if (occ % tif->tif_dir.td_scanlinesize)
{
TIFFErrorExtR(tif, module, "Fractional scanlines cannot be read");
return (0);
@@ -184,8 +186,8 @@ static int ThunderDecodeRow(TIFF *tif, uint8_t *buf, tmsize_t occ, uint16_t s)
{
if (!ThunderDecode(tif, row, tif->tif_dir.td_imagewidth))
return (0);
occ -= tif->tif_scanlinesize;
row += tif->tif_scanlinesize;
occ -= tif->tif_dir.td_scanlinesize;
row += tif->tif_dir.td_scanlinesize;
}
return (1);
}

95
3rdparty/libtiff/tif_tile.c vendored
View File

@@ -54,12 +54,50 @@ uint32_t TIFFComputeTile(TIFF *tif, uint32_t x, uint32_t y, uint32_t z,
uint32_t xpt = TIFFhowmany_32(td->td_imagewidth, dx);
uint32_t ypt = TIFFhowmany_32(td->td_imagelength, dy);
uint32_t zpt = TIFFhowmany_32(td->td_imagedepth, dz);
uint32_t xpt_ypt = _TIFFMultiply32(tif, xpt, ypt, "TIFFComputeTile");
uint32_t xpt_ypt_zpt =
_TIFFMultiply32(tif, xpt_ypt, zpt, "TIFFComputeTile");
uint64_t z_offset;
uint64_t y_offset;
uint64_t tile64;
if ((xpt_ypt == 0 && xpt != 0 && ypt != 0) ||
(xpt_ypt_zpt == 0 && xpt_ypt != 0 && zpt != 0))
return (0);
z_offset = _TIFFMultiply64(tif, xpt_ypt, z / dz, "TIFFComputeTile");
y_offset = _TIFFMultiply64(tif, xpt, y / dy, "TIFFComputeTile");
if ((z_offset == 0 && xpt_ypt != 0 && (z / dz) != 0) ||
(y_offset == 0 && xpt != 0 && (y / dy) != 0))
return (0);
tile64 = _TIFFAdd64(tif, z_offset, y_offset, "TIFFComputeTile");
if (tile64 == 0 && (z_offset != 0 || y_offset != 0))
return (0);
tile64 = _TIFFAdd64(tif, tile64, x / dx, "TIFFComputeTile");
if (tile64 == 0 && (z_offset != 0 || y_offset != 0 || (x / dx) != 0))
return (0);
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
tile = (xpt * ypt * zpt) * s + (xpt * ypt) * (z / dz) +
xpt * (y / dy) + x / dx;
else
tile = (xpt * ypt) * (z / dz) + xpt * (y / dy) + x / dx;
{
uint64_t sample_offset;
if (s >= td->td_samplesperpixel)
{
TIFFErrorExtR(
tif, "TIFFComputeTile", "%lu: Sample out of range, max %lu",
(unsigned long)s, (unsigned long)td->td_samplesperpixel);
return (0);
}
sample_offset =
_TIFFMultiply64(tif, xpt_ypt_zpt, s, "TIFFComputeTile");
if (sample_offset == 0 && xpt_ypt_zpt != 0 && s != 0)
return (0);
tile64 = _TIFFAdd64(tif, sample_offset, tile64, "TIFFComputeTile");
if (tile64 == 0 && (sample_offset != 0 || z_offset != 0 ||
y_offset != 0 || (x / dx) != 0))
return (0);
}
tile = _TIFFCastUInt64ToUInt32(tif, tile64, "TIFFComputeTile");
if (tile == 0 && tile64 != 0)
return (0);
}
return (tile);
}
@@ -187,54 +225,9 @@ tmsize_t TIFFTileRowSize(TIFF *tif)
*/
uint64_t TIFFVTileSize64(TIFF *tif, uint32_t nrows)
{
static const char module[] = "TIFFVTileSize64";
TIFFDirectory *td = &tif->tif_dir;
if (td->td_tilelength == 0 || td->td_tilewidth == 0 ||
td->td_tiledepth == 0)
return (0);
if ((td->td_planarconfig == PLANARCONFIG_CONTIG) &&
(td->td_photometric == PHOTOMETRIC_YCBCR) &&
(td->td_samplesperpixel == 3) && (!isUpSampled(tif)))
{
/*
* Packed YCbCr data contain one Cb+Cr for every
* HorizontalSampling*VerticalSampling Y values.
* Must also roundup width and height when calculating
* since images that are not a multiple of the
* horizontal/vertical subsampling area include
* YCbCr data for the extended image.
*/
uint16_t ycbcrsubsampling[2];
uint16_t samplingblock_samples;
uint32_t samplingblocks_hor;
uint32_t samplingblocks_ver;
uint64_t samplingrow_samples;
uint64_t samplingrow_size;
TIFFGetFieldDefaulted(tif, TIFFTAG_YCBCRSUBSAMPLING,
ycbcrsubsampling + 0, ycbcrsubsampling + 1);
if ((ycbcrsubsampling[0] != 1 && ycbcrsubsampling[0] != 2 &&
ycbcrsubsampling[0] != 4) ||
(ycbcrsubsampling[1] != 1 && ycbcrsubsampling[1] != 2 &&
ycbcrsubsampling[1] != 4))
{
TIFFErrorExtR(tif, module, "Invalid YCbCr subsampling (%dx%d)",
ycbcrsubsampling[0], ycbcrsubsampling[1]);
return 0;
}
samplingblock_samples = ycbcrsubsampling[0] * ycbcrsubsampling[1] + 2;
samplingblocks_hor =
TIFFhowmany_32(td->td_tilewidth, ycbcrsubsampling[0]);
samplingblocks_ver = TIFFhowmany_32(nrows, ycbcrsubsampling[1]);
samplingrow_samples = _TIFFMultiply64(tif, samplingblocks_hor,
samplingblock_samples, module);
samplingrow_size = TIFFhowmany8_64(_TIFFMultiply64(
tif, samplingrow_samples, td->td_bitspersample, module));
return (
_TIFFMultiply64(tif, samplingrow_size, samplingblocks_ver, module));
}
else
return (_TIFFMultiply64(tif, nrows, TIFFTileRowSize64(tif), module));
return _TIFFStrileSize64(tif, nrows, /* isStrip = */ FALSE);
}
tmsize_t TIFFVTileSize(TIFF *tif, uint32_t nrows)
{
static const char module[] = "TIFFVTileSize";

19
3rdparty/libtiff/tif_unix.c vendored
View File

@@ -77,10 +77,10 @@ static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
return (tmsize_t)-1;
}
fdh.h = fd;
for (bytes_read = 0; bytes_read < bytes_total; bytes_read += count)
for (bytes_read = 0; bytes_read < bytes_total; bytes_read += (size_t)count)
{
char *buf_offset = (char *)buf + bytes_read;
size_t io_size = bytes_total - bytes_read;
size_t io_size = (size_t)(bytes_total - bytes_read);
if (io_size > TIFF_IO_MAX)
io_size = TIFF_IO_MAX;
/* Below is an obvious false positive of Coverity Scan */
@@ -108,10 +108,11 @@ static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
return (tmsize_t)-1;
}
fdh.h = fd;
for (bytes_written = 0; bytes_written < bytes_total; bytes_written += count)
for (bytes_written = 0; bytes_written < bytes_total;
bytes_written += (size_t)count)
{
const char *buf_offset = (char *)buf + bytes_written;
size_t io_size = bytes_total - bytes_written;
size_t io_size = (size_t)(bytes_total - bytes_written);
if (io_size > TIFF_IO_MAX)
io_size = TIFF_IO_MAX;
/* Below is an obvious false positive of Coverity Scan */
@@ -174,7 +175,7 @@ static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
(void *)mmap(0, (size_t)sizem, PROT_READ, MAP_SHARED, fdh.fd, 0);
if (*pbase != (void *)-1)
{
*psize = (tmsize_t)sizem;
*psize = (toff_t)sizem;
return (1);
}
}
@@ -184,7 +185,7 @@ static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
static void _tiffUnmapProc(thandle_t fd, void *base, toff_t size)
{
(void)fd;
(void)munmap(base, (off_t)size);
(void)munmap(base, (size_t)size);
}
#else /* !HAVE_MMAP */
static int _tiffMapProc(thandle_t fd, void **pbase, toff_t *psize)
@@ -362,7 +363,8 @@ int _TIFFmemcmp(const void *p1, const void *p2, tmsize_t c)
return (memcmp(p1, p2, (size_t)c));
}
static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
static void TIFF_ATTRIBUTE((__format__(__printf__, 2, 0)))
unixWarningHandler(const char *module, const char *fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);
@@ -372,7 +374,8 @@ static void unixWarningHandler(const char *module, const char *fmt, va_list ap)
}
TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
static void unixErrorHandler(const char *module, const char *fmt, va_list ap)
static void TIFF_ATTRIBUTE((__format__(__printf__, 2, 0)))
unixErrorHandler(const char *module, const char *fmt, va_list ap)
{
if (module != NULL)
fprintf(stderr, "%s: ", module);

57
3rdparty/libtiff/tif_webp.c vendored
View File

@@ -84,15 +84,16 @@ static int TWebPDatasetWriter(const uint8_t *data, size_t data_size,
if ((tif->tif_rawcc + (tmsize_t)data_size) > tif->tif_rawdatasize)
{
TIFFErrorExtR(
tif, module, "Buffer too small by %" TIFF_SIZE_FORMAT " bytes.",
(size_t)(tif->tif_rawcc + data_size - tif->tif_rawdatasize));
TIFFErrorExtR(tif, module,
"Buffer too small by %" TIFF_SIZE_FORMAT " bytes.",
(size_t)((uint64_t)tif->tif_rawcc + (uint64_t)data_size -
(uint64_t)tif->tif_rawdatasize));
return 0;
}
else
{
_TIFFmemcpy(tif->tif_rawcp, data, data_size);
tif->tif_rawcc += data_size;
_TIFFmemcpy(tif->tif_rawcp, data, (tmsize_t)data_size);
tif->tif_rawcc += (tmsize_t)data_size;
tif->tif_rawcp += data_size;
return 1;
}
@@ -116,7 +117,7 @@ static int TWebPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
return 0;
}
memcpy(sp->pBuffer + sp->buffer_offset, bp, cc);
memcpy(sp->pBuffer + sp->buffer_offset, bp, (size_t)cc);
sp->buffer_offset += (unsigned)cc;
return 1;
@@ -141,7 +142,7 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"ZIPDecode: Scanline %" PRIu32 " cannot be read due to "
"previous error",
tif->tif_row);
tif->tif_dir.td_row);
return 0;
}
@@ -158,7 +159,7 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
segment_height = td->td_imagelength - tif->tif_dir.td_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
}
@@ -246,7 +247,7 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
sp->pBuffer = NULL;
}
sp->pBuffer = _TIFFmallocExt(tif, buffer_size);
sp->pBuffer = (uint8_t *)_TIFFmallocExt(tif, buffer_size);
if (!sp->pBuffer)
{
TIFFErrorExtR(tif, module, "Cannot allocate buffer");
@@ -262,10 +263,10 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
WebPInitDecBuffer(&sp->sDecBuffer);
sp->sDecBuffer.is_external_memory = 1;
sp->sDecBuffer.width = segment_width;
sp->sDecBuffer.height = segment_height;
sp->sDecBuffer.width = (int)segment_width;
sp->sDecBuffer.height = (int)segment_height;
sp->sDecBuffer.u.RGBA.rgba = decode_whole_strile ? op : sp->pBuffer;
sp->sDecBuffer.u.RGBA.stride = segment_width * sp->nSamples;
sp->sDecBuffer.u.RGBA.stride = (int)(segment_width * sp->nSamples);
sp->sDecBuffer.u.RGBA.size = buffer_size;
if (sp->nSamples > 3)
@@ -298,7 +299,7 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
return 0;
}
status = WebPIAppend(sp->psDecoder, tif->tif_rawcp, tif->tif_rawcc);
status = WebPIAppend(sp->psDecoder, tif->tif_rawcp, (size_t)tif->tif_rawcc);
if (status != VP8_STATUS_OK && status != VP8_STATUS_SUSPENDED)
{
@@ -345,7 +346,7 @@ static int TWebPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
}
else
{
memcpy(op, buf + (sp->last_y * stride), occ);
memcpy(op, buf + (sp->last_y * stride), (size_t)occ);
}
tif->tif_rawcp += tif->tif_rawcc;
@@ -465,7 +466,7 @@ static int TWebPPreDecode(TIFF *tif, uint16_t s)
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
segment_height = td->td_imagelength - tif->tif_dir.td_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
}
@@ -601,7 +602,7 @@ static int TWebPPreEncode(TIFF *tif, uint16_t s)
else
{
segment_width = td->td_imagewidth;
segment_height = td->td_imagelength - tif->tif_row;
segment_height = td->td_imagelength - tif->tif_dir.td_row;
if (segment_height > td->td_rowsperstrip)
segment_height = td->td_rowsperstrip;
}
@@ -623,7 +624,7 @@ static int TWebPPreEncode(TIFF *tif, uint16_t s)
sp->pBuffer = NULL;
}
sp->pBuffer = _TIFFmallocExt(tif, sp->buffer_size);
sp->pBuffer = (uint8_t *)_TIFFmallocExt(tif, sp->buffer_size);
if (!sp->pBuffer)
{
TIFFErrorExtR(tif, module, "Cannot allocate buffer");
@@ -631,8 +632,8 @@ static int TWebPPreEncode(TIFF *tif, uint16_t s)
}
sp->buffer_offset = 0;
sp->sPicture.width = segment_width;
sp->sPicture.height = segment_height;
sp->sPicture.width = (int)segment_width;
sp->sPicture.height = (int)segment_height;
sp->sPicture.writer = TWebPDatasetWriter;
sp->sPicture.custom_ptr = tif;
@@ -708,9 +709,11 @@ static int TWebPPostEncode(TIFF *tif)
case VP8_ENC_ERROR_USER_ABORT:
pszErrorMsg = "User interrupted";
break;
case VP8_ENC_OK:
case VP8_ENC_ERROR_LAST:
default:
TIFFErrorExtR(tif, module,
"WebPEncode returned an unknown error code: %d",
"WebPEncode returned an unknown error code: %u",
sp->sPicture.error_code);
pszErrorMsg = "Unknown WebP error type.";
break;
@@ -776,7 +779,7 @@ static int TWebPVSetField(TIFF *tif, uint32_t tag, va_list ap)
{
case TIFFTAG_WEBP_LEVEL:
sp->quality_level = (int)va_arg(ap, int);
if (sp->quality_level <= 0 || sp->quality_level > 100.0f)
if (sp->quality_level <= 0 || sp->quality_level > 100)
{
TIFFWarningExtR(tif, module,
"WEBP_LEVEL should be between 1 and 100");
@@ -844,6 +847,17 @@ static const TIFFField TWebPFields[] = {
FIELD_PSEUDO, TRUE, FALSE, "WEBP exact lossless", NULL},
};
static uint64_t TWebPGetMaxCompressionRatio(TIFF *tif)
{
/* See README_for_libtiff_developpers.md for raw data used to estimate
* the maximum compression rate. */
/* lossy compression: */
/* return (tif->tif_dir.td_samplesperpixel == 4) ? 2199 : 1685; */
/* lossless compression: */
return (tif->tif_dir.td_samplesperpixel == 4) ? 104194 : 78146;
}
int TIFFInitWebP(TIFF *tif, int scheme)
{
static const char module[] = "TIFFInitWebP";
@@ -907,6 +921,7 @@ int TIFFInitWebP(TIFF *tif, int scheme)
tif->tif_encodestrip = TWebPEncode;
tif->tif_encodetile = TWebPEncode;
tif->tif_cleanup = TWebPCleanup;
tif->tif_getmaxcompressionratio = TWebPGetMaxCompressionRatio;
return 1;
bad:

15
3rdparty/libtiff/tif_win32.c vendored
View File

@@ -5,6 +5,7 @@
* Permission to use, copy, modify, distribute, and sell this software and
* its documentation for any purpose is hereby granted without fee, provided
* that (i) the above copyright notices and this permission notice appear in
* that (i) the above copyright notices and this permission notice appear in
* all copies of the software and related documentation, and (ii) the names of
* Sam Leffler and Silicon Graphics may not be used in any advertising or
* publicity relating to the software without the specific, prior written
@@ -72,7 +73,7 @@ static tmsize_t _tiffReadProc(thandle_t fd, void *buf, tmsize_t size)
DWORD o;
tmsize_t p;
ma = (uint8_t *)buf;
mb = size;
mb = (uint64_t)size;
p = 0;
while (mb > 0)
{
@@ -101,7 +102,7 @@ static tmsize_t _tiffWriteProc(thandle_t fd, void *buf, tmsize_t size)
DWORD o;
tmsize_t p;
ma = (uint8_t *)buf;
mb = size;
mb = (uint64_t)size;
p = 0;
while (mb > 0)
{
@@ -123,7 +124,7 @@ static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
{
LARGE_INTEGER offli;
DWORD dwMoveMethod;
offli.QuadPart = off;
offli.QuadPart = (LONGLONG)off;
switch (whence)
{
case SEEK_SET:
@@ -140,11 +141,11 @@ static uint64_t _tiffSeekProc(thandle_t fd, uint64_t off, int whence)
break;
}
offli.LowPart =
SetFilePointer(fd, offli.LowPart, &offli.HighPart, dwMoveMethod);
SetFilePointer(fd, (LONG)offli.LowPart, &offli.HighPart, dwMoveMethod);
if ((offli.LowPart == INVALID_SET_FILE_POINTER) &&
(GetLastError() != NO_ERROR))
offli.QuadPart = 0;
return (offli.QuadPart);
return ((uint64_t)offli.QuadPart);
}
static int _tiffCloseProc(thandle_t fd) { return (CloseHandle(fd) ? 0 : -1); }
@@ -153,7 +154,7 @@ static uint64_t _tiffSizeProc(thandle_t fd)
{
LARGE_INTEGER m;
if (GetFileSizeEx(fd, &m))
return (m.QuadPart);
return ((uint64_t)m.QuadPart);
else
return (0);
}
@@ -343,7 +344,7 @@ TIFF *TIFFOpenWExt(const wchar_t *name, const char *mode, TIFFOpenOptions *opts)
NULL);
if (fd == INVALID_HANDLE_VALUE)
{
_TIFFErrorEarly(opts, NULL, module, "%S: Cannot open", name);
_TIFFErrorEarly(opts, NULL, module, "%ls: Cannot open", name);
return ((TIFF *)0);
}

181
3rdparty/libtiff/tif_write.c vendored
View File

@@ -30,7 +30,7 @@
#include "tiffiop.h"
#include <stdio.h>
#define STRIPINCR 20 /* expansion factor on strip array */
#define NOSTRIP ((uint32_t)(-1)) /* undefined state */
#define WRITECHECKSTRIPS(tif, module) \
(((tif)->tif_flags & TIFF_BEENWRITING) || TIFFWriteCheck((tif), 0, module))
@@ -38,7 +38,7 @@
(((tif)->tif_flags & TIFF_BEENWRITING) || TIFFWriteCheck((tif), 1, module))
#define BUFFERCHECK(tif) \
((((tif)->tif_flags & TIFF_BUFFERSETUP) && tif->tif_rawdata) || \
TIFFWriteBufferSetup((tif), NULL, (tmsize_t)-1))
TIFFWriteBufferSetup((tif), NULL, (tmsize_t)(-1)))
static int TIFFGrowStrips(TIFF *tif, uint32_t delta, const char *module);
static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
@@ -47,7 +47,7 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
{
static const char module[] = "TIFFWriteScanline";
register TIFFDirectory *td;
TIFFDirectory *td;
int status, imagegrew = 0;
uint32_t strip;
@@ -82,8 +82,16 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
/*
* Calculate strip and check for crossings.
*/
if (td->td_rowsperstrip == 0)
{
TIFFErrorExtR(tif, module,
"Cannot compute strip: RowsPerStrip is zero");
return (-1);
}
if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
{
uint64_t sample_offset;
uint64_t strip64;
if (sample >= td->td_samplesperpixel)
{
TIFFErrorExtR(tif, module, "%lu: Sample out of range, max %lu",
@@ -91,7 +99,18 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
(unsigned long)td->td_samplesperpixel);
return (-1);
}
strip = sample * td->td_stripsperimage + row / td->td_rowsperstrip;
sample_offset =
_TIFFMultiply64(tif, sample, td->td_stripsperimage, module);
if (sample_offset == 0 && sample != 0 && td->td_stripsperimage != 0)
return (-1);
strip64 =
_TIFFAdd64(tif, sample_offset, row / td->td_rowsperstrip, module);
if (strip64 == 0 &&
(sample_offset != 0 || (row / td->td_rowsperstrip) != 0))
return (-1);
strip = _TIFFCastUInt64ToUInt32(tif, strip64, module);
if (strip == 0 && strip64 != 0)
return (-1);
}
else
strip = row / td->td_rowsperstrip;
@@ -104,14 +123,14 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
*/
if (strip >= td->td_nstrips && !TIFFGrowStrips(tif, 1, module))
return (-1);
if (strip != tif->tif_curstrip)
if (strip != tif->tif_dir.td_curstrip)
{
/*
* Changing strips -- flush any data present.
*/
if (!TIFFFlushData(tif))
return (-1);
tif->tif_curstrip = strip;
tif->tif_dir.td_curstrip = strip;
/*
* Watch out for a growing image. The value of strips/image
* will initially be 1 (since it can't be deduced until the
@@ -125,7 +144,8 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
TIFFErrorExtR(tif, module, "Zero strips per image");
return (-1);
}
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_dir.td_row =
(strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
{
if (!(*tif->tif_setupencode)(tif))
@@ -148,35 +168,35 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
* beginning of a strip (or that we can randomly
* access the data -- i.e. no encoding).
*/
if (row != tif->tif_row)
if (row != tif->tif_dir.td_row)
{
if (row < tif->tif_row)
if (row < tif->tif_dir.td_row)
{
/*
* Moving backwards within the same strip:
* backup to the start and then decode
* forward (below).
*/
tif->tif_row =
tif->tif_dir.td_row =
(strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_rawcp = tif->tif_rawdata;
}
/*
* Seek forward to the desired row.
*/
if (!(*tif->tif_seek)(tif, row - tif->tif_row))
if (!(*tif->tif_seek)(tif, row - tif->tif_dir.td_row))
return (-1);
tif->tif_row = row;
tif->tif_dir.td_row = row;
}
/* swab if needed - note that source buffer will be altered */
tif->tif_postdecode(tif, (uint8_t *)buf, tif->tif_scanlinesize);
tif->tif_postdecode(tif, (uint8_t *)buf, tif->tif_dir.td_scanlinesize);
status = (*tif->tif_encoderow)(tif, (uint8_t *)buf, tif->tif_scanlinesize,
sample);
status = (*tif->tif_encoderow)(tif, (uint8_t *)buf,
tif->tif_dir.td_scanlinesize, sample);
/* we are now poised at the beginning of the next row */
tif->tif_row = row + 1;
tif->tif_dir.td_row = row + 1;
return (status);
}
@@ -188,7 +208,21 @@ int TIFFWriteScanline(TIFF *tif, void *buf, uint32_t row, uint16_t sample)
/* time if the new compressed tile is bigger than the older one. (GDAL #4771) */
static int _TIFFReserveLargeEnoughWriteBuffer(TIFF *tif, uint32_t strip_or_tile)
{
static const char module[] = "_TIFFReserveLargeEnoughWriteBuffer";
TIFFDirectory *td = &tif->tif_dir;
if (td->td_stripbytecount_p == NULL)
{
TIFFErrorExtR(tif, module, "Strip bytecount array pointer is NULL");
return 0;
}
if (strip_or_tile == NOSTRIP || strip_or_tile >= td->td_nstrips)
{
TIFFErrorExtR(tif, module, "Strip/tile number not valid");
return 0;
}
if (td->td_stripbytecount_p[strip_or_tile] > 0)
{
/* The +1 is to ensure at least one extra bytes */
@@ -254,7 +288,7 @@ tmsize_t TIFFWriteEncodedStrip(TIFF *tif, uint32_t strip, void *data,
tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curstrip = strip;
tif->tif_dir.td_curstrip = strip;
/* this informs TIFFAppendToStrip() we have changed or reset strip */
tif->tif_curoff = 0;
@@ -273,7 +307,7 @@ tmsize_t TIFFWriteEncodedStrip(TIFF *tif, uint32_t strip, void *data,
return ((tmsize_t)-1);
}
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_dir.td_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
{
if (!(*tif->tif_setupencode)(tif))
@@ -362,9 +396,9 @@ tmsize_t TIFFWriteRawStrip(TIFF *tif, uint32_t strip, void *data, tmsize_t cc)
return ((tmsize_t)-1);
}
if (tif->tif_curstrip != strip)
if (tif->tif_dir.td_curstrip != strip)
{
tif->tif_curstrip = strip;
tif->tif_dir.td_curstrip = strip;
/* this informs TIFFAppendToStrip() we have changed or reset strip */
tif->tif_curoff = 0;
@@ -375,7 +409,7 @@ tmsize_t TIFFWriteRawStrip(TIFF *tif, uint32_t strip, void *data, tmsize_t cc)
TIFFErrorExtR(tif, module, "Zero strips per image");
return ((tmsize_t)-1);
}
tif->tif_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
tif->tif_dir.td_row = (strip % td->td_stripsperimage) * td->td_rowsperstrip;
return (TIFFAppendToStrip(tif, strip, (uint8_t *)data, cc) ? cc
: (tmsize_t)-1);
}
@@ -437,7 +471,7 @@ tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
tif->tif_flags |= TIFF_BUF4WRITE;
tif->tif_curtile = tile;
tif->tif_dir.td_curtile = tile;
/* this informs TIFFAppendToStrip() we have changed or reset tile */
tif->tif_curoff = 0;
@@ -460,14 +494,14 @@ tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
TIFFErrorExtR(tif, module, "Zero tiles");
return ((tmsize_t)(-1));
}
tif->tif_row = (tile % howmany32) * td->td_tilelength;
tif->tif_dir.td_row = (tile % howmany32) * td->td_tilelength;
howmany32 = TIFFhowmany_32(td->td_imagewidth, td->td_tilewidth);
if (howmany32 == 0)
{
TIFFErrorExtR(tif, module, "Zero tiles");
return ((tmsize_t)(-1));
}
tif->tif_col = (tile % howmany32) * td->td_tilewidth;
tif->tif_dir.td_col = (tile % howmany32) * td->td_tilewidth;
if ((tif->tif_flags & TIFF_CODERSETUP) == 0)
{
@@ -482,8 +516,8 @@ tmsize_t TIFFWriteEncodedTile(TIFF *tif, uint32_t tile, void *data, tmsize_t cc)
* done so that callers can pass in some large number
* (e.g. -1) and have the tile size used instead.
*/
if (cc < 1 || cc > tif->tif_tilesize)
cc = tif->tif_tilesize;
if (cc < 1 || cc > tif->tif_dir.td_tilesize)
cc = tif->tif_dir.td_tilesize;
/* shortcut to avoid an extra memcpy() */
if (td->td_compression == COMPRESSION_NONE)
@@ -588,8 +622,10 @@ int TIFFSetupStrips(TIFF *tif)
* Place data at the end-of-file
* (by setting offsets to zero).
*/
_TIFFmemset(td->td_stripoffset_p, 0, td->td_nstrips * sizeof(uint64_t));
_TIFFmemset(td->td_stripbytecount_p, 0, td->td_nstrips * sizeof(uint64_t));
_TIFFmemset(td->td_stripoffset_p, 0,
(tmsize_t)((size_t)td->td_nstrips * sizeof(uint64_t)));
_TIFFmemset(td->td_stripbytecount_p, 0,
(tmsize_t)((size_t)td->td_nstrips * sizeof(uint64_t)));
TIFFSetFieldBit(tif, FIELD_STRIPOFFSETS);
TIFFSetFieldBit(tif, FIELD_STRIPBYTECOUNTS);
return (1);
@@ -644,14 +680,14 @@ int TIFFWriteCheck(TIFF *tif, int tiles, const char *module)
}
if (isTiled(tif))
{
tif->tif_tilesize = TIFFTileSize(tif);
if (tif->tif_tilesize == 0)
tif->tif_dir.td_tilesize = TIFFTileSize(tif);
if (tif->tif_dir.td_tilesize == 0)
return (0);
}
else
tif->tif_tilesize = (tmsize_t)(-1);
tif->tif_scanlinesize = TIFFScanlineSize(tif);
if (tif->tif_scanlinesize == 0)
tif->tif_dir.td_tilesize = (tmsize_t)(-1);
tif->tif_dir.td_scanlinesize = TIFFScanlineSize(tif);
if (tif->tif_dir.td_scanlinesize == 0)
return (0);
tif->tif_flags |= TIFF_BEENWRITING;
@@ -689,7 +725,7 @@ int TIFFWriteBufferSetup(TIFF *tif, void *bp, tmsize_t size)
}
if (size == (tmsize_t)(-1))
{
size = (isTiled(tif) ? tif->tif_tilesize : TIFFStripSize(tif));
size = (isTiled(tif) ? tif->tif_dir.td_tilesize : TIFFStripSize(tif));
/* Adds 10% margin for cases where compression would expand a bit */
if (size < TIFF_TMSIZE_T_MAX - size / 10)
@@ -732,26 +768,31 @@ static int TIFFGrowStrips(TIFF *tif, uint32_t delta, const char *module)
assert(td->td_planarconfig == PLANARCONFIG_CONTIG);
new_stripoffset = (uint64_t *)_TIFFreallocExt(
tif, td->td_stripoffset_p, (td->td_nstrips + delta) * sizeof(uint64_t));
tif, td->td_stripoffset_p,
(tmsize_t)(((size_t)td->td_nstrips + (size_t)delta) *
sizeof(uint64_t)));
/*
* Update td_stripoffset_p immediately so the old pointer is not left
* dangling if the second realloc fails.
*/
if (new_stripoffset)
td->td_stripoffset_p = new_stripoffset;
new_stripbytecount = (uint64_t *)_TIFFreallocExt(
tif, td->td_stripbytecount_p,
(td->td_nstrips + delta) * sizeof(uint64_t));
(tmsize_t)(((size_t)td->td_nstrips + (size_t)delta) *
sizeof(uint64_t)));
if (new_stripbytecount)
td->td_stripbytecount_p = new_stripbytecount;
if (new_stripoffset == NULL || new_stripbytecount == NULL)
{
if (new_stripoffset)
_TIFFfreeExt(tif, new_stripoffset);
if (new_stripbytecount)
_TIFFfreeExt(tif, new_stripbytecount);
td->td_nstrips = 0;
TIFFErrorExtR(tif, module, "No space to expand strip arrays");
return (0);
}
td->td_stripoffset_p = new_stripoffset;
td->td_stripbytecount_p = new_stripbytecount;
_TIFFmemset(td->td_stripoffset_p + td->td_nstrips, 0,
delta * sizeof(uint64_t));
(tmsize_t)((size_t)delta * sizeof(uint64_t)));
_TIFFmemset(td->td_stripbytecount_p + td->td_nstrips, 0,
delta * sizeof(uint64_t));
(tmsize_t)((size_t)delta * sizeof(uint64_t)));
td->td_nstrips += delta;
tif->tif_flags |= TIFF_DIRTYDIRECT;
@@ -769,6 +810,23 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
uint64_t m;
int64_t old_byte_count = -1;
/* Some security checks */
if (td->td_stripoffset_p == NULL)
{
TIFFErrorExtR(tif, module, "Strip offset array pointer is NULL");
return (0);
}
if (td->td_stripbytecount_p == NULL)
{
TIFFErrorExtR(tif, module, "Strip bytecount array pointer is NULL");
return (0);
}
if (strip == NOSTRIP)
{
TIFFErrorExtR(tif, module, "Strip number not valid (NOSTRIP)");
return (0);
}
if (tif->tif_curoff == 0)
tif->tif_lastvalidoff = 0;
@@ -790,7 +848,7 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
if (!SeekOK(tif, td->td_stripoffset_p[strip]))
{
TIFFErrorExtR(tif, module, "Seek error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
return (0);
}
@@ -812,11 +870,11 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
/*
* We are starting a fresh strip/tile, so set the size to zero.
*/
old_byte_count = td->td_stripbytecount_p[strip];
old_byte_count = (int64_t)td->td_stripbytecount_p[strip];
td->td_stripbytecount_p[strip] = 0;
}
m = tif->tif_curoff + cc;
m = tif->tif_curoff + (uint64_t)cc;
if (!(tif->tif_flags & TIFF_BIGTIFF))
m = (uint32_t)m;
if ((m < tif->tif_curoff) || (m < (uint64_t)cc))
@@ -850,7 +908,7 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
offsetRead = td->td_stripoffset_p[strip];
offsetWrite = TIFFSeekFile(tif, 0, SEEK_END);
m = offsetWrite + toCopy + cc;
m = offsetWrite + (uint64_t)toCopy + (uint64_t)cc;
if (!(tif->tif_flags & TIFF_BIGTIFF) && m != (uint32_t)m)
{
TIFFErrorExtR(tif, module, "Maximum TIFF file size exceeded");
@@ -872,13 +930,15 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
/* Move data written by previous calls to us at end of file */
while (toCopy > 0)
{
tmsize_t chunkSize =
toCopy < (uint64_t)tempSize ? (tmsize_t)toCopy : tempSize;
if (!SeekOK(tif, offsetRead))
{
TIFFErrorExtR(tif, module, "Seek error");
_TIFFfreeExt(tif, temp);
return (0);
}
if (!ReadOK(tif, temp, tempSize))
if (!ReadOK(tif, temp, chunkSize))
{
TIFFErrorExtR(tif, module, "Cannot read");
_TIFFfreeExt(tif, temp);
@@ -890,32 +950,32 @@ static int TIFFAppendToStrip(TIFF *tif, uint32_t strip, uint8_t *data,
_TIFFfreeExt(tif, temp);
return (0);
}
if (!WriteOK(tif, temp, tempSize))
if (!WriteOK(tif, temp, chunkSize))
{
TIFFErrorExtR(tif, module, "Cannot write");
_TIFFfreeExt(tif, temp);
return (0);
}
offsetRead += tempSize;
offsetWrite += tempSize;
td->td_stripbytecount_p[strip] += tempSize;
toCopy -= tempSize;
offsetRead += (uint64_t)chunkSize;
offsetWrite += (uint64_t)chunkSize;
td->td_stripbytecount_p[strip] += (uint64_t)chunkSize;
toCopy -= (uint64_t)chunkSize;
}
_TIFFfreeExt(tif, temp);
/* Append the data of this call */
offsetWrite += cc;
offsetWrite += (uint64_t)cc;
m = offsetWrite;
}
if (!WriteOK(tif, data, cc))
{
TIFFErrorExtR(tif, module, "Write error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
return (0);
}
tif->tif_curoff = m;
td->td_stripbytecount_p[strip] += cc;
td->td_stripbytecount_p[strip] += (uint64_t)cc;
if ((int64_t)td->td_stripbytecount_p[strip] != old_byte_count)
tif->tif_flags |= TIFF_DIRTYSTRIP;
@@ -935,9 +995,10 @@ int TIFFFlushData1(TIFF *tif)
if (!isFillOrder(tif, tif->tif_dir.td_fillorder) &&
(tif->tif_flags & TIFF_NOBITREV) == 0)
TIFFReverseBits((uint8_t *)tif->tif_rawdata, tif->tif_rawcc);
if (!TIFFAppendToStrip(
tif, isTiled(tif) ? tif->tif_curtile : tif->tif_curstrip,
tif->tif_rawdata, tif->tif_rawcc))
if (!TIFFAppendToStrip(tif,
isTiled(tif) ? tif->tif_dir.td_curtile
: tif->tif_dir.td_curstrip,
tif->tif_rawdata, tif->tif_rawcc))
{
/* We update those variables even in case of error since there's */
/* code that doesn't really check the return code of this */

38
3rdparty/libtiff/tif_zip.c vendored
View File

@@ -159,7 +159,8 @@ static int ZIPPreDecode(TIFF *tif, uint16_t s)
we need to simplify this code to reflect a ZLib that is likely updated
to deal with 8byte memory sizes, though this code will respond
appropriately even before we simplify it */
sp->stream.avail_in = TIFF_CLAMP_UINT64_TO_INT32_MAX(tif->tif_rawcc);
sp->stream.avail_in =
TIFF_CLAMP_UINT64_TO_INT32_MAX((uint64_t)tif->tif_rawcc);
if (inflateReset(&sp->stream) == Z_OK)
{
sp->read_error = 0;
@@ -183,7 +184,7 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"ZIPDecode: Scanline %" PRIu32 " cannot be read due to "
"previous error",
tif->tif_row);
tif->tif_dir.td_row);
return 0;
}
@@ -210,7 +211,7 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
}
else
{
uint32_t strip_height = td->td_imagelength - tif->tif_row;
uint32_t strip_height = td->td_imagelength - tif->tif_dir.td_row;
if (strip_height > td->td_rowsperstrip)
strip_height = td->td_rowsperstrip;
if (TIFFVStripSize64(tif, strip_height) != (uint64_t)occ)
@@ -254,7 +255,7 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
memset(op, 0, (size_t)occ);
TIFFErrorExtR(tif, module, "Decoding error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
sp->read_error = 1;
return 0;
}
@@ -275,8 +276,9 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
do
{
int state;
uInt avail_in_before = TIFF_CLAMP_UINT64_TO_INT32_MAX(tif->tif_rawcc);
uInt avail_out_before = TIFF_CLAMP_UINT64_TO_INT32_MAX(occ);
uInt avail_in_before =
TIFF_CLAMP_UINT64_TO_INT32_MAX((uint64_t)tif->tif_rawcc);
uInt avail_out_before = TIFF_CLAMP_UINT64_TO_INT32_MAX((uint64_t)occ);
sp->stream.avail_in = avail_in_before;
sp->stream.avail_out = avail_out_before;
state = inflate(&sp->stream, Z_PARTIAL_FLUSH);
@@ -288,7 +290,7 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
{
memset(sp->stream.next_out, 0, (size_t)occ);
TIFFErrorExtR(tif, module, "Decoding error at scanline %lu, %s",
(unsigned long)tif->tif_row, SAFE_MSG(sp));
(unsigned long)tif->tif_dir.td_row, SAFE_MSG(sp));
sp->read_error = 1;
return (0);
}
@@ -305,7 +307,7 @@ static int ZIPDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
TIFFErrorExtR(tif, module,
"Not enough data at scanline %lu (short %" PRIu64
" bytes)",
(unsigned long)tif->tif_row, (uint64_t)occ);
(unsigned long)tif->tif_dir.td_row, (uint64_t)occ);
memset(sp->stream.next_out, 0, (size_t)occ);
sp->read_error = 1;
return (0);
@@ -411,7 +413,7 @@ static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
}
else
{
uint32_t strip_height = td->td_imagelength - tif->tif_row;
uint32_t strip_height = td->td_imagelength - tif->tif_dir.td_row;
if (strip_height > td->td_rowsperstrip)
strip_height = td->td_rowsperstrip;
if (TIFFVStripSize64(tif, strip_height) != (uint64_t)cc)
@@ -463,11 +465,11 @@ static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
if (nCompressedBytes == 0)
{
TIFFErrorExtR(tif, module, "Encoder error at scanline %lu",
(unsigned long)tif->tif_row);
(unsigned long)tif->tif_dir.td_row);
return 0;
}
tif->tif_rawcc = nCompressedBytes;
tif->tif_rawcc = (tmsize_t)nCompressedBytes;
if (!TIFFFlushData1(tif))
return 0;
@@ -485,7 +487,7 @@ static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
appropriately even before we simplify it */
do
{
uInt avail_in_before = TIFF_CLAMP_UINT64_TO_INT32_MAX(cc);
uInt avail_in_before = TIFF_CLAMP_UINT64_TO_INT32_MAX((uint64_t)cc);
sp->stream.avail_in = avail_in_before;
if (deflate(&sp->stream, Z_NO_FLUSH) != Z_OK)
{
@@ -499,7 +501,7 @@ static int ZIPEncode(TIFF *tif, uint8_t *bp, tmsize_t cc, uint16_t s)
return 0;
sp->stream.next_out = tif->tif_rawdata;
sp->stream.avail_out =
TIFF_CLAMP_UINT64_TO_INT32_MAX(tif->tif_rawdatasize);
TIFF_CLAMP_UINT64_TO_INT32_MAX((uint64_t)tif->tif_rawdatasize);
}
cc -= (avail_in_before - sp->stream.avail_in);
} while (cc > 0);
@@ -682,7 +684,7 @@ static const TIFFField zipFields[] = {
static void *TIFF_zalloc(void *opaque, unsigned int items, unsigned int size)
{
static const char module[] = "TIFF_zalloc";
TIFF *tif = opaque;
TIFF *tif = (TIFF *)opaque;
if (items > ~(size_t)0 / size)
{
@@ -698,6 +700,13 @@ static void TIFF_zfree(void *opaque, void *ptr)
_TIFFfreeExt((TIFF *)opaque, ptr);
}
static uint64_t ZIPGetMaxCompressionRatio(TIFF *tif)
{
(void)tif;
/* cf https://zlib.net/zlib_tech.html */
return 1032;
}
int TIFFInitZIP(TIFF *tif, int scheme)
{
static const char module[] = "TIFFInitZIP";
@@ -764,6 +773,7 @@ int TIFFInitZIP(TIFF *tif, int scheme)
tif->tif_encodestrip = ZIPEncode;
tif->tif_encodetile = ZIPEncode;
tif->tif_cleanup = ZIPCleanup;
tif->tif_getmaxcompressionratio = ZIPGetMaxCompressionRatio;
/*
* Setup predictor setup.
*/

6
3rdparty/libtiff/tif_zstd.c vendored
View File

@@ -159,13 +159,13 @@ static int ZSTDDecode(TIFF *tif, uint8_t *op, tmsize_t occ, uint16_t s)
memset(op + out_buffer.pos, 0, out_buffer.size - out_buffer.pos);
TIFFErrorExtR(tif, module,
"Not enough data at scanline %lu (short %lu bytes)",
(unsigned long)tif->tif_row,
(unsigned long)tif->tif_dir.td_row,
(unsigned long)((size_t)occ - out_buffer.pos));
return 0;
}
tif->tif_rawcp += in_buffer.pos;
tif->tif_rawcc -= in_buffer.pos;
tif->tif_rawcc -= (tmsize_t)in_buffer.pos;
return 1;
}
@@ -287,7 +287,7 @@ static int ZSTDPostEncode(TIFF *tif)
}
if (sp->out_buffer.pos > 0)
{
tif->tif_rawcc = sp->out_buffer.pos;
tif->tif_rawcc = (tmsize_t)sp->out_buffer.pos;
if (!TIFFFlushData1(tif))
return 0;
sp->out_buffer.dst = tif->tif_rawcp;

3
3rdparty/libtiff/tiffconf.h.cmake.in vendored
View File

@@ -108,6 +108,9 @@
/* Support libdeflate enhanced compression */
#cmakedefine LIBDEFLATE_SUPPORT 1
/* Support webp compression */
#cmakedefine WEBP_SUPPORT 1
/* Support strip chopping (whether or not to convert single-strip uncompressed
images to multiple strips of ~8Kb to reduce memory usage) */
#cmakedefine STRIPCHOP_DEFAULT TIFF_STRIPCHOP

19
3rdparty/libtiff/tiffio.h vendored
View File

@@ -125,13 +125,13 @@ typedef void *thandle_t; /* client data handle */
*/
/* reference white */
#define D65_X0 (95.0470F)
#define D65_Y0 (100.0F)
#define D65_Z0 (108.8827F)
#define D65_X0 (95.0470f)
#define D65_Y0 (100.0f)
#define D65_Z0 (108.8827f)
#define D50_X0 (96.4250F)
#define D50_Y0 (100.0F)
#define D50_Z0 (82.4680F)
#define D50_X0 (96.4250f)
#define D50_Y0 (100.0f)
#define D50_Z0 (82.4680f)
/* Structure for holding information about a display device. */
@@ -254,7 +254,7 @@ struct _TIFFRGBAImage
* Macros for extracting components from the
* packed ABGR form returned by TIFFReadRGBAImage.
*/
#define TIFFGetR(abgr) ((abgr)&0xff)
#define TIFFGetR(abgr) ((abgr) & 0xff)
#define TIFFGetG(abgr) (((abgr) >> 8) & 0xff)
#define TIFFGetB(abgr) (((abgr) >> 16) & 0xff)
#define TIFFGetA(abgr) (((abgr) >> 24) & 0xff)
@@ -269,7 +269,7 @@ struct _TIFFRGBAImage
typedef int (*TIFFInitMethod)(TIFF *, int);
typedef struct
{
char *name;
const char *name;
uint16_t scheme;
TIFFInitMethod init;
} TIFFCodec;
@@ -584,6 +584,7 @@ extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
tmsize_t cc);
extern tmsize_t TIFFWriteRawTile(TIFF *tif, uint32_t tile, void *data,
tmsize_t cc);
extern uint64_t TIFFGetMaxCompressionRatio(TIFF *tif);
extern int TIFFDataWidth(
TIFFDataType); /* table of tag datatype widths within TIFF file. */
extern void TIFFSetWriteOffset(TIFF *tif, toff_t off);
@@ -659,7 +660,7 @@ extern int TIFFReadRGBAImageOriented(TIFF *, uint32_t, uint32_t, uint32_t *,
unsigned short field_bit; /* bit in fieldsset bit vector */
unsigned char field_oktochange; /* if true, can change while writing */
unsigned char field_passcount; /* if true, pass dir count on set */
char *field_name; /* ASCII name */
const char *field_name; /* ASCII name */
} TIFFFieldInfo;
extern int TIFFMergeFieldInfo(TIFF *, const TIFFFieldInfo[], uint32_t);

62
3rdparty/libtiff/tiffiop.h vendored
View File

@@ -38,6 +38,7 @@
#include <sys/types.h>
#endif
#include <math.h>
#include <string.h>
#ifdef HAVE_ASSERT_H
@@ -94,6 +95,7 @@ typedef int (*TIFFSeekMethod)(TIFF *, uint32_t);
typedef void (*TIFFPostMethod)(TIFF *tif, uint8_t *buf, tmsize_t size);
typedef uint32_t (*TIFFStripMethod)(TIFF *, uint32_t);
typedef void (*TIFFTileMethod)(TIFF *, uint32_t *, uint32_t *);
typedef uint64_t (*TIFFGetMaxCompressionRatioMethod)(TIFF *);
struct TIFFOffsetAndDirNumber
{
@@ -143,13 +145,18 @@ struct tiff
0x800000U /* read buffer (tif_rawdata) points into mmap() memory */
#define TIFF_DEFERSTRILELOAD \
0x1000000U /* defer strip/tile offset/bytecount array loading. */
#define TIFF_LAZYSTRILELOAD \
0x2000000U /* lazy/ondemand loading of strip/tile offset/bytecount values. \
Only used if TIFF_DEFERSTRILELOAD is set and in read-only \
mode */
#define TIFF_LAZYSTRILELOAD_DONE \
0x2000000U /* set when lazy/ondemand loading of strip/tile \
offset/bytecount values has been done. Only used if \
TIFF_DEFERSTRILELOAD is set and in read-only mode */
#define TIFF_CHOPPEDUPARRAYS \
0x4000000U /* set when allocChoppedUpStripArrays() has modified strip \
array */
#define TIFF_LAZYSTRILELOAD_ASKED \
0x8000000U /* set when lazy/ondemand loading of strip/tile \
offset/bytecount values has been requested on opening ('O' \
flag) */
uint64_t tif_diroff; /* file offset of current directory */
uint64_t tif_nextdiroff; /* file offset of following directory */
uint64_t tif_lastdiroff; /* file offset of last directory written so far */
@@ -162,7 +169,6 @@ struct tiff
tif_customdir; /* custom IFDs are separated from the main ones */
TIFFHeaderUnion tif_header; /* file's header block Classic/BigTIFF union */
uint16_t tif_header_size; /* file's header block and its length */
uint32_t tif_row; /* current scanline */
/* There are IFDs in the file and an "active" IFD in memory,
* from which fields are "set" and "get".
@@ -184,7 +190,6 @@ struct tiff
* - TIFF_NON_EXISTENT_DIR_NUMBER means 'dont know number of IFDs'.
* - 0 means 'empty file opened for writing, but no IFD written yet' */
tdir_t tif_curdircount;
uint32_t tif_curstrip; /* current strip for read/write */
uint64_t tif_curoff; /* current offset for read/write */
uint64_t tif_lastvalidoff; /* last valid offset allowed for rewrite in
place. Used only by TIFFAppendToStrip() */
@@ -192,10 +197,6 @@ struct tiff
/* SubIFD support */
uint16_t tif_nsubifd; /* remaining subifds to write */
uint64_t tif_subifdoff; /* offset for patching SubIFD link */
/* tiling support */
uint32_t tif_col; /* current column (offset by row too) */
uint32_t tif_curtile; /* current tile for read/write */
tmsize_t tif_tilesize; /* # of bytes in a tile */
/* compression scheme hooks */
int tif_decodestatus;
TIFFBoolMethod tif_fixuptags; /* called in TIFFReadDirectory */
@@ -216,10 +217,10 @@ struct tiff
TIFFVoidMethod tif_cleanup; /* cleanup state routine */
TIFFStripMethod tif_defstripsize; /* calculate/constrain strip size */
TIFFTileMethod tif_deftilesize; /* calculate/constrain tile size */
uint8_t *tif_data; /* compression scheme private data */
/* returns maximum compression ratio for current compression method */
TIFFGetMaxCompressionRatioMethod tif_getmaxcompressionratio;
uint8_t *tif_data; /* compression scheme private data */
/* input/output buffering */
tmsize_t tif_scanlinesize; /* # of bytes in a scanline */
tmsize_t tif_scanlineskew; /* scanline skew for reading strips */
uint8_t *tif_rawdata; /* raw data buffer */
tmsize_t tif_rawdatasize; /* # of bytes in raw data buffer */
tmsize_t tif_rawdataoff; /* rawdata offset within strip */
@@ -295,13 +296,15 @@ struct TIFFOpenOptions
* Default Read/Seek/Write definitions.
*/
#ifndef ReadOK
#define ReadOK(tif, buf, size) (TIFFReadFile((tif), (buf), (size)) == (size))
#define ReadOK(tif, buf, size) \
(TIFFReadFile((tif), (buf), (size)) == (tmsize_t)(size))
#endif
#ifndef SeekOK
#define SeekOK(tif, off) _TIFFSeekOK(tif, off)
#endif
#ifndef WriteOK
#define WriteOK(tif, buf, size) (TIFFWriteFile((tif), (buf), (size)) == (size))
#define WriteOK(tif, buf, size) \
(TIFFWriteFile((tif), (buf), (size)) == (tmsize_t)(size))
#endif
/* NB: the uint32_t casts are to silence certain ANSI-C compilers */
@@ -315,19 +318,19 @@ struct TIFFOpenOptions
(((uint32_t)(x) / (uint32_t)(y)) + \
((((uint32_t)(x) % (uint32_t)(y)) != 0) ? 1 : 0))
#define TIFFhowmany8_32(x) \
(((x)&0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
#define TIFFroundup_32(x, y) (TIFFhowmany_32(x, y) * (y))
(((x) & 0x07) ? ((uint32_t)(x) >> 3) + 1 : (uint32_t)(x) >> 3)
#define TIFFroundup_32(x, y) ((uint32_t)(TIFFhowmany_32(x, y) * (uint32_t)(y)))
#define TIFFhowmany_64(x, y) \
((((uint64_t)(x)) + (((uint64_t)(y)) - 1)) / ((uint64_t)(y)))
#define TIFFhowmany8_64(x) \
(((x)&0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)
#define TIFFroundup_64(x, y) (TIFFhowmany_64(x, y) * (y))
(((x) & 0x07) ? ((uint64_t)(x) >> 3) + 1 : (uint64_t)(x) >> 3)
#define TIFFroundup_64(x, y) ((uint64_t)(TIFFhowmany_64(x, y) * (uint64_t)(y)))
/* Safe multiply which returns zero if there is an *unsigned* integer overflow.
* This macro is not safe for *signed* integer types */
#define TIFFSafeMultiply(t, v, m) \
((((t)(m) != (t)0) && (((t)(((v) * (m)) / (m))) == (t)(v))) \
? (t)((v) * (m)) \
((((t)(m) != (t)0) && (((t)((((t)(v)) * ((t)(m))) / ((t)(m)))) == (t)(v))) \
? (t)(((t)(v)) * ((t)(m))) \
: (t)0)
#define TIFFmax(A, B) ((A) > (B) ? (A) : (B))
@@ -335,6 +338,10 @@ struct TIFFOpenOptions
#define TIFFArrayCount(a) (sizeof(a) / sizeof((a)[0]))
/* Float/double equality macros that suppress -Wfloat-equal warnings */
#define TIFF_FLOAT_EQ(x, y) (!(fabsf((x) - (y)) > 0.0f))
#define TIFF_DOUBLE_EQ(x, y) (!(fabs((x) - (y)) > 0.0))
/*
Support for large files.
@@ -355,7 +362,7 @@ struct TIFFOpenOptions
*/
#if defined(HAVE_FSEEKO)
#define fseek(stream, offset, whence) fseeko(stream, offset, whence)
#define ftell(stream, offset, whence) ftello(stream, offset, whence)
#define ftell(stream) ftello(stream)
#endif
#endif
#if defined(_WIN32) && \
@@ -459,9 +466,18 @@ extern "C"
extern uint32_t _TIFFMultiply32(TIFF *, uint32_t, uint32_t, const char *);
extern uint64_t _TIFFMultiply64(TIFF *, uint64_t, uint64_t, const char *);
extern uint64_t _TIFFAdd64(TIFF *, uint64_t, uint64_t, const char *);
extern tmsize_t _TIFFMultiplySSize(TIFF *, tmsize_t, tmsize_t,
const char *);
extern tmsize_t _TIFFAddSSize(TIFF *, tmsize_t, tmsize_t, const char *);
extern tmsize_t _TIFFCastUInt64ToSSize(TIFF *, uint64_t, const char *);
extern uint32_t _TIFFCastUInt64ToUInt32(TIFF *, uint64_t, const char *);
extern uint64_t _TIFFComputeRowSize64(TIFF *, uint32_t, uint16_t, uint16_t,
const char *);
extern tmsize_t _TIFFComputeRowOffset(TIFF *, tmsize_t rowstride, uint32_t,
const char *);
extern uint64_t _TIFFComputeBitOffset(TIFF *, uint32_t, uint16_t, uint16_t,
const char *);
extern void *_TIFFCheckMalloc(TIFF *, tmsize_t, tmsize_t, const char *);
extern void *_TIFFCheckRealloc(TIFF *, void *, tmsize_t, tmsize_t,
const char *);
@@ -471,6 +487,8 @@ extern "C"
extern void _TIFFCleanupIFDOffsetAndNumberMaps(TIFF *tif);
extern uint64_t _TIFFStrileSize64(TIFF *tif, uint32_t nrows, int isStrip);
extern tmsize_t _TIFFReadEncodedStripAndAllocBuffer(TIFF *tif,
uint32_t strip,
void **buf,

2
3rdparty/openjpeg/CMakeLists.txt vendored
View File

@@ -23,7 +23,7 @@ ocv_warnings_disable(CMAKE_C_FLAGS
# OPENJPEG version number, useful for packaging and doxygen doc:
set(OPENJPEG_VERSION_MAJOR 2)
set(OPENJPEG_VERSION_MINOR 5)
set(OPENJPEG_VERSION_BUILD 3)
set(OPENJPEG_VERSION_BUILD 4)
set(OPENJPEG_VERSION
"${OPENJPEG_VERSION_MAJOR}.${OPENJPEG_VERSION_MINOR}.${OPENJPEG_VERSION_BUILD}")
set(PACKAGE_VERSION

6
CMakeLists.txt
View File

@@ -1542,11 +1542,7 @@ if(WITH_WEBP OR HAVE_WEBP)
endif()
if(WITH_AVIF OR HAVE_AVIF)
if(libavif_VERSION)
status(" AVIF:" AVIF_FOUND THEN "${AVIF_LIBRARY} (ver ${libavif_VERSION})" ELSE "NO")
else()
status(" AVIF:" AVIF_FOUND THEN "${AVIF_LIBRARY}" ELSE "NO")
endif()
status(" AVIF:" AVIF_FOUND THEN "${AVIF_LIBRARY} (ver ${AVIF_VERSION})" ELSE "NO")
endif()
if(WITH_SPNG)

10
README.md
View File

@@ -7,7 +7,7 @@
* Courses: <https://opencv.org/courses>
* Docs: <https://docs.opencv.org/4.x/>
* Q&A forum: <https://forum.opencv.org>
* previous forum (read only): <http://answers.opencv.org>
* previous forum (read only): <https://answers.opencv.org>
* Issue tracking: <https://github.com/opencv/opencv/issues>
* Additional OpenCV functionality: <https://github.com/opencv/opencv_contrib>
* Donate to OpenCV: <https://opencv.org/support/>
@@ -28,9 +28,9 @@ Please read the [contribution guidelines](https://github.com/opencv/opencv/wiki/
### Additional Resources
* [Submit your OpenCV-based project](https://form.jotform.com/233105358823151) for inclusion in Community Friday on opencv.org
* [Subscribe to the OpenCV YouTube Channel](http://youtube.com/@opencvofficial) featuring OpenCV Live, an hour-long streaming show
* [Follow OpenCV on LinkedIn](http://linkedin.com/company/opencv/) for daily posts showing the state-of-the-art in computer vision & AI
* [Subscribe to the OpenCV YouTube Channel](https://youtube.com/@opencvofficial) featuring OpenCV Live, an hour-long streaming show
* [Follow OpenCV on LinkedIn](https://linkedin.com/company/opencv/) for daily posts showing the state-of-the-art in computer vision & AI
* [Apply to be an OpenCV Volunteer](https://form.jotform.com/232745316792159) to help organize events and online campaigns as well as amplify them
* [Follow OpenCV on Mastodon](http://mastodon.social/@opencv) in the Fediverse
* [Follow OpenCV on Twitter](https://twitter.com/opencvlive)
* [Follow OpenCV on Mastodon](https://mastodon.social/@opencv) in the Fediverse
* [Follow OpenCV on X](https://x.com/opencvofficial)
* [OpenCV.ai](https://opencv.ai): Computer Vision and AI development services from the OpenCV team.

6
cmake/OpenCVCompilerOptimizations.cmake
View File

@@ -872,20 +872,24 @@ macro(ocv_compiler_optimization_fill_cpu_config)
# define CV_CPU_HAS_SUPPORT_${OPT} 1
# define CV_CPU_CALL_${OPT}(fn, args) return (cpu_baseline::fn args)
# define CV_CPU_CALL_${OPT}_(fn, args) return (opt_${OPT}::fn args)
# define CV_CPU_GET_FN_PTR_${OPT}(fn) return (cpu_baseline::fn)
#elif !defined CV_DISABLE_OPTIMIZATION && defined CV_ENABLE_INTRINSICS && defined CV_CPU_DISPATCH_COMPILE_${OPT}
# define CV_TRY_${OPT} 1
# define CV_CPU_FORCE_${OPT} 0
# define CV_CPU_HAS_SUPPORT_${OPT} (cv::checkHardwareSupport(CV_CPU_${OPT}))
# define CV_CPU_CALL_${OPT}(fn, args) if (CV_CPU_HAS_SUPPORT_${OPT}) return (opt_${OPT}::fn args)
# define CV_CPU_CALL_${OPT}_(fn, args) if (CV_CPU_HAS_SUPPORT_${OPT}) return (opt_${OPT}::fn args)
# define CV_CPU_GET_FN_PTR_${OPT}(fn) if (CV_CPU_HAS_SUPPORT_${OPT}) return (opt_${OPT}::fn)
#else
# define CV_TRY_${OPT} 0
# define CV_CPU_FORCE_${OPT} 0
# define CV_CPU_HAS_SUPPORT_${OPT} 0
# define CV_CPU_CALL_${OPT}(fn, args)
# define CV_CPU_CALL_${OPT}_(fn, args)
# define CV_CPU_GET_FN_PTR_${OPT}(fn)
#endif
#define __CV_CPU_DISPATCH_CHAIN_${OPT}(fn, args, mode, ...) CV_CPU_CALL_${OPT}(fn, args); __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_ ## mode(fn, args, __VA_ARGS__))
#define __CV_CPU_DISPATCH_CHAIN_FN_${OPT}(fn, mode, ...) CV_CPU_GET_FN_PTR_${OPT}(fn); __CV_EXPAND(__CV_CPU_DISPATCH_CHAIN_FN_ ## mode(fn, __VA_ARGS__))
")
endif()
endforeach()
@@ -893,6 +897,8 @@ macro(ocv_compiler_optimization_fill_cpu_config)
set(OPENCV_CPU_CONTROL_DEFINITIONS_CONFIGMAKE "${OPENCV_CPU_CONTROL_DEFINITIONS_CONFIGMAKE}
#define CV_CPU_CALL_BASELINE(fn, args) return (cpu_baseline::fn args)
#define __CV_CPU_DISPATCH_CHAIN_BASELINE(fn, args, mode, ...) CV_CPU_CALL_BASELINE(fn, args) /* last in sequence */
#define CV_CPU_GET_FN_PTR_BASELINE(fn) return (cpu_baseline::fn)
#define __CV_CPU_DISPATCH_CHAIN_FN_BASELINE(fn, mode, ...) CV_CPU_GET_FN_PTR_BASELINE(fn) /* last in sequence */
")

41
cmake/OpenCVFindAVIF.cmake
View File

@@ -6,6 +6,7 @@
# AVIF_INCLUDE_DIRS - where to find avif/avif.h, etc.
# AVIF_LIBRARIES - List of libraries when using AVIF.
# AVIF_FOUND - True if AVIF is found.
# AVIF_VERSION - libavif version string (e.g. "1.4.0")
#=============================================================================
# Look for the header file.
@@ -40,7 +41,41 @@ else()
# all listed variables are TRUE
INCLUDE(${CMAKE_ROOT}/Modules/FindPackageHandleStandardArgs.cmake)
FIND_PACKAGE_HANDLE_STANDARD_ARGS(AVIF DEFAULT_MSG AVIF_LIBRARY AVIF_INCLUDE_DIR)
SET(AVIF_LIBRARIES ${AVIF_LIBRARY})
SET(AVIF_INCLUDE_DIRS ${AVIF_INCLUDE_DIR})
endif()
if(NOT AVIF_FOUND)
UNSET(AVIF_LIBRARIES)
UNSET(AVIF_INCLUDE_DIRS)
UNSET(AVIF_VERSION)
return()
endif()
SET(AVIF_LIBRARIES ${AVIF_LIBRARY})
SET(AVIF_INCLUDE_DIRS ${AVIF_INCLUDE_DIR})
# unset(libavif_VERSION) # For debugging: uncomment to test fallback version extraction when find_package(libavif) cannot find libavif
if(NOT libavif_VERSION)
find_file(AVIF_H NAMES avif/avif.h PATHS ${AVIF_INCLUDE_DIRS} NO_DEFAULT_PATH)
if(AVIF_H)
file(STRINGS "${AVIF_H}" AVIF_MAJOR_LINE REGEX "^#define[ \t]+AVIF_VERSION_MAJOR[ \t]+[0-9]+")
file(STRINGS "${AVIF_H}" AVIF_MINOR_LINE REGEX "^#define[ \t]+AVIF_VERSION_MINOR[ \t]+[0-9]+")
file(STRINGS "${AVIF_H}" AVIF_PATCH_LINE REGEX "^#define[ \t]+AVIF_VERSION_PATCH[ \t]+[0-9]+")
string(REGEX REPLACE ".*AVIF_VERSION_MAJOR[ \t]+([0-9]+).*" "\\1" AVIF_MAJOR "${AVIF_MAJOR_LINE}")
string(REGEX REPLACE ".*AVIF_VERSION_MINOR[ \t]+([0-9]+).*" "\\1" AVIF_MINOR "${AVIF_MINOR_LINE}")
string(REGEX REPLACE ".*AVIF_VERSION_PATCH[ \t]+([0-9]+).*" "\\1" AVIF_PATCH "${AVIF_PATCH_LINE}")
if(AVIF_MAJOR MATCHES "^[0-9]+$" AND AVIF_MINOR MATCHES "^[0-9]+$" AND AVIF_PATCH MATCHES "^[0-9]+$")
SET(libavif_VERSION "${AVIF_MAJOR}.${AVIF_MINOR}.${AVIF_PATCH}")
endif()
endif()
UNSET(AVIF_H CACHE)
UNSET(AVIF_H)
endif()
if(libavif_VERSION)
SET(AVIF_VERSION "${libavif_VERSION}")
endif()

4
cmake/OpenCVFindIPPIW.cmake
View File

@@ -88,9 +88,7 @@ macro(ippiw_setup PATH BUILD)
set(IPP_IW_LIBRARY ippiw)
set(IPP_IW_INCLUDES "${IPP_IW_PATH}/include")
set(IPP_IW_LIBRARIES ${IPP_IW_LIBRARY})
if(NOT EXISTS "${IPP_IW_PATH}/CMakeLists.txt")
file(COPY "${OpenCV_SOURCE_DIR}/3rdparty/ippicv/CMakeLists.txt" DESTINATION "${IPP_IW_PATH}")
endif()
file(COPY "${OpenCV_SOURCE_DIR}/3rdparty/ippicv/CMakeLists.txt" DESTINATION "${IPP_IW_PATH}") # always rewrite IPP cmake files
add_subdirectory("${IPP_IW_PATH}/" ${OpenCV_BINARY_DIR}/3rdparty/ippiw)
set(HAVE_IPP_IW 1)

127
cmake/OpenCVFindLibsGrfmt.cmake
View File

@@ -45,6 +45,11 @@ else()
endif()
if(NOT ZLIB_FOUND)
if(NOT BUILD_ZLIB)
message(WARNING "ZLIB library has not been found, falling back to built-in version. "
"Set ZLIB_ROOT or ZLIB_DIR variable so that find_package(ZLIB) would be able to find it. "
"See find_package and FindZLIB cmake documentation for details.")
endif()
ocv_clear_vars(ZLIB_LIBRARY ZLIB_LIBRARIES ZLIB_INCLUDE_DIR)
set(ZLIB_LIBRARY zlib CACHE INTERNAL "")
@@ -60,7 +65,7 @@ endif()
# --- libavif (optional) ---
if(WITH_AVIF)
ocv_clear_internal_cache_vars(AVIF_LIBRARY AVIF_INCLUDE_DIR)
ocv_clear_internal_cache_vars(AVIF_LIBRARIES AVIF_INCLUDE_DIRS)
include(cmake/OpenCVFindAVIF.cmake)
if(AVIF_FOUND)
set(HAVE_AVIF 1)
@@ -83,6 +88,12 @@ if(WITH_JPEG)
endif()
if(NOT JPEG_FOUND)
if(NOT BUILD_JPEG)
message(WARNING "JPEG library has not been found, falling back to built-in version. "
"Add the external installation prefix to CMAKE_PREFIX_PATH, or set JPEG_INCLUDE_DIR "
"and JPEG_LIBRARY, so that FindJPEG can locate it. "
"See FindJPEG cmake documentation for details.")
endif()
ocv_clear_vars(JPEG_LIBRARY JPEG_INCLUDE_DIR)
if(NOT BUILD_JPEG_TURBO_DISABLE)
@@ -134,55 +145,6 @@ if(WITH_JPEG)
set(HAVE_JPEG YES)
endif()
# --- libtiff (optional, should be searched after zlib and libjpeg) ---
if(WITH_TIFF)
if(BUILD_TIFF)
ocv_clear_vars(TIFF_FOUND)
else()
ocv_clear_internal_cache_vars(TIFF_LIBRARY TIFF_INCLUDE_DIR)
if(QNX)
set(TIFF_LIBRARY tiff)
set(TIFF_LIBRARIES tiff)
set(TIFF_FOUND TRUE)
else()
include(FindTIFF)
endif()
if(TIFF_FOUND)
ocv_parse_header("${TIFF_INCLUDE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
endif()
endif()
if(NOT TIFF_FOUND)
ocv_clear_vars(TIFF_LIBRARY TIFF_LIBRARIES TIFF_INCLUDE_DIR)
set(TIFF_LIBRARY libtiff CACHE INTERNAL "")
set(TIFF_LIBRARIES ${TIFF_LIBRARY})
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libtiff")
set(TIFF_INCLUDE_DIR "${${TIFF_LIBRARY}_SOURCE_DIR}" "${${TIFF_LIBRARY}_BINARY_DIR}" CACHE INTERNAL "")
ocv_parse_header("${${TIFF_LIBRARY}_SOURCE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
endif()
if(TIFF_VERSION_CLASSIC AND NOT TIFF_VERSION)
set(TIFF_VERSION ${TIFF_VERSION_CLASSIC})
endif()
if(TIFF_BIGTIFF_VERSION AND NOT TIFF_VERSION_BIG)
set(TIFF_VERSION_BIG ${TIFF_BIGTIFF_VERSION})
endif()
if(NOT TIFF_VERSION_STRING AND TIFF_INCLUDE_DIR)
foreach(_TIFF_INCLUDE_DIR IN LISTS TIFF_INCLUDE_DIR)
if(EXISTS "${_TIFF_INCLUDE_DIR}/tiffvers.h")
file(STRINGS "${_TIFF_INCLUDE_DIR}/tiffvers.h" tiff_version_str REGEX "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version .*")
string(REGEX REPLACE "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version +([^ \\n]*).*" "\\1" TIFF_VERSION_STRING "${tiff_version_str}")
unset(tiff_version_str)
endif()
endforeach()
endif()
set(HAVE_TIFF YES)
endif()
# --- libwebp (optional) ---
if(WITH_WEBP)
@@ -201,6 +163,11 @@ endif()
if(WITH_WEBP AND NOT WEBP_FOUND
AND (NOT ANDROID OR HAVE_CPUFEATURES)
)
if(NOT BUILD_WEBP)
message(WARNING "WebP library has not been found, falling back to built-in version. "
"Set WEBP_INCLUDE_DIR and WEBP_LIBRARY, or add the external installation prefix to "
"CMAKE_PREFIX_PATH, so that the external WebP can be located.")
endif()
ocv_clear_vars(WEBP_LIBRARY WEBP_INCLUDE_DIR)
set(WEBP_LIBRARY libwebp CACHE INTERNAL "")
set(WEBP_LIBRARIES ${WEBP_LIBRARY})
@@ -241,6 +208,61 @@ if(NOT WEBP_VERSION AND WEBP_INCLUDE_DIR)
set(WEBP_VERSION "decoder: ${WEBP_DECODER_ABI_VERSION}, encoder: ${WEBP_ENCODER_ABI_VERSION}, demux: ${WEBP_DEMUX_ABI_VERSION}")
endif()
# --- libtiff (optional, should be searched after zlib, libjpeg and libwebp) ---
if(WITH_TIFF)
if(BUILD_TIFF)
ocv_clear_vars(TIFF_FOUND)
else()
ocv_clear_internal_cache_vars(TIFF_LIBRARY TIFF_INCLUDE_DIR)
if(QNX)
set(TIFF_LIBRARY tiff)
set(TIFF_LIBRARIES tiff)
set(TIFF_FOUND TRUE)
else()
include(FindTIFF)
endif()
if(TIFF_FOUND)
ocv_parse_header("${TIFF_INCLUDE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
endif()
endif()
if(NOT TIFF_FOUND)
if(NOT BUILD_TIFF)
message(WARNING "TIFF library has not been found, falling back to built-in version. "
"Add the external installation prefix to CMAKE_PREFIX_PATH, or set TIFF_INCLUDE_DIR "
"and TIFF_LIBRARY, so that FindTIFF can locate it. "
"See FindTIFF cmake documentation for details.")
endif()
ocv_clear_vars(TIFF_LIBRARY TIFF_LIBRARIES TIFF_INCLUDE_DIR)
set(TIFF_LIBRARY libtiff CACHE INTERNAL "")
set(TIFF_LIBRARIES ${TIFF_LIBRARY})
add_subdirectory("${OpenCV_SOURCE_DIR}/3rdparty/libtiff")
set(TIFF_INCLUDE_DIR "${${TIFF_LIBRARY}_SOURCE_DIR}" "${${TIFF_LIBRARY}_BINARY_DIR}" CACHE INTERNAL "")
ocv_parse_header("${${TIFF_LIBRARY}_SOURCE_DIR}/tiff.h" TIFF_VERSION_LINES TIFF_VERSION_CLASSIC TIFF_VERSION_BIG TIFF_VERSION TIFF_BIGTIFF_VERSION)
endif()
if(TIFF_VERSION_CLASSIC AND NOT TIFF_VERSION)
set(TIFF_VERSION ${TIFF_VERSION_CLASSIC})
endif()
if(TIFF_BIGTIFF_VERSION AND NOT TIFF_VERSION_BIG)
set(TIFF_VERSION_BIG ${TIFF_BIGTIFF_VERSION})
endif()
if(NOT TIFF_VERSION_STRING AND TIFF_INCLUDE_DIR)
foreach(_TIFF_INCLUDE_DIR IN LISTS TIFF_INCLUDE_DIR)
if(EXISTS "${_TIFF_INCLUDE_DIR}/tiffvers.h")
file(STRINGS "${_TIFF_INCLUDE_DIR}/tiffvers.h" tiff_version_str REGEX "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version .*")
string(REGEX REPLACE "^#define[\t ]+TIFFLIB_VERSION_STR[\t ]+\"LIBTIFF, Version +([^ \\n]*).*" "\\1" TIFF_VERSION_STRING "${tiff_version_str}")
unset(tiff_version_str)
endif()
endforeach()
endif()
set(HAVE_TIFF YES)
endif()
# --- libjxl (optional) ---
if(WITH_JPEGXL)
ocv_clear_vars(HAVE_JPEGXL)
@@ -353,6 +375,11 @@ if(NOT HAVE_SPNG AND WITH_PNG)
endif()
if(NOT PNG_FOUND)
if(NOT BUILD_PNG)
message(WARNING "PNG library has not been found, falling back to built-in version. "
"Set PNG_ROOT or PNG_DIR variable so that find_package(PNG) would be able to find it. "
"See find_package and FindPNG cmake documentation for details.")
endif()
ocv_clear_vars(PNG_LIBRARY PNG_LIBRARIES PNG_INCLUDE_DIR PNG_DEFINITIONS)
set(PNG_LIBRARY libpng CACHE INTERNAL "")

3
cmake/OpenCVFindLibsPerf.cmake
View File

@@ -224,6 +224,9 @@ if(WITH_KLEIDICV)
set(HAVE_KLEIDICV ON)
endif()
endif()
if(HAVE_KLEIDICV AND EXISTS "${KLEIDICV_SOURCE_PATH}/LICENSES/Apache-2.0.txt")
ocv_install_3rdparty_licenses(KleidiCV "${KLEIDICV_SOURCE_PATH}/LICENSES/Apache-2.0.txt")
endif()
endif(WITH_KLEIDICV)
# --- FastCV ---

2
cmake/checks/cpu_rvv.cpp
View File

@@ -10,7 +10,7 @@
#include <riscv_vector.h>
#ifdef __THEAD_VERSION__
#if defined(__THEAD_VERSION__) && (defined(__riscv_v) && __riscv_v == 7000)
int test()
{
const float src[] = { 0.0f, 0.0f, 0.0f, 0.0f };

11
doc/js_tutorials/js_setup/js_setup/js_setup.markdown
View File

@@ -16,7 +16,7 @@ To Install Emscripten, follow instructions of [Emscripten SDK](https://emscripte
For example:
@code{.bash}
./emsdk update
git pull # Note: ./emsdk update is deprecated in modern emsdk; use git pull to update the repository.
./emsdk install latest
./emsdk activate latest
@endcode
@@ -37,13 +37,14 @@ emcmake sh -c 'echo ${EMSCRIPTEN}'
@endcode
The version 2.0.10 of emscripten is verified for latest WebAssembly. Please check the version of Emscripten to use the newest features of WebAssembly.
The Emscripten SDK is continuously updated. If you encounter build errors with the latest version, please install and activate a specific version explicitly.
For example:
@code{.bash}
./emsdk update
./emsdk install 2.0.10
./emsdk activate 2.0.10
git pull
./emsdk list # to show available versions. v6.0.9 is used in the following steps.
./emsdk install 6.0.9
./emsdk activate 6.0.9
@endcode
Obtaining OpenCV Source Code

20
doc/opencv.bib
View File

@@ -308,6 +308,16 @@
publisher = {GitHub},
howpublished = {\url{https://blog.chatfield.io/simple-method-for-distance-to-ellipse/}},
}
@inproceedings{Claus05a,
author = {Claus, David and Fitzgibbon, Andrew W.},
title = {A Rational Function Lens Distortion Model for General Cameras},
booktitle = {IEEE Conference on Computer Vision and Pattern Recognition},
volume = {1},
pages = {213--219},
year = {2005},
publisher = {IEEE},
doi = {10.1109/CVPR.2005.43},
}
@article{Chaumette06,
author = {Chaumette, Fran{\c c}ois and Hutchinson, S.},
title = {{Visual servo control, Part I: Basic approaches}},
@@ -552,6 +562,16 @@
publisher = {BMVA Press},
url = {https://www.researchgate.net/profile/Robert_Fisher5/publication/2237785_A_Buyer's_Guide_to_Conic_Fitting/links/0fcfd50f59aeded518000000/A-Buyers-Guide-to-Conic-Fitting.pdf}
}
@inproceedings{Fitzgibbon01,
author = {Fitzgibbon, Andrew W.},
title = {Simultaneous Linear Estimation of Multiple View Geometry and Lens Distortion},
booktitle = {IEEE Conference on Computer Vision and Pattern Recognition},
volume = {1},
pages = {125--132},
year = {2001},
publisher = {IEEE},
doi = {10.1109/CVPR.2001.990465},
}
@inproceedings{oy1998NumericallySD,
title = {Numerically Stable Direct Least Squares Fitting of Ellipses},
author = {Radim Hal oy and Jan Flusser},

11
doc/py_tutorials/py_gui/py_video_display/py_video_display.markdown
View File

@@ -123,15 +123,22 @@ FourCC code is passed as `cv.VideoWriter_fourcc('M','J','P','G')` or
`cv.VideoWriter_fourcc(*'MJPG')` for MJPG.
The below code captures from a camera, flips every frame in the vertical direction, and saves the video.
@note The frame size passed to `cv.VideoWriter` must match the resolution of the captured frames; otherwise, frame writing will fail.
@code{.py}
import numpy as np
import cv2 as cv
cap = cv.VideoCapture(0)
# Get camera frame resolution
frame_width = int(cap.get(cv.CAP_PROP_FRAME_WIDTH))
frame_height = int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
# Define the codec and create VideoWriter object
fourcc = cv.VideoWriter_fourcc(*'XVID')
out = cv.VideoWriter('output.avi', fourcc, 20.0, (640, 480))
out = cv.VideoWriter('output.avi', fourcc, 20.0, (frame_width, frame_height))
while cap.isOpened():
ret, frame = cap.read()
@@ -151,4 +158,4 @@ while cap.isOpened():
cap.release()
out.release()
cv.destroyAllWindows()
@endcode
@endcode

8
doc/tutorials/introduction/android_binary_package/dev_with_OCV_on_Android.markdown
View File

@@ -107,8 +107,8 @@ In addition to this instruction you can use some video guide, for example [this
![](images/add_module_3.png)
8. Before using any OpenCV function you have to load the library first. If you application includes other OpenCV-dependent native libraries you should load them ***after*** OpenCV initialization.
Add the folowing code to load the library at app start:
8. Before using any OpenCV function you have to load the library first. If your application includes other OpenCV-dependent native libraries you should load them ***after*** OpenCV initialization.
Add the following code to load the library at app start:
@snippet samples/android/tutorial-1-camerapreview/src/org/opencv/samples/tutorial1/Tutorial1Activity.java ocv_loader_init
Like this:
![](images/sample_code.png)
@@ -143,8 +143,8 @@ but OpenCV loading with Maven Central.
@endcode
`4.9.0` may be replaced by any version available as [official release](https://central.sonatype.com/artifact/org.opencv/opencv).
4. Before using any OpenCV function you have to load the library first. If you application includes other
OpenCV-dependent native libraries you should load them ***after*** OpenCV initialization. Add the folowing
4. Before using any OpenCV function you have to load the library first. If your application includes other
OpenCV-dependent native libraries you should load them ***after*** OpenCV initialization. Add the following
code to load the library at app start:
@snippet samples/android/tutorial-1-camerapreview/src/org/opencv/samples/tutorial1/Tutorial1Activity.java ocv_loader_init
Like this:

38
hal/armpl/include/armpl_hal_core.hpp
View File

@@ -86,6 +86,44 @@ int armpl_hal_dctFree2D(cvhalDFT *context);
#undef cv_hal_dctFree2D
#define cv_hal_dctFree2D armpl_hal_dctFree2D
int armpl_hal_gemm32f(const float* src1, size_t src1_step, const float* src2, size_t src2_step,
float alpha, const float* src3, size_t src3_step, float beta, float* dst, size_t dst_step,
int m, int n, int k, int flags);
int armpl_hal_gemm64f(const double* src1, size_t src1_step, const double* src2, size_t src2_step,
double alpha, const double* src3, size_t src3_step, double beta, double* dst, size_t dst_step,
int m, int n, int k, int flags);
int armpl_hal_gemm32fc(const float* src1, size_t src1_step, const float* src2, size_t src2_step,
float alpha, const float* src3, size_t src3_step, float beta, float* dst, size_t dst_step,
int m, int n, int k, int flags);
int armpl_hal_gemm64fc(const double* src1, size_t src1_step, const double* src2, size_t src2_step,
double alpha, const double* src3, size_t src3_step, double beta, double* dst, size_t dst_step,
int m, int n, int k, int flags);
#undef cv_hal_gemm32f
#define cv_hal_gemm32f armpl_hal_gemm32f
#undef cv_hal_gemm64f
#define cv_hal_gemm64f armpl_hal_gemm64f
#undef cv_hal_gemm32fc
#define cv_hal_gemm32fc armpl_hal_gemm32fc
#undef cv_hal_gemm64fc
#define cv_hal_gemm64fc armpl_hal_gemm64fc
int armpl_hal_SVD32f(float* src, size_t src_step, float* w, float* u, size_t u_step, float* vt, size_t vt_step, int m, int n, int flags);
int armpl_hal_SVD64f(double* src, size_t src_step, double* w, double* u, size_t u_step, double* vt, size_t vt_step, int m, int n, int flags);
#undef cv_hal_SVD32f
#define cv_hal_SVD32f armpl_hal_SVD32f
#undef cv_hal_SVD64f
#define cv_hal_SVD64f armpl_hal_SVD64f
int armpl_hal_LU32f(float* a, size_t a_step, int m, float* b, size_t b_step, int n, int* info);
int armpl_hal_LU64f(double* a, size_t a_step, int m, double* b, size_t b_step, int n, int* info);
#undef cv_hal_LU32f
#define cv_hal_LU32f armpl_hal_LU32f
#undef cv_hal_LU64f
#define cv_hal_LU64f armpl_hal_LU64f
#endif // HAVE_ARMPL
#endif // OPENCV_ARMPL_HAL_CORE_HPP

313
hal/armpl/src/armpl_hal_core.cpp
View File

@@ -3,9 +3,322 @@
#include "armpl_hal_core.hpp"
#include <fftw3.h>
#include <cblas.h>
#include <lapacke.h>
#include <algorithm>
#include <complex>
#include <vector>
#include <cstring>
#include <cstdio>
#include <cmath>
#define ARMPL_GEMM_MIN_WORK_VOLUME 10000
#define ARMPL_SVD_SMALL_MATRIX_THRESH 33
#define ARMPL_LU_SMALL_MATRIX_THRESH 100
namespace {
template <typename fptype> static inline void
armpl_transpose(const fptype *src, size_t src_ld, fptype *dst, size_t dst_ld, size_t m, size_t n)
{
for (size_t i = 0; i < m; i++)
for (size_t j = 0; j < n; j++)
dst[j*dst_ld + i] = src[i*src_ld + j];
}
template <typename fptype> static inline void
armpl_copy_matrix(const fptype *src, size_t src_ld, fptype *dst, size_t dst_ld, size_t m, size_t n)
{
for (size_t i = 0; i < m; i++)
std::copy(src + i*src_ld, src + i*src_ld + n, dst + i*dst_ld);
}
template <typename fptype> static inline void
armpl_set_value(fptype *dst, size_t dst_ld, fptype value, size_t m, size_t n)
{
for (size_t i = 0; i < m; i++)
std::fill(dst + i*dst_ld, dst + i*dst_ld + n, value);
}
static inline void
armpl_cblas_gemm(CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB, int a_m, int d_n, int a_n,
float alpha, const float *src1, int ldsrc1, const float *src2, int ldsrc2,
float beta, float *dst, int lddst)
{
cblas_sgemm(CblasRowMajor, transA, transB, a_m, d_n, a_n, alpha, src1, ldsrc1, src2, ldsrc2, beta, dst, lddst);
}
static inline void
armpl_cblas_gemm(CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB, int a_m, int d_n, int a_n,
double alpha, const double *src1, int ldsrc1, const double *src2, int ldsrc2,
double beta, double *dst, int lddst)
{
cblas_dgemm(CblasRowMajor, transA, transB, a_m, d_n, a_n, alpha, src1, ldsrc1, src2, ldsrc2, beta, dst, lddst);
}
static inline void
armpl_cblas_gemm(CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB, int a_m, int d_n, int a_n,
std::complex<float> alpha, const std::complex<float> *src1, int ldsrc1,
const std::complex<float> *src2, int ldsrc2,
std::complex<float> beta, std::complex<float> *dst, int lddst)
{
cblas_cgemm(CblasRowMajor, transA, transB, a_m, d_n, a_n, &alpha, src1, ldsrc1, src2, ldsrc2, &beta, dst, lddst);
}
static inline void
armpl_cblas_gemm(CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB, int a_m, int d_n, int a_n,
std::complex<double> alpha, const std::complex<double> *src1, int ldsrc1,
const std::complex<double> *src2, int ldsrc2,
std::complex<double> beta, std::complex<double> *dst, int lddst)
{
cblas_zgemm(CblasRowMajor, transA, transB, a_m, d_n, a_n, &alpha, src1, ldsrc1, src2, ldsrc2, &beta, dst, lddst);
}
template <typename elemtype, typename scalartype> static inline int
armpl_gemm_impl(const elemtype *src1, size_t src1_step, const elemtype *src2, size_t src2_step, scalartype alpha,
const elemtype *src3, size_t src3_step, scalartype beta, elemtype *dst, size_t dst_step,
int a_m, int a_n, int d_n, int flags)
{
int ldsrc1 = (int)(src1_step / sizeof(elemtype));
int ldsrc2 = (int)(src2_step / sizeof(elemtype));
int ldsrc3 = (int)(src3_step / sizeof(elemtype));
int lddst = (int)(dst_step / sizeof(elemtype));
int c_m, c_n, d_m;
CBLAS_TRANSPOSE transA, transB;
elemtype eAlpha = (elemtype)alpha;
elemtype eBeta = (elemtype)beta;
transB = (flags & CV_HAL_GEMM_2_T) ? CblasTrans : CblasNoTrans;
d_m = (flags & CV_HAL_GEMM_1_T) ? a_n : a_m;
if (flags & CV_HAL_GEMM_3_T)
{
c_m = d_n;
c_n = d_m;
}
else
{
c_m = d_m;
c_n = d_n;
}
if (flags & CV_HAL_GEMM_1_T)
{
transA = CblasTrans;
std::swap(a_n, a_m);
}
else
{
transA = CblasNoTrans;
}
if (src3 != dst && beta != 0.0 && src3_step != 0)
{
if (flags & CV_HAL_GEMM_3_T)
armpl_transpose(src3, ldsrc3, dst, lddst, c_m, c_n);
else
armpl_copy_matrix(src3, ldsrc3, dst, lddst, c_m, c_n);
}
else if (src3 == dst && (flags & CV_HAL_GEMM_3_T))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
else if (src3_step == 0 && beta != 0.0)
armpl_set_value(dst, lddst, elemtype(), d_m, d_n);
armpl_cblas_gemm(transA, transB, a_m, d_n, a_n, eAlpha, src1, ldsrc1, src2, ldsrc2, eBeta, dst, lddst);
return CV_HAL_ERROR_OK;
}
}
static inline bool armpl_gemm_below_min_volume(int m, int n, int k)
{
return (double)m * n * k < ARMPL_GEMM_MIN_WORK_VOLUME;
}
int armpl_hal_gemm32f(const float *src1, size_t src1_step, const float *src2, size_t src2_step, float alpha,
const float *src3, size_t src3_step, float beta, float *dst, size_t dst_step,
int m, int n, int k, int flags)
{
if (armpl_gemm_below_min_volume(m, n, k))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_gemm_impl<float, float>(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m, n, k, flags);
}
int armpl_hal_gemm64f(const double *src1, size_t src1_step, const double *src2, size_t src2_step, double alpha,
const double *src3, size_t src3_step, double beta, double *dst, size_t dst_step,
int m, int n, int k, int flags)
{
if (armpl_gemm_below_min_volume(m, n, k))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_gemm_impl<double, double>(src1, src1_step, src2, src2_step, alpha, src3, src3_step, beta, dst, dst_step, m, n, k, flags);
}
int armpl_hal_gemm32fc(const float *src1, size_t src1_step, const float *src2, size_t src2_step, float alpha,
const float *src3, size_t src3_step, float beta, float *dst, size_t dst_step,
int m, int n, int k, int flags)
{
if (armpl_gemm_below_min_volume(m, n, k))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
typedef std::complex<float> cplx;
return armpl_gemm_impl<cplx, float>(reinterpret_cast<const cplx*>(src1), src1_step, reinterpret_cast<const cplx*>(src2), src2_step, alpha,
reinterpret_cast<const cplx*>(src3), src3_step, beta, reinterpret_cast<cplx*>(dst), dst_step, m, n, k, flags);
}
int armpl_hal_gemm64fc(const double *src1, size_t src1_step, const double *src2, size_t src2_step, double alpha,
const double *src3, size_t src3_step, double beta, double *dst, size_t dst_step,
int m, int n, int k, int flags)
{
if (armpl_gemm_below_min_volume(m, n, k))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
typedef std::complex<double> cplx;
return armpl_gemm_impl<cplx, double>(reinterpret_cast<const cplx*>(src1), src1_step, reinterpret_cast<const cplx*>(src2), src2_step, alpha,
reinterpret_cast<const cplx*>(src3), src3_step, beta, reinterpret_cast<cplx*>(dst), dst_step, m, n, k, flags);
}
namespace {
static inline armpl_int_t
armpl_lapacke_gesdd(char jobz, int m, int n, float *a, int lda, float *s, float *u, int ldu, float *vt, int ldvt)
{
return LAPACKE_sgesdd(LAPACK_COL_MAJOR, jobz, m, n, a, lda, s, u, ldu, vt, ldvt);
}
static inline armpl_int_t
armpl_lapacke_gesdd(char jobz, int m, int n, double *a, int lda, double *s, double *u, int ldu, double *vt, int ldvt)
{
return LAPACKE_dgesdd(LAPACK_COL_MAJOR, jobz, m, n, a, lda, s, u, ldu, vt, ldvt);
}
template <typename fptype> static inline void
armpl_transpose_square_inplace(fptype *a, size_t lda, size_t n)
{
for (size_t i = 0; i < n - 1; i++)
for (size_t j = i + 1; j < n; j++)
std::swap(a[j*lda + i], a[i*lda + j]);
}
template <typename fptype> static inline int
armpl_svd(fptype *src, size_t src_step, fptype *w, fptype *u, size_t u_step, fptype *vt, size_t vt_step, int m, int n, int flags)
{
int lda = (int)(src_step / sizeof(fptype));
int ldu = (int)(u_step / sizeof(fptype));
int ldv = (int)(vt_step / sizeof(fptype));
std::vector<fptype> ubuf;
char jobz = ' ';
if (flags & CV_HAL_SVD_NO_UV)
{
ldv = 1;
jobz = 'N';
}
else if ((flags & CV_HAL_SVD_SHORT_UV) && (flags & CV_HAL_SVD_MODIFY_A))
jobz = 'O';
else if ((flags & CV_HAL_SVD_SHORT_UV) && !(flags & CV_HAL_SVD_MODIFY_A))
jobz = 'S';
else if (flags & CV_HAL_SVD_FULL_UV)
jobz = 'A';
if ((flags & CV_HAL_SVD_MODIFY_A) && (flags & CV_HAL_SVD_FULL_UV))
{
ubuf.resize((size_t)m * m);
u = ubuf.data();
ldu = m;
}
armpl_int_t linfo = armpl_lapacke_gesdd(jobz, m, n, src, lda, w, u, ldu, vt, ldv);
if (linfo != 0)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
if (!(flags & CV_HAL_SVD_NO_UV))
armpl_transpose_square_inplace(vt, ldv, n);
if ((flags & CV_HAL_SVD_MODIFY_A) && (flags & CV_HAL_SVD_FULL_UV))
{
for (int i = 0; i < m; i++)
std::copy(u + i*m, u + i*m + m, src + i*lda);
}
return CV_HAL_ERROR_OK;
}
static inline armpl_int_t armpl_lapacke_gesv(int m, int n, float *a, int lda, armpl_int_t *ipiv, float *b, int ldb){
return LAPACKE_sgesv(LAPACK_ROW_MAJOR, m, n, a, lda, ipiv, b, ldb);
}
static inline armpl_int_t armpl_lapacke_gesv(int m, int n, double *a, int lda, armpl_int_t *ipiv, double *b, int ldb){
return LAPACKE_dgesv(LAPACK_ROW_MAJOR, m, n, a, lda, ipiv, b, ldb);
}
static inline armpl_int_t armpl_lapacke_getrf(int m, float *a, int lda, armpl_int_t *ipiv){
return LAPACKE_sgetrf(LAPACK_ROW_MAJOR, m, m, a, lda, ipiv);
}
static inline armpl_int_t armpl_lapacke_getrf(int m, double *a, int lda, armpl_int_t *ipiv){
return LAPACKE_dgetrf(LAPACK_ROW_MAJOR, m, m, a, lda, ipiv);
}
template <typename fptype> static inline int
armpl_lu(fptype *a, size_t a_step, int m, fptype *b, size_t b_step, int n, int *info)
{
if(!info)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
int lda = (int)(a_step / sizeof(fptype));
std::vector<armpl_int_t> ipiv(m);
armpl_int_t linfo;
if (b)
{
int ldb = (int)(b_step / sizeof(fptype));
linfo = armpl_lapacke_gesv(m, n, a, lda, ipiv.data(), b, ldb);
}
else
{
linfo = armpl_lapacke_getrf(m, a, lda, ipiv.data());
}
if (linfo < 0)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
if (linfo == 0)
{
int sign = 0;
for (int i = 0; i < m; i++)
sign ^= (ipiv[i] != i + 1);
*info = sign ? -1 : 1;
}
else
*info = 0;
return CV_HAL_ERROR_OK;
}
}
int armpl_hal_SVD32f(float *src, size_t src_step, float *w, float *u, size_t u_step, float *vt, size_t vt_step, int m, int n, int flags)
{
if (m < ARMPL_SVD_SMALL_MATRIX_THRESH)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_svd(src, src_step, w, u, u_step, vt, vt_step, m, n, flags);
}
int armpl_hal_SVD64f(double *src, size_t src_step, double *w, double *u, size_t u_step, double *vt, size_t vt_step, int m, int n, int flags)
{
if (m < ARMPL_SVD_SMALL_MATRIX_THRESH)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_svd(src, src_step, w, u, u_step, vt, vt_step, m, n, flags);
}
int armpl_hal_LU32f(float *a, size_t a_step, int m, float *b, size_t b_step, int n, int *info) {
if (m < ARMPL_LU_SMALL_MATRIX_THRESH)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_lu(a, a_step, m, b, b_step, n, info);
}
int armpl_hal_LU64f(double *a, size_t a_step, int m, double *b, size_t b_step, int n, int *info) {
if (m < ARMPL_LU_SMALL_MATRIX_THRESH)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
return armpl_lu(a, a_step, m, b, b_step, n, info);
}
enum ArmPLDFTMode
{
ARMPL_DFT_C2C,

22
hal/carotene/hal/tegra_hal.hpp
View File

@@ -697,7 +697,7 @@ TegraBinaryOpScale_Invoker(addWeighted, addWeighted, 3, scales[0], scales[1], sc
src1, sz1, \
src2, sz2, \
dst, sz, \
scale, \
(float)scale, \
CAROTENE_NS::CONVERT_POLICY_SATURATE), \
CV_HAL_ERROR_OK \
: CV_HAL_ERROR_NOT_IMPLEMENTED \
@@ -721,7 +721,7 @@ TegraBinaryOpScale_Invoker(addWeighted, addWeighted, 3, scales[0], scales[1], sc
CAROTENE_NS::reciprocal(CAROTENE_NS::Size2D(w, h), \
src2, sz2, \
dst, sz, \
scale, \
(float)scale, \
CAROTENE_NS::CONVERT_POLICY_SATURATE), \
CV_HAL_ERROR_OK \
: CV_HAL_ERROR_NOT_IMPLEMENTED \
@@ -739,13 +739,13 @@ TegraBinaryOpScale_Invoker(addWeighted, addWeighted, 3, scales[0], scales[1], sc
)
#undef cv_hal_mul8u
#define cv_hal_mul8u TEGRA_MUL
#define cv_hal_mul8u(src1, sz1, src2, sz2, dst, sz, w, h, scale) TEGRA_MUL(src1, sz1, src2, sz2, dst, sz, w, h, (float)(scale))
#undef cv_hal_mul8s
#define cv_hal_mul8s TEGRA_MUL
#define cv_hal_mul8s(src1, sz1, src2, sz2, dst, sz, w, h, scale) TEGRA_MUL(src1, sz1, src2, sz2, dst, sz, w, h, (float)(scale))
#undef cv_hal_mul16u
#define cv_hal_mul16u TEGRA_MUL
#define cv_hal_mul16u(src1, sz1, src2, sz2, dst, sz, w, h, scale) TEGRA_MUL(src1, sz1, src2, sz2, dst, sz, w, h, (float)(scale))
#undef cv_hal_mul16s
#define cv_hal_mul16s TEGRA_MUL
#define cv_hal_mul16s(src1, sz1, src2, sz2, dst, sz, w, h, scale) TEGRA_MUL(src1, sz1, src2, sz2, dst, sz, w, h, (float)(scale))
#undef cv_hal_mul32s
#define cv_hal_mul32s TEGRA_MUL
#undef cv_hal_mul32f
@@ -788,7 +788,7 @@ TegraBinaryOpScale_Invoker(addWeighted, addWeighted, 3, scales[0], scales[1], sc
src1, sz1, \
src2, sz2, \
dst, sz, \
((double *)scales)[0], ((double *)scales)[1], ((double *)scales)[2]), \
(float)((double *)scales)[0], (float)((double *)scales)[1], (float)((double *)scales)[2]), \
CV_HAL_ERROR_OK \
: CV_HAL_ERROR_NOT_IMPLEMENTED \
)
@@ -1029,7 +1029,7 @@ TegraRowOp_Invoker(combine4, combine4, 4, 1, 0, RANGE_DATA(ST, src1_data, sizeof
TegraRowOp_Invoker(phase, phase, 2, 1, 1, RANGE_DATA(ST, src1_data, sizeof(CAROTENE_NS::f32)), range.end-range.start,
RANGE_DATA(ST, src2_data, sizeof(CAROTENE_NS::f32)), range.end-range.start,
RANGE_DATA(DT, dst1_data, sizeof(CAROTENE_NS::f32)), range.end-range.start, val)
RANGE_DATA(DT, dst1_data, sizeof(CAROTENE_NS::f32)), range.end-range.start, (float)val)
#define TEGRA_FASTATAN(y, x, dst, len, angleInDegrees) \
( \
CAROTENE_NS::isSupportedConfiguration() ? \
@@ -1441,13 +1441,13 @@ inline int TEGRA_MORPHFREE(cvhalFilter2D *context)
(dst_width + 0.5)/inv_scale_x + 0.5 >= src_width && (dst_height + 0.5)/inv_scale_y + 0.5 >= src_height && \
std::abs(dst_width / inv_scale_x - src_width) < 0.1 && std::abs(dst_height / inv_scale_y - src_height) < 0.1 ? \
CAROTENE_NS::resizeLinearOpenCV(CAROTENE_NS::Size2D(src_width, src_height), CAROTENE_NS::Size2D(dst_width, dst_height), \
src_data, src_step, dst_data, dst_step, 1.0/inv_scale_x, 1.0/inv_scale_y, ((src_type >> CV_CN_SHIFT) + 1)), \
src_data, src_step, dst_data, dst_step, (float)(1.0/inv_scale_x), (float)(1.0/inv_scale_y), ((src_type >> CV_CN_SHIFT) + 1)), \
CV_HAL_ERROR_OK : CV_HAL_ERROR_NOT_IMPLEMENTED : \
interpolation == CV_HAL_INTER_AREA ? \
CV_MAT_DEPTH(src_type) == CV_8U && CAROTENE_NS::isResizeAreaSupported(1.0/inv_scale_x, 1.0/inv_scale_y, ((src_type >> CV_CN_SHIFT) + 1)) && \
CV_MAT_DEPTH(src_type) == CV_8U && CAROTENE_NS::isResizeAreaSupported((float)(1.0/inv_scale_x), (float)(1.0/inv_scale_y), ((src_type >> CV_CN_SHIFT) + 1)) && \
std::abs(dst_width / inv_scale_x - src_width) < 0.1 && std::abs(dst_height / inv_scale_y - src_height) < 0.1 ? \
CAROTENE_NS::resizeAreaOpenCV(CAROTENE_NS::Size2D(src_width, src_height), CAROTENE_NS::Size2D(dst_width, dst_height), \
src_data, src_step, dst_data, dst_step, 1.0/inv_scale_x, 1.0/inv_scale_y, ((src_type >> CV_CN_SHIFT) + 1)), \
src_data, src_step, dst_data, dst_step, (float)(1.0/inv_scale_x), (float)(1.0/inv_scale_y), ((src_type >> CV_CN_SHIFT) + 1)), \
CV_HAL_ERROR_OK : CV_HAL_ERROR_NOT_IMPLEMENTED : \
/*nearest neighbour interpolation disabled due to rounding accuracy issues*/ \
/*interpolation == CV_HAL_INTER_NEAREST ? \

14
hal/carotene/src/resize.cpp
View File

@@ -1607,6 +1607,15 @@ void downsample_bilinear_8uc1(const Size2D &ssize, const Size2D &dsize,
cwi[k] = (short)floorf((col2[k] - c) * (1 << SHIFT_BITS) + 0.5f);
// When the sample point falls left of the first source column
// (c < 0, happens for the leftmost destination pixel when
// upscaling horizontally, wr < 1), the left-column weight cwi
// overflows past the full-scale value (1<<SHIFT_BITS) and the
// interpolation extrapolates beyond the source range. Clamp the
// weight so the leftmost pixel is taken as-is, matching the
// OpenCV scalar / OpenCL behaviour (if (x<0) x=0, u=0).
if(c < 0.f) cwi[k] = (1 << SHIFT_BITS);
if(col1[k] < 0) col1[k] = 0;
if(col2[k] >= (ptrdiff_t)ssize.width) col2[k] = ssize.width-1;
}
@@ -1770,6 +1779,11 @@ downsample_bilinear_8uc1_col_loop8:
cwi[k] = (s16)floorf((col2[k] - c) * (1 << SHIFT_BITS) + 0.5f);
// See the 16-wide loop above: clamp the left-column weight when the
// sample point is left of the first source column (horizontal
// upscaling, wr < 1) to avoid extrapolation on the leftmost pixel.
if(c < 0.f) cwi[k] = (1 << SHIFT_BITS);
if(col1[k] < 0) col1[k] = 0;
if(col2[k] >= (ptrdiff_t)ssize.width) col2[k] = (ptrdiff_t)ssize.width-1;
}

3
hal/fastcv/src/fastcv_hal_core.cpp
View File

@@ -164,6 +164,9 @@ int fastcv_hal_transpose2d(
if (src_data == dst_data)
CV_HAL_RETURN_NOT_IMPLEMENTED("In-place not supported");
if (src_step % element_size != 0 || dst_step % element_size != 0)
CV_HAL_RETURN_NOT_IMPLEMENTED("Row step not divisible by the element size is not supported");
fcvStatus status = FASTCV_SUCCESS;
switch (element_size)

10
hal/ipp/CMakeLists.txt
View File

@@ -19,6 +19,7 @@ add_library(ipphal STATIC
"${CMAKE_CURRENT_SOURCE_DIR}/src/deriv_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/resize_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/box_filter_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/bilateral_filter_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/sum_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/color_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/filter_ipp.cpp"
@@ -26,6 +27,8 @@ add_library(ipphal STATIC
"${CMAKE_CURRENT_SOURCE_DIR}/src/canny_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/threshold_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/distancetransform_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/histogram_ipp.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/samplers_ipp.cpp"
)
#TODO: HAVE_IPP_ICV and HAVE_IPP_IW added as private macro till OpenCV itself is
@@ -45,6 +48,13 @@ if(WITH_IPP_CALLS_ENFORCED)
message("WITH_IPP_CALLS_ENFORCED=${WITH_IPP_CALLS_ENFORCED}: enforced IPP calls are enabled in IPP HAL")
endif()
# Enable cv::instr tracing of IPP calls inside the HAL so they show up in the
# instrumentation trace / IPP weight. Reuses the engine exported from
# opencv_core (symbols resolved at link time as ipphal is archived into core).
if(ENABLE_INSTRUMENTATION)
target_compile_definitions(ipphal PRIVATE ENABLE_INSTRUMENTATION)
endif()
target_include_directories(ipphal PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
ocv_warnings_disable(CMAKE_CXX_FLAGS -Wno-suggest-override)

8
hal/ipp/include/ipp_hal_core.hpp
View File

@@ -35,6 +35,14 @@ int ipp_hal_minMaxIdxMaskStep(const uchar* src_data, size_t src_step, int width,
# define IPP_DISABLE_NORM_INF_16U_C1MR 0
#endif
// segmentation fault in ippiNorm[Diff]_Inf_32f_C3CMR with the macOS ippicv (2021.9.1);
// the newer Linux/Windows ippicv (2026.0.0) is not affected
#if defined(__APPLE__)
# define IPP_DISABLE_NORM_INF_32F_C3CMR 1
# else
# define IPP_DISABLE_NORM_INF_32F_C3CMR 0
#endif
int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t mask_step,
int width, int height, int type, int norm_type, double* result);

21
hal/ipp/include/ipp_hal_imgproc.hpp
View File

@@ -66,6 +66,16 @@ int ipp_hal_boxFilter(const uchar* src_data, size_t src_step, uchar* dst_data, s
#define cv_hal_boxFilter ipp_hal_boxFilter
#endif // defined(HAVE_IPP_IW) && !DISABLE_IPP_BOX_FILTER
#if defined(HAVE_IPP_IW)
int ipp_hal_bilateralFilter_offset(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step,
int width, int height, int depth, int cn,
int margin_left, int margin_top, int margin_right, int margin_bottom,
int d, double sigma_color, double sigma_space, int border_type);
#undef cv_hal_bilateralFilter_offset
#define cv_hal_bilateralFilter_offset ipp_hal_bilateralFilter_offset
#endif // HAVE_IPP_IW
int ipp_hal_remap32f(int src_type, const uchar *src_data, size_t src_step, int src_width, int src_height,
uchar *dst_data, size_t dst_step, int dst_width, int dst_height,
float* mapx, size_t mapx_step, float* mapy, size_t mapy_step,
@@ -154,6 +164,17 @@ int ipp_hal_distanceTransform(const uchar* src_data, size_t src_step, uchar* dst
#undef cv_hal_distanceTransform
#define cv_hal_distanceTransform ipp_hal_distanceTransform
int ipp_hal_calcHist(const uchar* src_data, size_t src_step, int src_type, int src_width, int src_height,
float* hist_data, int hist_size, const float** ranges, bool uniform, bool accumulate);
#undef cv_hal_calcHist
#define cv_hal_calcHist ipp_hal_calcHist
int ipp_hal_getRectSubPix(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height,
int patch_type, uchar* patch_data, size_t patch_step, int patch_width, int patch_height,
double center_x, double center_y);
#undef cv_hal_getRectSubPix
#define cv_hal_getRectSubPix ipp_hal_getRectSubPix
#endif // IPP_VERSION_X100 >= 700
#define IPP_DISABLE_PERF_CANNY_MT 1 // cv::Canny OpenCV MT performance is better

16
hal/ipp/include/ipp_utils.hpp
View File

@@ -1,6 +1,7 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
// Copyright (C) 2026, Intel Corporation, all rights reserved.
#ifndef __IPP_HAL_UTILS_HPP__
#define __IPP_HAL_UTILS_HPP__
@@ -23,7 +24,22 @@
# include "ipp.h"
#endif
// IPP call instrumentation for the standalone IPP HAL.
//
// The HAL is built as a separate static library that does not include the
// internal core/private.hpp, so by default its IPP calls never appear in the
// cv::instr trace (reported IPP weight = 0%). When the parent build enables
// ENABLE_INSTRUMENTATION, the shared instrumentation.private.hpp provides the
// exact same CV_INSTRUMENT_FUN_IPP macro used by core (backed by symbols exported
// from libopencv_core, resolved at link time), so HAL IPP calls are traced
// identically to in-module ones. Otherwise the no-op passthrough is used.
#if !defined(CV_INSTRUMENT_FUN_IPP)
#if defined(ENABLE_INSTRUMENTATION)
#include "opencv2/core/utils/instrumentation.private.hpp"
#else
#define CV_INSTRUMENT_FUN_IPP(FUN, ...) ((FUN)(__VA_ARGS__))
#endif // defined(ENABLE_INSTRUMENTATION)
#endif // !defined(CV_INSTRUMENT_FUN_IPP)
#define CV_HAL_CHECK_USE_IPP() if(!cv::ipp::useIPP()) return CV_HAL_ERROR_NOT_IMPLEMENTED;

162
hal/ipp/src/bilateral_filter_ipp.cpp Normal file
View File

@@ -0,0 +1,162 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html
// Copyright (C) 2026, BigVision LLC, all rights reserved.
// Third party copyrights are property of their respective owners.
#include "ipp_hal_imgproc.hpp"
#ifdef HAVE_IPP_IW
#include <opencv2/core.hpp>
#include "precomp_ipp.hpp"
#define IPP_BILATERAL_PARALLEL 1
class ipp_bilateralFilterParallel: public cv::ParallelLoopBody
{
public:
ipp_bilateralFilterParallel(::ipp::IwiImage &_src, ::ipp::IwiImage &_dst, int _radius, Ipp32f _valSquareSigma, Ipp32f _posSquareSigma, ::ipp::IwiBorderType _borderType, bool *_ok):
src(_src), dst(_dst)
{
pOk = _ok;
radius = _radius;
valSquareSigma = _valSquareSigma;
posSquareSigma = _posSquareSigma;
borderType = _borderType;
*pOk = true;
}
~ipp_bilateralFilterParallel() {}
virtual void operator() (const cv::Range& range) const CV_OVERRIDE
{
if(*pOk == false)
return;
try
{
::ipp::IwiTile tile = ::ipp::IwiRoi(0, range.start, dst.m_size.width, range.end - range.start);
CV_INSTRUMENT_FUN_IPP(::ipp::iwiFilterBilateral, src, dst, radius, valSquareSigma, posSquareSigma, ::ipp::IwDefault(), borderType, tile);
}
catch(const ::ipp::IwException &)
{
*pOk = false;
return;
}
}
private:
::ipp::IwiImage &src;
::ipp::IwiImage &dst;
int radius;
Ipp32f valSquareSigma;
Ipp32f posSquareSigma;
::ipp::IwiBorderType borderType;
bool *pOk;
const ipp_bilateralFilterParallel& operator= (const ipp_bilateralFilterParallel&);
};
int ipp_hal_bilateralFilter_offset(const uchar* src_data, size_t src_step,
uchar* dst_data, size_t dst_step,
int width, int height, int depth, int cn,
int margin_left, int margin_top, int margin_right, int margin_bottom,
int d, double sigma_color, double sigma_space, int border_type)
{
CV_HAL_CHECK_USE_IPP();
if(!((depth == CV_8U || depth == CV_32F) && (cn == 1 || cn == 3)))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
constexpr double eps = 1e-6;
if(sigma_color <= eps || sigma_space <= eps)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
int bt = border_type & ~cv::BORDER_ISOLATED;
IppiBorderType ippBorderType =
bt == cv::BORDER_CONSTANT ? ippBorderConst :
bt == cv::BORDER_REPLICATE ? ippBorderRepl :
bt == cv::BORDER_REFLECT_101 ? ippBorderMirror :
bt == cv::BORDER_TRANSPARENT ? ippBorderTransp :
(IppiBorderType)-1;
if((int)ippBorderType == -1)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
int radius = IPP_MAX(((d <= 0) ? cvRound(sigma_space*1.5) : d/2), 1);
Ipp32f valSquareSigma = (Ipp32f)(sigma_color*sigma_color);
Ipp32f posSquareSigma = (Ipp32f)(sigma_space*sigma_space);
IwSize marginLeft = margin_left;
IwSize marginTop = margin_top;
IwSize marginRight = margin_right;
IwSize marginBottom = margin_bottom;
try
{
::ipp::IwiBorderSize inMemBorder(marginLeft, marginTop, marginRight, marginBottom);
::ipp::IwiImage iwSrc, iwDst;
iwSrc.Init(IwiSize{width, height}, ippiGetDataType(depth), cn,
inMemBorder, (void*)src_data, IwSize(src_step));
iwDst.Init(IwiSize{width, height}, ippiGetDataType(depth), cn,
IwiBorderSize(), dst_data, IwSize(dst_step));
// already have physical border
int inMemFlags = 0;
if(!(border_type & cv::BORDER_ISOLATED))
{
if(marginLeft)
{
if(marginLeft >= radius) inMemFlags |= ippBorderInMemLeft;
else return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
if(marginTop)
{
if(marginTop >= radius) inMemFlags |= ippBorderInMemTop;
else return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
if(marginRight)
{
if(marginRight >= radius) inMemFlags |= ippBorderInMemRight;
else return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
if(marginBottom)
{
if(marginBottom >= radius) inMemFlags |= ippBorderInMemBottom;
else return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
}
::ipp::IwiBorderType ippBorder((IppiBorderType)(ippBorderType | inMemFlags));
const int threads = ippiSuggestThreadsNum(iwDst, 2);
if(IPP_BILATERAL_PARALLEL && threads > 1) {
bool ok = true;
cv::Range range(0, (int)iwDst.m_size.height);
ipp_bilateralFilterParallel invoker(iwSrc, iwDst, radius, valSquareSigma, posSquareSigma, ippBorder, &ok);
if(!ok)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
int maxTiles = (int)iwDst.m_size.height / radius;
int numTiles = threads * 4;
if(numTiles > maxTiles) {
numTiles = (maxTiles / threads) * threads;
}
cv::parallel_for_(range, invoker, numTiles);
if(!ok)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
} else {
CV_INSTRUMENT_FUN_IPP(::ipp::iwiFilterBilateral, iwSrc, iwDst, radius, valSquareSigma, posSquareSigma, ::ipp::IwDefault(), ippBorder);
}
}
catch(const ::ipp::IwException &)
{
return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
return CV_HAL_ERROR_OK;
}
#endif

223
hal/ipp/src/histogram_ipp.cpp Normal file
View File

@@ -0,0 +1,223 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
// Copyright (C) 2026, BigVision LLC, all rights reserved.
// Third party copyrights are property of their respective owners.
#include "ipp_hal_imgproc.hpp"
#include <opencv2/core.hpp>
#include <opencv2/core/utils/tls.hpp>
#include "precomp_ipp.hpp"
#if IPP_VERSION_X100 >= 700
#define IPP_HISTOGRAM_PARALLEL 1
namespace cv { namespace ipp { unsigned long long getIppTopFeatures(); } }
using namespace cv;
namespace {
typedef IppStatus(CV_STDCALL * IppiHistogram_C1)(const void* pSrc, int srcStep,
IppiSize roiSize, Ipp32u* pHist, const IppiHistogramSpec* pSpec, Ipp8u* pBuffer);
static IppiHistogram_C1 getIppiHistogramFunction_C1(int type)
{
IppiHistogram_C1 ippFunction =
(type == CV_8UC1) ? (IppiHistogram_C1)ippiHistogram_8u_C1R :
(type == CV_16UC1) ? (IppiHistogram_C1)ippiHistogram_16u_C1R :
(type == CV_32FC1) ? (IppiHistogram_C1)ippiHistogram_32f_C1R :
NULL;
return ippFunction;
}
class ipp_calcHistParallelTLS
{
public:
ipp_calcHistParallelTLS() {}
IppAutoBuffer<IppiHistogramSpec> spec;
IppAutoBuffer<Ipp8u> buffer;
IppAutoBuffer<Ipp32u> thist;
};
class ipp_calcHistParallel: public ParallelLoopBody
{
public:
ipp_calcHistParallel(const Mat &src, Mat &hist, Ipp32s histSize, const float *ranges, bool uniform, bool &ok):
ParallelLoopBody(), m_src(src), m_hist(hist), m_ok(ok)
{
ok = true;
m_uniform = uniform;
m_ranges = ranges;
m_histSize = histSize;
m_type = ippiGetDataType(src.type());
m_levelsNum = histSize+1;
ippiHistogram_C1 = getIppiHistogramFunction_C1(src.type());
m_fullRoi = ippiSize(src.size());
m_bufferSize = 0;
m_specSize = 0;
if(!ippiHistogram_C1)
{
ok = false;
return;
}
if(ippiHistogramGetBufferSize(m_type, m_fullRoi, &m_levelsNum, 1, 1, &m_specSize, &m_bufferSize) < 0)
{
ok = false;
return;
}
hist.setTo(0);
}
virtual void operator() (const Range & range) const CV_OVERRIDE
{
if(!m_ok)
return;
ipp_calcHistParallelTLS *pTls = m_tls.get();
IppiSize roi = {m_src.cols, range.end - range.start };
bool mtLoop = false;
if(m_fullRoi.height != roi.height)
mtLoop = true;
if(!pTls->spec)
{
pTls->spec.allocate(m_specSize);
if(!pTls->spec.get())
{
m_ok = false;
return;
}
pTls->buffer.allocate(m_bufferSize);
if(!pTls->buffer.get() && m_bufferSize)
{
m_ok = false;
return;
}
if(m_uniform)
{
if(ippiHistogramUniformInit(m_type, (Ipp32f*)&m_ranges[0], (Ipp32f*)&m_ranges[1], (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
{
m_ok = false;
return;
}
}
else
{
if(ippiHistogramInit(m_type, (const Ipp32f**)&m_ranges, (Ipp32s*)&m_levelsNum, 1, pTls->spec) < 0)
{
m_ok = false;
return;
}
}
pTls->thist.allocate(m_histSize*sizeof(Ipp32u));
}
if(CV_INSTRUMENT_FUN_IPP(ippiHistogram_C1, m_src.ptr(range.start), (int)m_src.step, roi, pTls->thist, pTls->spec, pTls->buffer) < 0)
{
m_ok = false;
return;
}
if(mtLoop)
{
for(int i = 0; i < m_histSize; i++)
CV_XADD((int*)(m_hist.ptr(i)), *(int*)((Ipp32u*)pTls->thist + i));
}
else
ippiCopy_32s_C1R((Ipp32s*)pTls->thist.get(), sizeof(Ipp32u), (Ipp32s*)m_hist.ptr(), (int)m_hist.step, ippiSize(1, m_histSize));
}
private:
const Mat &m_src;
Mat &m_hist;
Ipp32s m_histSize;
const float *m_ranges;
bool m_uniform;
IppiHistogram_C1 ippiHistogram_C1;
IppiSize m_fullRoi;
IppDataType m_type;
Ipp32s m_levelsNum;
int m_bufferSize;
int m_specSize;
mutable Mutex m_syncMutex;
TLSData<ipp_calcHistParallelTLS> m_tls;
volatile bool &m_ok;
const ipp_calcHistParallel & operator = (const ipp_calcHistParallel & );
};
static bool ipp_calchist(const Mat &image, Mat &hist, int histSize, const float** ranges, bool uniform, bool accumulate)
{
#if IPP_VERSION_X100 < 201801
// No SSE42 optimization for uniform 32f
if(uniform && image.depth() == CV_32F && cv::ipp::getIppTopFeatures() == ippCPUID_SSE42)
return false;
#endif
// IPP_DISABLE_HISTOGRAM - https://github.com/opencv/opencv/issues/11544
// and https://github.com/opencv/opencv/issues/21595
if ((uniform && (ranges[0][1] - ranges[0][0]) != histSize) || abs(ranges[0][0]) != cvFloor(ranges[0][0]))
return false;
Mat ihist = hist;
if(accumulate)
ihist.create(1, &histSize, CV_32S);
bool ok = true;
int threads = ippiSuggestThreadsNum(image.cols, image.rows, image.elemSize(), (1+((double)ihist.total()/image.total()))*2);
Range range(0, image.rows);
ipp_calcHistParallel invoker(image, ihist, histSize, ranges[0], uniform, ok);
if(!ok)
return false;
if(IPP_HISTOGRAM_PARALLEL && threads > 1)
parallel_for_(range, invoker, threads*2);
else
invoker(range);
if(ok)
{
if(accumulate)
{
IppiSize histRoi = ippiSize(1, histSize);
IppAutoBuffer<Ipp32f> fhist(histSize*sizeof(Ipp32f));
CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)fhist, sizeof(Ipp32f), histRoi);
CV_INSTRUMENT_FUN_IPP(ippiAdd_32f_C1IR, (Ipp32f*)fhist, sizeof(Ipp32f), (Ipp32f*)hist.ptr(), (int)hist.step, histRoi);
}
else
CV_INSTRUMENT_FUN_IPP(ippiConvert_32s32f_C1R, (Ipp32s*)ihist.ptr(), (int)ihist.step, (Ipp32f*)hist.ptr(), (int)hist.step, ippiSize(1, histSize));
}
return ok;
}
} // namespace
int ipp_hal_calcHist(const uchar* src_data, size_t src_step, int src_type, int src_width, int src_height,
float* hist_data, int hist_size, const float** ranges, bool uniform, bool accumulate)
{
CV_HAL_CHECK_USE_IPP();
Mat image(src_height, src_width, src_type, (void*)src_data, src_step);
Mat hist(1, &hist_size, CV_32F, (void*)hist_data);
if(ipp_calchist(image, hist, hist_size, ranges, uniform, accumulate))
return CV_HAL_ERROR_OK;
return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
#endif

4
hal/ipp/src/matchtemplate_ipp.cpp
View File

@@ -114,10 +114,12 @@ int ipp_hal_matchTemplate(const uchar* src_data, size_t src_step, int src_width,
if(templ.size().area()*4 > img.size().area())
return CV_HAL_ERROR_NOT_IMPLEMENTED;
#if IPP_VERSION_X100 < 202610
// CV_8U SQDIFF/SQDIFF_NORMED suffer from float32 catastrophic cancellation
// in IPP's internal accumulators; fall through to the double-precision path instead.
// in IPP's internal accumulators (older versions); fall through to the double-precision path instead.
if(depth == CV_8U && (method == cv::TM_SQDIFF || method == cv::TM_SQDIFF_NORMED))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
#endif
if(method == cv::TM_SQDIFF)
{

4
hal/ipp/src/norm_ipp.cpp
View File

@@ -50,7 +50,9 @@ int ipp_hal_norm(const uchar* src, size_t src_step, const uchar* mask, size_t ma
norm_type == cv::NORM_INF ?
(type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_8u_C3CMR :
type == CV_16UC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_16u_C3CMR :
#if (!IPP_DISABLE_NORM_INF_32F_C3CMR)
type == CV_32FC3 ? (ippiMaskNormFuncC3)ippiNorm_Inf_32f_C3CMR :
#endif
0) :
norm_type == cv::NORM_L1 ?
(type == CV_8UC3 ? (ippiMaskNormFuncC3)ippiNorm_L1_8u_C3CMR :
@@ -265,7 +267,9 @@ int ipp_hal_normDiff(const uchar* src1, size_t src1_step, const uchar* src2, siz
norm_type == cv::NORM_INF ?
(type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_8u_C3CMR :
type == CV_16UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_16u_C3CMR :
#if (!IPP_DISABLE_NORM_INF_32F_C3CMR)
type == CV_32FC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_Inf_32f_C3CMR :
#endif
0) :
norm_type == cv::NORM_L1 ?
(type == CV_8UC3 ? (ippiMaskNormDiffFuncC3)ippiNormDiff_L1_8u_C3CMR :

26
hal/ipp/src/precomp_ipp.hpp
View File

@@ -120,4 +120,30 @@ static inline int ippiSuggestRowThreadsNum(const ::ipp::IwiImage &image, size_t
}
#endif
#if IPP_VERSION_X100 >= 201700
#define CV_IPP_MALLOC(SIZE) ippMalloc_L(SIZE)
#else
#define CV_IPP_MALLOC(SIZE) ippMalloc((int)SIZE)
#endif
template<typename T>
class IppAutoBuffer
{
public:
IppAutoBuffer() { m_size = 0; m_pBuffer = NULL; }
explicit IppAutoBuffer(size_t size) { m_size = 0; m_pBuffer = NULL; allocate(size); }
~IppAutoBuffer() { deallocate(); }
T* allocate(size_t size) { if(m_size < size) { deallocate(); m_pBuffer = (T*)CV_IPP_MALLOC(size); m_size = size; } return m_pBuffer; }
void deallocate() { if(m_pBuffer) { ippFree(m_pBuffer); m_pBuffer = NULL; } m_size = 0; }
inline T* get() { return (T*)m_pBuffer;}
inline operator T* () { return (T*)m_pBuffer;}
inline operator const T* () const { return (const T*)m_pBuffer;}
private:
IppAutoBuffer(IppAutoBuffer &) {}
IppAutoBuffer& operator =(const IppAutoBuffer &) {return *this;}
size_t m_size;
T* m_pBuffer;
};
#endif //__PRECOMP_IPP_HPP__

66
hal/ipp/src/samplers_ipp.cpp Normal file
View File

@@ -0,0 +1,66 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
// Copyright (C) 2026, BigVision LLC, all rights reserved.
// Third party copyrights are property of their respective owners.
#include "ipp_hal_imgproc.hpp"
#include <opencv2/core.hpp>
#include "precomp_ipp.hpp"
#if IPP_VERSION_X100 >= 700
using namespace cv;
int ipp_hal_getRectSubPix(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height,
int patch_type, uchar* patch_data, size_t patch_step, int patch_width, int patch_height,
double center_x, double center_y)
{
CV_HAL_CHECK_USE_IPP();
int ddepth = CV_MAT_DEPTH(patch_type);
// ippiCopySubpixIntersect replicates the border incorrectly in some cases, see
// https://github.com/opencv/opencv/issues/30301. The window position is computed the same way as IPP does,
// including (int)(x + w) - w, which is not equal to cvFloor() for some inputs.
float fx = (float)center_x - 0.5f * (patch_width - 1);
float fy = (float)center_y - 0.5f * (patch_height - 1);
int sx = (int)(fx + patch_width) - patch_width;
int sy = (int)(fy + patch_height) - patch_height;
// the window crosses the top edge and reaches the last column: the top rows get src(0, cols-2)
// instead of src(0, cols-1), and for 1-column images IPP reads outside of the image
if( sy < 0 && sx >= src_width - patch_width )
return CV_HAL_ERROR_NOT_IMPLEMENTED;
// 8u->8u, the window lies totally to the left of the image: the fixed-point weights overflow
if( src_type == CV_8UC1 && ddepth == CV_8U && fx + patch_width < 0 )
return CV_HAL_ERROR_NOT_IMPLEMENTED;
typedef IppStatus (CV_STDCALL *ippiGetRectSubPixFunc)( const void* src, int src_step,
IppiSize src_size, void* dst,
int dst_step, IppiSize win_size,
IppiPoint_32f center,
IppiPoint* minpt, IppiPoint* maxpt );
ippiGetRectSubPixFunc ippiCopySubpixIntersect =
src_type == CV_8UC1 && ddepth == CV_8U ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u_C1R :
src_type == CV_8UC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_8u32f_C1R :
src_type == CV_32FC1 && ddepth == CV_32F ? (ippiGetRectSubPixFunc)ippiCopySubpixIntersect_32f_C1R : 0;
if( ippiCopySubpixIntersect )
{
IppiPoint minpt = {0, 0}, maxpt = {0, 0};
IppiPoint_32f icenter = {(float)center_x, (float)center_y};
IppiSize src_size = {src_width, src_height}, win_size = {patch_width, patch_height};
if( CV_INSTRUMENT_FUN_IPP(ippiCopySubpixIntersect, src_data, (int)src_step, src_size, patch_data,
(int)patch_step, win_size, icenter, &minpt, &maxpt) >= 0 )
return CV_HAL_ERROR_OK;
}
return CV_HAL_ERROR_NOT_IMPLEMENTED;
}
#endif

15
hal/ipp/src/warp_ipp.cpp
View File

@@ -99,14 +99,17 @@ int ipp_hal_warpAffine(int src_type, const uchar *src_data, size_t src_step, int
{{1, 1, 0}, {0, 0, 0}, {1, 1, 0}, {1, 1, 0}}, //32F
{{1, 1, 0}, {0, 0, 0}, {1, 1, 0}, {1, 1, 0}}}; //64F
#else // IPP_CALLS_ENFORCED is not defined, results are strictly aligned to OpenCV implementation
// NEAREST column kept 0 for all types: IPP's iwiWarpAffine rounds source coords at the
// half-pixel boundary unlike the native kernel (warpAffineBlocklineNN), so its NN output
// is not bit-exact. Forces fallback to native. See https://github.com/opencv/opencv/issues/29279
/* C1 C2 C3 C4 */
char impl[CV_DEPTH_MAX][4][3]={{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //8U
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //8S
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {1, 0, 0}}, //16U
{{1, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 0, 0}}, //16S
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //16U
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //16S
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //32S
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}, //32F
{{1, 0, 0}, {0, 0, 0}, {1, 0, 0}, {1, 0, 0}}}; //64F
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}; //64F
#endif
if(impl[CV_TYPE(src_type)][CV_MAT_CN(src_type)-1][interpolation] == 0)
@@ -232,10 +235,10 @@ int ipp_hal_warpPerspective(int src_type, const uchar *src_data, size_t src_step
/* C1 C2 C3 C4 */
char impl[CV_DEPTH_MAX][4][2]={{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, //8U
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, //8S
{{0, 0}, {0, 0}, {0, 0}, {0, 1}}, //16U
{{1, 1}, {0, 0}, {1, 0}, {1, 1}}, //16S
{{0, 0}, {0, 0}, {0, 1}, {0, 1}}, //16U
{{1, 1}, {0, 0}, {1, 1}, {1, 1}}, //16S
{{1, 1}, {0, 0}, {1, 0}, {1, 1}}, //32S
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}, //32F
{{1, 0}, {0, 0}, {0, 0}, {0, 0}}, //32F
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}}; //64F
#endif

2
hal/ndsrvp/src/bilateralFilter.cpp
View File

@@ -189,7 +189,7 @@ int bilateralFilter(const uchar* src_data, size_t src_step,
// calculate source border
std::vector<uchar> padding;
padding.resize(cal_width * cal_height * cn);
padding.resize((size_t)cal_width * cal_height * cn);
uchar* pad_data = &padding[0];
int pad_step = cal_width * cn;

17
hal/riscv-rvv/include/core.hpp
View File

@@ -99,9 +99,18 @@ int fast_atan_64(const double* y, const double* x, double* dst, size_t n, bool a
/* ############ split ############ */
int split8u(const uchar* src, uchar** dst, int len, int cn);
int split16u(const ushort* src, ushort** dst, int len, int cn);
int split32s(const int* src, int** dst, int len, int cn);
int split64s(const int64* src, int64** dst, int len, int cn);
#undef cv_hal_split8u
#define cv_hal_split8u cv::rvv_hal::core::split8u
#undef cv_hal_split16u
#define cv_hal_split16u cv::rvv_hal::core::split16u
#undef cv_hal_split32s
#define cv_hal_split32s cv::rvv_hal::core::split32s
#undef cv_hal_split64s
#define cv_hal_split64s cv::rvv_hal::core::split64s
/* ############ sqrt ############ */
@@ -325,6 +334,14 @@ int transpose2d(const uchar* src_data, size_t src_step, uchar* dst_data, size_t
#undef cv_hal_transpose2d
#define cv_hal_transpose2d cv::rvv_hal::core::transpose2d
/* ############ rotate90 ############ */
int rotate90(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height,
uchar* dst_data, size_t dst_step, int angle);
#undef cv_hal_rotate90
#define cv_hal_rotate90 cv::rvv_hal::core::rotate90
#endif // CV_HAL_RVV_1P0_ENABLED
}}} // cv::rvv_hal::core

49
hal/riscv-rvv/src/core/convert_scale.cpp
View File

@@ -221,6 +221,53 @@ inline int convertScale_16U32F(const uchar* src, size_t src_step, uchar* dst, si
return CV_HAL_ERROR_OK;
}
inline int convertScale_16S8U(const uchar* src, size_t src_step, uchar* dst, size_t dst_step, int width, int height, double alpha, double beta)
{
if (alpha == 1.0 && beta == 0.0)
{
for (int i = 0; i < height; i++)
{
const short* src_row = reinterpret_cast<const short*>(src + i * src_step);
uchar* dst_row = dst + i * dst_step;
int vl;
for (int j = 0; j < width; j += vl)
{
vl = __riscv_vsetvl_e16m4(width - j);
auto vec_src = __riscv_vle16_v_i16m4(src_row + j, vl);
// clamp the negative half to zero first: vnclipu would wrap it to 255
auto vec_src_u16 = __riscv_vreinterpret_v_i16m4_u16m4(__riscv_vmax(vec_src, 0, vl));
auto vec_dst = __riscv_vnclipu(vec_src_u16, 0, __RISCV_VXRM_RNU, vl);
__riscv_vse8_v_u8m2(dst_row + j, vec_dst, vl);
}
}
return CV_HAL_ERROR_OK;
}
int vlmax = __riscv_vsetvlmax_e32m8();
auto vec_b = __riscv_vfmv_v_f_f32m8(beta, vlmax);
float a = alpha;
for (int i = 0; i < height; i++)
{
const short* src_row = reinterpret_cast<const short*>(src + i * src_step);
uchar* dst_row = dst + i * dst_step;
int vl;
for (int j = 0; j < width; j += vl)
{
vl = __riscv_vsetvl_e16m4(width - j);
auto vec_src = __riscv_vle16_v_i16m4(src_row + j, vl);
auto vec_src_f32 = __riscv_vfwcvt_f(vec_src, vl);
auto vec_fma = __riscv_vfmadd(vec_src_f32, a, vec_b, vl);
auto vec_dst_u16 = __riscv_vfncvt_xu(vec_fma, vl);
auto vec_dst = __riscv_vnclipu(vec_dst_u16, 0, __RISCV_VXRM_RNU, vl);
__riscv_vse8_v_u8m2(dst_row + j, vec_dst, vl);
}
}
return CV_HAL_ERROR_OK;
}
inline int convertScale_16S32F(const uchar* src, size_t src_step, uchar* dst, size_t dst_step, int width, int height, double alpha, double beta)
{
int vlmax = __riscv_vsetvlmax_e32m8();
@@ -333,6 +380,8 @@ int convertScale(const uchar* src, size_t src_step, uchar* dst, size_t dst_step,
case CV_16S:
switch (ddepth)
{
case CV_8U:
return convertScale_16S8U(src, src_step, dst, dst_step, width, height, alpha, beta);
case CV_32F:
return convertScale_16S32F(src, src_step, dst, dst_step, width, height, alpha, beta);
}

23
hal/riscv-rvv/src/core/copy_mask.cpp
View File

@@ -30,8 +30,27 @@ static int copyToMasked_e##X##c1(const uchar *src_data, size_t src_step, const u
return CV_HAL_ERROR_OK; \
}
CV_HAL_RVV_COPY_MASK_eXc1(8, 8)
CV_HAL_RVV_COPY_MASK_eXc1(16, 4)
#define CV_HAL_RVV_COPY_MASK_MERGE_eXc1(X, data_lmul, mask_lmul) \
static int copyToMasked_e##X##c1(const uchar *src_data, size_t src_step, const uchar *mask_data, size_t mask_step, \
uchar *dst_data, size_t dst_step, int width, int height) { \
for (; height--; mask_data += mask_step, src_data += src_step, dst_data += dst_step) { \
const uint##X##_t *src = (const uint##X##_t*)src_data; \
uint##X##_t *dst = (uint##X##_t*)dst_data; \
int vl; \
for (int i = 0; i < width; i += vl) { \
vl = __riscv_vsetvl_e##X##m##data_lmul(width - i); \
auto m = __riscv_vmsne(__riscv_vle8_v_u8m##mask_lmul(mask_data + i, vl), 0, vl); \
auto src_v = __riscv_vle##X##_v_u##X##m##data_lmul(src + i, vl); \
auto dst_v = __riscv_vle##X##_v_u##X##m##data_lmul(dst + i, vl); \
__riscv_vse##X##_v_u##X##m##data_lmul(dst + i, __riscv_vmerge(dst_v, src_v, m, vl), vl); \
} \
} \
return CV_HAL_ERROR_OK; \
}
CV_HAL_RVV_COPY_MASK_MERGE_eXc1(8, 8, 8)
CV_HAL_RVV_COPY_MASK_MERGE_eXc1(16, 8, 4)
CV_HAL_RVV_COPY_MASK_eXc1(32, 2)
CV_HAL_RVV_COPY_MASK_eXc1(64, 1)

81
hal/riscv-rvv/src/core/flip.cpp
View File

@@ -7,16 +7,7 @@
#include "rvv_hal.hpp"
#if defined (__clang__) && __clang_major__ < 18
#define OPENCV_HAL_IMPL_RVV_VCREATE_x3(suffix, width, v0, v1, v2) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x3(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2);
#define __riscv_vcreate_v_u8m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u8, 2, v0, v1, v2)
#define __riscv_vcreate_v_u16m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u16, 2, v0, v1, v2)
#define __riscv_vcreate_v_u32m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u32, 2, v0, v1, v2)
#define __riscv_vcreate_v_u64m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u64, 2, v0, v1, v2)
#endif
#include "rvv_vcreate.hpp"
namespace cv { namespace rvv_hal { namespace core {
@@ -24,24 +15,50 @@ namespace cv { namespace rvv_hal { namespace core {
namespace {
template <typename RVV>
struct FlipC1 : RVV
{
static inline typename RVV::VecType gather(typename RVV::VecType v,
typename RVV::VecType indices, size_t vl)
{
return __riscv_vrgather(v, indices, vl);
}
};
template <>
struct FlipC1<RVV_U8M8> : RVV_U8M4
{
// e8,m4 data and e16,m8 indices have the same number of lanes.
// 8-bit indices wrap when more than 256 bytes are reversed at once.
static inline RVV_U16M8::VecType vid(size_t vl)
{
return RVV_U16M8::vid(vl);
}
static inline VecType gather(VecType v, RVV_U16M8::VecType indices, size_t vl)
{
return __riscv_vrgatherei16(v, indices, vl);
}
};
#define CV_HAL_RVV_FLIP_C1(name, _Tps, RVV) \
inline void flip_##name(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int src_width, int src_height, int flip_mode) { \
for (int h = 0; h < src_height; h++) { \
const _Tps* src_row = (const _Tps*)(src_data + src_step * h); \
_Tps* dst_row = (_Tps*)(dst_data + dst_step * (flip_mode < 0 ? (src_height - h) : (h + 1))); \
_Tps* dst_row = (_Tps*)(dst_data + dst_step * (flip_mode < 0 ? (src_height - 1 - h) : h)) + src_width; \
int vl; \
for (int w = 0; w < src_width; w += vl) { \
vl = RVV::setvl(src_width - w); \
RVV::VecType indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto v = RVV::vload(src_row + w, vl); \
RVV::vstore(dst_row - w - vl, __riscv_vrgather(v, indices, vl), vl); \
RVV::vstore(dst_row - w - vl, RVV::gather(v, indices, vl), vl); \
} \
} \
}
CV_HAL_RVV_FLIP_C1(8UC1, uchar, RVV_U8M8)
CV_HAL_RVV_FLIP_C1(16UC1, ushort, RVV_U16M8)
CV_HAL_RVV_FLIP_C1(32UC1, unsigned, RVV_U32M8)
CV_HAL_RVV_FLIP_C1(64UC1, uint64_t, RVV_U64M8)
CV_HAL_RVV_FLIP_C1(8UC1, uchar, FlipC1<RVV_U8M8>)
CV_HAL_RVV_FLIP_C1(16UC1, ushort, FlipC1<RVV_U16M8>)
CV_HAL_RVV_FLIP_C1(32UC1, unsigned, FlipC1<RVV_U32M8>)
CV_HAL_RVV_FLIP_C1(64UC1, uint64_t, FlipC1<RVV_U64M8>)
#define CV_HAL_RVV_FLIP_INPLACE_C1(name, _Tps, RVV) \
inline void flip_inplace_##name(uchar* data, size_t step, int width, int height, int flip_mode) { \
@@ -50,36 +67,36 @@ inline void flip_inplace_##name(uchar* data, size_t step, int width, int height,
int h; \
for (h = 0; h < new_height; h++) { \
_Tps* row_begin = (_Tps*)(data + step * h); \
_Tps* row_end = (_Tps*)(data + step * (flip_mode < 0 ? (height - h) : (h + 1))); \
_Tps* row_end = (_Tps*)(data + step * (flip_mode < 0 ? (height - 1 - h) : h)) + width; \
int vl; \
for (int w = 0; w < new_width; w += vl) { \
vl = RVV::setvl(new_width - w); \
RVV::VecType indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto v_left = RVV::vload(row_begin + w, vl); \
auto v_right = RVV::vload(row_end - w - vl, vl); \
RVV::vstore(row_begin + w, __riscv_vrgather(v_right, indices, vl), vl); \
RVV::vstore(row_end - w - vl, __riscv_vrgather(v_left, indices, vl), vl); \
RVV::vstore(row_begin + w, RVV::gather(v_right, indices, vl), vl); \
RVV::vstore(row_end - w - vl, RVV::gather(v_left, indices, vl), vl); \
} \
} \
if (flip_mode == -1 && new_height * 2 != height) { \
_Tps* row_begin = (_Tps*)(data + step * h); \
_Tps* row_end = (_Tps*)(data + step * (h + 1)); \
_Tps* row_end = (_Tps*)(data + step * h) + width; \
new_width /= 2; \
int vl; \
for (int w = 0; w < new_width; w += vl) { \
vl = RVV::setvl(new_width - w); \
RVV::VecType indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto indices = __riscv_vrsub(RVV::vid(vl), vl - 1, vl); \
auto v_left = RVV::vload(row_begin + w, vl); \
auto v_right = RVV::vload(row_end - w - vl, vl); \
RVV::vstore(row_begin + w, __riscv_vrgather(v_right, indices, vl), vl); \
RVV::vstore(row_end - w - vl, __riscv_vrgather(v_left, indices, vl), vl); \
RVV::vstore(row_begin + w, RVV::gather(v_right, indices, vl), vl); \
RVV::vstore(row_end - w - vl, RVV::gather(v_left, indices, vl), vl); \
} \
} \
}
CV_HAL_RVV_FLIP_INPLACE_C1(8UC1, uchar, RVV_U8M8)
CV_HAL_RVV_FLIP_INPLACE_C1(16UC1, ushort, RVV_U16M8)
CV_HAL_RVV_FLIP_INPLACE_C1(32UC1, unsigned, RVV_U32M8)
CV_HAL_RVV_FLIP_INPLACE_C1(64UC1, uint64_t, RVV_U64M8)
CV_HAL_RVV_FLIP_INPLACE_C1(8UC1, uchar, FlipC1<RVV_U8M8>)
CV_HAL_RVV_FLIP_INPLACE_C1(16UC1, ushort, FlipC1<RVV_U16M8>)
CV_HAL_RVV_FLIP_INPLACE_C1(32UC1, unsigned, FlipC1<RVV_U32M8>)
CV_HAL_RVV_FLIP_INPLACE_C1(64UC1, uint64_t, FlipC1<RVV_U64M8>)
// Suppress warnings of "ignoring attributes applied to VecType after definition",
// VecType is vuint8m2x3_t, vuint16m2x3_t, vuint32m2x3_t or vuint64m2x3_t
@@ -113,7 +130,7 @@ CV_HAL_RVV_FLIP_C3_TYPES(64)
inline void flip_##name(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step, int src_width, int src_height, int flip_mode) { \
for (int h = 0; h < src_height; h++) { \
const _Tps* src_row = (const _Tps*)(src_data + src_step * h); \
_Tps* dst_row = (_Tps*)(dst_data + dst_step * (flip_mode < 0 ? (src_height - h) : (h + 1))); \
_Tps* dst_row = (_Tps*)(dst_data + dst_step * (flip_mode < 0 ? (src_height - 1 - h) : h)) + 3 * src_width; \
int vl; \
for (int w = 0; w < src_width; w += vl) { \
vl = RVV::setvl(src_width - w); \
@@ -136,7 +153,7 @@ inline void flip_inplace_##name(uchar* data, size_t step, int width, int height,
int h; \
for (h = 0; h < new_height; h++) { \
_Tps* row_begin = (_Tps*)(data + step * h); \
_Tps* row_end = (_Tps*)(data + step * (flip_mode < 0 ? (height - h) : (h + 1))); \
_Tps* row_end = (_Tps*)(data + step * (flip_mode < 0 ? (height - 1 - h) : h)) + 3 * width; \
int vl; \
for (int w = 0; w < new_width; w += vl) { \
vl = RVV::setvl(new_width - w); \
@@ -151,7 +168,7 @@ inline void flip_inplace_##name(uchar* data, size_t step, int width, int height,
} \
if (flip_mode == -1 && new_height * 2 != height) { \
_Tps* row_begin = (_Tps*)(data + step * h); \
_Tps* row_end = (_Tps*)(data + step * (h + 1)); \
_Tps* row_end = (_Tps*)(data + step * h) + 3 * width; \
new_width /= 2; \
int vl; \
for (int w = 0; w < new_width; w += vl) { \

233
hal/riscv-rvv/src/core/merge.cpp
View File

@@ -28,6 +28,12 @@
#define __riscv_vcreate_v_u16m4x2(v0, v1) OPENCV_HAL_IMPL_RVV_VCREATE_x2(u16, 4, v0, v1)
#define __riscv_vcreate_v_u16m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u16, 2, v0, v1, v2)
#define __riscv_vcreate_v_u16m2x4(v0, v1, v2, v3) OPENCV_HAL_IMPL_RVV_VCREATE_x4(u16, 2, v0, v1, v2, v3)
#define __riscv_vcreate_v_i32m4x2(v0, v1) OPENCV_HAL_IMPL_RVV_VCREATE_x2(i32, 4, v0, v1)
#define __riscv_vcreate_v_i32m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(i32, 2, v0, v1, v2)
#define __riscv_vcreate_v_i32m2x4(v0, v1, v2, v3) OPENCV_HAL_IMPL_RVV_VCREATE_x4(i32, 2, v0, v1, v2, v3)
#define __riscv_vcreate_v_i64m4x2(v0, v1) OPENCV_HAL_IMPL_RVV_VCREATE_x2(i64, 4, v0, v1)
#define __riscv_vcreate_v_i64m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(i64, 2, v0, v1, v2)
#define __riscv_vcreate_v_i64m2x4(v0, v1, v2, v3) OPENCV_HAL_IMPL_RVV_VCREATE_x4(i64, 2, v0, v1, v2, v3)
#endif // clang < 18
namespace cv { namespace rvv_hal { namespace core {
@@ -204,146 +210,177 @@ int merge16u(const ushort** src, ushort* dst, int len, int cn ) {
return CV_HAL_ERROR_OK;
}
#if defined __GNUC__ && !defined(__clang__)
__attribute__((optimize("no-tree-vectorize")))
#endif
int merge32s(const int** src, int* dst, int len, int cn ) {
int k = cn % 4 ? cn % 4 : 4;
int i, j;
if( k == 1 )
int vl = 0;
if (cn == 1)
{
const int* src0 = src[0];
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( i = j = 0; i < len; i++, j += cn )
dst[j] = src0[i];
}
else if( k == 2 )
{
const int *src0 = src[0], *src1 = src[1];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
for (int i = 0; i < len; i += vl)
{
dst[j] = src0[i];
dst[j+1] = src1[i];
vl = __riscv_vsetvl_e32m8(len - i);
__riscv_vse32_v_i32m8(dst + i, __riscv_vle32_v_i32m8(src0 + i, vl), vl);
}
}
else if( k == 3 )
else if (cn == 2)
{
const int *src0 = src[0], *src1 = src[1];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e32m4(len - i);
vint32m4x2_t seg = __riscv_vcreate_v_i32m4x2(
__riscv_vle32_v_i32m4(src0 + i, vl),
__riscv_vle32_v_i32m4(src1 + i, vl)
);
__riscv_vsseg2e32_v_i32m4x2(dst + i * cn, seg, vl);
}
}
else if (cn == 3)
{
const int *src0 = src[0], *src1 = src[1], *src2 = src[2];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
for (int i = 0; i < len; i += vl)
{
dst[j] = src0[i];
dst[j+1] = src1[i];
dst[j+2] = src2[i];
vl = __riscv_vsetvl_e32m2(len - i);
vint32m2x3_t seg = __riscv_vcreate_v_i32m2x3(
__riscv_vle32_v_i32m2(src0 + i, vl),
__riscv_vle32_v_i32m2(src1 + i, vl),
__riscv_vle32_v_i32m2(src2 + i, vl)
);
__riscv_vsseg3e32_v_i32m2x3(dst + i * cn, seg, vl);
}
}
else if (cn == 4)
{
const int *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e32m2(len - i);
vint32m2x4_t seg = __riscv_vcreate_v_i32m2x4(
__riscv_vle32_v_i32m2(src0 + i, vl),
__riscv_vle32_v_i32m2(src1 + i, vl),
__riscv_vle32_v_i32m2(src2 + i, vl),
__riscv_vle32_v_i32m2(src3 + i, vl)
);
__riscv_vsseg4e32_v_i32m2x4(dst + i * cn, seg, vl);
}
}
else
{
const int *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
int k = 0;
for (; k <= cn - 4; k += 4)
{
dst[j] = src0[i]; dst[j+1] = src1[i];
dst[j+2] = src2[i]; dst[j+3] = src3[i];
const int *src0 = src[k], *src1 = src[k + 1], *src2 = src[k + 2], *src3 = src[k + 3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e32m2(len - i);
vint32m2x4_t seg = __riscv_vcreate_v_i32m2x4(
__riscv_vle32_v_i32m2(src0 + i, vl),
__riscv_vle32_v_i32m2(src1 + i, vl),
__riscv_vle32_v_i32m2(src2 + i, vl),
__riscv_vle32_v_i32m2(src3 + i, vl)
);
__riscv_vssseg4e32_v_i32m2x4(dst + k + i * cn, cn * sizeof(int), seg, vl);
}
}
}
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; k < cn; k += 4 )
{
const int *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
for( i = 0, j = k; i < len; i++, j += cn )
for (; k < cn; ++k)
{
dst[j] = src0[i]; dst[j+1] = src1[i];
dst[j+2] = src2[i]; dst[j+3] = src3[i];
const int* srcK = src[k];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e32m2(len - i);
vint32m2_t seg = __riscv_vle32_v_i32m2(srcK + i, vl);
__riscv_vsse32_v_i32m2(dst + k + i * cn, cn * sizeof(int), seg, vl);
}
}
}
return CV_HAL_ERROR_OK;
}
#if defined __GNUC__ && !defined(__clang__)
__attribute__((optimize("no-tree-vectorize")))
#endif
int merge64s(const int64** src, int64* dst, int len, int cn ) {
int k = cn % 4 ? cn % 4 : 4;
int i, j;
if( k == 1 )
int vl = 0;
if (cn == 1)
{
const int64* src0 = src[0];
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( i = j = 0; i < len; i++, j += cn )
dst[j] = src0[i];
}
else if( k == 2 )
{
const int64 *src0 = src[0], *src1 = src[1];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
for (int i = 0; i < len; i += vl)
{
dst[j] = src0[i];
dst[j+1] = src1[i];
vl = __riscv_vsetvl_e64m8(len - i);
__riscv_vse64_v_i64m8(dst + i, __riscv_vle64_v_i64m8(src0 + i, vl), vl);
}
}
else if( k == 3 )
else if (cn == 2)
{
const int64 *src0 = src[0], *src1 = src[1];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e64m4(len - i);
vint64m4x2_t seg = __riscv_vcreate_v_i64m4x2(
__riscv_vle64_v_i64m4(src0 + i, vl),
__riscv_vle64_v_i64m4(src1 + i, vl)
);
__riscv_vsseg2e64_v_i64m4x2(dst + i * cn, seg, vl);
}
}
else if (cn == 3)
{
const int64 *src0 = src[0], *src1 = src[1], *src2 = src[2];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
for (int i = 0; i < len; i += vl)
{
dst[j] = src0[i];
dst[j+1] = src1[i];
dst[j+2] = src2[i];
vl = __riscv_vsetvl_e64m2(len - i);
vint64m2x3_t seg = __riscv_vcreate_v_i64m2x3(
__riscv_vle64_v_i64m2(src0 + i, vl),
__riscv_vle64_v_i64m2(src1 + i, vl),
__riscv_vle64_v_i64m2(src2 + i, vl)
);
__riscv_vsseg3e64_v_i64m2x3(dst + i * cn, seg, vl);
}
}
else if (cn == 4)
{
const int64 *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e64m2(len - i);
vint64m2x4_t seg = __riscv_vcreate_v_i64m2x4(
__riscv_vle64_v_i64m2(src0 + i, vl),
__riscv_vle64_v_i64m2(src1 + i, vl),
__riscv_vle64_v_i64m2(src2 + i, vl),
__riscv_vle64_v_i64m2(src3 + i, vl)
);
__riscv_vsseg4e64_v_i64m2x4(dst + i * cn, seg, vl);
}
}
else
{
const int64 *src0 = src[0], *src1 = src[1], *src2 = src[2], *src3 = src[3];
i = j = 0;
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; i < len; i++, j += cn )
int k = 0;
for (; k <= cn - 4; k += 4)
{
dst[j] = src0[i]; dst[j+1] = src1[i];
dst[j+2] = src2[i]; dst[j+3] = src3[i];
const int64 *src0 = src[k], *src1 = src[k + 1], *src2 = src[k + 2], *src3 = src[k + 3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e64m2(len - i);
vint64m2x4_t seg = __riscv_vcreate_v_i64m2x4(
__riscv_vle64_v_i64m2(src0 + i, vl),
__riscv_vle64_v_i64m2(src1 + i, vl),
__riscv_vle64_v_i64m2(src2 + i, vl),
__riscv_vle64_v_i64m2(src3 + i, vl)
);
__riscv_vssseg4e64_v_i64m2x4(dst + k + i * cn, cn * sizeof(int64), seg, vl);
}
}
}
#if defined(__clang__)
#pragma clang loop vectorize(disable)
#endif
for( ; k < cn; k += 4 )
{
const int64 *src0 = src[k], *src1 = src[k+1], *src2 = src[k+2], *src3 = src[k+3];
for( i = 0, j = k; i < len; i++, j += cn )
for (; k < cn; ++k)
{
dst[j] = src0[i]; dst[j+1] = src1[i];
dst[j+2] = src2[i]; dst[j+3] = src3[i];
const int64* srcK = src[k];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e64m2(len - i);
vint64m2_t seg = __riscv_vle64_v_i64m2(srcK + i, vl);
__riscv_vsse64_v_i64m2(dst + k + i * cn, cn * sizeof(int64), seg, vl);
}
}
}
return CV_HAL_ERROR_OK;
}
#endif // CV_HAL_RVV_1P0_ENABLED
}}} // cv::rvv_hal::core

115
hal/riscv-rvv/src/core/rotate.cpp Normal file
View File

@@ -0,0 +1,115 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
#include "rvv_hal.hpp"
#include "rvv_vcreate.hpp"
namespace cv { namespace rvv_hal { namespace core {
#if CV_HAL_RVV_1P0_ENABLED
namespace {
#define CV_HAL_RVV_ROTATE_8_ROWS(func, T, RVV, suffix, bits) \
static void func(const uchar* src_data, size_t src_step, int src_width, int src_height, \
uchar* dst_data, size_t dst_step, int angle) \
{ \
const size_t src_step_elems = src_step / sizeof(T); \
int y = 0; \
for (; y <= src_height - 8; y += 8) \
{ \
const T* src = reinterpret_cast<const T*>(src_data) + y * src_step_elems; \
for (int x = 0; x < src_width; ) \
{ \
const size_t vl = __riscv_vsetvl_e##bits##m1(src_width - x); \
auto v0 = __riscv_vle##bits##_v_##suffix##m1(src + x, vl); \
auto v1 = __riscv_vle##bits##_v_##suffix##m1(src + src_step_elems + x, vl); \
auto v2 = __riscv_vle##bits##_v_##suffix##m1(src + 2 * src_step_elems + x, vl); \
auto v3 = __riscv_vle##bits##_v_##suffix##m1(src + 3 * src_step_elems + x, vl); \
auto v4 = __riscv_vle##bits##_v_##suffix##m1(src + 4 * src_step_elems + x, vl); \
auto v5 = __riscv_vle##bits##_v_##suffix##m1(src + 5 * src_step_elems + x, vl); \
auto v6 = __riscv_vle##bits##_v_##suffix##m1(src + 6 * src_step_elems + x, vl); \
auto v7 = __riscv_vle##bits##_v_##suffix##m1(src + 7 * src_step_elems + x, vl); \
vuint##bits##m1x8_t v; \
T* dst; \
ptrdiff_t stride; \
if (angle == 90) \
{ \
v = __riscv_vcreate_v_##suffix##m1x8(v7, v6, v5, v4, v3, v2, v1, v0); \
dst = reinterpret_cast<T*>(dst_data + static_cast<size_t>(x) * dst_step) \
+ src_height - y - 8; \
stride = static_cast<ptrdiff_t>(dst_step); \
} \
else \
{ \
v = __riscv_vcreate_v_##suffix##m1x8(v0, v1, v2, v3, v4, v5, v6, v7); \
dst = reinterpret_cast<T*>(dst_data + static_cast<size_t>(src_width - 1 - x) * dst_step) + y; \
stride = -static_cast<ptrdiff_t>(dst_step); \
} \
__riscv_vssseg8e##bits(dst, stride, v, vl); \
x += static_cast<int>(vl); \
} \
} \
for (; y < src_height; ++y) \
{ \
const T* src = reinterpret_cast<const T*>(src_data + static_cast<size_t>(y) * src_step); \
for (int x = 0; x < src_width; ) \
{ \
const size_t vl = RVV::setvl(src_width - x); \
auto v = RVV::vload(src + x, vl); \
T* dst; \
ptrdiff_t stride; \
if (angle == 90) \
{ \
dst = reinterpret_cast<T*>(dst_data + static_cast<size_t>(x) * dst_step) \
+ src_height - 1 - y; \
stride = static_cast<ptrdiff_t>(dst_step); \
} \
else \
{ \
dst = reinterpret_cast<T*>(dst_data + static_cast<size_t>(src_width - 1 - x) * dst_step) + y; \
stride = -static_cast<ptrdiff_t>(dst_step); \
} \
RVV::vstore_stride(dst, stride, v, vl); \
x += static_cast<int>(vl); \
} \
} \
}
CV_HAL_RVV_ROTATE_8_ROWS(rotate90_8u, uint8_t, RVV_U8M8, u8, 8)
CV_HAL_RVV_ROTATE_8_ROWS(rotate90_16u, uint16_t, RVV_U16M8, u16, 16)
CV_HAL_RVV_ROTATE_8_ROWS(rotate90_32u, uint32_t, RVV_U32M8, u32, 32)
CV_HAL_RVV_ROTATE_8_ROWS(rotate90_64u, uint64_t, RVV_U64M8, u64, 64)
#undef CV_HAL_RVV_ROTATE_8_ROWS
} // namespace
int rotate90(int src_type, const uchar* src_data, size_t src_step, int src_width, int src_height,
uchar* dst_data, size_t dst_step, int angle)
{
if (src_data == dst_data || (angle != 90 && angle != 270))
return CV_HAL_ERROR_NOT_IMPLEMENTED;
const size_t element_size = CV_ELEM_SIZE(src_type);
if (src_step % element_size != 0 || dst_step % element_size != 0)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
using RotateFunc = void (*)(const uchar*, size_t, int, int, uchar*, size_t, int);
static RotateFunc rotate90Funcs[] = {
nullptr, rotate90_8u, rotate90_16u, nullptr, rotate90_32u,
nullptr, nullptr, nullptr, rotate90_64u
};
RotateFunc func = element_size < sizeof(rotate90Funcs) / sizeof(rotate90Funcs[0])
? rotate90Funcs[element_size] : nullptr;
if (!func)
return CV_HAL_ERROR_NOT_IMPLEMENTED;
func(src_data, src_step, src_width, src_height, dst_data, dst_step, angle);
return CV_HAL_ERROR_OK;
}
#endif // CV_HAL_RVV_1P0_ENABLED
}}} // cv::rvv_hal::core

48
hal/riscv-rvv/src/core/rvv_vcreate.hpp Normal file
View File

@@ -0,0 +1,48 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
//
// Copyright (C) 2025, Institute of Software, Chinese Academy of Sciences.
// Copyright (C) 2025, SpaceMIT Inc., all rights reserved.
#ifndef OPENCV_HAL_RVV_VCREATE_HPP_INCLUDED
#define OPENCV_HAL_RVV_VCREATE_HPP_INCLUDED
// Tuple creation intrinsics were added in Clang 18.
// These shims are shared by flip, transpose and rotate.
#if defined(__clang__) && __clang_major__ < 18
#define OPENCV_HAL_IMPL_RVV_VCREATE_x3(suffix, width, v0, v1, v2) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x3(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2);
#define __riscv_vcreate_v_u8m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u8, 2, v0, v1, v2)
#define __riscv_vcreate_v_u16m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u16, 2, v0, v1, v2)
#define __riscv_vcreate_v_u32m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u32, 2, v0, v1, v2)
#define __riscv_vcreate_v_u64m2x3(v0, v1, v2) OPENCV_HAL_IMPL_RVV_VCREATE_x3(u64, 2, v0, v1, v2)
#define OPENCV_HAL_IMPL_RVV_VCREATE_x4(suffix, width, v0, v1, v2, v3) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x4(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2); \
v = __riscv_vset(v, 3, v3);
#define OPENCV_HAL_IMPL_RVV_VCREATE_x8(suffix, width, v0, v1, v2, v3, v4, v5, v6, v7) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x8(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2); \
v = __riscv_vset(v, 3, v3); \
v = __riscv_vset(v, 4, v4); \
v = __riscv_vset(v, 5, v5); \
v = __riscv_vset(v, 6, v6); \
v = __riscv_vset(v, 7, v7);
#define __riscv_vcreate_v_u8m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u8, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_u16m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u16, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_i32m1x4(v0, v1, v2, v3) OPENCV_HAL_IMPL_RVV_VCREATE_x4(i32, 1, v0, v1, v2, v3)
#define __riscv_vcreate_v_i64m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(i64, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_u32m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u32, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_u64m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u64, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#endif
#endif // OPENCV_HAL_RVV_VCREATE_HPP_INCLUDED

160
hal/riscv-rvv/src/core/split.cpp
View File

@@ -8,84 +8,92 @@ namespace cv { namespace rvv_hal { namespace core {
#if CV_HAL_RVV_1P0_ENABLED
int split8u(const uchar* src, uchar** dst, int len, int cn)
{
int vl = 0;
if (cn == 1)
{
uchar* dst0 = dst[0];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m8(len - i);
__riscv_vse8_v_u8m8(dst0 + i, __riscv_vle8_v_u8m8(src + i, vl), vl);
}
}
else if (cn == 2)
{
uchar *dst0 = dst[0], *dst1 = dst[1];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m4(len - i);
vuint8m4x2_t seg = __riscv_vlseg2e8_v_u8m4x2(src + i * cn, vl);
__riscv_vse8_v_u8m4(dst0 + i, __riscv_vget_v_u8m4x2_u8m4(seg, 0), vl);
__riscv_vse8_v_u8m4(dst1 + i, __riscv_vget_v_u8m4x2_u8m4(seg, 1), vl);
}
}
else if (cn == 3)
{
uchar *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m2(len - i);
vuint8m2x3_t seg = __riscv_vlseg3e8_v_u8m2x3(src + i * cn, vl);
__riscv_vse8_v_u8m2(dst0 + i, __riscv_vget_v_u8m2x3_u8m2(seg, 0), vl);
__riscv_vse8_v_u8m2(dst1 + i, __riscv_vget_v_u8m2x3_u8m2(seg, 1), vl);
__riscv_vse8_v_u8m2(dst2 + i, __riscv_vget_v_u8m2x3_u8m2(seg, 2), vl);
}
}
else if (cn == 4)
{
uchar *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m2(len - i);
vuint8m2x4_t seg = __riscv_vlseg4e8_v_u8m2x4(src + i * cn, vl);
__riscv_vse8_v_u8m2(dst0 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 0), vl);
__riscv_vse8_v_u8m2(dst1 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 1), vl);
__riscv_vse8_v_u8m2(dst2 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 2), vl);
__riscv_vse8_v_u8m2(dst3 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 3), vl);
}
}
else
{
int k = 0;
for (; k <= cn - 4; k += 4)
{
uchar *dst0 = dst[k], *dst1 = dst[k + 1], *dst2 = dst[k + 2], *dst3 = dst[k + 3];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m2(len - i);
vuint8m2x4_t seg = __riscv_vlsseg4e8_v_u8m2x4(src + k + i * cn, cn, vl);
__riscv_vse8_v_u8m2(dst0 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 0), vl);
__riscv_vse8_v_u8m2(dst1 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 1), vl);
__riscv_vse8_v_u8m2(dst2 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 2), vl);
__riscv_vse8_v_u8m2(dst3 + i, __riscv_vget_v_u8m2x4_u8m2(seg, 3), vl);
}
}
for (; k < cn; ++k)
{
uchar* dstK = dst[k];
for (int i = 0; i < len; i += vl)
{
vl = __riscv_vsetvl_e8m2(len - i);
vuint8m2_t seg = __riscv_vlse8_v_u8m2(src + k + i * cn, cn, vl);
__riscv_vse8_v_u8m2(dstK + i, seg, vl);
}
}
}
return CV_HAL_ERROR_OK;
#define OPENCV_HAL_IMPL_RVV_SPLIT(func, T, vtype, suffix, width) \
int func(const T* src, T** dst, int len, int cn) \
{ \
int vl = 0; \
if (cn == 1) \
{ \
T* dst0 = dst[0]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m8(len - i); \
__riscv_vse##width##_v_##suffix##m8(dst0 + i, __riscv_vle##width##_v_##suffix##m8(src + i, vl), vl); \
} \
} \
else if (cn == 2) \
{ \
T *dst0 = dst[0], *dst1 = dst[1]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m4(len - i); \
v##vtype##m4x2_t seg = __riscv_vlseg2e##width##_v_##suffix##m4x2(src + i * cn, vl); \
__riscv_vse##width##_v_##suffix##m4(dst0 + i, __riscv_vget_v_##suffix##m4x2_##suffix##m4(seg, 0), vl); \
__riscv_vse##width##_v_##suffix##m4(dst1 + i, __riscv_vget_v_##suffix##m4x2_##suffix##m4(seg, 1), vl); \
} \
} \
else if (cn == 3) \
{ \
T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m2(len - i); \
v##vtype##m2x3_t seg = __riscv_vlseg3e##width##_v_##suffix##m2x3(src + i * cn, vl); \
__riscv_vse##width##_v_##suffix##m2(dst0 + i, __riscv_vget_v_##suffix##m2x3_##suffix##m2(seg, 0), vl); \
__riscv_vse##width##_v_##suffix##m2(dst1 + i, __riscv_vget_v_##suffix##m2x3_##suffix##m2(seg, 1), vl); \
__riscv_vse##width##_v_##suffix##m2(dst2 + i, __riscv_vget_v_##suffix##m2x3_##suffix##m2(seg, 2), vl); \
} \
} \
else if (cn == 4) \
{ \
T *dst0 = dst[0], *dst1 = dst[1], *dst2 = dst[2], *dst3 = dst[3]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m2(len - i); \
v##vtype##m2x4_t seg = __riscv_vlseg4e##width##_v_##suffix##m2x4(src + i * cn, vl); \
__riscv_vse##width##_v_##suffix##m2(dst0 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 0), vl); \
__riscv_vse##width##_v_##suffix##m2(dst1 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 1), vl); \
__riscv_vse##width##_v_##suffix##m2(dst2 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 2), vl); \
__riscv_vse##width##_v_##suffix##m2(dst3 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 3), vl); \
} \
} \
else \
{ \
int k = 0; \
for (; k <= cn - 4; k += 4) \
{ \
T *dst0 = dst[k], *dst1 = dst[k + 1], *dst2 = dst[k + 2], *dst3 = dst[k + 3]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m2(len - i); \
v##vtype##m2x4_t seg = __riscv_vlsseg4e##width##_v_##suffix##m2x4(src + k + i * cn, cn * sizeof(T), vl); \
__riscv_vse##width##_v_##suffix##m2(dst0 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 0), vl); \
__riscv_vse##width##_v_##suffix##m2(dst1 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 1), vl); \
__riscv_vse##width##_v_##suffix##m2(dst2 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 2), vl); \
__riscv_vse##width##_v_##suffix##m2(dst3 + i, __riscv_vget_v_##suffix##m2x4_##suffix##m2(seg, 3), vl); \
} \
} \
for (; k < cn; ++k) \
{ \
T* dstK = dst[k]; \
for (int i = 0; i < len; i += vl) \
{ \
vl = __riscv_vsetvl_e##width##m2(len - i); \
v##vtype##m2_t seg = __riscv_vlse##width##_v_##suffix##m2(src + k + i * cn, cn * sizeof(T), vl); \
__riscv_vse##width##_v_##suffix##m2(dstK + i, seg, vl); \
} \
} \
} \
return CV_HAL_ERROR_OK; \
}
OPENCV_HAL_IMPL_RVV_SPLIT(split8u, uchar, uint8, u8, 8)
OPENCV_HAL_IMPL_RVV_SPLIT(split16u, ushort, uint16, u16, 16)
OPENCV_HAL_IMPL_RVV_SPLIT(split32s, int, int32, i32, 32)
OPENCV_HAL_IMPL_RVV_SPLIT(split64s, int64, int64, i64, 64)
#undef OPENCV_HAL_IMPL_RVV_SPLIT
#endif // CV_HAL_RVV_1P0_ENABLED
}}} // cv::rvv_hal::core

26
hal/riscv-rvv/src/core/transpose.cpp
View File

@@ -7,28 +7,7 @@
#include "rvv_hal.hpp"
#if defined (__clang__) && __clang_major__ < 18
#define OPENCV_HAL_IMPL_RVV_VCREATE_x4(suffix, width, v0, v1, v2, v3) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x4(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2); \
v = __riscv_vset(v, 3, v3);
#define OPENCV_HAL_IMPL_RVV_VCREATE_x8(suffix, width, v0, v1, v2, v3, v4, v5, v6, v7) \
__riscv_vset_v_##suffix##m##width##_##suffix##m##width##x8(v, 0, v0); \
v = __riscv_vset(v, 1, v1); \
v = __riscv_vset(v, 2, v2); \
v = __riscv_vset(v, 3, v3); \
v = __riscv_vset(v, 4, v4); \
v = __riscv_vset(v, 5, v5); \
v = __riscv_vset(v, 6, v6); \
v = __riscv_vset(v, 7, v7);
#define __riscv_vcreate_v_u8m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u8, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_u16m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(u16, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#define __riscv_vcreate_v_i32m1x4(v0, v1, v2, v3) OPENCV_HAL_IMPL_RVV_VCREATE_x4(i32, 1, v0, v1, v2, v3)
#define __riscv_vcreate_v_i64m1x8(v0, v1, v2, v3, v4, v5, v6, v7) OPENCV_HAL_IMPL_RVV_VCREATE_x8(i64, 1, v0, v1, v2, v3, v4, v5, v6, v7)
#endif
#include "rvv_vcreate.hpp"
namespace cv { namespace rvv_hal { namespace core {
@@ -186,7 +165,8 @@ static void transpose2d_32sC2(const uchar *src_data, size_t src_step, uchar *dst
using Transpose2dFunc = void (*)(const uchar*, size_t, uchar*, size_t, int, int);
int transpose2d(const uchar* src_data, size_t src_step, uchar* dst_data, size_t dst_step,
int src_width, int src_height, int element_size) {
if (src_data == dst_data) {
if (src_data == dst_data || element_size <= 0 ||
src_step % element_size != 0 || dst_step % element_size != 0) {
return CV_HAL_ERROR_NOT_IMPLEMENTED;
}

5
modules/calib3d/include/opencv2/calib3d.hpp
View File

@@ -3855,6 +3855,11 @@ map_y(u,v) \leftarrow y''' f_y + c_y
where \f$(k_1, k_2, p_1, p_2[, k_3[, k_4, k_5, k_6[, s_1, s_2, s_3, s_4[, \tau_x, \tau_y]]]])\f$
are the distortion coefficients.
@note The rational distortion model used by OpenCV can be seen as a
combination of the Brown-Conrady Model and the Division Model @cite Fitzgibbon01.
It should not be confused with the Rational Function Model @cite Claus05a, which
uses conics to represent lens distortion.
In case of a stereo camera, this function is called twice: once for each camera head, after
#stereoRectify, which in its turn is called after #stereoCalibrate. But if the stereo camera
was not calibrated, it is still possible to compute the rectification transformations directly from

80
modules/calib3d/misc/python/test/test_calibration.py
View File

@@ -92,5 +92,85 @@ class calibration_test(NewOpenCVTests):
self.assertTrue(isinstance(dist, (float, np.floating)))
self.assertGreaterEqual(dist, 0.0)
@staticmethod
def _random_rt():
# random rotation (axis-angle) + random translation
axis = np.random.uniform(-1, 1, 3)
axis /= np.linalg.norm(axis)
angle = np.random.uniform(0.2, 1.0) * (1 if np.random.rand() > 0.5 else -1)
rvec = (axis * angle).astype(np.float64)
R, _ = cv.Rodrigues(rvec)
t = np.random.uniform(-100, 100, 3).astype(np.float64)
return R, t
@staticmethod
def _to_T(R, t):
T = np.eye(4)
T[:3, :3] = R
T[:3, 3] = t
return T
def test_calibrateHandEye(self):
# Ground truth camera-to-gripper transform (what calibrateHandEye should recover)
R_cam2gripper_gt, t_cam2gripper_gt = self._random_rt()
X = self._to_T(R_cam2gripper_gt, t_cam2gripper_gt)
# Arbitrary fixed target-to-base transform (the calibration board doesn't move)
R_target2base, t_target2base = self._random_rt()
Wt = self._to_T(R_target2base, t_target2base)
n_poses = 10
Rs_gripper2base, ts_gripper2base = [], []
Rs_target2cam, ts_target2cam = [], []
for _ in range(n_poses):
R_g2b, t_g2b = self._random_rt()
G = self._to_T(R_g2b, t_g2b)
# Consistent synthetic data: Wt == G @ X @ T_target2cam for every pose
T_target2cam = np.linalg.inv(X) @ np.linalg.inv(G) @ Wt
Rs_gripper2base.append(R_g2b)
ts_gripper2base.append(t_g2b)
Rs_target2cam.append(T_target2cam[:3, :3])
ts_target2cam.append(T_target2cam[:3, 3])
R_cam2gripper, t_cam2gripper = cv.calibrateHandEye(
Rs_gripper2base, ts_gripper2base, Rs_target2cam, ts_target2cam)
self.assertLess(cv.norm(R_cam2gripper - R_cam2gripper_gt, cv.NORM_L1), 1e-3)
self.assertLess(cv.norm(t_cam2gripper.flatten() - t_cam2gripper_gt, cv.NORM_L1), 1e-3)
def test_calibrateRobotWorldHandEye(self):
# Ground truth outputs (what calibrateRobotWorldHandEye should recover)
R_base2world_gt, t_base2world_gt = self._random_rt()
X = self._to_T(R_base2world_gt, t_base2world_gt)
R_gripper2cam_gt, t_gripper2cam_gt = self._random_rt()
Z = self._to_T(R_gripper2cam_gt, t_gripper2cam_gt)
n_poses = 10
Rs_world2cam, ts_world2cam = [], []
Rs_base2gripper, ts_base2gripper = [], []
for _ in range(n_poses):
R_b2g, t_b2g = self._random_rt()
B = self._to_T(R_b2g, t_b2g)
# Consistent synthetic data: A_i @ X == Z @ B_i => A_i = Z @ B_i @ inv(X)
A = Z @ B @ np.linalg.inv(X)
Rs_world2cam.append(A[:3, :3])
# NOTE: unlike calibrateHandEye, calibrateRobotWorldHandEye's Shah/Li
# solvers require translations as explicit (3,1) column vectors, not
# flat (3,) arrays -- passing (3,) raises a gemm shape-assertion error.
ts_world2cam.append(A[:3, 3].reshape(3, 1))
Rs_base2gripper.append(R_b2g)
ts_base2gripper.append(t_b2g.reshape(3, 1))
R_base2world, t_base2world, R_gripper2cam, t_gripper2cam = cv.calibrateRobotWorldHandEye(
Rs_world2cam, ts_world2cam, Rs_base2gripper, ts_base2gripper)
self.assertLess(cv.norm(R_base2world - R_base2world_gt, cv.NORM_L1), 1e-3)
self.assertLess(cv.norm(t_base2world.flatten() - t_base2world_gt, cv.NORM_L1), 1e-3)
self.assertLess(cv.norm(R_gripper2cam - R_gripper2cam_gt, cv.NORM_L1), 1e-3)
self.assertLess(cv.norm(t_gripper2cam.flatten() - t_gripper2cam_gt, cv.NORM_L1), 1e-3)
if __name__ == '__main__':
NewOpenCVTests.bootstrap()

41
modules/calib3d/perf/perf_filterspeckles.cpp Normal file
View File

@@ -0,0 +1,41 @@
// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
// Copyright (C) 2026, Intel Corporation, all rights reserved.
#include "perf_precomp.hpp"
namespace opencv_test
{
using namespace perf;
#define FILTERSPECKLES_TYPES CV_8UC1, CV_16SC1
typedef tuple<Size, MatType> Size_MatType_t;
typedef perf::TestBaseWithParam<Size_MatType_t> Size_MatType_FilterSpeckles;
PERF_TEST_P(Size_MatType_FilterSpeckles, filterSpeckles,
testing::Combine(
testing::Values(szVGA, sz720p, sz1080p),
testing::Values(FILTERSPECKLES_TYPES)
))
{
Size sz = get<0>(GetParam());
int type = get<1>(GetParam());
// filterSpeckles works in place on a disparity map.
Mat src(sz, type);
Mat dst(sz, type);
declare.in(src, WARMUP_RNG).out(dst);
while (next())
{
src.copyTo(dst);
startTimer();
cv::filterSpeckles(dst, 0, 2, 2);
stopTimer();
}
SANITY_CHECK_NOTHING();
}
} // namespace

14
modules/calib3d/src/calibration.cpp
View File

@@ -2471,14 +2471,14 @@ static void collectCalibrationData( InputArrayOfArrays objectPoints,
Mat objectPoint = objectPoints.getMat(i);
if (objectPoint.empty())
CV_Error(cv::Error::StsBadSize, "objectPoints should not contain empty vector of vectors of points");
int numberOfObjectPoints = objectPoint.checkVector(3, CV_32F);
int numberOfObjectPoints = objectPoint.checkVector(3, CV_32F, false);
if (numberOfObjectPoints <= 0)
CV_Error(cv::Error::StsUnsupportedFormat, "objectPoints should contain vector of vectors of points of type Point3f");
Mat imagePoint1 = imagePoints1.getMat(i);
if (imagePoint1.empty())
CV_Error(cv::Error::StsBadSize, "imagePoints1 should not contain empty vector of vectors of points");
int numberOfImagePoints = imagePoint1.checkVector(2, CV_32F);
int numberOfImagePoints = imagePoint1.checkVector(2, CV_32F, false);
if (numberOfImagePoints <= 0)
CV_Error(cv::Error::StsUnsupportedFormat, "imagePoints1 should contain vector of vectors of points of type Point2f");
CV_CheckEQ(numberOfObjectPoints, numberOfImagePoints, "Number of object and image points must be equal");
@@ -2507,7 +2507,11 @@ static void collectCalibrationData( InputArrayOfArrays objectPoints,
{
Mat objpt = objectPoints.getMat(i);
Mat imgpt1 = imagePoints1.getMat(i);
int numberOfObjectPoints = objpt.checkVector(3, CV_32F);
int numberOfObjectPoints = objpt.checkVector(3, CV_32F, false);
if (!objpt.isContinuous())
objpt = objpt.clone();
if (!imgpt1.isContinuous())
imgpt1 = imgpt1.clone();
nPointsMat.at<int>(i) = numberOfObjectPoints;
for (int n = 0; n < numberOfObjectPoints; ++n)
{
@@ -2518,8 +2522,10 @@ static void collectCalibrationData( InputArrayOfArrays objectPoints,
if (imgPtData2)
{
Mat imgpt2 = imagePoints2.getMat(i);
int numberOfImage2Points = imgpt2.checkVector(2, CV_32F);
int numberOfImage2Points = imgpt2.checkVector(2, CV_32F, false);
CV_CheckEQ(numberOfObjectPoints, numberOfImage2Points, "Number of object and image(2) points must be equal");
if (!imgpt2.isContinuous())
imgpt2 = imgpt2.clone();
for (int n = 0; n < numberOfImage2Points; ++n)
{
imgPtData2[j + n] = imgpt2.ptr<Point2f>()[n];

200
modules/calib3d/src/fisheye.cpp
View File

@@ -55,6 +55,99 @@ namespace cv { namespace
};
}}
namespace cv { namespace
{
static double normalizePoints(const Mat& points,
Mat& normalizedPoints,
Mat& pointMean)
{
using std::fpclassify;
using std::sqrt;
constexpr double defaultPointScale = 1.0;
const Mat pointCoordinates =
points.reshape(1, static_cast<int>(points.total()));
reduce(pointCoordinates, pointMean, 0, REDUCE_AVG);
Mat centeredPoints = pointCoordinates -
Mat::ones(pointCoordinates.rows, 1, CV_64F) * pointMean;
// Apply Hartley normalization. The maximum coordinate is an intermediate
// preconditioner that prevents the squared norm from underflowing.
double maximumCoordinate = norm(centeredPoints, NORM_INF);
if (fpclassify(maximumCoordinate) == FP_ZERO)
{
maximumCoordinate = defaultPointScale;
}
Mat scaledPoints = centeredPoints / maximumCoordinate;
double standardDeviation =
norm(scaledPoints, NORM_L2) / sqrt(scaledPoints.total());
if (fpclassify(standardDeviation) == FP_ZERO)
{
standardDeviation = defaultPointScale;
}
scaledPoints = scaledPoints / standardDeviation;
normalizedPoints = scaledPoints.reshape(points.channels(), points.rows);
// Restore the standard deviation to the original coordinate scale.
return maximumCoordinate * standardDeviation;
}
class ExtrinsicsCallback : public LMSolver::Callback
{
public:
ExtrinsicsCallback(Mat imagePoints, Mat objectPoints,
internal::IntrinsicParams params)
: imagePoints_(imagePoints)
, objectPoints_(objectPoints)
, params_(params)
{
}
bool compute(InputArray extrinsics, OutputArray residuals,
OutputArray J) const override
{
Vec6d rtvec;
extrinsics.copyTo(rtvec);
const Vec3d rvec(rtvec.val);
const Vec3d tvec(rtvec.val + 3);
Mat expected;
if (J.needed())
{
Mat jacobians;
internal::projectPoints(objectPoints_, expected, rvec, tvec,
params_, jacobians);
jacobians.colRange(8, 14).copyTo(J);
}
else
{
internal::projectPoints(objectPoints_, expected, rvec, tvec,
params_, noArray());
}
if (residuals.needed())
{
Mat residualDifference;
// LMSolver expects the Jacobian of the ideal projection.
subtract(expected, imagePoints_, residualDifference);
residualDifference = residualDifference.reshape(1);
transpose(residualDifference, residuals);
}
return true;
}
private:
Mat imagePoints_;
Mat objectPoints_;
internal::IntrinsicParams params_;
};
}}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// cv::fisheye::projectPoints
@@ -786,9 +879,32 @@ double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArray
errors.isEstimate = finalParam.isEstimate;
std::vector<Vec3d> omc(objectPoints.total()), Tc(objectPoints.total());
// Keep each view normalized through calibration to avoid scale-dependent
// overflow in the Jacobian and uncertainty calculations.
const size_t numberOfViews = objectPoints.total();
std::vector<Mat> normalizedObjectPoints(numberOfViews);
std::vector<Vec3d> objectPointMeans(numberOfViews);
std::vector<double> objectPointScales(numberOfViews);
for (size_t image_idx = 0; image_idx < numberOfViews; ++image_idx)
{
Mat object;
objectPoints.getMat(static_cast<int>(image_idx)).convertTo(object,
CV_64FC3);
Mat objectPointMean;
objectPointScales[image_idx] =
normalizePoints(object, normalizedObjectPoints[image_idx],
objectPointMean);
objectPointMeans[image_idx] =
Vec3d(objectPointMean.at<double>(0, 0),
objectPointMean.at<double>(0, 1),
objectPointMean.at<double>(0, 2));
}
CalibrateExtrinsics(objectPoints, imagePoints, finalParam, check_cond, thresh_cond, omc, Tc);
std::vector<Vec3d> omc(numberOfViews);
std::vector<Vec3d> Tc(numberOfViews);
CalibrateExtrinsics(normalizedObjectPoints, imagePoints, finalParam,
check_cond, thresh_cond, omc, Tc);
//-------------------------------Optimization
@@ -802,7 +918,8 @@ double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArray
double alpha_smooth2 = 1 - std::pow(1 - alpha_smooth, iter + 1.0);
Mat JJ2, ex3;
ComputeJacobians(objectPoints, imagePoints, finalParam, omc, Tc, check_cond,thresh_cond, JJ2, ex3);
ComputeJacobians(normalizedObjectPoints, imagePoints, finalParam, omc,
Tc, check_cond, thresh_cond, JJ2, ex3);
Mat G;
solve(JJ2, ex3, G);
@@ -816,15 +933,25 @@ double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArray
if (recompute_extrinsic)
{
CalibrateExtrinsics(objectPoints, imagePoints, finalParam, check_cond,
thresh_cond, omc, Tc);
CalibrateExtrinsics(normalizedObjectPoints, imagePoints, finalParam,
check_cond, thresh_cond, omc, Tc);
}
}
//-------------------------------Validation
double rms;
EstimateUncertainties(objectPoints, imagePoints, finalParam, omc, Tc, errors, err_std, thresh_cond,
check_cond, rms);
EstimateUncertainties(normalizedObjectPoints, imagePoints, finalParam, omc,
Tc, errors, err_std, thresh_cond, check_cond, rms);
std::vector<Vec3d> physicalTranslations(numberOfViews);
for (size_t image_idx = 0; image_idx < numberOfViews; ++image_idx)
{
Matx33d rotationMatrix;
Rodrigues(omc[image_idx], rotationMatrix);
physicalTranslations[image_idx] =
objectPointScales[image_idx] * Tc[image_idx] -
rotationMatrix * objectPointMeans[image_idx];
}
//-------------------------------
_K = Matx33d(finalParam.f[0], finalParam.f[0] * finalParam.alpha, finalParam.c[0],
@@ -835,7 +962,7 @@ double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArray
if (D.needed()) cv::Mat(finalParam.k).convertTo(D, D.empty() ? CV_64FC1 : D.type());
if (rvecs.isMatVector())
{
int N = (int)objectPoints.total();
int N = static_cast<int>(numberOfViews);
if(rvecs.empty())
rvecs.create(N, 1, CV_64FC3);
@@ -848,13 +975,16 @@ double cv::fisheye::calibrate(InputArrayOfArrays objectPoints, InputArrayOfArray
rvecs.create(3, 1, CV_64F, i, true);
tvecs.create(3, 1, CV_64F, i, true);
memcpy(rvecs.getMat(i).ptr(), omc[i].val, sizeof(Vec3d));
memcpy(tvecs.getMat(i).ptr(), Tc[i].val, sizeof(Vec3d));
memcpy(tvecs.getMat(i).ptr(), physicalTranslations[i].val,
sizeof(Vec3d));
}
}
else
{
if (rvecs.needed()) cv::Mat(omc).convertTo(rvecs, rvecs.empty() ? CV_64FC3 : rvecs.type());
if (tvecs.needed()) cv::Mat(Tc).convertTo(tvecs, tvecs.empty() ? CV_64FC3 : tvecs.type());
if (tvecs.needed())
cv::Mat(physicalTranslations).convertTo(
tvecs, tvecs.empty() ? CV_64FC3 : tvecs.type());
}
return rms;
@@ -1264,46 +1394,32 @@ void cv::internal::projectPoints(cv::InputArray objectPoints, cv::OutputArray im
void cv::internal::ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
Mat& tvec, Mat& J, const int MaxIter,
const IntrinsicParams& param, const double thresh_cond)
const IntrinsicParams& param)
{
CV_Assert(!objectPoints.empty() && objectPoints.type() == CV_64FC3);
CV_Assert(!imagePoints.empty() && imagePoints.type() == CV_64FC2);
CV_Assert(rvec.total() > 2 && tvec.total() > 2);
Vec6d extrinsics(rvec.at<double>(0), rvec.at<double>(1), rvec.at<double>(2),
tvec.at<double>(0), tvec.at<double>(1), tvec.at<double>(2));
double change = 1;
int iter = 0;
tvec.at<double>(0), tvec.at<double>(1),
tvec.at<double>(2));
while (change > 1e-10 && iter < MaxIter)
{
std::vector<Point2d> x;
Mat jacobians;
projectPoints(objectPoints, x, rvec, tvec, param, jacobians);
auto callback =
cv::makePtr<ExtrinsicsCallback>(imagePoints, objectPoints,
param);
const double solverEpsilon = std::numeric_limits<double>::epsilon();
auto solver = LMSolver::create(callback, MaxIter, solverEpsilon);
solver->run(extrinsics);
Mat ex = imagePoints - Mat(x).t();
ex = ex.reshape(1, 2);
// Copy back refined parameters
const cv::Vec3d r(extrinsics.val);
const cv::Vec3d t(extrinsics.val + 3);
J = jacobians.colRange(8, 14).clone();
cv::copyTo(r, rvec, cv::noArray());
cv::copyTo(t, tvec, cv::noArray());
SVD svd(J, SVD::NO_UV);
double condJJ = svd.w.at<double>(0)/svd.w.at<double>(5);
if (condJJ > thresh_cond)
change = 0;
else
{
Vec6d param_innov;
solve(J, ex.reshape(1, (int)ex.total()), param_innov, DECOMP_SVD + DECOMP_NORMAL);
Vec6d param_up = extrinsics + param_innov;
change = norm(param_innov)/norm(param_up);
extrinsics = param_up;
iter = iter + 1;
rvec = Mat(Vec3d(extrinsics.val));
tvec = Mat(Vec3d(extrinsics.val+3));
}
}
// Avoid caching, which would require mutable state, at the expense of
// one final recomputation.
callback->compute(extrinsics, noArray(), J);
}
cv::Mat cv::internal::ComputeHomography(Mat m, Mat M)
@@ -1493,7 +1609,7 @@ void cv::internal::CalibrateExtrinsics(InputArrayOfArrays objectPoints, InputArr
InitExtrinsics(imT ? image.t() : image, obT ? object.t() : object, param, omckk, Tckk);
ComputeExtrinsicRefine(!imT ? image.t() : image, !obT ? object.t() : object, omckk, Tckk, JJ_kk, maxIter, param, thresh_cond);
ComputeExtrinsicRefine(!imT ? image.t() : image, !obT ? object.t() : object, omckk, Tckk, JJ_kk, maxIter, param);
if (check_cond)
{
SVD svd(JJ_kk, SVD::NO_UV);

2
modules/calib3d/src/fisheye.hpp
View File

@@ -25,7 +25,7 @@ void projectPoints(cv::InputArray objectPoints, cv::OutputArray imagePoints,
void ComputeExtrinsicRefine(const Mat& imagePoints, const Mat& objectPoints, Mat& rvec,
Mat& tvec, Mat& J, const int MaxIter,
const IntrinsicParams& param, const double thresh_cond);
const IntrinsicParams& param);
CV_EXPORTS Mat ComputeHomography(Mat m, Mat M);
CV_EXPORTS Mat NormalizePixels(const Mat& imagePoints, const IntrinsicParams& param);

6
modules/calib3d/src/ippe.cpp
View File

@@ -303,13 +303,17 @@ void PoseSolver::rot2vec(InputArray _R, OutputArray _r)
Mat rvec = _r.getMat();
double trace = R.at<double>(0, 0) + R.at<double>(1, 1) + R.at<double>(2, 2);
double w_norm = acos((trace - 1.0) / 2.0);
double w_norm = acos(std::min(std::max((trace - 1.0) / 2.0, -1.0), 1.0));
double eps = std::numeric_limits<float>::epsilon();
double d = 1 / (2 * sin(w_norm)) * w_norm;
if (w_norm < eps) //rotation is the identity
{
rvec.setTo(0);
}
else if (sin(w_norm) < 1e-5) //close to 180 degrees, the axis can't be read from R - R^T
{
Rodrigues(R, rvec);
}
else
{
double c0 = R.at<double>(2, 1) - R.at<double>(1, 2);

16
modules/calib3d/src/solvepnp.cpp
View File

@@ -750,14 +750,14 @@ static void solvePnPRefine(InputArray _objectPoints, InputArray _imagePoints,
Mat params(6, 1, CV_64FC1);
for (int i = 0; i < 3; i++)
{
params.at<double>(i,0) = rvec.at<double>(i,0);
params.at<double>(i+3,0) = tvec.at<double>(i,0);
params.at<double>(i,0) = rvec.at<double>(i);
params.at<double>(i+3,0) = tvec.at<double>(i);
}
LMSolver::create(makePtr<SolvePnPRefineLMCallback>(opoints, ipoints, cameraMatrix, distCoeffs), _criteria.maxCount, _criteria.epsilon)->run(params);
params.rowRange(0, 3).convertTo(rvec0, rvec0.depth());
params.rowRange(3, 6).convertTo(tvec0, tvec0.depth());
params.rowRange(0, 3).reshape(1, rvec0.rows).convertTo(rvec0, rvec0.depth());
params.rowRange(3, 6).reshape(1, tvec0.rows).convertTo(tvec0, tvec0.depth());
}
else if (_flags == SOLVEPNP_REFINE_VVS)
{
@@ -765,6 +765,10 @@ static void solvePnPRefine(InputArray _objectPoints, InputArray _imagePoints,
Mat rvec, tvec;
rvec0.convertTo(rvec, CV_64F);
tvec0.convertTo(tvec, CV_64F);
// tvec is used in matrix arithmetic below (R1 * tvec) which requires
// a Size(3,1) column vector; rvec0/tvec0 (and hence rvec/tvec) may
// be Size(1,3) row vectors per this function's own precondition check.
tvec = tvec.reshape(1, 3);
std::vector<Point2d> ipoints_normalized;
undistortPoints(ipoints, ipoints_normalized, cameraMatrix, distCoeffs);
@@ -799,8 +803,8 @@ static void solvePnPRefine(InputArray _objectPoints, InputArray _imagePoints,
}
Rodrigues(R, rvec);
rvec.convertTo(rvec0, rvec0.depth());
tvec.convertTo(tvec0, tvec0.depth());
rvec.reshape(1, rvec0.rows).convertTo(rvec0, rvec0.depth());
tvec.reshape(1, tvec0.rows).convertTo(tvec0, tvec0.depth());
}
}

1
modules/calib3d/src/stereo_geom.cpp
View File

@@ -3,6 +3,7 @@
// of this distribution and at http://opencv.org/license.html
#include "precomp.hpp"
#include <iterator>
namespace cv {

67
modules/calib3d/src/stereosgbm.cpp
View File

@@ -2074,41 +2074,44 @@ void SGBM3WayMainLoop::impl(const Range& range) const
{
d = 0;
#if (CV_SIMD || CV_SIMD_SCALABLE)
horPassCostVolume+=x;
int thresh = (100*min_cost)/(100-uniquenessRatio);
v_int16 thresh_reg = vx_setall_s16((short)(thresh+1));
v_int16 d1 = vx_setall_s16((short)(best_d-1));
v_int16 d2 = vx_setall_s16((short)(best_d+1));
v_int16 eight_reg = vx_setall_s16((short)VTraits<v_int16>::vlanes());
v_int16 cur_d = vx_load(idx_row);
v_int16 mask;
if(uniquenessRatio<100)
{
horPassCostVolume+=x;
int thresh = (100*min_cost)/(100-uniquenessRatio);
v_int16 thresh_reg = vx_setall_s16(saturate_cast<short>(thresh+1));
v_int16 d1 = vx_setall_s16((short)(best_d-1));
v_int16 d2 = vx_setall_s16((short)(best_d+1));
v_int16 eight_reg = vx_setall_s16((short)VTraits<v_int16>::vlanes());
v_int16 cur_d = vx_load(idx_row);
v_int16 mask;
for( ; d <= D - 2*VTraits<v_int16>::vlanes(); d+=2*VTraits<v_int16>::vlanes() )
{
mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
cur_d = v_add(cur_d, eight_reg);
if( v_check_any(mask) )
break;
mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d + VTraits<v_int16>::vlanes()), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
cur_d = v_add(cur_d, eight_reg);
if( v_check_any(mask) )
break;
}
if( d <= D - 2*VTraits<v_int16>::vlanes() )
{
horPassCostVolume-=x;
continue;
}
if( d <= D - VTraits<v_int16>::vlanes() )
{
if( v_check_any(v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)))) )
for( ; d <= D - 2*VTraits<v_int16>::vlanes(); d+=2*VTraits<v_int16>::vlanes() )
{
mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
cur_d = v_add(cur_d, eight_reg);
if( v_check_any(mask) )
break;
mask = v_and(v_lt(vx_load_aligned(horPassCostVolume + d + VTraits<v_int16>::vlanes()), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)));
cur_d = v_add(cur_d, eight_reg);
if( v_check_any(mask) )
break;
}
if( d <= D - 2*VTraits<v_int16>::vlanes() )
{
horPassCostVolume-=x;
continue;
}
d+=VTraits<v_int16>::vlanes();
if( d <= D - VTraits<v_int16>::vlanes() )
{
if( v_check_any(v_and(v_lt(vx_load_aligned(horPassCostVolume + d), thresh_reg), v_or(v_lt(cur_d, d1), v_gt(cur_d, d2)))) )
{
horPassCostVolume-=x;
continue;
}
d+=VTraits<v_int16>::vlanes();
}
horPassCostVolume-=x;
}
horPassCostVolume-=x;
#endif
for( ; d < D; d++ )
{
@@ -2553,6 +2556,9 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
if( (unsigned)x2 >= (unsigned)cols )
continue;
if( disp2cost[x2] > c )
{
disp2cost[x2] = c;
@@ -2573,6 +2579,9 @@ void cv::validateDisparity( InputOutputArray _disp, InputArray _cost, int minDis
int x2 = x - ((d + DISP_SCALE/2) >> DISP_SHIFT);
if( (unsigned)x2 >= (unsigned)cols )
continue;
if( disp2cost[x2] > c )
{
disp2cost[x2] = c;

83
modules/calib3d/test/test_cameracalibration.cpp
View File

@@ -1851,6 +1851,89 @@ void CV_StereoCalibrationTest_CPP::correct( const Mat& F,
///////////////////////////////////////////////////////////////////////////////////////////////////
TEST(Calib3d_CalibrateCamera_CPP, regression) { CV_CameraCalibrationTest_CPP test; test.safe_run(); }
TEST(Calib3d_CalibrateCamera_CPP, nonContinuousPointVectors)
{
const Size imageSize(640, 480);
const Mat cameraTruth = Mat(Matx33d(800.0, 0.0, 320.0,
0.0, 810.0, 240.0,
0.0, 0.0, 1.0));
const Mat distTruth = Mat::zeros(5, 1, CV_64F);
vector<Point3f> board;
for (int y = 0; y < 6; ++y)
for (int x = 0; x < 7; ++x)
board.push_back(Point3f((x - 3) * 0.04f, (y - 2.5f) * 0.04f, 0.0f));
const Vec3d rotations[] = {
Vec3d(-0.20, 0.10, 0.02), Vec3d( 0.15, -0.12, -0.04),
Vec3d(-0.08, -0.18, 0.08), Vec3d( 0.22, 0.05, -0.10),
Vec3d(-0.16, 0.20, 0.12), Vec3d( 0.10, 0.16, -0.07)
};
const Vec3d translations[] = {
Vec3d(-0.08, -0.04, 1.10), Vec3d( 0.06, -0.03, 1.25),
Vec3d(-0.04, 0.07, 1.35), Vec3d( 0.08, 0.05, 1.20),
Vec3d( 0.00, -0.08, 1.40), Vec3d(-0.06, 0.02, 1.15)
};
vector<Mat> objectContinuous, imageContinuous;
vector<Mat> objectBacking, imageBacking, objectBackingBefore, imageBackingBefore;
vector<Mat> objectRoi, imageRoi;
for (size_t i = 0; i < sizeof(rotations) / sizeof(rotations[0]); ++i)
{
vector<Point2f> projected;
projectPoints(board, rotations[i], translations[i], cameraTruth, distTruth, projected);
objectContinuous.push_back(Mat(board).clone());
imageContinuous.push_back(Mat(projected).clone());
Mat objectStorage((int)board.size(), 2, CV_32FC3, Scalar(-11.0f, -22.0f, -33.0f));
Mat imageStorage((int)board.size(), 2, CV_32FC2, Scalar(-44.0f, -55.0f));
objectContinuous.back().copyTo(objectStorage.col(0));
imageContinuous.back().copyTo(imageStorage.col(0));
objectBacking.push_back(objectStorage);
imageBacking.push_back(imageStorage);
objectBackingBefore.push_back(objectStorage.clone());
imageBackingBefore.push_back(imageStorage.clone());
objectRoi.push_back(objectStorage.col(0));
imageRoi.push_back(imageStorage.col(0));
ASSERT_TRUE(objectContinuous.back().isContinuous());
ASSERT_TRUE(imageContinuous.back().isContinuous());
ASSERT_FALSE(objectRoi.back().isContinuous());
ASSERT_FALSE(imageRoi.back().isContinuous());
ASSERT_EQ(objectContinuous.back().size(), objectRoi.back().size());
ASSERT_EQ(imageContinuous.back().size(), imageRoi.back().size());
ASSERT_EQ(objectContinuous.back().type(), objectRoi.back().type());
ASSERT_EQ(imageContinuous.back().type(), imageRoi.back().type());
EXPECT_EQ(0.0, cv::norm(objectContinuous.back(), objectRoi.back(), NORM_INF));
EXPECT_EQ(0.0, cv::norm(imageContinuous.back(), imageRoi.back(), NORM_INF));
}
Mat cameraContinuous, distContinuous;
const double rmsContinuous = calibrateCamera(objectContinuous, imageContinuous, imageSize,
cameraContinuous, distContinuous,
noArray(), noArray());
EXPECT_LT(rmsContinuous, 1e-4);
Mat cameraRoi, distRoi;
double rmsRoi = -1.0;
SCOPED_TRACE(format("continuous RMS: %.12g", rmsContinuous));
ASSERT_NO_THROW(rmsRoi = calibrateCamera(objectRoi, imageRoi, imageSize,
cameraRoi, distRoi, noArray(), noArray()));
EXPECT_LT(rmsRoi, 1e-4);
EXPECT_NEAR(rmsContinuous, rmsRoi, 1e-12);
EXPECT_LE(cv::norm(cameraContinuous, cameraRoi, NORM_INF), 2e-9);
EXPECT_LE(cv::norm(distContinuous, distRoi, NORM_INF), 2e-9);
for (size_t i = 0; i < objectBacking.size(); ++i)
{
EXPECT_EQ(0.0, cv::norm(objectBacking[i], objectBackingBefore[i], NORM_INF));
EXPECT_EQ(0.0, cv::norm(imageBacking[i], imageBackingBefore[i], NORM_INF));
}
}
TEST(Calib3d_CalibrationMatrixValues_CPP, accuracy) { CV_CalibrationMatrixValuesTest_CPP test; test.safe_run(); }
TEST(Calib3d_ProjectPoints_CPP, regression) { CV_ProjectPointsTest_CPP test; test.safe_run(); }

227
modules/calib3d/test/test_fisheye.cpp
View File

@@ -66,6 +66,57 @@ protected:
static void merge4(const cv::Mat& tl, const cv::Mat& tr, const cv::Mat& bl, const cv::Mat& br, cv::Mat& merged);
};
static int fixedIntrinsicCalibrationFlags(const bool checkCondition)
{
int flags = cv::fisheye::CALIB_USE_INTRINSIC_GUESS |
cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC |
cv::fisheye::CALIB_FIX_FOCAL_LENGTH |
cv::fisheye::CALIB_FIX_PRINCIPAL_POINT |
cv::fisheye::CALIB_FIX_SKEW |
cv::fisheye::CALIB_FIX_K1 |
cv::fisheye::CALIB_FIX_K2 |
cv::fisheye::CALIB_FIX_K3 |
cv::fisheye::CALIB_FIX_K4;
if (checkCondition)
{
flags |= cv::fisheye::CALIB_CHECK_COND;
}
return flags;
}
static void createNearCollinearView(cv::Matx33d& cameraMatrix,
cv::Vec4d& distortion,
cv::Size& imageSize,
std::vector<cv::Point3d>& objectPoints,
std::vector<cv::Point2d>& imagePoints)
{
const double focalLengthX = 600.0;
const double focalLengthY = 610.0;
const double principalPointX = 320.0;
const double principalPointY = 240.0;
const double lateralPerturbation = 1e-8;
cameraMatrix = cv::Matx33d(focalLengthX, 0.0, principalPointX,
0.0, focalLengthY, principalPointY,
0.0, 0.0, 1.0);
distortion = cv::Vec4d::all(0);
const cv::Vec3d trueR(0.2, -0.15, 0.1);
const cv::Vec3d trueT(0.1, -0.2, 3.0);
imageSize = cv::Size(640, 480);
objectPoints = {
{-0.4, -lateralPerturbation, 0.0},
{-0.3, lateralPerturbation, 0.1},
{-0.2, -lateralPerturbation, 0.2},
{-0.1, lateralPerturbation, 0.3},
{0.0, -lateralPerturbation, 0.4},
{0.1, lateralPerturbation, 0.5},
{0.2, -lateralPerturbation, 0.6},
{0.3, lateralPerturbation, 0.7},
{0.4, -lateralPerturbation, 0.8}};
cv::fisheye::projectPoints(objectPoints, imagePoints, trueR, trueT,
cameraMatrix, distortion);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// TESTS::
@@ -561,6 +612,182 @@ TEST_F(fisheyeTest, jacobians)
CV_Assert (cv::norm(x2 - xpred) < 1e-10);
}
class FisheyeExtrinsicRefinementScaleTest
: public fisheyeTest,
public ::testing::WithParamInterface<double>
{
};
TEST_P(FisheyeExtrinsicRefinementScaleTest, IsInvariantToObjectPointScale)
{
const cv::Matx33d cameraMatrix(600.0, 0.0, 320.0,
0.0, 610.0, 240.0,
0.0, 0.0, 1.0);
const cv::Vec4d distortion = cv::Vec4d::all(0);
const std::vector<cv::Vec3d> trueR = {
{0.15, -0.1, 0.08}, {-0.1, 0.12, -0.06}};
const std::vector<cv::Vec3d> trueT = {
{0.2, -0.15, 3.0}, {-0.3, 0.1, 2.5}};
const cv::Size testImageSize(640, 480);
const int maxIterations = 1;
const double scale = GetParam();
const std::vector<cv::Point3d> baseObjectPoints = {
{-0.4, -0.3, 0.0}, {0.0, -0.3, 0.1}, {0.4, -0.3, 0.0},
{-0.4, 0.0, 0.1}, {0.0, 0.0, 0.0}, {0.4, 0.0, 0.1},
{-0.4, 0.3, 0.0}, {0.0, 0.3, 0.1}, {0.4, 0.3, 0.0}};
std::vector<std::vector<cv::Point3d> > objectPoints(2);
std::vector<std::vector<cv::Point2d> > imagePoints(2);
for (size_t view = 0; view < trueR.size(); ++view)
{
for (const cv::Point3d& point : baseObjectPoints)
{
objectPoints[view].emplace_back(point * scale);
}
const cv::Vec3d scaledTrueT = trueT[view] * scale;
cv::fisheye::projectPoints(objectPoints[view], imagePoints[view],
trueR[view], scaledTrueT,
cameraMatrix, distortion);
}
cv::Mat estimatedK = cv::Mat(cameraMatrix);
cv::Mat estimatedD = cv::Mat(distortion);
std::vector<cv::Vec3d> estimatedR;
std::vector<cv::Vec3d> estimatedT;
const int flags = fixedIntrinsicCalibrationFlags(false);
cv::fisheye::calibrate(objectPoints, imagePoints, testImageSize, estimatedK,
estimatedD, estimatedR, estimatedT, flags,
cv::TermCriteria(cv::TermCriteria::COUNT,
maxIterations, 0));
double rms = 0;
for (size_t view = 0; view < objectPoints.size(); ++view)
{
std::vector<cv::Point2d> reprojected;
cv::fisheye::projectPoints(objectPoints[view], reprojected,
estimatedR[view], estimatedT[view],
cameraMatrix, distortion);
rms += cv::norm(cv::Mat(reprojected) - cv::Mat(imagePoints[view]),
cv::NORM_L2SQR);
}
EXPECT_NEAR(std::sqrt(rms / (2 * baseObjectPoints.size())), 0.0, 1e-8);
}
constexpr double normalObjectPointScale = 1.0;
constexpr double smallObjectPointScale = 1e-7;
constexpr double smallestNormalObjectPointScale =
std::numeric_limits<double>::min();
INSTANTIATE_TEST_CASE_P(Fisheye, FisheyeExtrinsicRefinementScaleTest,
::testing::Values(normalObjectPointScale,
smallObjectPointScale,
smallestNormalObjectPointScale));
TEST_F(fisheyeTest, CalibrationHandlesTranslatedObjectPoints)
{
const cv::Matx33d cameraMatrix(600.0, 0.0, 320.0,
0.0, 610.0, 240.0,
0.0, 0.0, 1.0);
const cv::Vec4d distortion = cv::Vec4d::all(0);
const cv::Vec3d trueR(0.15, -0.1, 0.08);
const cv::Vec3d trueT(0.2, -0.15, 3.0);
constexpr double objectPointOffsetMagnitude = 1e6;
constexpr double reprojectionTolerance = 1e-7;
const cv::Vec3d objectPointOffset(objectPointOffsetMagnitude,
-2.0 * objectPointOffsetMagnitude,
3.0 * objectPointOffsetMagnitude);
const cv::Size testImageSize(640, 480);
const int maxIterations = 1;
const std::vector<cv::Point3d> baseObjectPoints = {
{-0.4, -0.3, 0.0}, {0.0, -0.3, 0.1}, {0.4, -0.3, 0.0},
{-0.4, 0.0, 0.1}, {0.0, 0.0, 0.0}, {0.4, 0.0, 0.1},
{-0.4, 0.3, 0.0}, {0.0, 0.3, 0.1}, {0.4, 0.3, 0.0}};
cv::Matx33d rotationMatrix;
cv::Rodrigues(trueR, rotationMatrix);
const cv::Vec3d rotatedOffset = rotationMatrix * objectPointOffset;
const cv::Vec3d shiftedTrueT = trueT - rotatedOffset;
std::vector<cv::Point3d> objectPoints;
for (const cv::Point3d& point : baseObjectPoints)
{
objectPoints.emplace_back(point + cv::Point3d(objectPointOffset));
}
std::vector<cv::Point2d> imagePoints;
cv::fisheye::projectPoints(objectPoints, imagePoints, trueR, shiftedTrueT,
cameraMatrix, distortion);
cv::Mat estimatedK = cv::Mat(cameraMatrix);
cv::Mat estimatedD = cv::Mat(distortion);
std::vector<cv::Vec3d> estimatedR;
std::vector<cv::Vec3d> estimatedT;
const int flags = fixedIntrinsicCalibrationFlags(false);
cv::fisheye::calibrate(
std::vector<std::vector<cv::Point3d> >(1, objectPoints),
std::vector<std::vector<cv::Point2d> >(1, imagePoints),
testImageSize, estimatedK, estimatedD, estimatedR, estimatedT, flags,
cv::TermCriteria(cv::TermCriteria::COUNT, maxIterations, 0));
std::vector<cv::Point2d> reprojected;
cv::fisheye::projectPoints(objectPoints, reprojected, estimatedR[0],
estimatedT[0], cameraMatrix, distortion);
const double rms = cv::norm(cv::Mat(reprojected) - cv::Mat(imagePoints),
cv::NORM_L2SQR);
const double reprojectionRms =
std::sqrt(rms / (2 * baseObjectPoints.size()));
EXPECT_NEAR(reprojectionRms, 0.0, reprojectionTolerance);
}
TEST_F(fisheyeTest, CalibrationRefinesNearCollinearView)
{
cv::Matx33d cameraMatrix;
cv::Vec4d distortion;
cv::Size testImageSize;
std::vector<cv::Point3d> objectPoints;
std::vector<cv::Point2d> imagePoints;
createNearCollinearView(cameraMatrix, distortion, testImageSize,
objectPoints, imagePoints);
cv::Mat estimatedK = cv::Mat(cameraMatrix);
cv::Mat estimatedD = cv::Mat(distortion);
std::vector<cv::Vec3d> estimatedR;
std::vector<cv::Vec3d> estimatedT;
const int flags = fixedIntrinsicCalibrationFlags(false);
const double rms = cv::fisheye::calibrate(
std::vector<std::vector<cv::Point3d> >(1, objectPoints),
std::vector<std::vector<cv::Point2d> >(1, imagePoints),
testImageSize, estimatedK, estimatedD, estimatedR, estimatedT, flags,
cv::TermCriteria(cv::TermCriteria::COUNT, 20, 0));
EXPECT_LT(rms, 1e-8);
}
TEST_F(fisheyeTest, CalibrationCheckCondRejectsNearCollinearView)
{
cv::Matx33d cameraMatrix;
cv::Vec4d distortion;
cv::Size testImageSize;
std::vector<cv::Point3d> objectPoints;
std::vector<cv::Point2d> imagePoints;
createNearCollinearView(cameraMatrix, distortion, testImageSize,
objectPoints, imagePoints);
cv::Mat estimatedK = cv::Mat(cameraMatrix);
cv::Mat estimatedD = cv::Mat(distortion);
const int flags = fixedIntrinsicCalibrationFlags(true);
EXPECT_THROW(
cv::fisheye::calibrate(
std::vector<std::vector<cv::Point3d> >(1, objectPoints),
std::vector<std::vector<cv::Point2d> >(1, imagePoints),
testImageSize, estimatedK, estimatedD, cv::noArray(),
cv::noArray(), flags,
cv::TermCriteria(cv::TermCriteria::COUNT, 20, 0)),
cv::Exception);
}
TEST_F(fisheyeTest, Calibration)
{
const int n_images = 34;

81
modules/calib3d/test/test_solvepnp_ransac.cpp
View File

@@ -2110,6 +2110,61 @@ TEST(Calib3d_SolvePnPRansac, inputShape)
}
}
TEST(Calib3d_SolvePnP, refine_row_vector)
{
// solvePnPRefineLM()/VVS() explicitly accept rvec/tvec as either
// Size(1,3) (row vector) or Size(3,1) (column vector) per their
// own precondition check, but historically only the column-vector
// shape was exercised. Verify both orientations converge to the
// same, correct result.
Matx33d intrinsics(605.4, 0.0, 317.35,
0.0, 601.2, 242.63,
0.0, 0.0, 1.0);
double L = 0.1;
vector<Point3d> p3d;
p3d.push_back(Point3d(-L, -L, 0.0));
p3d.push_back(Point3d(L, -L, 0.0));
p3d.push_back(Point3d(L, L, 0.0));
p3d.push_back(Point3d(-L, L, L/2));
p3d.push_back(Point3d(0, 0, -L/2));
Mat rvec_ground_truth = (Mat_<double>(3,1) << 0.3, -0.2, 0.75);
Mat tvec_ground_truth = (Mat_<double>(3,1) << 0.15, -0.2, 1.5);
vector<Point2d> p2d;
projectPoints(p3d, rvec_ground_truth, tvec_ground_truth, intrinsics, noArray(), p2d);
for (int method = 0; method < 2; method++)
{
Mat rvec_col = (Mat_<double>(3,1) << 0.1, -0.1, 0.1);
Mat tvec_col = (Mat_<double>(3,1) << 0.0, -0.5, 1.0);
Mat rvec_row = rvec_col.reshape(1, 1).clone();
Mat tvec_row = tvec_col.reshape(1, 1).clone();
if (method == 0)
{
solvePnPRefineLM(p3d, p2d, intrinsics, noArray(), rvec_col, tvec_col);
solvePnPRefineLM(p3d, p2d, intrinsics, noArray(), rvec_row, tvec_row);
}
else
{
solvePnPRefineVVS(p3d, p2d, intrinsics, noArray(), rvec_col, tvec_col);
solvePnPRefineVVS(p3d, p2d, intrinsics, noArray(), rvec_row, tvec_row);
}
EXPECT_LE(cvtest::norm(rvec_ground_truth, rvec_col, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(tvec_ground_truth, tvec_col, NORM_INF), 1e-6);
// the row-vector call must converge to the same result as the
// column-vector call, and must actually write back into rvec_row/
// tvec_row (a shape mismatch during write-back previously left
// these unmodified even after fixing the read-side OOB)
EXPECT_LE(cvtest::norm(rvec_col, rvec_row.reshape(1, 3), NORM_INF), 1e-9);
EXPECT_LE(cvtest::norm(tvec_col, tvec_row.reshape(1, 3), NORM_INF), 1e-9);
}
}
TEST(Calib3d_SolvePnP, inputShape)
{
//https://github.com/opencv/opencv/issues/14423
@@ -2349,4 +2404,30 @@ TEST(AP3P, ctheta1p_nan_23607)
}
}
TEST(Calib3d_SolvePnP, regression_30402)
{
// A tag seen exactly head-on: the pose has a 180 degree rotation about X.
const double L = 0.05;
std::vector<Point3d> objectPoints = {
Point3d(-L, L, 0), Point3d( L, L, 0), Point3d( L, -L, 0), Point3d(-L, -L, 0)
};
Matx33d intrinsics(800, 0, 320,
0, 800, 240,
0, 0, 1);
Vec3d rvecGT(CV_PI, 0, 0), tvecGT(0, 0, 0.5);
std::vector<Point2d> imagePoints;
projectPoints(objectPoints, rvecGT, tvecGT, intrinsics, noArray(), imagePoints);
Mat rvec, tvec;
ASSERT_TRUE(solvePnP(objectPoints, imagePoints, intrinsics, noArray(), rvec, tvec,
false, SOLVEPNP_IPPE_SQUARE));
Mat R, RGT;
cv::Rodrigues(rvec, R);
cv::Rodrigues(rvecGT, RGT);
EXPECT_LE(cvtest::norm(R, RGT, NORM_INF), 1e-6);
EXPECT_LE(cvtest::norm(tvec, Mat(tvecGT), NORM_INF), 1e-6);
}
}} // namespace

67
modules/calib3d/test/test_stereomatching.cpp
View File

@@ -952,6 +952,73 @@ TEST(Calib3d_StereoSGBM, deterministic) {
}
TEST(Calib3d_StereoSGBM, regression_29761)
{
Mat leftImg(256, 256, CV_8UC1), rightImg(256, 256, CV_8UC1);
randu(leftImg, Scalar(0), Scalar(255));
randu(rightImg, Scalar(0), Scalar(255));
Ptr<StereoSGBM> sgbm = StereoSGBM::create( 0, 64, 5, 100, 200, 1, 31, 100, 0, 0, StereoSGBM::MODE_SGBM_3WAY);
Mat leftDisp;
sgbm->compute( leftImg, rightImg, leftDisp);
EXPECT_EQ(countNonZero(leftDisp != -StereoMatcher::DISP_SCALE), 0);
}
/* < cost type, x2 is past the last column (otherwise it is before the first one) > */
typedef tuple < int, bool > ValidateDisparity_Params_t;
typedef testing::TestWithParam< ValidateDisparity_Params_t > Calib3d_ValidateDisparity;
TEST_P(Calib3d_ValidateDisparity, out_of_range_disparity)
{
const int costType = get<0>(GetParam());
const bool pastEnd = get<1>(GetParam());
// The row is wide enough for validateDisparity to allocate its work buffer on the heap.
const int cols = 160, numberOfDisparities = 16, disp12MaxDiff = 0;
const int minDisparity = pastEnd ? 0 : 2;
const short invalid = (short)((minDisparity - 1)*16);
struct Px { int x; short d; int cost; short expected; };
std::vector<Px> pixels;
if( pastEnd )
{
// disparity -2 at x = 159 gives x2 = 161 >= cols
pixels.push_back({100, 80, 0, 80});
pixels.push_back({159, -32, 0, -32});
}
else
{
// x = 154 and x = 155 both map to slot 152, 154 has the lower cost, so 155 fails the cross-check.
// x = 159 gives x2 = -8, which is outside the buffer and used to overwrite the cost of slot 152.
pixels.push_back({154, 32, 0, 32});
pixels.push_back({155, 48, 10, invalid});
pixels.push_back({159, 2672, 0, 2672});
}
Mat1s disp(1, cols, invalid), expected(1, cols, invalid);
Mat1i cost32(1, cols, 0);
for( size_t i = 0; i < pixels.size(); i++ )
{
disp(0, pixels[i].x) = pixels[i].d;
cost32(0, pixels[i].x) = pixels[i].cost;
expected(0, pixels[i].x) = pixels[i].expected;
}
Mat cost;
cost32.convertTo(cost, costType);
validateDisparity(disp, cost, minDisparity, numberOfDisparities, disp12MaxDiff);
EXPECT_EQ(0, cvtest::norm(disp, expected, NORM_INF));
}
INSTANTIATE_TEST_CASE_P(/*nothing*/, Calib3d_ValidateDisparity,
testing::Combine(
testing::Values(CV_16S, CV_32S),
testing::Bool()
)
);
TEST(Calib3d_StereoSGBM_HH4, regression)
{
String path = cvtest::TS::ptr()->get_data_path() + "cv/stereomatching/datasets/teddy/";

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